dorthoquad.h

Go to the documentation of this file.

/*
 * $Id: dorthoquad.h 15331 2013-09-16 08:33:56Z predoehl $
 */

#ifndef DORTHOQUAD_H_UOFARIZONAVISION
#define DORTHOQUAD_H_UOFARIZONAVISION

#include <i_cpp/i_image.h>
#include <l_cpp/l_int_matrix.h>
#include <l_cpp/l_stdio_wrap.h>
#include <topo/master.h>
#include <topo_cpp/layer.h>

#include <vector>
#include <boost/scoped_ptr.hpp>


namespace kjb
{
namespace TopoFusion
{


extern const char* IVILAB_DOQ_TILE_CACHE_DIRECTORY;


class Tile_manager
{
    boost::scoped_ptr< Temporary_Recursively_Removing_Directory > td;

    // singleton-enforcement:  you can instantiate this class at most once.
    static bool m_instantiated;

    bool m_temp_cache;

    // Not copyable, not assignable
    Tile_manager& operator=(const Tile_manager&); // teaser
    Tile_manager(const Tile_manager&); // teaser

public:
    Tile_manager(const char* dir = IVILAB_DOQ_TILE_CACHE_DIRECTORY);

    ~Tile_manager();

    bool is_using_a_temporary_cache() const
    {
        return m_temp_cache;
    }

    static bool is_already_instantiated_elsewhere()
    {
        return m_instantiated;
    }
};



class DOrthoQuad
{

public:
    typedef unsigned char Pixel;    

private:

    struct Loc
    {
        enum { UNUSED = -1 };
        long    left,   
                top;    
        char    zone;   

        Loc()
        :   left( UNUSED )
        {}

        Loc( long l, long t, char z )
        :   left( l ),
            top( t ),
            zone( z )
        {}

        bool is_unused() const
        {
            return UNUSED == left;
        }

        bool operator==( const Loc& that ) const
        {
            return left == that.left && top == that.top && zone == that.zone;
        }

        static Loc tile_nw_from_utm_center(
            const pt& center, 
            int tilesize_m,   
            int numtiles      
        )
        {
            return Loc(
                static_cast< long >( center.x / tilesize_m - numtiles ),
                static_cast< long >( center.y / tilesize_m + numtiles ),
                center.zone
            );
        }
    };

    Loc m_current; 

    char m_tileset_code;

    Image m_doq; 

    int num_tile_buf() const;

    int fillDoq( const Loc&, int );

    void clearCache( const Loc&, int );

public:

    int num_tiles_to_cover( int ) const;

    DOrthoQuad( unsigned edge_length_pix = 0 );


    int fill( const pt& );

    int refill( const pt& );


    char select_tileset(char);



    long left() const;

    long top() const;

    char zone() const
    {
        return m_current.zone;
    }


    size_t width() const;

    size_t height() const;

    bool isReady() const
    {
        return ! m_current.is_unused();
    }

    int as_matrix( Int_matrix* ) const;

    kjb_c::Pixel read_color( unsigned, unsigned ) const;

    kjb_c::Pixel read_abs_color( long, long ) const;

    Pixel read( unsigned, unsigned ) const;

    Pixel read_abs( long, long ) const;

    Pixel read_abs( const pt& ) const;

    pt center() const
    {
        return make_pt(left()+width()/2, top()-height()/2, m_current.zone);
    }

    const kjb::Image& debug_access_internal_image_buffer() const
    {
        return m_doq;
    }

    float meters_per_pixel() const;

};


Int_matrix get_aerial_image(const pt&, size_t, size_t);

Image get_topographic_map_detail(const pt&, size_t, size_t);


} // end namespace TopoFusion
} // end namespace kjb

#endif