| Earth Observation Mission CFI Software Visibility Software User Manual for JAVA |

Public Member Functions

# EECFI.SwathId Class Reference

Class that stores the Swath data. More...

Inheritance diagram for EECFI.SwathId:

List of all members.

## Public Member Functions
| SwathId (AtmosId atmosId, SwathInfo swathInfo) throws CfiError
| Constructor with parameters.
void | close () throws CfiError
| Release all resources managed by this object.
native SwathIdData | getData ()
| Get swath data.
native void | setData (SwathIdData swathInfo)
| Set swath data.
native ZoneCoverageOut | zoneVisTimeCoverage (ZoneCoverageIn input) throws CfiError
| The zoneVisTimeCoverage method computes the portion of the input zone that is covered by the input satellite in input time visibility segments.
native AreaOfInterest | computeAoi (OrbitId orbitId, VisTimeInterval timeInterval, double minLon, double maxLon, double minLat, double maxLat) throws CfiError
| Compute the area of interest (aoi) based on SDF file and time interval. The function provides the pre-calculation of an area of interest (aoi), which is defined by min/max lon/lat that includes the projection of all segments from the satellite to the intersection with the ellipsoid.
native void | init (AtmosId atmosId, SwathInfo swathInfo) throws CfiError
| Private init function.

## Detailed Description

Class that stores the Swath data.

## Constructor & Destructor Documentation

EECFI.SwathId::SwathId | ( | AtmosId | atmosId,
|  | SwathInfo | swathInfo |
| ) |  |  | throws CfiError

Constructor with parameters.

Parameters:

  | atmosId | Atmosphere Id.
  | swathInfo | Swath information.

## Member Function Documentation

void EECFI.SwathId.close | ( |  | ) | throws CfiError

Release all resources managed by this object.

IMPORTANT: The life time of the EOCFI Java objects must be explicitly managed by the program work flow. Failure to perform this release will lead to resource leakage and might have a significant impact in performance.

native AreaOfInterest EECFI.SwathId.computeAoi | ( | OrbitId | orbitId,
|  | VisTimeInterval | timeInterval,
|  | double | minLon,
|  | double | maxLon,
|  | double | minLat,
|  | double | maxLat |
| ) |  |  | throws CfiError

Compute the area of interest (aoi) based on SDF file and time interval.
The function provides the pre-calculation of an area of interest (aoi), which is defined by min/max lon/lat that includes the projection of all segments from the satellite to the intersection with the ellipsoid.

native SwathIdData EECFI.SwathId.getData | ( |  | ) |

Get swath data.

native void EECFI.SwathId.init | ( | AtmosId | atmosId,
|  | SwathInfo | swathInfo |
| ) |  |  | throws CfiError

Private init function.

native void EECFI.SwathId.setData | ( | SwathIdData | swathInfo | ) |

Set swath data.

ZoneCoverageOut EECFI.SwathId::zoneVisTimeCoverage | ( | ZoneCoverageIn | input | ) | throws CfiError

The zoneVisTimeCoverage method computes the portion of the input zone that is covered by the input satellite in input time visibility segments.

# Overview

The SwathId::zoneVisTimeCoverage method computes the portion of the input zone that is covered by a swath during a set of input time visibility intervals (also called segments). The user has to initialize the input object of type ZonevisibilityCoverageIn in order to provide the required information for the computation: zone, swath, attitude definition, orbit_id, list of visibility times. Note that the visibilityIntervalList field is of type VisibilityList that is the output of the Swath::zoneVisTimeCompute method. The following outputs are returned in the ZonevisibilityCoverageOut object (assuming that intervals are numbered from 0 to N-1 as stored in the vector segments of visibilityIntervalList, N is the number of elements in segments vector):

1. The area of the zone in Km2 (zoneArea field);
2. The total coverage (totalCoverage field): this is the percentage of zone covered by all intervals, i.e. 100 minus the percentage of zone not covered by any interval;
3. The coverage per interval (coveragePerInterval field): this is an array of size N that contains the coverage percentages computed considering only one interval. Item of the vector with index i (0,1,2,......N-1) is the percentage of zone covered by the interval i (0,1,2,...N-1) only.
4. The coverage per number of intervals (coverageByNIntervals field): this is an array of size N that contains the percentages of zone covered by exactly 1,2,...,N intervals. Item with index i (0,1,2,...N-1) is the percentage of the zone covered by exactly i+1 (1,2,...N) intervals. This array can be used to evaluate how much segments are overlapping. Ideally, with segments not overlapping, only the first item of this array should be different from zero, and should be close to the total coverage. If other items of the array are different from zero, this means that portions of the zone are covered by more than one segment;
5. The cumulative coverage (cumulativeCoverage field): this is an array of size N that contains the cumulative coverage percentage. Item with index i (0,1,2,...N-1) is the percentage of zone covered by intervals 0,1,2...i+1 considered together. This output considers the order in which time segments are provided. For example, if intervals are sorted by time, this output can be used to evaluate when a target coverage percentage is reached.

The computation is performed by means of a grid of points inside the zone. The portion of these points that are within the swath gives the percentage of area covered. The precision of the computation then depends on the distance between points. Two ways of computing the points can be provided by the user via the type_coverage field:

1. XVCFI_COVERAGE_FIXED_DISTANCE: a fixed distance between points is used. The value of these distance is provided by the user (in kilometers);
3. XVCFI_COVERAGE_PERCENTAGE_PRECISION: the required percentage precision is provided by the user. The function computes internally the distance needed to achieve the requested precision. The distance is computed in a way that the area of the zone computed with the grid created with such distance is close to the expected one (computed by analytical methods) by a percentage equal or better than input percentage precision. That is, if area_zone is the zone area computed analytically and area_grid is the area of the zone computed with the grid, the accuracy percentage is defined as:
   percen_accuracy = 100. * (1- abs( (area_zone-area_grid) / area_zone) )
   The selected distance fulfills that percen_accuracy is greater or equal to input percentage precision. That means that the closer the input percentage precision to 100% the more accurate are the computations.

WARNING: The user has to be aware that requesting a small distance or a big value for precision increase the number of points to be analyzed and this has an impact on performances. The following example is presented to explain how this function operates:
A simplified representation of the input zone is given in Fig. 1: the zone is split into 10 tiles of same size. Three time intervals are provided as input, they are identified with their indexes: 0,1,2
During time interval 0, tiles 2,3,4 are covered, see Fig. 2.
During time interval 1, tiles 3,4,5,6 are covered, see. Fig. 3
During time interval 2, tiles 4,5,6,7,8 are covered, see Fig. 4.
Considering all three segments, 7 tiles of the zone (2 to 8) are covered, this corresponds to 70% of the whole zone (see Fig. 5). Therefore, if cov_out is the output variable of type ZonevisibilityCoverageOut:
cov_out.totalCoverage = 70
intervals 0,1,2 cover respectively 3,4,5 tiles corresponding to 30%, 40%, 50% of the whole zone. Therefore:
cov_out.coveragePerInterva[0] = 30
cov_out.coveragePerInterva[1] = 40
cov_out.coveragePerInterva[2] = 50
Fig. 6 details the computation of the coverageByNIntervals field. Tiles with same colors are covered by the same number of segments.
Tile 2 is covered only by interval 0. Tiles 7,8 are covered only by interval 4. Therefore tiles 2,7,8 are covered by only one interval. This corresponds to 30% of the whole zone. Therefore:
cov_out.coverage_ByNIntervals[0] = 30
Similarly tiles 3,5,6 are covered by only 2 intervals and tile 4 is covered by all 3 segments. Therefore:
cov_out.coverageByNIntervals[1] = 30
cov_out.coverageByNIntervals[2] = 10
Fig. 7 details the computation of the cumulativeCoverage field. Tiles with same color are those tiles that are covered by a segment but not but the previous ones in the list.
Item 0 is the coverage of the first segment only, that is tiles 2,3,4, i.e. 30%.
Item 1 is the cumulative coverage of the first and second segments, that is tiles 2,3,4,5,6, that is 50%.
item 2 is the cumulative coverage of the first the second and third segment, that is tiles 2,3,4,5,6,7,8 that is 70%. Therefore:
cov_out.cumulativeCoverage [0] = 30
cov_out.cumulativeCoverage [1] = 50
cov_out.cumulativeCoverage [2] = 70

Parameters:

  | input | Inputs for zone coverage computation.

Returns:
  Coverage results.