E:/Projetos_Primeiro_Semestre_2012/TerraView/terralib/src/terralib/image_processing/TePDIRegGrowSeg.hpp

Go to the documentation of this file.

/*
TerraLib - a library for developing GIS applications.
Copyright  2001, 2002, 2003 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 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 TEPDIREGGROWSEG_HPP
  #define TEPDIREGGROWSEG_HPP

  #include "TePDIAlgorithm.hpp"

  #include "../kernel/TeSharedPtr.h"
  
  #include <map>
  
  #define MAXCLOSECELLS   5
  #define SQR_NC          65025
  #define TAMJAN          128
  #define STATDEAD        (char)2    
  
  class TePDIRGSCell;
  
  
  class CloserCells;
  
  typedef map<long, TePDIRGSCell *> TePDIRGSCellList;    
  
  
class PDI_DLL TePDIRGSCell
{
public:
        TePDIRGSCell ();

   TePDIRGSCell( unsigned long *tuple, long id, short lin, short col, short nban );

   ~TePDIRGSCell();

   void Init( unsigned long *tuple, long id, short lin, short col, short nban );

   void ResetId( long idc ) { Idnumber_ = idc; }

   char Dead()  { return (Stat_ & STATDEAD); }

   void Kill() { Stat_ = STATDEAD; }

   void BoundingRectangle( int& lmin, int& cmin, int& lmax, int& cmax )
        { lmin = LinMin_; cmin = ColMin_; lmax = LinMax_; cmax = ColMax_; }

   int LineMax () { return LinMax_;}

   bool Merge( TePDIRGSCell *c );

   void AdjustNeighborhood();//{ Cc_->Adjust(); /*Neighbors_->Adjust();*/ }

   bool AddNeighbor( TePDIRGSCell* c, float dist );

   bool InsertNeighbor( TePDIRGSCell* c, float dist );

   TePDIRGSCell* ClosestNeighbor( float& dist );

   float Distance( TePDIRGSCell *c );

   long Id() { return Idnumber_; }

   long Area() { return Npix_; }

   int GetNban() { return Nban_; }

   void Print();

private:
        char            Stat_;
        
        long            Idnumber_;
        
        long            Npix_;
        
        int             Nban_;
        
        float           delta_;
        
        int             LinMin_;
        
        int             LinMax_;
        
        int             ColMin_;
        
        int             ColMax_;
        
        float           *Media_;
        
        float           *PreviousMedia_;
        
        TePDIRGSCellList        *Neighbors_;
        
        CloserCells     *Cc_;

};  


class PDI_DLL CellStack : public vector< TePDIRGSCell* >
{
public:

        void Push(TePDIRGSCell* c)
        { push_back(c); }

        TePDIRGSCell* Peek()
    {
                if (size()==0){
                        return NULL;
                } else {
                        return back();
                }
        }

        TePDIRGSCell* Pop()
        {
                TePDIRGSCell* c;
                if (size()==0)
                {
                        c = new TePDIRGSCell();
                } else {
                        c = back();
                        pop_back();
                }
                return c;
        }

        ~CellStack ()
        {
                TePDIRGSCell *b;
                while (size()!=0)
                {
                        b = Pop();
                        delete b;
                }
        }
        
        void Clear ()
        {
                TePDIRGSCell *b;
                while (size()!=0)
                {
                        b = Pop();
                        delete b;
                }
        }
};


class PDI_DLL CloserCells
{
public :
        TePDIRGSCell    *cmin[MAXCLOSECELLS];

        float   dmin[MAXCLOSECELLS];
        
        CloserCells()
        {
                for(short i = 0; i < MAXCLOSECELLS; i++ )
                {
                        cmin[i] = NULL;
                        dmin[i] = 1000000.;
                }
        }

        void
        Insert( TePDIRGSCell *cell, float dist )
        {
                TePDIRGSCell    **pci,
                        **p;
                float   *di,
                        *d;

                for( pci = &cmin[0], di = &dmin[0]; pci < &cmin[MAXCLOSECELLS]; pci++, di++ )
                {
                        if( *pci == NULL )
                        {
                                *pci = cell;
                                *di  = dist;
                                return;
                        }
                        if( dist <= *di )
                        {
                                if( dist == *di && (*pci)->Id() < cell->Id() )
                                        continue;
                                if( pci < &cmin[MAXCLOSECELLS] )
                                {
                                        for( p = &cmin[MAXCLOSECELLS-1], d = &dmin[MAXCLOSECELLS-1]; p > pci; p--, d-- )
                                        {
                                                *p = *(p-1);
                                                *d = *(d-1);
                                        }
                                }
                                *pci = cell;
                                *di  = dist;
                                return;
                        }
                }
        }

        void
        Update( TePDIRGSCell *cell, float dist )
        {
                char    ok = 1;
                TePDIRGSCell    **pci,
                        **pc0,
                        **pc01,
                        **pc02;
                float *di = 0;
                float *d0 = 0;
                float *d01 = 0;

                pc0 = NULL;
                for( pci = &cmin[0], di = &dmin[0]; pci < &cmin[MAXCLOSECELLS]; pci++, di++ )
                {
                        if( *pci == NULL )
                        {
                                pc0 = pci;
                                d0  = di;
                        }
                        else if( (*pci)->Dead() )
                        {
                                *pci = NULL;
                                pc0 = pci;
                                d0  = di;
                        }
                        else if( *pci == cell )
                        {
                                *pci = NULL;
                                pc0  = pci;
                                d0   = di;
                        }

                        if( ok && dist <= *di )
                        {
                                if( dist == *di )
                                {
                                        if( *pci == NULL )
                                        {
                                                if( pci < &cmin[MAXCLOSECELLS-1] )
                                                        continue;
                                        }
                                        else if( (*pci)->Id() < cell->Id() )
                                                continue;
                                }
                                if( pc0 != NULL )
                                {
                                        for( pc01 = pc0, d01 = d0; pc01 < pci-1; pc01++, d01++ )
                                        {
                                                *pc01 = *(pc01+1);
                                                *d01  = *(d01+1);
                                        }
                                        *pc01 = cell;
                                        *d01  = dist;
                                }
                                else if( pci < &cmin[MAXCLOSECELLS-1] )
                                {
                                        for( pc01 = pci+1, d01 = di+1; pc01 < &cmin[MAXCLOSECELLS-1]; pc01++, d01++ )
                                        {
                                                if( (*pc01) == NULL ) break;
                                                if( (*pc01)->Dead() ) break;
                                                if( *pc01 == cell )   break;
                                        }
                                        for( pc02 = pc01; pc02 > pci; pc02-- )
                                        {
                                                *pc02 = *(pc02-1);
                                                *d01  = *(d01-1);
                                                d01--;
                                        }
                                        *pci = cell;
                                        *di  = dist;
                                }
                                else
                                {
                                        *pci = cell;
                                        *di  = dist;
                                }
                                ok   = 0;
                        }
                }
                return;
        }

        TePDIRGSCell*
        Minimum( float& dist )
        {
                if( cmin[0] != NULL )
                {
                        if( !cmin[0]->Dead() )
                        {
                                dist = dmin[0];
                                return cmin[0];
                        }
                }
                for( short i = 1; i < MAXCLOSECELLS; i++ )
                {
                        if( cmin[i] != NULL )
                                if( !cmin[i]->Dead() )
                                {
                                        dist = dmin[i];
                                        return cmin[i];
                                }
                }

                return NULL;
        }

        void
        Adjust()
        {
                for( short i = 0; i < MAXCLOSECELLS; i++ )
                        if( cmin[i] != NULL )
                                if( cmin[i]->Dead() )
                                        cmin[i] = NULL;
        }

        void
        Reset()
        {
                for(short i = 0; i < MAXCLOSECELLS; i++ )
                {
                        cmin[i] = NULL;
                        dmin[i] = 1000000.0;
                }
        }
};


  class PDI_DLL TePDIRegGrowSeg : public TePDIAlgorithm {
    public :
      
      TePDIRegGrowSeg();

      ~TePDIRegGrowSeg();
      
      bool CheckParameters( const TePDIParameters& parameters ) const;      

    protected :
    
      TePDITypes::TePDIRasterPtrType  Imagein_;
      
      TePDITypes::TePDIRasterPtrType  Imagelab_;
      
      TePDITypes::TePDIRasterPtrType  Imageexc_;
      
      TePDIRGSCellList        *ListCell_;
      
      TePDIRGSCell            **WindowCell_;
      
      long            OnLimbo_;
      
      unsigned long   *tuple_;
      
      long            NWindow_;
      
      long            WindowLines_;
      
      long            WindowColumns_;
      
      long            CurrentWindow_;
      
      long            WindowOffset_;
      
      int             Areamin_;
      
      double          Difsim_;
      
      int             Nlin_;
      
      int             Ncol_;
      
      int             Nban_;
      
      int             ilin_;
       
      int flin_;
      
      int             icol_;
      
      int fcol_;
      
      int             sizelin_;
       
      int sizecol_;    
      
      CellStack cellStack;
    
      void ResetState( const TePDIParameters& params );    
     
      bool RunImplementation();
      
      TePDIRGSCell* MergeCells( TePDIRGSCell *c1, TePDIRGSCell *c2 );
  
          bool InitWindow();
  
      void Adjust();
  
      bool MergeSmallCells( long area, int linmax);
  
      bool MergeSimilarCells();
  
      bool MergeMutuallyClosestCells();
  
      bool Resort();      
  };
  
#endif