nedgrid.h

Go to the documentation of this file.

/*
 * $Id: nedgrid.h 18278 2014-11-25 01:42:10Z ksimek $
 */

#ifndef NEDGRID_H_UOFARIZONA_VISION
#define NEDGRID_H_UOFARIZONA_VISION

#include <l_cpp/l_exception.h>
#include <m_cpp/m_matrix.h>
#include <topo_cpp/layer.h>
#include <string>
#include <deque>
#include <vector>
#include <algorithm>
#include <utility>

#include <boost/scoped_ptr.hpp>

namespace kjb
{


extern const int NED_ELLIPSOID;



class Ned13_one_degree_grid
{
public:
    typedef std::vector<std::string> Path; 

    struct IntegralLL;

    Ned13_one_degree_grid(const IntegralLL& ill, const Path& path);

    Ned13_one_degree_grid(int, int, const Path&);

#if 0
    void display(const std::string&, int) const;
#endif

    bool is_in_bounds(const IntegralLL&) const;

    float elevation_meters(const IntegralLL&) const;

    float maximum_elevation() const
    {
        return max_and_min_elevations().first;
    }

    float minimum_elevation() const
    {
        return max_and_min_elevations().second;
    }

    std::pair<float, float> max_and_min_elevations() const;

    void swap(Ned13_one_degree_grid&);

    IntegralLL northwest_corner() const;

    IntegralLL southeast_corner() const;

private:
    boost::scoped_ptr< IntegralLL > nw_corner;

    std::deque< float > elevation;

    void grid_rc(const IntegralLL&, int*, int*) const;

    bool grid_inbounds(int, int) const;

    // teasers:  this object is not copyable or assignable (swappable, though)
    Ned13_one_degree_grid(const Ned13_one_degree_grid&);
    Ned13_one_degree_grid& operator=(const Ned13_one_degree_grid&);
};



struct Ned13_one_degree_grid::IntegralLL
{
    int     ilat,   
            ilon;   

    double dd_latitude() const;

    double dd_longitude() const;

    // named ctor constructs from float n latitude, e longitude degrees,
    static IntegralLL from_lat_lon(double, double);

    // named ctor constructs from integer n latitude, e longitude degrees
    static IntegralLL from_lat_lon(int, int);

private:
    IntegralLL(int, int);
};

double delta_e_meters(const Ned13_one_degree_grid::IntegralLL&);

double delta_n_meters(const Ned13_one_degree_grid::IntegralLL&);

std::pair<double, double> delta_n_e_meters(
    const Ned13_one_degree_grid::IntegralLL&
);

TopoFusion::pt ned13_ill_to_utm(const Ned13_one_degree_grid::IntegralLL&);


Ned13_one_degree_grid::IntegralLL utm_to_se_ned13_ill(const TopoFusion::pt&);


inline bool operator==(
    const Ned13_one_degree_grid::IntegralLL& p,
    const Ned13_one_degree_grid::IntegralLL& q
)
{
    return p.ilat == q.ilat && p.ilon == q.ilon;
}


inline bool operator<(
    const kjb::Ned13_one_degree_grid::IntegralLL& p,
    const kjb::Ned13_one_degree_grid::IntegralLL& q
)
{
    return p.ilat == q.ilat ? p.ilon < q.ilon : p.ilat < q.ilat;
}


Ned13_one_degree_grid::IntegralLL round_nw_to_whole_degrees(
    const Ned13_one_degree_grid::IntegralLL&
);



class Ned13_grid_cache
{
    std::vector< Ned13_one_degree_grid* > m_grids;
    Ned13_one_degree_grid* most_recent;
    const std::vector< std::string > m_path;

    void discard_cache();

    // teasers
    Ned13_grid_cache(const Ned13_grid_cache&); // not copyable
    Ned13_grid_cache& operator=(const Ned13_grid_cache&); // not assignable

public:
    Ned13_grid_cache(
        const std::vector< std::string >& path = std::vector<std::string>()
    )
    :   most_recent(00),
        m_path(path.begin(), path.end())
    {}

    virtual ~Ned13_grid_cache()
    {
        discard_cache();
    }

    const Ned13_one_degree_grid& fetch(
        const Ned13_one_degree_grid::IntegralLL&
    );

    const Ned13_one_degree_grid& fetch(double, double);

    const Ned13_one_degree_grid& fetch(const TopoFusion::pt& p)
    {
        return fetch(round_nw_to_whole_degrees(utm_to_se_ned13_ill(p)));
    }

    size_t cache_size() const
    {
        return m_grids.size();
    }
};


struct Ned13_caching_reader
{
    Ned13_caching_reader(
        const std::vector< std::string >& path = std::vector<std::string>()
    )
    :   cache(path)
    {}

    virtual float elevation_meters(const TopoFusion::pt&) = 0;

    virtual ~Ned13_caching_reader() {}

    Ned13_grid_cache cache;
};


struct Ned13_nearest_se_neighbor_reader
:   public Ned13_caching_reader
{
    float elevation_meters(const TopoFusion::pt&);

    Ned13_nearest_se_neighbor_reader(
        const std::vector< std::string >& path = std::vector<std::string>()
    )
    :   Ned13_caching_reader(path)
    {}
};


struct Ned13_bilinear_reader
:   public Ned13_caching_reader
{
    float elevation_meters(const TopoFusion::pt&);

    Ned13_bilinear_reader(
        const std::vector< std::string >& path = std::vector<std::string>()
    )
    :   Ned13_caching_reader(path)
    {}
};


struct Ned13_gp_reader
:   public Ned13_caching_reader
{
    float elevation_meters(const TopoFusion::pt&);

    Ned13_gp_reader(
        const std::vector< std::string >& path = std::vector<std::string>()
    )
    :   Ned13_caching_reader(path)
    {}

    static float characteristic_length_squared() { return 500; }
};


int ned13_grid(
    const TopoFusion::pt& center,
    Matrix *elev_o,
    Matrix *elev_de_o,
    Matrix *elev_dn_o,
    int eastwest_size_meters = 2000,
    int northsouth_size_meters = 2000,
    int resolution_meters = 1,
    Ned13_caching_reader *cache = 0,
    const std::vector< std::string > &path = std::vector< std::string >()
);



inline
Matrix ned13_grid(
    const TopoFusion::pt& center,
    int eastwest_size_meters = 2000,
    int northsouth_size_meters = 2000,
    int resolution_meters = 1,
    Ned13_caching_reader *cache = 0,
    const std::vector< std::string > &path = std::vector< std::string >()
)
{
    Matrix e;
    ETX(ned13_grid(center, &e, 0, 0, eastwest_size_meters,
                    northsouth_size_meters, resolution_meters, cache, path));
    return e;
}


TopoFusion::pt dem_to_doq_displacement(const TopoFusion::pt&);


void set_spy_filename(const std::string&);

TopoFusion::pt force_zone_to_this(const TopoFusion::pt&, char use_this_zone);

}


namespace std
{

//template<> // <-- overloading is preferred to template specialization in this context.
//                  (also, this doesn't compile in c++11)
inline void swap(kjb::Ned13_one_degree_grid &p, kjb::Ned13_one_degree_grid &q)
{
    p.swap(q);
}

}

#endif /* NEDGRID_H_UOFARIZONA_VISION */