epr_api.h

Insar图像处理软件

    /**
     * The record info which describes a record of this dataset.
     */
    EPR_SRecordInfo* record_info;


    /**
     * A short description of the band's contents
     */
    char* description;
};


/**
 * The <code>EPR_DSD</code> structure contains information
 * about the propertier of a dataset properties and its location 
 * within an ENVISAT product file 
 *
 * @see epr_read_dsd
 */
struct EPR_DSD
{
    /**
     * The magic number for this structure.
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The index of this DSD (zero-based)
     */    
    int index;

    /**
     * The dataset name.
     */    
    char* ds_name;

    /**
     * The dataset type descriptor.
     */
    char* ds_type;

    /**
     * The filename in the DDDB with the description of this dataset.
     */
    char* filename;

    /**
     * The offset of dataset-information the product file.
     */
    uint ds_offset;

    /**
     * The size of dataset-information in dataset product file.
     */
    uint ds_size;

    /**
     * The number of dataset records for the given dataset name.
     */
    uint num_dsr;

    /**
     * The size of dataset record for the given dataset name.
     */
    uint dsr_size;
};


/**
 * The <code>EPR_Record</code> structure represents a 
 * record instance read from an ENVISAT dataset.
 * A record is composed of multiple fields.
 *
 * @see EPR_Field
 */
struct EPR_Record
{
    /**
     * The magic number for this structure.
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The corresponding record info for this record (a 'soft' pointer).
     */
    EPR_SRecordInfo* info;

    /**
     * The number of fields contained in this record.
     * The value is always equal <code>info->field_infos->length</code> and is
     * provided here for convenience only.
     */
    uint num_fields;

    /**
     * The record fields. An array of <code>EPR_Field*</code>
     * of length <code>info->num_fields</code>
     */
    EPR_SField** fields;
};

/**
 * Represents a field within a record. A field is composed of 
 * one or more data elements of one of the types defined in the
 * in <code>field_info</code>.
 *
 * @see EPR_Record
 */
struct EPR_Field 
{
    /**
     * The magic number for this structure. 
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The corresponding field info for this field.
     * @supplierCardinality 1
     */
    EPR_SFieldInfo* info;

    /**
     * The elements of this field.
     *
     * <p> In order to use the data, this member must be casted to one
     * of the following array data types:
     * <ol>
     *   <li><code>unsigned char*</code> - array of unsigned 8-bit integer elements</li>
     *   <li><code>char*</code> - array of signed 8-bit integer fields</li>
     *   <li><code>unsigned short*</code> - array of unsigned 16-bit integer elements</li>
     *   <li><code>short*</code> - array of signed 16-bit integer elements</li>
     *   <li><code>unsigned long*</code> - array of unsigned 32-bit integer elements</li>
     *   <li><code>long*</code> - array of signed 32-bit floating point elements</li>
     *   <li><code>float*</code> - array of signed 32-bit floating point elements</li>
     *   <li><code>double*</code> - array of signed 64-bit floating point elements</li>
     *   <li><code>EPR_STime*</code> - array of MJD elements</li>
     * </ol>
     * Dedicated access routine are available
     * The element type is given by <code>info->data_type_id</code> and the array length by
     * <code>info->num_elems</code>.
     */
    void* elems;
};

/**
 * Represents a raster in which data will be stored.
 *  
 * All 'size' parameter are in PIXEL.
 */
struct EPR_Raster 
{
    /**
     * The magic number for this structure. 
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The data type of the band's pixel values. 
     * <br>All corresponding with EPR_DataTypeId types are possible
     */
    EPR_EDataTypeId data_type;

    /**
     * The width of the source .
     */
    ulong source_width;

     /**
     * The height of the source. 
     */
    ulong source_height;

     /**
     * The sub-sampling for the across-track direction in pixel. 
     */
    ulong source_step_x;

     /**
     * The sub-sampling for the along-track direction in pixel.
     */
    ulong source_step_y;

     /**
     * The width of the raster in pixel. 
     * <br>raster_width  = (source_width  - 1) / source_step_x + 1
     */
    ulong raster_width;

     /**
     * The height of the raster in pixel. 
     * <br>raster_height = (source_height - 1) / source_step_y + 1
     */
    ulong raster_height;

     /**
     * The elements of this raster. 
     * <br>Its volume is <b>raster_width * raster_height * sizeof(data_type) in bytes</b>.
     */
    void* buffer;
};


/**
 * The <code>EPR_DatasetRef</code> structure represents the information from <code>dddb</code>
 * <br>with the reference to data name (in dddb), field-name and index
 * of the element in field-array, in which (by name) searchable values are located.
 * Example for the search for a scaling_offset information:
 * This information for the <code>reflec_10</code> is described with the <code>Scaling_Factor_GADS.22.10</code>
 * In <code>dataset_id</code> the searched ENVISAT product name (e.g. <code>MER_RR__2P</code>) is located.
 * <br>In the corresponding file (e.g. <code>/product/MER_RR__2P.dd</code>) the path, 
 * how to find that information will be decribed.
 * In that file, in the field number <code>22</code> there is an information about the location 
 * of the searched value in the ENVISAT product data.
 *
 * @see EPR_SDatasetId
 */
struct EPR_DatasetRef
{
    EPR_SDatasetId* dataset_id;
    int             field_index; /* -1 if not used */
    int             elem_index;  /* -1 if not used */
};

/**
 * Represents a flag-field within a flag-record.
 * 
 */
struct EPR_FlagDef 
{
    /**
     * The magic number for this structure. 
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The flag name.
     */
    char* name;

     /**
     * The bit number, where this flag can appear.
     */
    uint bit_index;

     /**
     * The flag description.
     */
    char* description;
};


/**
 * The <code>EPR_BandId</code> structure contains information
 * about a band within an ENVISAT product file which has been opened with the
 * <code>epr_open_product()</code> API function.
 *
 * A new <code>EPR_BandId</code> instance can be obtained with the
 * <code>epr_get_band_id()</code> API function.
 * 
 * @see epr_open_product
 * @see epr_get_band_id
 */
struct EPR_BandId
{
    /**
     * The magic number for this structure. 
     * IMPORTANT: This must always be the first member of this structure.
     */
    EPR_Magic magic;

    /**
     * The ID of the product to which this band belongs to.
     */
    EPR_SProductId* product_id;

    /**
     * The name as presented to the user in a band selection dialog
     * (also known as spectral subset)
     */
    char* band_name;

    /**
     * The (zero-based) spectral band index. -1 if this is not a spectral band.
     */
    int spectr_band_index;

    /**
     * The reference of the source dataset containing the raw data used to
     * create the band's pixel values. The external format used in the DDDB 
     * is <MDS-name>.<field>, where <field> is a one-based index (field=1 
     * corresponds to the first field)
     */
     EPR_SDatasetRef dataset_ref; 

    /**
     * The sample model operation applied to the source dataset for getting the
     * correct samples from the MDS (e.g. MERIS L2). Possible values are
     * *  --> no operation (direct copy)
     * 1OF2  --> first byte of 2-byte interleaved MDS
     * 2OF2  --> second byte of 2-byte interleaved MDS
     * 0123  --> combine 3-bytes interleaved to 4-byte integer
     */
     EPR_ESampleModel sample_model; 

    /**
     * The data type of the band's pixel values. Possible values are:
     * <p><ld>
     * <li>*     --> the datatype remains unchanged.</li>
     * UChar  --> 8-bit unsigned integer
     * ULong  --> 32-bit unsigned integer
     * Float  --> 32-bit IEEE floating point
     * </ld>
     */
     EPR_EDataTypeId data_type;

    /**
     * The scaling method which must be applied to the raw source data in order
     * to get the 'real' pixel values in geo-physical units. Possible values are:
     * *            --> no scaling applied
     * Linear_Scale --> linear scaling applied: y = offset + scale * x
     * Log_Scale    --> logarithmic scaling applied: y = log10(offset + scale * x)
     */
     EPR_EScalingMethod scaling_method; 

    /**
     * The scaling offset. Possible values are:
     * *            --> no offset provided (implies scaling_method=*)
     * <const.>     --> a floating point constant
     * <GADS>.<field>[.<field2>]
     *              --> value is provided in global annotation dataset with name
     *                  <GADS> in field <field>. Optionally a second element index
     *                  for multiple-element fields can be given too
     */
     float scaling_offset;

    /**
     * The scaling factor. Possible values are:
     * *            --> no factor provided (implies scaling_method=*)
     * const.       --> a floating point constant
     * <GADS>.<field>[.<field2>]
     *              --> value is provided in global annotation dataset with name
     *                  <GADS> in field <field>. Optionally a second element index
     *                  for multiple-element fields can be given too
     */
     float scaling_factor;

    /**
     * A bit-mask expression used to filter valid pixels. All others are set to zero.
     */
     char* bm_expr;

    /**
     * The flag coding is a list of EPR_SFlag instances. It determines each of the flags 
     * used in this band (= flags dataset).
     * Each flag has a name, a bit-index and a description.
     */
    EPR_SPtrArray* flag_coding; 

    /**