mi32/watermdl.h

Go to the documentation of this file.

#ifndef  INC_MI32_WATERMDL_H
#define  INC_MI32_WATERMDL_H

#ifndef INC_RVC_DBTABLE_H
#include <rvc/dbtable.h>
#endif

#ifndef INC_RVC_RASTER_H
#include <rvc/raster.h>
#endif

#ifndef INC_RVC_NULLMASK_H
#include <rvc/nullmask.h>
#endif

#ifndef INC_RVC_ARRAY_H
#include <rvc/array.h>
#endif

#ifndef INC_RVC_VECTOR_H
#include <rvc/vector.h>
#endif

#ifndef INC_MI32_MICACHE_H
#include <mi32/micache.h>
#endif

#include <map>


#ifndef GENERATING_DOXYGEN_OUTPUT
template <typename _TT> class ARRAYCACHE : public MICACHEIO {
public:
   ARRAYCACHE () {}
   virtual ~ARRAYCACHE () {}

   ERRVALUE Init (
      const INT32 NumCache, 
      RVC::ARRAY* Array
      ) {
      ERRVALUE err = m_Cache.Create(NumCache, sizeof(_TT), *this);
      if (err < 0) return err;
      m_Array = Array;
      return 0;
      }

   ERRVALUE Select (
      const INT32 itemid,
      MICACHE::ITEMINFO& iteminfo
      ) { return (m_Cache.Select(itemid, iteminfo, MICACHE::SELECTFLAG_None, m_Array)); }

   ERRVALUE Read (
      const INT32 itemid,
      _TT& item
      ) { return (m_Cache.Read(itemid, 0, sizeof(_TT), &item, m_Array)); }


   void Clear (
      ) {
      m_Cache.Flush();
      m_Cache.Free();
      m_Array = 0;
      return;
      }

private:

   SIMPLE_ARRAY<_TT> m_Buffer;

   RVC::ARRAY* m_Array;
   MICACHE m_Cache;

   ERRVALUE CacheLoad (
      MICACHE::ITEMINFO &iteminfo
      ) { 
      RVC::ARRAY* Array = (RVC::ARRAY*)iteminfo.GetUserDataPtr();
      return Array->Read(iteminfo.GetItemID(), iteminfo.GetMemPtr()); 
      }

   ERRVALUE CacheSave (
      MICACHE::ITEMINFO& iteminfo
      ) { 
      RVC::ARRAY* Array = (RVC::ARRAY*)iteminfo.GetUserDataPtr();
      return Array->Write(iteminfo.GetItemID(), iteminfo.GetMemPtr()); 
      }

   };

#endif // GENERATING_DOXYGEN_OUTPUT



 
class WATERSHED {

public:

   // ENUMERATIONS

   enum STATUS {                             
      STATUS_NotInitialized = -1,            
      STATUS_Initial = 0,                    
      STATUS_HasDepressions = 1,             
      STATUS_DepressionsFilled = 2           
      };

   enum FLAGS {                                 
      FLAGS_None                    = 0x0000,   
      FLAGS_FillDepressions         = 0x0001,   
      FLAGS_FillUpperDepressions    = 0x0002,   

      FLAGS_FillLowerDepressions    = 0x0004,   

      FLAGS_FillDoubleDepressions   = 0x0008,   

      FLAGS_FillDepressionsMask     = 0x000F,   
      FLAGS_FlowPath                = 0x0010,   
      FLAGS_Basin                   = 0x0020,   
      FLAGS_Ridge                   = 0x0040,   
      FLAGS_CatchmentArea           = 0x0100,   
      FLAGS_TopographicIndex        = 0x0200,   
      FLAGS_MaximumUpFlow           = 0x0400,   
      FLAGS_DownFlow                = 0x0800,   
      FLAGS_BasinAttribute          = 0x1000,   
      FLAGS_WatershedAttribute      = 0x2000,   
      FLAGS_ObjectMask              = 0x3F70    
      };

   enum DIRECTION {                          
      DIRECTION_Null = 0,                    
      DIRECTION_TopRight = 1,
      DIRECTION_Right = 2,
      DIRECTION_BottomRight = 3,
      DIRECTION_Bottom = 4,
      DIRECTION_BottomLeft = 5,
      DIRECTION_Left = 6,
      DIRECTION_TopLeft = 7,
      DIRECTION_Top = 8,
      DIRECTION_DepressionFlat = 12,         
      DIRECTION_Minimum = 13,                
      DIRECTION_Multiple = 14,               
      DIRECTION_Flat = 15                    
      };

   enum EXTREMA {                            
      EXTREMA_Null = 0,                      
      EXTREMA_Normal = 1,                    
      EXTREMA_Maximum = 2,                   
      EXTREMA_Minimum = 3,                   
      EXTREMA_Flat = 4,                      
      EXTREMA_FlatExit = 5,                  
      EXTREMA_FlatEntry = 6,                 
      EXTREMA_Saddle = 7                     
      };

   enum OUTPUT {                             
      OUTPUT_None = -1,
      OUTPUT_First = 0,
      OUTPUT_RasterAdjusted = 0,             

      OUTPUT_RasterExtrema = 1,              
      OUTPUT_RasterFlowDirection = 2,        
      OUTPUT_RasterAccumulation = 3,         

      OUTPUT_RasterWatershed = 4,            


      OUTPUT_RasterCatchmentArea = 5,        
      OUTPUT_RasterTopographicIndex = 6,     
      OUTPUT_RasterMaximumUpFlow = 7,        
      OUTPUT_RasterDownFlow = 8,             
      OUTPUT_VectorWatershed = 9,            

      OUTPUT_VectorFlowPath = 10,            

      OUTPUT_VectorBasin = 11,               

      OUTPUT_VectorRidge = 12,               
      OUTPUT_VectorUserFlowPath = 13,        

      OUTPUT_VectorUserBasin = 14,           

      OUTPUT_VectorSegmentedFlowPath = 15,
      OUTPUT_Count = 16
      };

   enum SEGMENTATIONPARAMETER {
      SEGMENTATIONPARAMETER_None = 0,
      SEGMENTATIONPARAMETER_FlowAccumulation = 1,
      SEGMENTATIONPARAMETER_Elevation = 2
      };

   enum SEGMENTATIONINTERVAL {
      SEGMENTATIONINTERVAL_Equal = 0,
      SEGMENTATIONINTERVAL_Unequal = 1,
      SEGMENTATIONINTERVAL_Exponential = 2
      };

   class ATTRIBUTE;

   // NESTED CLASSES
   class POURCANDIDATE {

   public:

      // MEMBERS

      // CONSTRUCTION / DESTRUCTION
      POURCANDIDATE (                        
         ) {
         }

      POURCANDIDATE (                        
         const DPOINT3D& Point,              
         const INT32 LeftWatershed,          
         const INT32 RightWatershed          
         ) :
         m_Record(Point, LeftWatershed, RightWatershed)
         {
         }

      POURCANDIDATE (                                 
         const POURCANDIDATE &rhs
         ) :
         m_Record(rhs.m_Record)
         {
         }

      ~POURCANDIDATE (                                
         ) {
         }
 
      // OPERATORS
 
      POURCANDIDATE& operator= (                      
         const POURCANDIDATE& rhs
         ) {
         if (this != &rhs) {
            m_Record = rhs.m_Record;
            }
         return (*this);
         }

      void Init (                            
         const DPOINT3D& Point,              
         const INT32 LeftWatershed,          
         const INT32 RightWatershed          
         ) {
         m_Record.m_Point = Point;
         m_Record.m_LeftWatershed = LeftWatershed;
         m_Record.m_RightWatershed = RightWatershed;
         return;
         }

      // METHODS

      const INT32 GetLeftWatershed (
         ) const {
         return m_Record.m_LeftWatershed;
         }

      const INT32 GetRightWatershed (
         ) const {
         return m_Record.m_RightWatershed;
         }

      const DPOINT3D& GetPoint (
         ) const {
         return m_Record.m_Point;
         }

   private:

      friend class WATERSHED::ATTRIBUTE;

      struct RECORD {

         DPOINT3D m_Point;                      
         INT32 m_LeftWatershed;                 
         INT32 m_RightWatershed;                

         RECORD (
            ) :
            m_Point(),
            m_LeftWatershed(-1),
            m_RightWatershed(-1)
            {
            };

         RECORD (
            const DPOINT3D& Point,     
            const INT32 LeftWatershed,
            const INT32 RightWatershed
            ) :
            m_Point(Point),
            m_LeftWatershed(LeftWatershed),
            m_RightWatershed(RightWatershed)
            {
            };

         };
      // MEMBERS

         RECORD m_Record;

      };

   class POUR {

   public:

      // ENUMERATIONS

      enum TYPE {                            
         TYPE_None = 0,                      
         TYPE_Single = 1,                    
         TYPE_Double = 2                     
         };


      // MEMBERS

      // CONSTRUCTION / DESTRUCTION

      POUR (                                 
         ) {
         }

      POUR (                              
         const TYPE type,                 
         const POURCANDIDATE& pourcandidate,    
         const INT32 id                   
         ) :
         m_Record(type, pourcandidate, id)
         {
         }

      POUR (                                 
         const POUR &rhs
         ) :
         m_Record(rhs.m_Record)
         {
         }

      ~POUR (                       
         ) {
         }
 
      // OPERATORS
 
      POUR& operator= (                      
         const POUR& rhs
         ) {
         if (this != &rhs) {
            m_Record = rhs.m_Record;
            }
         return (*this);
         }

      void Init (                               
         const TYPE type,                       
         const POURCANDIDATE& pourcandidate,    
         const INT32 id                         
         ) {
         m_Record.m_Type = type;
         m_Record.m_Point = pourcandidate.GetPoint();
         m_Record.m_LeftWatershed = pourcandidate.GetLeftWatershed();
         m_Record.m_RightWatershed = pourcandidate.GetRightWatershed();
         m_Record.m_ElementIDOfVectorPoint = id;
         }

      // METHODS

      const INT32 GetLeftWatershed (
         ) const {
         return m_Record.m_LeftWatershed;
         }

      const INT32 GetRightWatershed (
         ) const {
         return m_Record.m_RightWatershed;
         }

      const DPOINT3D& GetPoint (
         ) const {
         return m_Record.m_Point;
         }

      const TYPE GetType (
         ) const {
         return m_Record.m_Type;
         }

      const INT32 GetElementIDOfVectorPoint (
         ) const {
         return m_Record.m_ElementIDOfVectorPoint;
         }

   private:

      friend class WATERSHED::ATTRIBUTE;

      struct RECORD {

         TYPE m_Type;                           
         DPOINT3D m_Point;                      
         INT32 m_LeftWatershed;                 
         INT32 m_RightWatershed;                
         INT32 m_ElementIDOfVectorPoint;        

         RECORD (
            ) :
            m_Type(TYPE_None),
            m_Point(),
            m_LeftWatershed(-1),
            m_RightWatershed(-1),
            m_ElementIDOfVectorPoint(-1)
            {
            };

         RECORD (
            const TYPE type,                       
            const POURCANDIDATE& pourcandidate,    
            const INT32 id                         
            ) :
            m_Type(type),
            m_Point(pourcandidate.GetPoint()),
            m_LeftWatershed(pourcandidate.GetLeftWatershed()),
            m_RightWatershed(pourcandidate.GetRightWatershed()),
            m_ElementIDOfVectorPoint(id)
            {
            };

         };
      // MEMBERS

      RECORD m_Record;

      };


   class POLYGON {

   public:

      // MEMBERS

      // CONSTRUCTION / DESTRUCTION

      POLYGON (                              
         ) {
         }

      POLYGON (                              
         const POLYGON &rhs
         ) :
         m_Record(rhs.m_Record),
         m_VectorPolygons(rhs.m_VectorPolygons),
         m_UpperPours(rhs.m_UpperPours),
         m_LowerPours(rhs.m_LowerPours)
         {
         }

      ~POLYGON (                    
         ) {
         m_VectorPolygons.Clear();
         m_UpperPours.Clear();
         m_LowerPours.Clear();
         }

      // OPERATORS

      POLYGON& operator= (                   
         const POLYGON& rhs
         ) {
         if (this != &rhs) {
            m_Record = rhs.m_Record;
            m_VectorPolygons = rhs.m_VectorPolygons;
            m_UpperPours = rhs.m_UpperPours;
            m_LowerPours = rhs.m_LowerPours;
            }
         return (*this);
         }


      // METHODS

      const bool HasDepression (
         ) const {
         return (m_Record.m_Z > m_Record.m_MinZ);
         }

      const double GetArea (
         ) const {
         return m_Record.m_Area;
         }

      const double GetPerimeter (
         ) const {
         return m_Record.m_Perimeter;
         }

      const double GetDepressionArea (
         ) const {
         return m_Record.m_DepressionArea;
         }

      const double GetDepressionVolume (
         ) const {
         return m_Record.m_DepressionVolume;
         }

      const double GetZ (
         ) const {
         return m_Record.m_Z;
         }

      const double GetRawZ (
         ) const {
         return m_Record.m_RawZ;
         }

      const double GetMinZ (
         ) const {
         return m_Record.m_MinZ;
         }

      const double GetMaxZ (
         ) const {
         return m_Record.m_MaxZ;
         }

      const INT32 GetNumberOfVectorPolygons (
         ) const {
         return m_VectorPolygons.GetNumItems();
         }

      const INT32 GetIDOfVectorPolygon (
         const UINT32 index                  
         ) const {
         if (index < (UINT32)m_VectorPolygons.GetNumItems()) return m_VectorPolygons[(int)index];
         return -1;
         }

      const UINT32 GetNumberOfLowerPours (
         ) const {
         return (m_LowerPours.GetNumItems());
         }

      const INT32 GetIDOfLowerPour (
         const UINT32 index                  
         ) const {
         if (index < (UINT32)m_LowerPours.GetNumItems()) return m_LowerPours[(int)index];
         return -1;
         }

      const INT32 GetNumberOfUpperPours (
         ) const {
         return (m_UpperPours.GetNumItems());
         }

      const INT32 GetIDOfUpperPour (
         const UINT32 index                  
         ) const {
         if (index < (UINT32)m_UpperPours.GetNumItems()) return m_UpperPours[(int)index];
         return -1;
         }

   private:

      friend class WATERSHED::ATTRIBUTE;

      struct RECORD {
         double m_DepressionArea;               
         double m_DepressionVolume;             
         double m_Area;                         
         double m_Perimeter;                    
         double m_MinZ;                         
         double m_Z;                            
         double m_RawZ;                         
         double m_MaxZ;                         
         INT32 m_NextVector;
         INT32 m_NextUpper;
         INT32 m_NextLower;
         INT32 m_Spare;

         RECORD (
            ) :
            m_DepressionArea(0.0),     
            m_DepressionVolume(0.0),   
            m_Area(0.0),
            m_Perimeter(0.0),       
            m_MinZ(DBL_MAX),
            m_Z(DBL_MAX),
            m_RawZ(DBL_MAX),
            m_MaxZ(-DBL_MAX),
            m_NextVector(-1),
            m_NextUpper(-1),
            m_NextLower(-1),
            m_Spare(0)
            {
            };

         };

      struct NEXTRECORD {
         INT32 m_ID;
         INT32 m_Next;

         NEXTRECORD (
            ) :
            m_ID(-1),
            m_Next(-1)
            {
            };
         };

      // MEMBERS

      RECORD m_Record;

      SIMPLE_ARRAY<INT32> m_VectorPolygons;  
      SIMPLE_ARRAY<INT32> m_UpperPours;      
      SIMPLE_ARRAY<INT32> m_LowerPours;      

      };

   class ATTRIBUTE {

   public:

      // CONSTRUCTION / DESTRUCTION

      ATTRIBUTE (                            
         const UINT32 NumberRasterPolygons   
         );

      ~ATTRIBUTE (                           
         );

      ERRVALUE CheckInternalElevation (
         const INT32 watershed,              
         const double elevation              
         );

      ERRVALUE CheckElevationAndAddArea (
         const INT32 watershed,              
         const double elevation,             
         const double area                   
         );

      ERRVALUE CheckBoundaryElevation (
         const INT32 watershed,              
         const double z,                     
         const double rawZ                
         );

      ERRVALUE Init (                              
         const INT32 NumPolys,               
         const INT32 NumLines,               
         const INT32 NumNodes             
         );

      ERRVALUE AddLink (
         const INT32 watershed,              
         const INT32 VectorPolygon           
         );

      ERRVALUE AddArea (
         const INT32 watershed,              
         const double area                
         );

      ERRVALUE AddDepressionArea (
         const INT32 watershed,              
         const double area                
         );

      ERRVALUE AddDepressionVolume (
         const INT32 watershed,              
         const double volume                 
         );

      ERRVALUE AddDepressionData (
         const INT32 watershed,              
         const double area,                  
         const double volume                 
         );

      ERRVALUE AddPerimeter (
         const INT32 watershed,              
         const double perimeter              
         );

      ERRVALUE AddVectorPolygon (
         const INT32 watershed,              
         const INT32 VectorPolygon           
         );

      ERRVALUE AddLowerPour (
         const INT32 watershed,              
         const INT32 LowerPour               
         );

      ERRVALUE AddUpperPour (
         const INT32 watershed,              
         const INT32 UpperPour               
         );

      ERRVALUE AddPour (
         const POUR& pour                    
         );

      ERRVALUE AddPourCandidate (
         const POURCANDIDATE& pourcandidate                    
         );

      ERRVALUE DefinePours (
         RVC::VECTOR& vector
         );

      void RisePourType (
         POUR::TYPE& type
         ) {
         switch (type) {
            case POUR::TYPE_None: type = POUR::TYPE_Single; break;
            case POUR::TYPE_Single: type = POUR::TYPE_Double; break;
            }
         return;
         }

      ERRVALUE SaveAsVectorPoint (
         RVC::VECTOR& vector,
         const DPOINT3D& point,
         const INT32 id                   
         );

      const bool HasDepressions (
         ) const {
         return (m_NumberOfDepressions > 0);
         };

      const bool HasDepression (
         const INT32 watershed               
         );

      const double GetWatershedZ (
         const INT32 watershed               
         );

      const INT32 GetNumberOfWatershedPolygonsWithDepression (
         ) const {
         return m_NumberOfDepressions;
         }

      const INT32 GetNumberOfWatershedPolygons (
         ) const {
         return m_PolygonArray.GetNumItems();
         };

      bool GetWatershedPolygon (
         const INT32 index,                     
         POLYGON& polygon
         );

      const INT32 GetNumberOfVectorPolygons (
         ) const {
         return m_VectorArray.GetNumItems();
         };

      const INT32 GetIDOfWatershedPolygonForVectorPolygon (
         const INT32 index                   
         );

      const INT32 GetNumberOfPours (
         ) const {
         return  (m_PourArray.GetNumItems());
         };

      bool GetPour (
         const INT32 index,                     
         POUR& pour
         );

      const INT32 GetNumberOfPourCandidates (
         ) const {
         return  (m_PourCandidateArray.GetNumItems());
         };

      bool GetPourCandidate (
         const INT32 index,
         POURCANDIDATE& pourcandidate
         );

      const INT32 GetNumberOfDoublePours (
         ) const {
         return m_NumberOfDoublePours;
         }


   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct LINKRECORD {
         INT32 m_Watershed;

         LINKRECORD (
            ) :
            m_Watershed(-1)
            {
            };

         };


      // MEMBERS

      INT32 m_NumberOfDepressions;              
      INT32 m_NumberOfDoublePours;              

      RVC::OBJECT m_File;

      RVC::ARRAY m_PourCandidateArray;
      RVC::ARRAY m_PourArray;
      RVC::ARRAY m_PolygonArray;
      RVC::ARRAY m_VectorArray;
      RVC::ARRAY m_UpperPourArray;
      RVC::ARRAY m_LowerPourArray;
      RVC::ARRAY m_LinkArray;

      ARRAYCACHE<POURCANDIDATE::RECORD> m_PourCandidateCache;  // MICACHE
      ARRAYCACHE<POUR::RECORD> m_PourCache;
      ARRAYCACHE<POLYGON::RECORD> m_PolygonCache;
      ARRAYCACHE<POLYGON::NEXTRECORD> m_VectorCache;
      ARRAYCACHE<POLYGON::NEXTRECORD> m_UpperPourCache;
      ARRAYCACHE<POLYGON::NEXTRECORD> m_LowerPourCache;
      ARRAYCACHE<LINKRECORD> m_LinkCache;

      POURCANDIDATE::RECORD m_PourCandidateRecord;
      POUR::RECORD m_PourRecord;
      POLYGON::RECORD m_PolygonRecord;
      POLYGON::NEXTRECORD m_NextRecord;
      LINKRECORD m_LinkRecord;

      // CONSTRUCTION / DESTRUCTION

      ATTRIBUTE (                            
         );

      ATTRIBUTE (                            
      const ATTRIBUTE &rhs
      );

      // OPERATORS

      ATTRIBUTE& operator= (                 
         const ATTRIBUTE& rhs
         );

      ERRVALUE Make ();
      ERRVALUE Delete();
      ERRVALUE FillPolygonsTable(const UINT32 NumberOfRasterPolygons);
      ERRVALUE FillLinksTable(const UINT32 NumberOfVectorPolygons);

      #endif // GENERATING_DOXYGEN_OUTPUT

      };

   // TYPEDEFS

   // MEMBERS

   static const UINT32 DefaultOutlet;        


   static const UINT32 DefaultInlet;         


   static const UINT32 DefaultBranch;        


   static const UINT32 DefaultBasin;         

   static const bool DefaultValleySeparation;


   static const UINT32 MinimumOutlet;        
   static const UINT32 MinimumInlet;         
   static const UINT32 MinimumBranch;        
   static const UINT32 MinimumBasin;         


   static const UINT32 s_DefaultDepressionMaximumArea;                           
   static const UINT32 s_DefaultDepressionMaximumNullArea;                          
   static const double s_DefaultDepressionMaximumDepth;                          
   static const UINT32 s_DefaultDepressionMinimumDepthArea;                         
   static const bool s_DefaultPutNullCellAtUnfilledDepression;                

   static const UINT32 s_MinimumDepressionMaximumArea;                           
   static const UINT32 s_MinimumDepressionMaximumNullArea;                          
   static const double s_MinimumDepressionMaximumDepth;                          
   static const UINT32 s_MinimumDepressionMinimumDepthArea;                         

   static const UINT32 s_MaximumDepressionMaximumArea;                           
   static const UINT32 s_MaximumDepressionMaximumNullArea;                          
   static const double s_MaximumDepressionMaximumDepth;                          
   static const UINT32 s_MaximumDepressionMinimumDepthArea;                         
                         
   static UINT32 GetDefaultInlet (
      WATERSHED *watershed
      ) {
      if (watershed == 0) return DefaultInlet;
      return watershed->GetDefaultInlet();
      }

   static UINT32 GetDefaultOutlet (
      WATERSHED *watershed
      ) {
      if (watershed == 0) return DefaultOutlet;
      return watershed->GetDefaultOutlet();
      }

   static UINT32 GetDefaultBasin (
      WATERSHED *watershed
      ) {
      if (watershed == 0) return DefaultBasin;
      return watershed->GetDefaultBasin();
      }

   static UINT32 GetDefaultBranch (
      WATERSHED *watershed
      ) {
      if (watershed == 0) return DefaultBranch;
      return watershed->GetDefaultBranch();
      }

   // CONSTRUCTION / DESTRUCTION

   WATERSHED (                               
      const RVC::OBJITEM& objitem               
      );

   ~WATERSHED (                              
      );

   // OPERATORS

   // METHODS
         
   ERRVALUE Compute (
      const FLAGS flags                      
      );

   ERRVALUE FillDepressions (
      const SIMPLE_ARRAY<INT32> &depressions,      
      const FLAGS flags                            
      );

   ERRVALUE ComputeElements (
      const SIMPLE_ARRAY<LPOINT2D> &seeds,   
      const FLAGS flags                      
      );

   ERRVALUE ComputeFlowpathSegmentation (
      const SEGMENTATIONPARAMETER parameter,
      const SEGMENTATIONINTERVAL interval,
      const DOUBLE_ARRAY<double>& values
      );

   ERRVALUE ComputeExtraRasters (
      const FLAGS flags                      
      );

   bool GetObjItem (
      const OUTPUT id,                       
      RVC::OBJITEM& objitem
      ) const;

   INT32 GetNumberOfObjects (
      ) const;

   STATUS GetStatus (
      ) const {
      return m_Status;
      }


   ERRVALUE SetMask (                        
      const RVC::OBJITEM& objitem,
      const bool use
      );


   UINT32 GetBasin (
      ) const {
      return m_Basin;
      }

   void SetBasin (
      const UINT32 basin                     
      ) {
      if (basin < MinimumBasin) m_Basin = MinimumBasin;
      else m_Basin = basin;
      return;
      }

   UINT32 GetBranch (
      ) const {
      return m_Branch;
      }

   void SetBranch (
      const UINT32 branch                    
      ) {
      if (branch < MinimumBranch) m_Branch = MinimumBranch;
      else m_Branch = branch;
      return;
      }

   UINT32 GetOutlet (
      ) const {
      return m_Outlet;
      }

   void SetOutlet (
      const UINT32 outlet                    
      ) {
      if (outlet < MinimumOutlet) m_Outlet = MinimumOutlet;
      else m_Outlet = outlet;
      return;
      }

   UINT32 GetInlet (
      ) const {
      return m_Inlet;
      }

   void SetInlet (
      const UINT32 inlet                     
      ) {
      if (inlet < MinimumInlet) m_Inlet = MinimumInlet;
      else m_Inlet = inlet;
      return;
      }

   bool IsValleySeparated (
      ) const {
      return m_ValleySeparation;
      }

   void SetValleySeparation (
      const bool separation                  
      ) {
      m_ValleySeparation = separation;
      return;
      }

   UINT32 DepressionMaximumArea (
      ) const {
      return m_DepressionMaximumArea;
      }

   void SetDepressionMaximumArea (
      const UINT32 area                   
      ) {
      m_DepressionMaximumArea = bound(area, s_MinimumDepressionMaximumArea, s_MaximumDepressionMaximumArea);
      return;
      }

   UINT32 DepressionMaximumNullArea (
      ) const {
      return m_DepressionMaximumNullArea;
      }

   void SetDepressionMaximumNullArea (
      const UINT32 area                   
      ) {
      m_DepressionMaximumNullArea = bound(area, s_MinimumDepressionMaximumNullArea, s_MaximumDepressionMaximumNullArea);
      return;
      }

   double DepressionMaximumDepth (
      ) const {
      return m_DepressionMaximumDepth;
      }

   void SetDepressionMaximumDepth (
      const double depth                     
      ) {
      m_DepressionMaximumDepth = bound(depth, s_MinimumDepressionMaximumDepth, s_MaximumDepressionMaximumDepth);
      return;
      }

   UINT32 DepressionMinimumDepthArea (
      ) const {
      return m_DepressionMinimumDepthArea;
      }

   void SetDepressionMinimumDepthArea (
      const UINT32 area                   
      ) {
      m_DepressionMinimumDepthArea = bound(area, s_MinimumDepressionMinimumDepthArea, s_MaximumDepressionMinimumDepthArea);
      return;
      }

   bool GetPutNullCellAtUnfilledDepression (
      ) const {
      return m_PutNullCellAtUnfilledDepression;
      }

   void SetPutNullCellAtUnfilledDepression (
      const bool value                 
      ) {
      m_PutNullCellAtUnfilledDepression = value;
      return;
      }


   const INT32 GetNumberOfWatershedPolygons (
      ) const {
      if (m_Attribute == 0) return 0;
      return (m_Attribute->GetNumberOfWatershedPolygons() - 1);
      };

   bool GetWatershedPolygon (
      POLYGON &polygon,                      
      const INT32 index                      
      ) {
      if (m_Attribute == 0) return false;
      return m_Attribute->GetWatershedPolygon(index, polygon);
      }

   const INT32 GetNumberOfWatershedPolygonsWithDepression (
      ) const {
      if (m_Attribute == 0) return 0;
      return m_Attribute->GetNumberOfWatershedPolygonsWithDepression();
      }

   const INT32 GetNumberOfVectorPolygons (
      ) const {
      if (m_Attribute == 0) return 0;
      return (m_Attribute->GetNumberOfVectorPolygons());
      };

   const INT32 GetIDOfWatershedPolygonAtPoint (
      const DPOINT2D &point                        
      );

   const INT32 GetIDOfWatershedPolygonForVectorPolygon (
      const INT32 index                      
      ) const {
      if (m_Attribute == 0) return -1;
      return (m_Attribute->GetIDOfWatershedPolygonForVectorPolygon(index));
      };

   const INT32 GetNumberOfPours (
      ) const {
      if (m_Attribute == 0) return 0;
      return (m_Attribute->GetNumberOfPours());
      };

   bool GetPour (
      POUR &pour,                            
      const INT32 index                      
      ) {
      if (m_Attribute == 0) return false;
      return m_Attribute->GetPour(index, pour);
      }

   const INT32 GetNumberOfDoublePours (
      ) const {
      if (m_Attribute == 0) return 0;
      return m_Attribute->GetNumberOfDoublePours();
      }

   UINT32 GetDefaultInlet (
      ) {
      const double z = (double)MAX(m_NumColumns, m_NumLines) / 1024;
      return FAST_ROUND_POSITIVE(MinimumInlet * MAX(1.0, z));
      }

   UINT32 GetDefaultOutlet (
      ) {
      const double z = (double)MAX(m_NumColumns, m_NumLines) / 1024;
      return FAST_ROUND_POSITIVE(MinimumOutlet * MAX(1.0, z));
      }

   UINT32 GetDefaultBasin (
      ) {
      const double x = (double)m_NumColumns / 1024;
      const double y = (double)m_NumLines / 1024;
      return FAST_ROUND_POSITIVE(MinimumBasin * MAX(1.0, x * y));
      }

   UINT32 GetDefaultBranch (
      ) {
      const double x = (double)m_NumColumns / 1024;
      const double y = (double)m_NumLines / 1024;
      return FAST_ROUND_POSITIVE(MinimumBranch * MAX(1.0, x * y));
      }

private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

   // ENUMERATIONS

   enum RASTERS {
      RASTER_First            = 0,              
      RASTER_Adjusted         = 0,           
      RASTER_Extrema          = 1,           
      RASTER_FlowDirection    = 2,           
      RASTER_Accumulation     = 3,           
      RASTER_Watershed        = 4,           
      RASTER_CatchmentArea    = 5,           
      RASTER_TopographicIndex = 6,           
      RASTER_MaximumUpFlow    = 7,           
      RASTER_DownFlow         = 8,           
      RASTER_Temp             = 9,           
      RASTER_Bin              = 10,          
      RASTER_Count            = 11
      };

   enum VECTORS {
      VECTOR_First         = 0,              
      VECTOR_Watershed     = 0,              
      VECTOR_FlowPath      = 1,              
      VECTOR_Basin         = 2,              
      VECTOR_Ridge         = 3,              
      VECTOR_UserFlowPath  = 4,              
      VECTOR_UserBasin     = 5,              
      VECTOR_SegmentedFlowPath = 6,          
      VECTOR_Count         = 7
      };

   struct STREAMORDER { 
      INT32 m_Line;
      INT32 m_Parent;
      UINT32 m_Accumulation;
      INT32 m_Child;
      UINT32 m_ChildAccumulation;
      UINT8 m_NumChildren;
      INT32 m_ID;
      UINT16 m_Horton;
      UINT16 m_Strahler;
      UINT16 m_Shreve;
      UINT16 m_Scheidegger;

      STREAMORDER (
         ) :
         m_Line(-1),
         m_Parent(-1),
         m_Accumulation(0),
         m_Child(-1),
         m_ChildAccumulation(0),
         m_NumChildren(0),
         m_ID(0),
         m_Horton(0),
         m_Strahler(0),
         m_Shreve(0),
         m_Scheidegger(0)
         {
         };

      };

   struct ORDERSTAT {
      double length;
      double area;
      INT32 number;
      };

   // TYPEDEFS

   typedef std::map<INT32, ORDERSTAT> ORDERSTATMAP;

   // MEMBERS

   const RVC::OBJITEM m_DEMObjItem;
   INT32 m_NumLines;
   INT32 m_NumColumns;

   RVC::OBJECT m_RasterTempFiles[RASTER_Count];
   RVC::RASTER m_Rasters[RASTER_Count];
   RVC::OBJECT m_VectorTempFiles[VECTOR_Count];
   RVC::VECTOR m_Vectors[VECTOR_Count];
   RVC::OBJITEM m_ObjItems[OUTPUT_Count];
   ATTRIBUTE *m_Attribute;                   
   STATUS m_Status;                          
   UINT32 m_Outlet;                          
   UINT32 m_Inlet;                           
   UINT32 m_Branch;                          
   UINT32 m_Basin;                           
   bool m_ValleySeparation;                  
   UINT32 m_DepressionMaximumArea;                          
   UINT32 m_DepressionMaximumNullArea;                         
   double m_DepressionMaximumDepth;                         
   UINT32 m_DepressionMinimumDepthArea;                           
   bool m_PutNullCellAtUnfilledDepression;                  

   bool m_UseMask;
   RVC::OBJITEM m_MaskObjItem;               
   SIMPLE_ARRAY<UINT8> m_NullBuffer;

   FLAGS m_Flags;


   // CONSTRUCTION / DESTRUCTION

   WATERSHED (                            
      );

   WATERSHED (                            
      const WATERSHED &rhs
      );

   // OPERATORS

   WATERSHED& operator= (                 
      const WATERSHED& rhs
      );


   // METHODS

   ERRVALUE CheckNeededSpace ();
   ERRVALUE CopyMaskAsNull ();

   ERRVALUE MakeAdjustedElevation (RVC::RASTER& dem);
   ERRVALUE MakeFlowDirection (RVC::RASTER& dem);
   ERRVALUE MakeAccumulation (RVC::RASTER& dem);
   ERRVALUE MakeExtrema (RVC::RASTER& dem);
   ERRVALUE MakeWatershedRaster (RVC::RASTER& dem);
   ERRVALUE MakeTemp (RVC::RASTER& dem);
   ERRVALUE MakeBin (RVC::RASTER& dem);
   ERRVALUE MakeCatchmentArea (RVC::RASTER& dem);
   ERRVALUE MakeTopographicIndex (RVC::RASTER& dem);
   ERRVALUE MakeMaximumUpFlow (RVC::RASTER& dem);
   ERRVALUE MakeDownFlow (RVC::RASTER& dem);

   ERRVALUE MakeVector (
      RVC::RASTER& dem,
      const RVC::DESCRIPTOR& descriptor,
      const WATERSHED::VECTORS id,
      const RVC::VECTOR::POINTTYPE PointType,
      const RVC::VECTOR::TOPOLOGYTYPE TopologyType
      );

   ERRVALUE ComputeAccumulation ();
   ERRVALUE ComputeAttribute ();
   ERRVALUE ComputeBasin (const SIMPLE_ARRAY<LPOINT3D> &seeds);
   ERRVALUE ComputeBasin (const SIMPLE_ARRAY<LPOINT2D> &seeds);
   ERRVALUE ComputeDatabases ();
   ERRVALUE ComputeExtrema ();
   ERRVALUE ComputeFlowDirection ();
   template<typename _TT> ERRVALUE ComputeFlowPath (SIMPLE_ARRAY<LPOINT3D> &seeds);
   template<typename _TT> ERRVALUE ComputeFlowPath (const SIMPLE_ARRAY<LPOINT2D> &seeds);
   template<typename _TT> ERRVALUE ComputeRidge ();        
   ERRVALUE ComputeStandard ();
   ERRVALUE ComputeBasinTables (const INT32 numBasins);
   ERRVALUE ComputeBasinAttributes (const INT32 numBasins);
   ERRVALUE ComputeWatershedAttributes ();
   ERRVALUE ComputeFlowPathTables ();
   ERRVALUE ComputeVectorTables (const INT32 numBasins);
   ERRVALUE ComputeTableFlowFeatures ();
   ERRVALUE ComputeTableWatershedVectorPolygons ();
   ERRVALUE ComputeTableWatershed ();
   ERRVALUE ComputeTablePour ();
   ERRVALUE ComputeTableLower ();
   ERRVALUE ComputeTableStreamOrder ();
   ERRVALUE ComputeTableStreamProperties ();
   ERRVALUE ComputeTableFlowDistance (const VECTORS vid);
   ERRVALUE ComputeTableFlowDown (const VECTORS vid);
   ERRVALUE ComputeTableUpper ();
   ERRVALUE ComputeWatershedRaster ();
   ERRVALUE ComputeWatershedVector ();
   ERRVALUE ComputeCatchmentArea ();
   ERRVALUE ComputeTopographicIndex ();
   template<typename _TT> ERRVALUE CalculateTopographicIndex ();
   ERRVALUE ComputeMaximumUpFlow ();
   ERRVALUE InitMaximumUpFlow ();
   ERRVALUE CalculateMaximumUpFlow ();
   ERRVALUE ComputeDownFlow ();
   ERRVALUE ComputeBoundaries (const VECTORS id, const INT32 limit);
   ERRVALUE FillDepressions ();
   ERRVALUE CalculateLowerDepressions (const INT32 watershed, SIMPLE_ARRAY<bool> &filling);
   ERRVALUE CalculateUpperDepressions (const INT32 watershed, SIMPLE_ARRAY<bool> &filling);
   ERRVALUE CalculateDepressionsToBeFilled (SIMPLE_ARRAY<bool> &filling, const SIMPLE_ARRAY<INT32> &depressions);
   void DestroyInternalObjects ();
   ERRVALUE MakeRasterObject (const RASTERS id);
   ERRVALUE MakeVectorObject (const VECTORS id);
   RVC::RASTER& GetRasterObject (const RASTERS id, const bool checkifopen = true);
   RVC::OBJECT& GetRasterTempFile (const RASTERS id);
   RVC::VECTOR& GetVectorObject (const VECTORS id, const bool checkifopen = true);
   RVC::OBJECT& GetVectorTempFile (const VECTORS id);
   ERRVALUE  MakeDefaultRasterCalculation ();
   ERRVALUE  MakeDefaultRasterCalculation (const RASTERS id);
   void SetObjItem (const OUTPUT id);
   ERRVALUE ClearVectorObject (const VECTORS id);
   void ClearObjItem (const OUTPUT id);
   void ClearObjItems ();

   ERRVALUE CopyObjectTo (RVC::OBJECT& object, const char *filename);

   template<typename _TT> ERRVALUE CalculateExtrema (const _TT tmin, const _TT tmax);
   template<typename _TT> ERRVALUE ReadAdjLine (RVC::NULLMASK& NullMask, _TT* adjbuf, UINT8* vldbuf, const INT32 line);
   template<typename _TT> ERRVALUE ReadAdjLine (_TT* adjbuf, const INT32 line);
   template<typename _TT> void MinMaxAdjLine(const _TT *const adjbuf, const UINT8 *const vldbuf, _TT*  minbuf, _TT*  maxbuf, const _TT tmin, const _TT tmax, const INT32 numColumns);
   template<typename _TT> ERRVALUE CalculateFlowDirection (const _TT tmax);
   ERRVALUE InitFlowDirectionOnFlat ();
   template<typename _TT> ERRVALUE ResolveFlowDirectionOnFlat ();
   ERRVALUE InitAccumulation ();
   ERRVALUE CalculateAccumulation ();
   ERRVALUE ReadDirLine(UINT8* dirbuf, const INT32 line);
   ERRVALUE ReadAccLine(UINT32* accbuf, const INT32 line);
   ERRVALUE InitWatershedRaster ();
   ERRVALUE CalculateWatershedRaster ();
   ERRVALUE ComputeBoundaryInitTemp (const INT32 limit);
   ERRVALUE ReadWtrLine(INT32* wtrbuf, const INT32 line);
   ERRVALUE ComputeBoundaryInitBinary ();
   template<typename _TT> ERRVALUE CalculateBoundaries (const VECTORS id);
   template<typename _TT> ERRVALUE ComputeAttributeWatershed ();
   template<typename _TT> ERRVALUE ComputeAttributeLines (RVC::VECTOR& vector);
   template<typename _TT> ERRVALUE ComputeAttributeNodes (RVC::VECTOR& vector);
   template<typename _TT> ERRVALUE ComputeAttributeDepression ();
   template<typename _TT> ERRVALUE FillSelectedDepressions (const SIMPLE_ARRAY<bool> &filling);
   ERRVALUE ComputeBasinMarkPolygons (const SIMPLE_ARRAY<LPOINT3D> &seeds);
   ERRVALUE ComputeBasinMarkPolygons (const SIMPLE_ARRAY<LPOINT2D> &seeds, SIMPLE_ARRAY<INT32>& polygons);
   ERRVALUE ComputeBasinRestorePolygons (const SIMPLE_ARRAY<LPOINT3D> &seeds);
   ERRVALUE ComputeBasinRestorePolygons (const SIMPLE_ARRAY<INT32>& polygons);
   
   #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(WATERSHED::FLAGS)
DEFINE_ENUM_OP_BITWISE(WATERSHED::OUTPUT)
#endif

#endif

---