| Earth Observation Mission CFI Software Visibility Software User Manual |

Public Member Functions | Protected 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) throw (CfiError)
| Copy constructor.
| SwathId (SwathId &swathIdIn)
| Copy constructor.
| ~SwathId () throw (CfiError)
| Class destructor.
SwathIdData | getData ()
| Get swath data.
void | setData (SwathIdData &swathInfo)
| Set swath data.
void | operator= (const SwathId &swathIdIn)
| Copy operator.
ZoneCoverageOut | zoneVisTimeCoverage (ZoneCoverageIn &input) throw (CfiError)
| The zoneVisTimeCoverage method computes the portion of the input zone that is covered by the input satellite in input time visibility segments.
## Protected Member Functions
GenericId * | getId ()
| Get the id.
void | eraseObject () throw (CfiError)
| Close swath id of object.

## Detailed Description

Class that stores the Swath data.

## Constructor & Destructor Documentation

EECFI::SwathId::SwathId | ( | AtmosId & | atmosIdIn,
|  | SwathInfo & | swathInfo |
| ) |  |  | throw (CfiError)

Copy constructor.

Parameters:

  | atmosIdIn | Atmos id.
  | swathInfo | Swath data.

EECFI::SwathId::SwathId | ( | SwathId & | swathIdIn | ) |

Copy constructor.

EECFI::SwathId::~SwathId | ( |  | ) | throw (CfiError)

Class destructor.

References eraseObject().

## Member Function Documentation

void EECFI::SwathId::eraseObject | ( |  | ) | throw (CfiError)`[protected]`

Close swath id of object.

References EECFI::CfiId::status(), EECFI::CfiId::subtractInstance(), and EECFI::CfiClass::throwWarn.

Referenced by operator=(), and ~SwathId().

SwathIdData EECFI::SwathId::getData | ( |  | ) |

Get swath data.

Returns:
  Swath id data.

GenericId * SwathId::getId | ( |  | ) | `[protected]`

Get the id.

Returns:
  xl_time_id.

void EECFI::SwathId::operator= | ( | const SwathId & | swathIdIn | ) |

Copy operator.

Parameters:

  | swathIdIn | SwathId we want to copy.

References EECFI::CfiId::addInstance(), and eraseObject().

void EECFI::SwathId::setData | ( | SwathIdData & | swathInfo | ) |

Set swath data.

Parameters:

  | swathInfo | Swath id data.

References EECFI::SwathIdData::filename, EECFI::SwathIdData::nofRegenOrbits, EECFI::SwathIdData::orbitRef, EECFI::SwathIdData::sdfFile, EECFI::SwathIdData::stfFile, EECFI::SwathIdData::type, EECFI::SwathIdData::valOrbitStart, and EECFI::SwathIdData::valOrbitStop.

ZoneCoverageOut EECFI::SwathId::zoneVisTimeCoverage | ( | ZoneCoverageIn & | input | ) | throw (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 function 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 structure 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 visibilityIntervalList, N is the number of elements in visibilityIntervalList 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 a vector 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 a vector 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 a vector 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.

References EECFI::ZoneCoverageOut::coverageByNIntervals, EECFI::ZoneCoverageOut::coveragePerInterval, EECFI::ZoneCoverageOut::cumulativeCoverage, EECFI::ZoneCoverageOut::totalCoverage, and EECFI::ZoneCoverageOut::zoneArea.