E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeCoverage.h

Go to the documentation of this file.

/************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright © 2001-2007 INPE and Tecgraf/PUC-Rio.

This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

You should have received a copy of the GNU Lesser General Public
License along with this library.

The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
#ifndef  __TERRALIB_INTERNAL_COVERAGE_H
#define  __TERRALIB_INTERNAL_COVERAGE_H

#include "TeGeometry.h"
#include "TeDataTypes.h"
#include "TeCoverageParams.h"
#include "TeCoverageDecoder.h"
#include "TeCoverageDecoderCacheLRU.h"
#include "TeCoverageDecoderDatabase.h"
#include "TeCoverageInterpolator.h"
#include "TeCoverageInterpolatorNN.h"
#include <vector>

template <class T>
class TeCoverage : public TeGeometry
{
public:


    TeCoverage(TeCoverageParams& params, TeCoverageInterpolator<T>* interpolator = NULL) :
        params_(params),
        interpolator_(interpolator),
        decoder_(NULL)
    {
    }


    virtual ~TeCoverage()
    {
        clear();
    }


    virtual void init()
    {
        // Initialize decoder according to persistence type
        if (!decoder_)
        {
            if (params_.getPersistenceType() == TePERSISTENCE_DATABASE)
            {
                decoder_ = new TeCoverageDecoderDatabase<T>(params_);
                decoder_->init();
            }
            else if (params_.getPersistenceType() == TePERSISTENCE_DATABASE_CACHELRU)
            {
                decoder_ = new TeCoverageDecoderCacheLRU<T>(params_);
                decoder_->init();
            }
        }

        // Initialize interpolator
        if (!interpolator_)
        {
            // If undefined, create default interpolator
            interpolator_ = createDefaultInterpolator();
        }
        interpolator_->setDecoder(decoder_);

        // Set box according to params
        setBox(params_.getBoundingBox());
    }


    virtual void clear()
    {
        if (decoder_)
        {
            delete(decoder_);
            decoder_ = NULL;
        }
        if (interpolator_)
        {
            delete(interpolator_);
            interpolator_ = NULL;
        }
    }


    TeGeomRep elemType()
    {
        return TeCOVERAGE;
    }


    TeCoverageParams& getParameters()
    {
        return params_;
    }

    class iterator
    {
        typedef typename std::vector<TeGeomValuePair<T> >::iterator geom_it;
    public:

        iterator(geom_it it) :
            it_(it)
        {
        }
          
        virtual ~iterator()
        {
        }

        iterator operator++()
        {
            it_++;
            return *this;
        }
    
        iterator operator++(int)
        {
            iterator temp = *this;
            ++it_;
            return temp;
        }


        T operator*()
        {
            return it_->geom;
        }


        T* operator->()
        {
            return &(it_->geom);
        }
        

        double operator[](int dimension)
        {
            return it_->value[dimension];
        }
        
        bool operator==(const iterator& rhs)
        {
            return it_ == rhs.it_;
        }

        bool operator!=(const iterator& rhs)
        {
            return it_ != rhs.it_;
        }

    protected:
        geom_it it_; 
    };   

    // ---------------------  End of class TeCoverage::iterator


    typename TeCoverage<T>::iterator begin(
            TePolygon& poly = TePolygon(),
            TeSpatialRelation relation = TeINTERSECTS)
    {
        std::vector<TeGeomValuePair<T> >& selected = selectGeomValuePairs(poly, relation);
        TeCoverage<T>::iterator beginIt = TeCoverage<T>::iterator(selected.begin());
        return beginIt;
    }


    typename TeCoverage<T>::iterator end(
            TePolygon& poly = TePolygon(),
            TeSpatialRelation relation = TeINTERSECTS)
    {
        std::vector<TeGeomValuePair<T> >& selected = selectGeomValuePairs(poly, relation);
        TeCoverage<T>::iterator endIt = TeCoverage<T>::iterator(selected.end());
        return endIt;
    }


    void evaluate(const TeCoord2D& location, std::vector<double>& value)
    {
        interpolator_->evaluate(location, value);
    }


    void evaluate(TeRaster& raster, const int rasterBand, const int coverageDimension, const TeBox& box = TeBox())
    {
        interpolator_->evaluate(raster, rasterBand, coverageDimension, box);
    }

protected:

    TeCoverageParams& params_; 
    TeCoverageDecoder<T>* decoder_; 
    TeCoverageInterpolator<T>* interpolator_; 


    TeCoverageInterpolator<T>* createDefaultInterpolator()
    {
        // Default Coverage interpolator is nearest neighbour
        return new TeCoverageInterpolatorNN<T>();
    }


    std::vector<TeGeomValuePair<T> >& selectGeomValuePairs(const TePolygon& poly, const TeSpatialRelation relation)
    {
        std::vector<TeGeomValuePair<T> >& selected = lastSelectionResult_;

        // Search decoder only if the selection is different from the last one
        if ((!TeEquals(lastSelectionPolygon_, poly)) || lastSelectionRelation_ != relation)
        {
            decoder_->selectGeomValuePairs(poly, relation, selected);

            // Save selection parameters and result
            lastSelectionPolygon_ = poly;
            lastSelectionRelation_ = relation;
            lastSelectionResult_ = selected;
        }
        return selected;
    }

private:

    TePolygon lastSelectionPolygon_; 
    TeSpatialRelation lastSelectionRelation_; 
    std::vector<TeGeomValuePair<T> > lastSelectionResult_; 
};


#endif // __TERRALIB_INTERNAL_COVERAGE_H