rvc/rasterthemeparm.h

Go to the documentation of this file.

#ifndef INC_RVC_RASTERTHEMEPARM_H
#define INC_RVC_RASTERTHEMEPARM_H

#ifndef INC_RVC_SIMPLE_H
   #include <rvc/simple.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif


namespace RVC {
class OBJMAKEPARMS;     // Forward Declaration

class RASTERTHEMEPARM : public RVC::SIMPLE {
   public:

      enum DISTRIB {
         DISTRIB_UserDefined = 0,
         DISTRIB_EqualCount,
         DISTRIB_EqualInterval,
         };

      enum ROUNDMODE {
         ROUNDMODE_None = 0,
         ROUNDMODE_Closest,
         ROUNDMODE_Down,
         ROUNDMODE_Up
         };

      enum COLORPATH {
         COLORPATH_Auto = 0,
         COLORPATH_RGB,
         COLORPATH_HISCW,
         COLORPATH_HISCCW,
         COLORPATH_HBSCW,
         COLORPATH_HBSCCW,
         COLORPATH_MaxAuto = COLORPATH_HBSCCW
         };

      struct SPREAD {
         INT16 MinClass;                  
         INT16 MaxClass;                  
         UINT8 AllClasses;                
         UINT8 DoColor;                   
         COLORPATH ColorPath;             
         COLOR StartColor;                
         COLOR EndColor;                  
         };

      RASTERTHEMEPARM ();

      RASTERTHEMEPARM (
         const RVC::RASTERTHEMEPARM& rhs
         );

      virtual ~RASTERTHEMEPARM ();

      RVC::RASTERTHEMEPARM& operator= (
         const RVC::RASTERTHEMEPARM& rhs
         );

      INT16 GetNumClasses () const
         { return (m_NumClasses); }

      bool IsUpperInclusive () const
         { return (m_IsUpperInclusive); }

      DISTRIB GetDistribMode () const
         { return (m_DistribMode); }

      ROUNDMODE GetRoundMode () const
         { return (m_RoundMode); }

      bool IsFirstClassExcluded () const
         { return (m_ExcludeFirstClass); }

      bool IsLastClassExcluded () const
         { return (m_ExcludeLastClass); }

      bool IsLimitedToDataRange () const
         { return (m_LimitToDataRange); }

      double GetRoundTo () const
         { return (m_RoundTo); }

      const SIMPLE_ARRAY<double>& GetClassBoundaries () const
         { return (m_ClassBoundaries); }

      const SPREAD& GetSpread () const
         { return (m_Spread); }

      void SetNumClasses (INT16 numclasses)
         { m_NumClasses = numclasses; }

      void SetUpperIsInclusive (bool isupperinclusive)
         { m_IsUpperInclusive = isupperinclusive; }

      void SetDistribMode (DISTRIB distribmode)
         { m_DistribMode = distribmode; }

      void SetRoundMode (ROUNDMODE roundmode)
         { m_RoundMode= roundmode; }

      void SetExcludeFirstClass (bool excludefirstclass)
         { m_ExcludeFirstClass = excludefirstclass; }

      void SetExcludeLastClass (bool excludelastclass)
         { m_ExcludeLastClass = excludelastclass; }

      void SetLimitToDataRange (bool limittorange)
         { m_LimitToDataRange = limittorange; }

      void SetRoundTo (double roundto)
         { m_RoundTo = roundto; }

      void SetClassBoundaries (const SIMPLE_ARRAY<double> &boundaries);

      void SetSpread (const SPREAD &spread);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      bool m_IsUpperInclusive;                  // For floating point rasters set true if you want the cell on the boundary to be included in the upper range
      INT16 m_NumClasses;                       // Number of classes
      DISTRIB m_DistribMode;                    // Distribution mode, DISTRIB_...
      ROUNDMODE m_RoundMode;                    // Rounding mode, ROUNDMODE_...
      bool m_ExcludeFirstClass;                 // Exclude first class from distribution
      bool m_ExcludeLastClass;                  // Exclude last class from distribution
      bool m_LimitToDataRange;                  // Limit class value ranges to existing data range
      double m_RoundTo;                         // Interval to round to
      double m_lastmaxval;                      // Last maximum range value
      SIMPLE_ARRAY<double> m_ClassBoundaries;  // Boundaries of the ranges for the classes
      SPREAD m_Spread;

      // Implementation of RVC::OBJECT virtual methods
      virtual OBJTYPE v_GetDftObjectType () const;

      // Implementation of RVC::SIMPLE virtual methods
      virtual ERRVALUE v_GetDftNameDesc (const OBJECT& parent, DESCRIPTOR& Descriptor);
      virtual ERRVALUE v_MakeData (RVC::OBJMAKEPARMS& ObjMakeParms);
      virtual ERRVALUE v_ReadData (RVC::OBJOPENPARMS& ObjOpenParms);
      virtual ERRVALUE v_WriteData (RVC::OBJOPENPARMS& ObjOpenParms);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };
}     // End of RVC namespace

#endif   // INC_RVC_RASTTHEMEPRM_H

---