E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeComputeAttributeStrategies.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 TeComputeAttrStrategies_H
#define TeComputeAttrStrategies_H

#include "TeAttribute.h"
#include "TeBox.h"
#include "TeUtils.h"
#include "TeNetwork.h"
#include "TeKdTree.h"
#include "TeLayer.h"

typedef TeSAM::TeAdaptativeKdTreeNode<TeCoord2D, vector<TePoint>, TePoint> KDNODE;
typedef TeSAM::TeAdaptativeKdTree<KDNODE> KDTREE;

class TeTheme;
class TeRaster;
class TeQuerier;


template<class Iterator>
class TeComputeAttrStrategy  
{
           public:
                      TeProperty  defaultValue () { return defaultValue_; }

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator /*first*/, Iterator /*last*/, const string& /*columnName*/)
                      {
                                 vector<TeProperty> result;
                                 result.push_back (defaultValue_);
                                 return result;
                      }

                      virtual ~TeComputeAttrStrategy(){}

                      bool ComputeAttrIsDummy(double value, double dummy)
                      {
                                 return (ABS(value - dummy) < 0.001);
                      }


           protected:
                      TeComputeAttrStrategy () {};

                      TeProperty defaultValue_;
};


template<class Iterator>
class TeAverageStrategy: public TeComputeAttrStrategy<Iterator>  
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TeAverageStrategy (double dummyV = 0.0, double defaultV = 0.0) {this->defaultValue_.value_ = Te2String (defaultV); dummy = dummyV; }

                      virtual ~TeAverageStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 double     tot_val = 0.0;
                                 int                   num = 0;

                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if( !ComputeAttrIsDummy((*it), dummy) )
                                            {
                                                       tot_val += (*it);
                                                       num++;
                                            }
                                            ++it;
                                 }
           
                                 TeProperty  prop;
                                 prop.attr_.rep_.name_ = columnName;
                                 prop.attr_.rep_.type_ = TeREAL;
                                 prop.attr_.rep_.numChar_ = 48;
                                 if (num > 0)
                                 {
                                            double val = tot_val/num;
                                            prop.value_ = Te2String (val);
                                 }
                                 else prop.value_ = this->defaultValue_.value_;
           
                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }
           private:
                      double dummy;
};


template<class Iterator>
class TeSTDevStrategy: public TeComputeAttrStrategy<Iterator>  
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TeSTDevStrategy (double dummyV = 0.0, double defaultV = 0.0) {this->defaultValue_.value_ = Te2String (defaultV); dummy = dummyV; }

                      virtual ~TeSTDevStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 double tot_val = 0.0;
                                 double stdev = 0.0;
                                 int           num = 0;
                                 
                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if( !ComputeAttrIsDummy((*it), dummy) )
                                            {
                                                       tot_val += (*it);
                                                       num++;
                                            }
                                            ++it;
                                 }
                                 if(num > 0)
                                 {
                                            double mean = tot_val / num;
                                            it = first;
                                            while (it != last)
                                            {
                                                       if( !ComputeAttrIsDummy((*it), dummy) ) stdev += pow((*it) - mean, 2);

                                                       ++it;
                                            }
                                            stdev = stdev / num;
                                            stdev = sqrt(stdev);
                                 }

                                 TeProperty  prop;
                                 prop.attr_.rep_.name_ = columnName;
                                 prop.attr_.rep_.type_ = TeREAL;
                                 prop.attr_.rep_.numChar_ = 48;

                                 if (num > 0) prop.value_ = Te2String (stdev);
                                 else         prop.value_ = this->defaultValue_.value_;
           
                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }          
           private:
                      double dummy;
};


template<class Iterator>
class TeSumStrategy: public TeComputeAttrStrategy<Iterator>   
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TeSumStrategy (double dummyV = 0.0, double defaultV = 0.0) {this->defaultValue_.value_ = Te2String (defaultV); dummy = dummyV; }

                      virtual ~TeSumStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {  
                                 double sum = 0.0;
                                 Iterator it = first;
                                 bool found = false;
                                 while (it != last)
                                 {
                                            if( !ComputeAttrIsDummy((*it), dummy) )
                                            {
                                                       sum += (*it);
                                                       found = true;
                                            }
                                            ++it;
                                 }

                                 TeProperty  prop;

                                 if (first == last || !found) prop = this->defaultValue_;
                                 else  prop.value_ = Te2String (sum);

                                 prop.attr_.rep_.name_ = columnName;
                                 prop.attr_.rep_.type_ = TeREAL;
                                 prop.attr_.rep_.numChar_ = 48;
                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }
           private:
                      double dummy;
};


template<class Iterator>
class TeMinimumStrategy: public TeComputeAttrStrategy<Iterator>   
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TeMinimumStrategy (double dummyV = 0.0, double defaultV = 0.0) {this->defaultValue_.value_ = Te2String (defaultV); dummy = dummyV; }

                      virtual ~TeMinimumStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 double min = TeMAXFLOAT;
                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if( !ComputeAttrIsDummy((*it), dummy) )
                                            {
                                                       double val = (*it);
                                                       if (val < min) min = val;
                                            }
                                            ++it;
                                 }

                                 TeProperty  prop;
                                 prop.attr_.rep_.name_ = columnName;
                                 prop.attr_.rep_.type_ = TeREAL;
                                 prop.attr_.rep_.numChar_ = 48;

                                 if (first == last || min == TeMAXFLOAT)
                                            prop.value_ = this->defaultValue_.value_; 
                                 else  
                                            prop.value_ = Te2String (min);

                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }
           private:
                      double dummy;
};


template<class Iterator>
class TeMaximumStrategy: public TeComputeAttrStrategy<Iterator>   
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TeMaximumStrategy (double dummyV = 0.0, double defaultV = 0.0) {this->defaultValue_.value_ = Te2String (defaultV); dummy = dummyV; }

                      virtual ~TeMaximumStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 double     max =  TeMINFLOAT;
                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if( !ComputeAttrIsDummy((*it), dummy) )
                                            {
                                                       double val = (*it);
                                                       if (val > max) max = val;
                                            }
                                            ++it;
                                 }

                                 TeProperty  prop;
                                 prop.attr_.rep_.name_ = columnName;
                                 prop.attr_.rep_.type_ = TeREAL;
                                 prop.attr_.rep_.numChar_ = 48;

                                 if (first == last || max == TeMINFLOAT)
                                            prop.value_ = this->defaultValue_.value_; 
                                 else  
                                            prop.value_ = Te2String (max);

                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }
           private:
                      double dummy;
};


template<class Iterator>
class TeCategoryPercentageStrategy: public TeComputeAttrStrategy<Iterator>   
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                                 \param classes                              classes for regrouping the values           
                      */         
                      TeCategoryPercentageStrategy (map<string, string>& classes, double defaultValue = 0.0) 
                      {
                                 this->defaultValue_.value_ = Te2String (defaultValue); 
                                 classesMap_ = classes;
                                 usingMap = true;
                      }

                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                                 \param dummyV                               the ignored value
                      */         

                      TeCategoryPercentageStrategy(double defaultValue = 0.0, string dummyV = "")
                      {
                                 usingMap = false;
                                 this->defaultValue_.value_ = Te2String (defaultValue); 
                                 dummy = dummyV;
                      }

                      virtual ~TeCategoryPercentageStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 TeProperty category;
                                 int num = 0;

                                 // initialize count
                                 map<string, int>  count;

                                 if(usingMap)
                                 {
                                            map<string, string>::iterator itMap = classesMap_.begin();
                                            while (itMap != classesMap_.end())
                                            {
                                                       count[(*itMap).second] = 0;
                                                       ++itMap;
                                            }

                                            Iterator it = first;
                                            while (it != last)
                                            {
                                                       if (it.getProperty (category))
                                                       {
                                                                  count[classesMap_[category.value_]]++;
                                                                  num++;
                                                       }
                                                       ++it;
                                            }
                                 }
                                 else // use the data to initialize the counter
                                 {
                                            Iterator it = first;
                                            while (it != last)
                                            {
                                                       if (it.getProperty (category) && category.value_ != dummy)
                                                                  count[category.value_] = 0;

                                                       ++it;
                                            }

                                            it = first;
                                            while (it != last)
                                            {
                                                       if (it.getProperty (category) && category.value_ != dummy)
                                                       {
                                                                  count[category.value_]++;
                                                                  num++;
                                                       }
                                                       ++it;
                                            }
                                 }

                                 TePropertyVector  result;
                                 map <string, int>:: iterator count_it = count.begin();

                                 while(count_it != count.end())  
                                 {
                                            string value_ =  (*count_it).first;
                                            for (unsigned i = 0; i < value_.size(); i++)
                                                       if(value_[i] == '.' || value_[i] == '+' || value_[i] == '-')
                                                                  // remove them from value because they cant be part of a column name
                                                                  value_[i] = '_';

                                            TeProperty prop;
                                            prop.attr_.rep_.name_ = columnName + value_;
                                            prop.attr_.rep_.type_ = TeREAL;
                                            prop.attr_.rep_.numChar_ = 48;

                                            double percent = 0.0;
                                            double value = (double)(*count_it).second;
                                            if (num != 0) percent = value/num;
                                            prop.value_    = Te2String (percent);
                                            result.push_back (prop);
                                            ++count_it;
                                 }
                                 return result;
                      }

           private:
                      map<string, string> classesMap_;
                      bool usingMap;
                      string dummy;
};


template<class Iterator>
class TePresenceStrategy: public TeComputeAttrStrategy<Iterator>
{
           public:
                      /* 
                                 \param defaultValue              the returned value of the compute method when the iterator is empty          
                      */         
                      TePresenceStrategy (bool defaultValue = 0) 
                      {
                                 this->defaultValue_.attr_.rep_.type_ = TeINT;
                                 this->defaultValue_.value_ = Te2String (defaultValue); 
                                 this->defaultValue_.attr_.rep_.numChar_ = 48;
                      }

                      virtual ~TePresenceStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 TeProperty prop;
                                 if (first != last) 
                                            prop.value_ = "1";
                                 else
                                            prop = this->defaultValue_;
           
                                 TePropertyVector  result;
                                 prop.attr_.rep_.name_ = columnName; 
                                 prop.attr_.rep_.type_ = TeINT;
                                 prop.attr_.rep_.numChar_ = 48;
                                 result.push_back (prop);
                                 return result;
                      }
};

template<class Iterator>
class TeMajorityStrategy: public TeComputeAttrStrategy<Iterator>
{
           public:
                      /* 
                                 \param defaultType               the type of the default value    
                      */         
                      TeMajorityStrategy (TeAttrDataType defaultType = TeINT, string defaultValue = "", string dummyV = "")
                      {
                                 this->defaultValue_.attr_.rep_.type_ = defaultType;
                                 this->defaultValue_.value_ = defaultValue; 
                                 dummy = dummyV;
                      }

                      virtual ~TeMajorityStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual  vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 TeProperty category;
                                 category.attr_.rep_.type_ = this->defaultValue_.attr_.rep_.type_;
           
                                 map<string, int>  count;
                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if (it.getProperty (category) && category.value_ != dummy)
                                                       count[category.value_]++;

                                            ++it;
                                 }
           
                                 TeProperty prop;
                                 prop.attr_.rep_.type_ = category.attr_.rep_.type_;
                                 prop.value_ = this->defaultValue_.value_;
                                 prop.attr_.rep_.name_ = columnName; 
                                 prop.attr_.rep_.numChar_ = 48;

                                 int max = 0;
                                 map <string, int>:: iterator count_it = count.begin();
                                 while(count_it != count.end())  
                                 {
                                            if ((*count_it).second > max)
                                            {
                                                       prop.value_ = (*count_it).first;
                                                       max = (*count_it).second;
                                            }
                                            ++count_it;                      
                                 }
                                 TePropertyVector  result;
                                 result.push_back (prop);
                                 return result;
                      }
           private:
                      string dummy;
};


template<class Iterator>
class TeMajorityCategoryStrategy: public TeComputeAttrStrategy<Iterator>   
{
           public:
                      /*
                                 \param classesMap                the returning values for each categoty
                                 \param defaultValue              the type of the attribute to be created
                      */         
                      TeMajorityCategoryStrategy (const map<string, string>& classesMap, TeAttrDataType defaultType = TeINT) 
                      {
                                 this->defaultValue_.attr_.rep_.type_ = defaultType;
                                 this->defaultValue_.value_ = "0"; 
                                 classesMap_ = classesMap;
                      }

                      virtual ~TeMajorityCategoryStrategy() {}

                      /* 
                                 \param first                     the first element of the Iterator
                                 \param last                                 the last element of the Iterator
                                 \param columnName     the attribute name to be generated in the TeProperty's
                      */
                      virtual vector<TeProperty> compute (Iterator first, Iterator last, const string& columnName)
                      {
                                 TeProperty category;
                                 category.attr_.rep_.type_ = this->defaultValue_.attr_.rep_.type_;

                                 // initialize count
                                 map<string, int>  count;
                                 map<string, string>::iterator itMap = classesMap_.begin();
                                 while (itMap != classesMap_.end())
                                 {
                                            count[(*itMap).second] = 0;
                                            ++itMap;
                                 }

                                 Iterator it = first;
                                 while (it != last)
                                 {
                                            if (it.getProperty (category))
                                            {
                                                       count[classesMap_[category.value_]]++;
                                            }
                                            ++it;
                                 }

                                 TePropertyVector  result;
                                 TeProperty prop;
                                 prop.attr_.rep_.type_ = TeSTRING;
                                 //         prop.value_ = defaultValue_.value_;
                                 prop.attr_.rep_.name_ = columnName; 
                                 prop.attr_.rep_.numChar_ = 48;

                                 int max = 0;
                                 map <string, int>:: iterator count_it = count.begin();
                                 while(count_it != count.end())  
                                 {
                                            if ((*count_it).second > max)
                                            {
                                                       prop.value_ = (*count_it).first;
                                                       max = (*count_it).second;
                                            }
                                            ++count_it;                      
                                 }

                                 result.push_back (prop);
                                 return result;
                      }

           protected:
                                 map<string, string> classesMap_;
};

class TL_DLL TeComputeSpatialStrategy  
{
           public:
                      virtual ~TeComputeSpatialStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute(TeBox box) = 0;

                      virtual TeAttrDataType Type() { return TeREAL; }

                      /* 
                                 \param box            the box to be used
                                 \patam att            the attribute returned together with the objects. If none, this function returns only the geometries
                      */
                      TeQuerier* getWithinGeometry(TeBox box, string att = "");

           protected:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param rep_                                 the representation to be used    
                      */         
                      TeComputeSpatialStrategy (TeTheme* theme_, TeGeomRep rep_) { theme = theme_; rep = rep_; }

                      TeTheme* theme;

                      TeGeomRep rep;
};


class TL_DLL TeAverageWeighByAreaStrategy: public TeComputeSpatialStrategy 
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param att_                                 the attribute used to compute the sum. It must be numerical
                                 \param rep_                                 the representation to be used    
                      */         
                      TeAverageWeighByAreaStrategy  (TeTheme* theme_, string att_, TeGeomRep rep_) : TeComputeSpatialStrategy(theme_, rep_) { attribute = att_; }

                      virtual ~TeAverageWeighByAreaStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);

           private:
                      string attribute;
};


class TL_DLL TeSumWeighByAreaStrategy: public TeComputeSpatialStrategy  
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param att_                                 the attribute used to compute the sum. It must be numerical
                                 \param rep_                                 the representation to be used    
                      */         
                      TeSumWeighByAreaStrategy (TeTheme* theme_, string att_, TeGeomRep rep_) : TeComputeSpatialStrategy(theme_, rep_) { attribute = att_; }

                      virtual ~TeSumWeighByAreaStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual  string compute (TeBox box);

           private:
                      string attribute;
};


class TL_DLL TeCategoryMajorityStrategy: public TeComputeSpatialStrategy  
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param att_                                 the attribute used to compute the majority
                                 \param classesMap     a map to reclassify the values
                      */         
                      TeCategoryMajorityStrategy (TeTheme* theme_, string att_, map<string, string>& classesMap) : TeComputeSpatialStrategy(theme_, TePOLYGONS) 
           {classesMap = classesMap; attribute = att_;}

                      virtual ~TeCategoryMajorityStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual  string compute (TeBox box);        

           protected:
                                 map<string, string> classesMap;

                                 string attribute;
};


class TL_DLL TeCountObjectsStrategy: public TeComputeSpatialStrategy  
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param geom_                     the representation to be used    
                      */         
                      TeCountObjectsStrategy (TeTheme* theme_, TeGeomRep geom_) : TeComputeSpatialStrategy(theme_, geom_) { }

                      virtual ~TeCountObjectsStrategy() { }

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);

                      virtual TeAttrDataType Type() { return TeINT; }
};


class TL_DLL TeCountPolygonalObjectsStrategy: public TeCountObjectsStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeCountPolygonalObjectsStrategy (TeTheme* theme_) : TeCountObjectsStrategy(theme_, TePOLYGONS) {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);
};


class TL_DLL TeCountLineObjectsStrategy: public TeCountObjectsStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeCountLineObjectsStrategy (TeTheme* theme_) : TeCountObjectsStrategy(theme_, TeLINES) {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);
};


class TL_DLL TeCountPointObjectsStrategy: public TeCountObjectsStrategy 
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeCountPointObjectsStrategy (TeTheme* theme_) : TeCountObjectsStrategy(theme_, TePOINTS) {}
};


class TL_DLL TeLineLengthStrategy: public TeComputeSpatialStrategy 
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeLineLengthStrategy (TeTheme* theme_) : TeComputeSpatialStrategy(theme_, TeLINES){}

                      virtual ~TeLineLengthStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual  string compute (TeBox box);
};


class TL_DLL TeTotalAreaPercentageStrategy: public TeComputeSpatialStrategy  
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeTotalAreaPercentageStrategy (TeTheme* theme_) : TeComputeSpatialStrategy(theme_, TePOLYGONS){}

                      virtual ~TeTotalAreaPercentageStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);
};

/*
// pedro@20061214
class TeMinimumDistanceNetStrategy:  public TeComputeSpatialStrategy
{
           public:
                      TeMinimumDistanceNetStrategy(TeTheme* theme_, TeGeomRep rep_, TeGraphNetwork* net, double dist_ = 50) : TeComputeSpatialStrategy(theme_, rep_) { maxDist = dist_; tree = NULL; }
                      
                      virtual ~TeMinimumDistanceNetStrategy() { if(tree) delete tree; }

        void CreatePoints(TeCoord2D p1, TeCoord2D p2); // create all intermediate points between them, using the maximum distance

                      virtual string compute (TeBox box);

                      virtual TeAttrDataType Type() { return TeREAL; }

           private:   

                      double maxDist;

                      vector<pair<TeCoord2D, TePoint> > dataSet;

                      KDTREE* tree;
};
*/


class TL_DLL TeMinimumDistanceStrategy:  public TeComputeSpatialStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param gep_                                 the geometry to be used
                                 \param distError_     the maximum error tolerated by this operator
                      */         
                      TeMinimumDistanceStrategy(TeTheme* theme_, TeGeomRep rep_, double distError_ = 50); 

                      virtual ~TeMinimumDistanceStrategy() { if(tree) delete tree; }

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);

           protected:
        void CreatePoints(TeCoord2D p1, TeCoord2D p2);

                      double maxDist;

                      vector<pair<TeCoord2D, TePoint> > dataSet;

                      KDTREE* tree;
};


class TL_DLL TeMinimumDistancePolygonsStrategy: public TeMinimumDistanceStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param distError_     the maximum error tolerated by this operator
                      */         
                      TeMinimumDistancePolygonsStrategy(TeTheme* theme_, double distError_ = 150);

                      virtual ~TeMinimumDistancePolygonsStrategy() {}

                      /* 
                                 \param box            compute the attribute of a cell having this box
                      */
                      virtual string compute (TeBox box);
};


class TL_DLL TeMinimumDistanceLinesStrategy : public TeMinimumDistanceStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                                 \param distError_     the maximum error tolerated by this operator
                      */         
                      TeMinimumDistanceLinesStrategy(TeTheme* theme_, double distError_ = 150);

                      virtual ~TeMinimumDistanceLinesStrategy() {}
};


class TL_DLL TeMinimumDistancePointsStrategy: public TeMinimumDistanceStrategy
{
           public:
                      /* 
                                 \param theme_                    the theme to be used as basis for computing the attribute
                      */         
                      TeMinimumDistancePointsStrategy(TeTheme* theme_);

                      virtual ~TeMinimumDistancePointsStrategy() {}
};

#endif