E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/kernel/TeNeighbours.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_NEGHBOURS_H
#define  __TERRALIB_INTERNAL_NEGHBOURS_H

#include "TeUtils.h"
#include "TeAttribute.h"

#include <vector> 
#include <string>
#include <map> 
using namespace std;


class TL_DLL TeProxMatrixAttributes  
{
           private:
                      double     _weight;
                      int                   _slice;
                      int                   _order;
                      double     _centroid_distance;
                      double     _borders_length;
                      double     _net_objects_distance;
                      double     _net_minimum_path;


           public:
                      
                      TeProxMatrixAttributes(); 

                      TeProxMatrixAttributes(const double& w, const int& slice, const int& order, 
                                 const double& cent_dist, const double& border_length, 
                                 const double& net_distance, const double& net_minimun_path): 
                                            _weight(w), _slice(slice), 
                                            _order(order), _centroid_distance(cent_dist), 
                _borders_length(border_length), 
                _net_objects_distance(net_distance), 
                _net_minimum_path(net_minimun_path)
                      {}
                      
                      TeProxMatrixAttributes (const TeProxMatrixAttributes& att); 
                      
                      double     Weight() {return _weight;}

                      int                   Slice () {return _slice;}

                      int                   Order() {return _order;}

                      double     BorderLength() {return _borders_length;}

                      double     CentroidDistance() {return _centroid_distance;}

                      double     NetworkObjectsDistance() {return _net_objects_distance;}

                      double     NetworkMinimumPath () {return _net_minimum_path;}

                      void Weight(double w) {_weight = w;}

                      void Slice (int s) {_slice = s;}
                      
                      void Order(int o) {_order = o;}

                      void BorderLength(double l) {_borders_length = l;}

                      void CentroidDistance(double d) {_centroid_distance = d;}

                      void NetworkObjectsDistance(double d) {_net_objects_distance = d;}

                      void NetworkMinimumPath (double d) {_net_minimum_path = d;}

                      TePropertyVector getProperties ();

                      bool WasBordersLengthComputed () {if (_borders_length == -1.0) return false; else return true;}
                      
                      bool WasCentroidDistanceComputed () {if (_centroid_distance == -1.0) return false; else return true;}
                      
                      bool WasNetworkObjectsDistanceComputed () {if (_net_objects_distance == -1.0) return false; else return true;}
                      
                      bool WasNetworkMinimumPathComputed () {if (_net_minimum_path == -1.0) return false; else return true;}

                      TeProxMatrixAttributes& operator= (const TeProxMatrixAttributes& att); 
                      
                      bool operator==(const TeProxMatrixAttributes& att) const;
                                 
                      virtual ~TeProxMatrixAttributes() {}
};

typedef map<string, TeProxMatrixAttributes> TeNeighboursMap;


class TL_DLL TeNeighbours  
{
private:
           typedef pair<string, TeProxMatrixAttributes>           neigh_values;
           typedef vector<neigh_values>                                                 neigh_vector;

           neigh_vector _neigh; 
           

public:

           typedef neigh_vector::iterator iterator;
           typedef neigh_vector::const_iterator const_iterator;

           TeNeighbours () {};

           TeNeighbours(const TeNeighboursMap& neigh);

           TeNeighbours(const TeNeighbours& neigh);
           
           int size() const  { return _neigh.size();}

    iterator begin()     { return _neigh.begin();}

    iterator end()       { return _neigh.end();}

           string ObjectId (int n);  

           string operator[](int n);  

           double Weight (int n);                      

           double Weight (const string& object_id);    
           
           TeProxMatrixAttributes Attributes (int n);
           
           bool Insert (const string& object_id, const TeProxMatrixAttributes& attr);

           bool Remove (const string& object_id);

           TeNeighbours& operator= (const TeNeighbours& neigh);

           bool operator==(const TeNeighbours& p);

           virtual ~TeNeighbours() {}

};

#endif