/home/pascal/depot/filedata/src/pmfiledata.h

/***************************************************************************
 *   Copyright (C) 2010 by Nicolas PASCAL   *
 *   nicolas.pascal@icare.univ-lille1.fr   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef PMFILEDATA_H
#define PMFILEDATA_H

#include "hdffiledata.h"
#include "pixel.h"
#include "satellitefiledata.h"

class PMFileData : public SatelliteFileData, public HDFFileData {
    static const float colocation_tolerance;

    /***** constants *****/
    static const string latitude_name;
    static const string longitude_name;
    static const int16 sz_grid_y;
    static const int16 sz_grid_x;

    /***** Product characteristics *****/
    string product;
    string version;
    int lat_lon_index_max [2];
    int orbit_nb;
    int16 * irow_shift_data;
    float32 node_lon;

    void init();
    void set_time_coverage();
    void parse_filename ( const string & short_filename );
    static bool check_filename(const string & short_filename);
    void set_lat_lon_index_max();

public:
    PMFileData(const string &name, const string &mode="r");
    ~PMFileData();
    void load_geolocation_data();
    void free_geolocation_data();

    const bool contain_location(const float &lat,const float &lon, const double &tolerance=0.01);
    const bool contain_data(const float &lat, const float &lon, const double &time, const double &colocation_tolerance=0.01) ;
    const float get_nearest_point_distance ( const float &lat, const float &lon,
                                             const float coloc_tolerance = PMFileData::colocation_tolerance ) {
        UnimplementedMethod e(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        throw e;
    };
    string get_product () const { return product; }
    string get_version () const { return version; }
     const bool get_index(const float &lat, const float& lon, int igrid [2], const float colocation_tolerance=0.01);
     const bool get_index(const float &lat, const float& lon, int &idata, const float colocation_tolerance=0.01);
     virtual void get_vindex(vector < vector < int > > &v_index, const float &lat, const float& lon,
                                            const float colocation_tolerance=0.01 ) {
        UnimplementedMethod e(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        throw e;
     };

    const int get_nb_geo_points() {
        return ( PMFileData::sz_grid_y * PMFileData::sz_grid_x ) ;
    }
    virtual void load_v_pixel() {;};
    virtual void close_data_file() {
        free_hdf_file();
    };
    virtual void open_data_file() {
        load_hdf_file();
    };
    virtual void get_pixel_coord ( const vector < int > & ipix, float &lat, float &lon, double &time ) {
        float lat_minmax [2];
        float lon_minmax [2];
        int   igrid [2];
        copy ( ipix.begin(), ipix.end(), igrid );
        grid_to_geolocation ( igrid, lat_minmax, lon_minmax );
        lat = -9999.;
        if ( lat_minmax [0] != -9999. && lat_minmax [1] != -9999. )
            lat = ( lat_minmax [0] + lat_minmax [1] ) / 2.;
        lon = -9999.;
        if ( lon_minmax [0] != -9999. && lon_minmax [1] != -9999. )
            lon = ( lon_minmax [0] + lon_minmax [1] ) / 2.;
        time = -9999.;
    };
    int get_orbit_nb() const {
        return orbit_nb;
    }

    void geolocation_to_grid ( const float * lat_lon, int * igrid );
    inline void geolocation_to_grid ( const float &lat, const float &lon, int * igrid ) {
        float lat_lon [] = { lat, lon };
        geolocation_to_grid ( lat_lon, igrid );
    };

    void grid_to_geolocation ( const int* igrid, float* lat_minmax, float* lon_minmax = NULL );

    const int16* get_irow_shift_data() const {
        return irow_shift_data;
    }

    float32 get_node_lon() const {
        return node_lon;
    }

    void read_node_lon ();
    const bool is_geolocation_data_loaded() const {
        return ( lat_data != NULL && lon_data != NULL );
    };

    static const int16 get_sz_grid_y() {
        return sz_grid_y;
    }

    static const int16 get_sz_grid_x() {
        return sz_grid_x;
    }

};

#endif