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

/***************************************************************************
 *   Copyright (C) 2005 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 SATELLITEFILEDATA_H
#define SATELLITEFILEDATA_H

#include "filedata.h"
#include "pixel.h"
#include "geometry.h"
#include "viewing_geometry.h"
#include "observation.h"
#include <map>

class SatelliteFileData : virtual public FileData {
protected:
    // define types for coincident pixels search
    typedef P_Pixel_base<float, vector <int> > PixelType;
    typedef vector<PixelType>::iterator I_Pixel;

    /***** Geolocation buffers *****/
    float *lat_data;
    float *lon_data;
    double *time_data;
    vector< PixelType > v_pixel;
    typedef vector <int> PixelIndice;
    std::map <PixelIndice, Carthesian::Segment3D> viewing_directions;
    typedef vector <int> DataIndice;
    std::map <PixelIndice, DataIndice> ipix2idata;

public:
    SatelliteFileData(const string &name, const string &mode/*= "r"*/) : FileData(name,mode) {
        lat_data  = NULL;
        lon_data  = NULL;
        time_data = NULL;
    };
    virtual ~SatelliteFileData();

    virtual const bool contain_data(const float &lat,const float &lon, const double &time, const double &tolerance)=0;

     virtual const bool contain_location(const float &lat,const float &lon, const double &tolerance)=0 ;

     virtual const bool get_index(const float &lat, const float& lon, int &nearest_pix_idx, const float colocation_tolerance)=0;

     virtual void get_vindex(vector < vector < int > > &v_index, const float &lat, const float& lon, const float colocation_tolerance) = 0;

     virtual const float get_nearest_point_distance(const float &lat, const float &lon, const float coloc_tolerance)=0;
    virtual void load_geolocation_data()=0;
    virtual void free_geolocation_data();
    virtual const bool is_geolocation_data_loaded() const;

    virtual void close_data_file()=0;

    virtual void open_data_file()=0;
    virtual void load_v_pixel() = 0;
    virtual void free_v_pixel();
    virtual const vector< PixelType > & get_v_pixel() const {
        return v_pixel;
    }
    virtual void get_pixel_coord ( const vector < int > & ipix, float &lat, float &lon, double &time ) = 0;
    float* get_lat_data() const {
        return lat_data;
    }
    float* get_lon_data() const {
        return lon_data;
    }
    double* get_time_data() const {
        return time_data;
    }
//     virtual void load_viewing_directions () {
//         UnimplementedMethod e(__FILE__,__LINE__,__PRETTY_FUNCTION__);
//         throw e;
//     };
//     virtual void free_viewing_directions ();
//     void print_viewing_directions ();
    virtual void load_pix2data_map () {
        UnimplementedMethod e(__FILE__,__LINE__,__PRETTY_FUNCTION__);
        throw e;
    };
    void print_pix2data_map ();
    void free_pix2data_map ();
//     const std::map< PixelIndice, Carthesian::Segment3D > & get_viewing_directions() const {
//         return viewing_directions;
//     }
//     const Carthesian::Segment3D & get_viewing_direction(const PixelIndice & ipix) {
//         return viewing_directions[ipix];
//     }
    virtual void get_viewing_directions (const vector <int> & ipix, vector <Observation> & v_obs){v_obs.clear();};
    virtual bool is_viewing_directions_data_loaded() {return false;};
    virtual void load_viewing_directions_data () {;};
    virtual void free_viewing_directions_data () {;};
};

#endif