mi32/geofrmla.h

Go to the documentation of this file.

#ifndef  INC_MI32_GEOFRMLA_H
#define  INC_MI32_GEOFRMLA_H

#ifndef  INC_RVC_TIN_H
#include <rvc/tin.h>
#endif

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

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

#ifndef  INC_MI32_CONTRASTPARM_H
#include <mi32/contrastparm.h>
#endif

#ifndef  INC_MI32_SERIALIZERITEM_H
#include <mi32/serializeritem.h>
#endif

#if !defined(INC_MI32_XBASE_H) && defined(X_NATIVE)
#include <mi32/xbase.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class RASTINTERP;
struct MENUITEM;
struct MxPromptCallbackStruct;
namespace SML {
   class SYMBOL;
   class EDITOR;
   class CONTEXT;
   }
#endif


class GEOFORMULA {
   public:

      // Do not change the values as they are stored in serializations.
      enum OUTPUTTYPE {
         OUTPUTTYPE_Numeric =    0,
         OUTPUTTYPE_Color =      1
         };

      // Do not change the values as they are stored in serializations.
      enum EXTENTSMODE {
         EXTENTSMODE_UserDefined =     0,
         EXTENTSMODE_Intersection =    1,
         EXTENTSMODE_Union =           2,
         EXTENTSMODE_Region =          3
         };

      enum SCRIPTFLAGS {
         SCRIPTFLAG_None =          0x00,
         SCRIPTFLAG_AllSymbols =    0x01,
         SCRIPTFLAG_NoParse =       0x02
         };
         //-------------------------------------------------------------------------

      class EDITOR;

      class OBJECT {
         public:

            OBJECT (
               const OBJECT& rhs
               );

            virtual ~OBJECT (
               ) = 0;

            OBJECT& operator= (
               const OBJECT& rhs
               );

            ERRVALUE AddSymbols (
               GEOFORMULA& formula,
               bool OnlyIfUsed = true
               );

            void ClearSymbols (
               );

            void Close (
               );

            const RVC::OBJITEM& GetObjectItem (
               ) const { return (m_objitem); }

            const FILEPATH& GetPath (
               ) const { return (m_objitem.GetFilePath()); }

            const SPATREF::COORDREFSYS& GetCoordRefSys (
               ) const { return (GetMapRegion().GetCoordRefSys()); }

            const REGION2D& GetMapRegion (
               ) const { return (m_MapRegion); }

            const REGION2D& GetObjRegion (
               ) const { return (m_ObjRegion); }

            const MISTRING& GetSymbolName (
               ) const { return (m_SymbolName); }

            ERRVALUE Open (
               );

         protected:

            MISTRING m_SymbolName;              
            SML::SYMBOL *m_symobj;                 
            SIMPLE_ARRAY<DPOINT2D> m_pointbuf;  

            OBJECT (
               const RVC::OBJITEM& objitem
               );

            OBJECT (
               RVC::OBJTYPE objtype,
               INIHANDLE handle,
               int objnum
               );

            OBJECT (
               RVC::OBJTYPE objtype,
               const MISTRING& SymbolName,
               const RVC::OBJITEM& ObjItem
               );

            ERRVALUE SetObjPoint (
               int idx
               );
               
            void WriteDefn (
               INIHANDLE handle,
               int objnum
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            SML::SYMBOL *m_symx;                // Symbol for object X coordinate
            SML::SYMBOL *m_symy;                // Symbol for object Y coordinate
            MAT3X3 m_fwd, m_inv;                // Affine transformation, used if 'm_IsAffine' is set
            bool m_IsAffine;                    // Set if transformation is affine

            RVC::OBJITEM m_objitem;
            REGION2D m_ObjRegion;               // Region defining object extents
            REGION2D m_MapRegion;               // Region defining object extents
            TRANS2D_MAPGEN m_trans;             // Transformation from object to virtual raster

            ERRVALUE CalcObjPoints (
               const GEOFORMULA& formula,
               const DPOINT2D& start,
               const DPOINT2D& inc,
               INT32 numvals
               );

            ERRVALUE SetupTrans (
               GEOFORMULA& formula
               );

            virtual ERRVALUE v_AddSymbols (
               GEOFORMULA& formula,
               bool OnlyIfUsed
               );

            virtual void v_ClearSymbols (
               );

            virtual void v_Close (
               ) = 0;

            virtual ERRVALUE v_Open (
               ) = 0;

            virtual ERRVALUE v_SetObjPoint (
               int idx
               ) = 0;

            virtual void v_WriteDefn (
               INIHANDLE handle,
               int objnum
               ) const = 0;

         friend class GEOFORMULA;
         #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of GEOFORMULA::OBJECT
         //-------------------------------------------------------------------------

      class RASTER : public OBJECT {
         public:

            RASTER (
               const RASTER& rhs
               );

            virtual ~RASTER (
               );

            RASTER& operator= (
               const RASTER& rhs
               );

            void SetContrastType (
               CONTRASTPARM::METHOD ContrastMethod
               ) { m_ContrastMethod = ContrastMethod; }

            void SetContrastUseTable (
               bool contusetable
               ) { m_UseContrastTable = contusetable; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            enum DATATYPE {
               DATATYPE_RasterNumeric =      0,
               DATATYPE_RasterColor =        1,
               DATATYPE_RasterComplex =      2
               };

            RVC::RASTER m_ObjRaster;
            DATATYPE m_datatype;             
            CONTRASTPARM::METHOD m_ContrastMethod;                
            bool m_UseContrastTable;               
            RASTINTERP *m_pRastInterp;
            SML::SYMBOL *m_symval;
            SML::SYMBOL *m_symred;
            SML::SYMBOL *m_symgreen;
            SML::SYMBOL *m_symblue;
            bool m_NeedValue;                

            RASTER (
               const RVC::OBJITEM& ObjItem
               );

            RASTER (
               INIHANDLE handle,
               int objnum
               );

            RASTER (
               const MISTRING& SymbolName,
               const RVC::OBJITEM& ObjItem
               );

            ERRVALUE SerialWrite (
               SERIALIZER& serializer
               );
            #endif // GENERATING_DOXYGEN_OUTPUT

            virtual ERRVALUE v_AddSymbols (
               GEOFORMULA& formula,
               bool OnlyIfUsed
               );

            virtual void v_ClearSymbols (
               );

            virtual void v_Close (
               );

            virtual ERRVALUE v_Open (
               );

            virtual ERRVALUE v_SetObjPoint (
               int idx
               );

            virtual void v_WriteDefn (
               INIHANDLE handle,
               int objnum
               ) const;

         friend class GEOFORMULA;
         friend class EDITOR;
         }; // End of GEOFORMULA::RASTER
         //-------------------------------------------------------------------------

      class VECTOR : public OBJECT {
         public:

            VECTOR (
               );

            VECTOR (
               const VECTOR& rhs
               );

            virtual ~VECTOR (
               );

            VECTOR& operator= (
               const VECTOR& rhs
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            RVC::VECTOR m_VectObj;
            
            VECTOR (
               const RVC::OBJITEM& ObjItem
               );

            VECTOR (
               INIHANDLE handle,
               int objnum
               ):
               OBJECT(RVC::OBJTYPE_Vector,handle,objnum)
               { }

            VECTOR (
               const MISTRING& SymbolName,
               const RVC::OBJITEM& ObjItem
               );

            ERRVALUE SerialWrite (
               SERIALIZER& serializer
               );
            #endif // GENERATING_DOXYGEN_OUTPUT

            virtual void v_Close (
               );

            virtual ERRVALUE v_Open (
               );

            virtual ERRVALUE v_SetObjPoint (
               int idx
               );

            virtual void v_WriteDefn (
               INIHANDLE handle,
               int objnum
               ) const;

         friend class GEOFORMULA;
         }; 
         //-------------------------------------------------------------------------

      class TIN : public OBJECT {
         public:

            TIN (
               );

            TIN (
               const TIN& rhs
               );

            virtual ~TIN (
               );

            TIN& operator= (
               const TIN& rhs
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            RVC::TIN m_TinObj;
            SML::SYMBOL *m_symval;

            TIN (
               const RVC::OBJITEM& ObjItem
               );

            TIN (
               INIHANDLE handle,
               int objnum
               ):
               OBJECT(RVC::OBJTYPE_TIN,handle,objnum)
               { }

            TIN (
               const MISTRING& SymbolName,
               const RVC::OBJITEM& ObjItem
               );

            ERRVALUE SerialWrite (
               SERIALIZER& serializer
               );
            #endif // GENERATING_DOXYGEN_OUTPUT

            virtual ERRVALUE v_AddSymbols (
               GEOFORMULA& formula,
               bool OnlyIfUsed
               );

            virtual void v_ClearSymbols (
               );

            virtual void v_Close (
               );

            virtual ERRVALUE v_Open (
               );

            virtual ERRVALUE v_SetObjPoint (
               int idx
               );

            virtual void v_WriteDefn (
               INIHANDLE handle,
               int objnum
               ) const;

         friend class GEOFORMULA;
         }; // End of GEOFORMULA::TIN
         //-------------------------------------------------------------------------

      class VALUE {
         public:

            VALUE (
               );

            VALUE (
               const VALUE& rhs
               );

            virtual ~VALUE (
               ) {
               }

            VALUE& operator= (
               const VALUE& rhs
               );

            void ClearSymbol (
               ) { m_Symbol = 0; }

            void CreateSymbol (
               SML::CONTEXT *context
               );

            double GetDefaultValue (
               ) const { return (m_DefaultValue); }

            const MISTRING& GetSymbolName (
               ) const { return (m_SymbolName); }

            void SetDefaultValue (
               double value
               ) { m_DefaultValue = m_UserValue = value; }

            void SetSymbolName (
               const MIUNICODE* SymbolName
               ) { m_SymbolName = SymbolName; }

            void SetUserValue (
               double value
               ) { m_UserValue = value; }

            void WriteDefn (
               INIHANDLE handle,
               int idx
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            MISTRING m_SymbolName;              
            double m_DefaultValue;              
            double m_UserValue;                 
            SML::SYMBOL *m_Symbol;                 

            VALUE (
               INIHANDLE handle,
               int valnum
               );

            VALUE (
               const MIUNICODE *name,
               double dftvalue
               );

            static const SERIALIZERITEM* SerialGetItemDef ();

            ERRVALUE SerialRead (
               SERIALIZER& serializer
               );

            ERRVALUE SerialWrite (
               SERIALIZER& serializer
               );

         #endif // GENERATING_DOXYGEN_OUTPUT
         friend class GEOFORMULA;
         friend class EDITOR;
         }; // End of GEOFORMULA::VALUE
         //-------------------------------------------------------------------------

   #ifdef X_NATIVE
      class EDITOR {
         public:

            explicit EDITOR (
               GEOFORMULA& formula
               );

            ~EDITOR (
               ) {
               }

            bool CheckValid (
               Widget pageform,
               int scriptpage
               );

            Widget CreateFormExtents (
               Widget pwidget,
               void *arglist,
               int argcount
               );

            void CreatePageObjects (Widget);

            void CreatePageValues (Widget);

            void CreatePageScript (Widget);

            void DisableUpdateContext (
               ) { ++m_UpdateContextDisabled; }

            void EnableUpdateContext (
               ) { if (m_UpdateContextDisabled) --m_UpdateContextDisabled; }

            SML::EDITOR* GetScriptEditHandle (
               ) const {
               return (m_qehandle);
               }

            const MISTRING& GetScript (
               ) const;

            void* GetTextEditHandle (
               ) const {
               return (m_tehandle);
               }

            bool IsChanged (
               ) const { return (m_IsChanged); }

            int Reset (
               );

            ERRVALUE SelectExtentsRegion (
               );

            void SetChanged (
               bool ischanged = true
               ) { m_IsChanged = ischanged; }

            void SetMsgLine (
               Widget MsgLine
               );

            void ShowAllDetails (
               );

            void ShowObjListDetails (
               bool show = true
               );

            void ShowValListDetails (
               bool show = true
               );

            int UpdateObjects (
               );

            void UpdateScriptContext (
               bool doinit
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            struct OBJINFO {

               EDITOR& m_editor;
               OBJECT& m_object;
               Widget m_form;
               Widget m_DetailsTB;
               Widget m_SymbolP;
               Widget m_ObjectLabel;
               Widget m_detform;
               Widget m_ContrastMethodOM;
               Widget m_usecontabTB;
               MIUNICODE m_symname[32];

               OBJINFO (
                  EDITOR& editor,
                  OBJECT& object
                  ):
                  m_editor(editor),
                  m_object(object)
                  {
                  }
               };

            struct VALINFO {

               EDITOR& m_editor;
               VALUE& m_value;
               Widget m_form;
               Widget m_SymbolP;
               Widget m_detform;
               MIUNICODE m_symname[32];

               VALINFO (
                  EDITOR& editor,
                  VALUE& value
                  ):
                  m_editor(editor),
                  m_value(value)
                  {
                  }
               };

            GEOFORMULA& m_Formula;                 
            Widget m_Shell;
            Widget m_MsgLine;
            Widget m_ObjectsPage;
            Widget m_ObjectsRC;
            Widget m_ShowObjListDetailsTB;
            Widget m_ValuesPage;
            Widget m_ValuesRC;
            Widget m_ShowValListDetailsTB;
            Widget m_ScriptPage;
            Widget m_ScriptXeT;
            Widget m_ExtentsOM;
            Widget m_ExtentsRegionPB;
            Widget m_ExtentsRegionXeT;
            void *m_tehandle;                      
            SML::EDITOR *m_qehandle;                  
            bool m_IsChanged;
            bool m_HasRaster;
            bool m_ShowObjListDetails;
            bool m_ShowValListDetails;
            UINT32 m_UpdateContextDisabled;
            MIUNICODE m_NewValueName[16];
            double m_NewValueDefault;

            MILIST<OBJINFO> m_ObjInfoList;
            MILIST<VALINFO> m_ValInfoList;
            REGION2D m_MapRegionUnion;                // Union of selected object MapRegions
            REGION2D m_MapRegionIntersection;         // Intersection of selected object MapRegions

            static void CB_AddValue (Widget, void*, void*);
            static void CB_OptionExtentsMode (Widget, void*, void*);
            static void CB_OptionRastContType (Widget, void*, void*);
            static void CB_SelectExtentsRegion (Widget, void*, void*);
            static void CB_ToggleRastContUseTab (Widget, void*, void*);

            static MENUITEM* GetMenuOptionContrast ();
            static MENUITEM* GetMenuOptionExtentsMode ();

            static void PCB_ChangeObjectSymbolName (
               MxPromptCallbackStruct *cbs,
               void *vobjinfo
               );

            static void PCB_ChangeValueSymbolName (
               MxPromptCallbackStruct *cbs,
               void *vobjinfo
               );

            static bool NewValueCheckOK (
               void *veditor
               );

            static Widget NewValueCreateForm (
               Widget pwidget,
               void *veditor,
               void *arglist,
               int argcount
               );

            void ClearMessage (
               ) const;

            void CreateObjectForm (
               OBJECT& obj,
               const char *IconName
               );

            void CreateValueForm (
               VALUE& val
               );

            void SetSensitive () const;

            EDITOR (const EDITOR&);
            EDITOR& operator= (const EDITOR&);
            #endif // GENERATING_DOXYGEN_OUTPUT

         friend class GEOFORMULA;
         }; // End of GEOFORMULA::EDITOR
   #endif
         //-------------------------------------------------------------------------

      GEOFORMULA (
         );

      GEOFORMULA (
         const GEOFORMULA& rhs
         );

      ~GEOFORMULA (
         );

      GEOFORMULA& operator= (
         const GEOFORMULA& rhs
         );

      ERRVALUE AddValue (
         const MIUNICODE *SymbolName,           
         double value                        
         );

      ERRVALUE CreateFromObjects (
         const RVC::OBJITEMLIST& objitems
         );

   #ifdef USE_MGUI
      ERRVALUE DlgSelectExtentsRegion (
         MDLGPARENT dlgparent,
         const REGION2D *testregion = 0               
         );
   #endif

   #ifdef USE_MGUI
      ERRVALUE DlgSelectObjects (
         MDLGPARENT dlgparent
         );
   #endif

      ERRVALUE Evaluate (
         const DPOINT2D& start,
         const DPOINT2D& increment,
         INT32 numvals,
         void *buffer,
         UINT8 *omask
         );

      const REGION2D& GetExtMapRegion (
         ) const { return (m_ExtMapRegion); }

      ERRVALUE GetFirstObjectCoordRefSys (
         SPATREF::COORDREFSYS& CoordRefSys   
         ) const;

      ERRVALUE GetMinRasterCellSize (
         double& MinCellSize                 
         ) const;

      int GetNumObjects (
         ) const {
         return (m_Rasters.GetNumItems() + m_Vectors.GetNumItems() + m_TINs.GetNumItems());
         }

      void GetObjItems(RVC::OBJITEMLIST& objitems);

      const MILIST<RASTER>& GetObjectListRaster (
         ) const {
         return (m_Rasters);
         }

      const MILIST<TIN>& GetObjectListTIN (
         ) const {
         return (m_TINs);
         }

      const MILIST<VECTOR>& GetObjectListVector (
         ) const {
         return (m_Vectors);
         }

      OUTPUTTYPE GetOutputType (
         ) const {
         return (m_OutputType);
         }

      const MISTRING& GetScript (
         ) const {
         return (m_Script);
         }

      ERRVALUE GetTransToExtCRS (
         TRANS2D_MAPGEN& Trans,              
         bool dooutput = false               
         ) const;

      ERRVALUE OpenObjects (
         );

      ERRVALUE ReadDefn (
         const FILEPATH& filepath
         );

      ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         );

      void SetExtMapCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) { m_ExtMapRegion.SetCoordRefSys(CoordRefSys); m_Trans.SetOutputMapCoordRefSys(CoordRefSys); }

      ERRVALUE SetObjItems (const RVC::OBJITEMLIST& objitems);

      void SetOutputCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) { m_Trans.SetInputMapCoordRefSys(CoordRefSys); }

      void SetOutputTrans (
         const MAT3X3 fwd,
         const MAT3X3 inv
         ) { m_Trans.SetInputTrans(fwd,inv); }

      void SetOutputTrans (
         const TRANS2D_AFFINE& trans
         ) { m_Trans.SetInputTrans(trans); }

      void SetOutputTrans (
         const TRANS2D_MAPGEN& trans
         ) { m_Trans.CopyOutputToInput(trans); }

      void SetOutputTransIdentity (
         ) { m_Trans.SetInputTransIdentity(); }

      void SetOutputType (
         OUTPUTTYPE OutputType
         ) { m_OutputType = OutputType; }

      void SetScript (
         const MIUNICODE* script
         ) { m_Script = script; }

      ERRVALUE Start (
         const DRECT2D *extents,
         SCRIPTFLAGS flags = SCRIPTFLAG_None
         );

      void Stop (
         );

      ERRVALUE WriteDefn (
         const FILEPATH& filepath
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      OUTPUTTYPE m_OutputType;                  
      EXTENTSMODE m_ExtentsMode;                
      SML::CONTEXT *m_Context;                     
      int m_Segment;                            
      SML::SYMBOL *m_symred;                       
      SML::SYMBOL *m_symgreen;                     
      SML::SYMBOL *m_symblue;                   
      bool m_AllAffine;                         
   #ifdef X_NATIVE
      EDITOR *m_editor;
   #endif

      MILIST<RASTER> m_Rasters;                 
      MILIST<VECTOR> m_Vectors;                 
      MILIST<TIN> m_TINs;                       
      MILIST<VALUE> m_Values;
      MISTRING m_Script;                        
      RVC::OBJITEM m_ObjItemRegion;
      REGION2D m_ExtMapRegion;                  
      TRANS2D_MAPGEN m_Trans;                   
      SIMPLE_ARRAY<DPOINT2D> m_ipointbuf;

      static const SERIALIZERITEM* SerialGetItemDef ();
      static ERRVALUE SerializerCB_Object (SERIALIZER&, const SERIALIZERITEM*, void*, SERIALIZERITEM::ACTION);
      static ERRVALUE SerializerCB_Value (SERIALIZER&, const SERIALIZERITEM*, void*, SERIALIZERITEM::ACTION);

      ERRVALUE AddObjectRegion (
         const OBJECT& object
         );

      SML::SYMBOL* AddSymbol (
         const MISTRING& basename,
         const char* subname,
         bool OnlyIfUsed
         );

      void Clear ();

      void Copy (
         const GEOFORMULA& rhs
         );

      OBJECT* FindObjectByName (
         const MIUNICODE *symname
         );

      const VALUE* FindValueByName (
         const MIUNICODE *symname
         ) const;

      const OBJECT* GetFirstObject () const;

      int GetNumNameUses (const MISTRING& symname) const;

      ERRVALUE InitQuery (
         SCRIPTFLAGS flags = SCRIPTFLAG_None
         );

      bool SetObjectSymbolName (
         OBJECT& obj,
         const MIUNICODE *symname
         );

      bool SetValueSymbolName (
         VALUE& obj,
         const MIUNICODE *symname
         );

      void StopQuery ();
      #endif // GENERATING_DOXYGEN_OUTPUT

   friend class EDITOR;
   friend class OBJECT;
   friend class RASTER;
   friend class VECTOR;
   friend class TIN;
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(GEOFORMULA::SCRIPTFLAGS)
#endif

#endif   // INC_MI32_GEOFRMLA_H

---