geofrmla.h

Go to the documentation of this file.

/**
 * \file geofrmla.h <mi32/geofrmla.h>
 * \brief GeoFormula class definitions
 *
 * \if NODOC
 * $Id: geofrmla.h_v 1.21 2004/07/23 14:23:26 mju Exp $
 *
 * $Log: geofrmla.h_v $
 * Revision 1.21  2004/07/23 14:23:26  mju
 * Add getTransToExtCRS, remove getTransObjToMap.
 *
 * Revision 1.20  2004/07/22 19:43:47  mju
 * Keep separate objregion and mapregion.
 *
 * Revision 1.19  2004/06/30 19:27:34  mju
 * *** empty log message ***
 *
 * Revision 1.18  2004/06/29 14:31:44  mju
 * Add GetTransObjToMap.
 *
 * Revision 1.17  2004/06/29 14:25:29  mju
 * Use region2d.
 *
 * Revision 1.16  2004/06/28 17:55:27  mju
 * Convert to spatref system.
 *
 * Revision 1.15  2004/04/28 15:28:04  mju
 * Add ability to disable scriptcontext updates in editor.
 *
 * Revision 1.14  2004/03/05 15:13:15  mju
 * Use virtual dtor if class has virtual fn.
 *
 * Revision 1.13  2004/02/07 16:16:53  scowan
 * Removed vector and tin object info's.
 *
 * Revision 1.12  2004/02/07 16:06:11  scowan
 * Changed to use rvc interface classes instead of qtree.
 *
 * Revision 1.11  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.10  2003/08/26 21:06:24  mju
 * When create formula from objects adjust duplicate names.
 *
 * Revision 1.9  2002/08/26 14:42:00  mju
 * Avoid shadowing method name with parm name.
 *
 * Revision 1.8  2002/05/16 14:42:02  dwilliss
 * Never mind, MOTU beat me to it.
 *
 * Revision 1.7  2002/05/15 23:27:25  scowan
 * Fixed deprecated stuff.
 *
 * Revision 1.6  2001/02/16 21:16:53  mju
 * Add SetOutputTrans from TRANS2D_MAPGEN.
 *
 * Revision 1.5  2000/11/13 17:19:41  mju
 * win32-native.
 *
 * Revision 1.4  2000/11/13 15:01:02  mju
 * Change so can use as formula layer in GRE.
 *
 * Revision 1.3  2000/11/09 16:01:12  mju
 * Forgot to make FilterObject static.
 *
 * Revision 1.2  2000/11/09 16:00:04  mju
 * Add FilterObject.
 *
 * Revision 1.1  2000/11/08 21:47:41  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_GEOFRMLA_H
#define  INC_MI32_GEOFRMLA_H

#ifndef  INC_SML
#include <mi32/sml.h>
#endif

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

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

#ifndef  INC_MI32_RINTERP_H
#include <mi32/rinterp.h>
#endif

#ifndef  INC_MI32_SERIALIZ_H
#include <mi32/serializ.h>
#endif


//! Geospatial Formula class.
class GEOFORMULA {
   public:

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

      //! Mode for determining extents.
      // 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;

      //! GEOFORMULA::OBJECT
      class OBJECT {
         public:

            //! Default constructor.
            OBJECT (
               );

            //! Copy constructor.
            OBJECT (
               const OBJECT& rhs
               );

            //! Destructor.
            virtual ~OBJECT (
               ) = 0;

            //! Assignment.
            OBJECT& operator= (
               const OBJECT& rhs
               );

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

            virtual void ClearSymbols (
               );

            virtual void Close (
               );

            const RVCGENINFO& GetInfo (
               ) const { return (m_objitem.GetInfo()); }

            RVCINODENUM GetInode (
               ) const { return (m_objitem.GetInode()); }

            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); }

            virtual ERRVALUE Open (
               );

         protected:

            MISTRING m_SymbolName;              //!< Name used in formula script
            RVCFILEHANDLE m_fhandle;            //!< Open file handle
            SMLSYMBOL *m_symobj;                //!< Symbol for object in context
            SIMPLE_ARRAY<DPOINT2D> m_pointbuf;  //!< Point buffer

            //! Construct from RVC object.
            OBJECT (
               const RVCOBJITEM& objitem
               );

            //! Constructor used when reading formula definition.
            OBJECT (
               int objtype,
               INIHANDLE handle,
               int objnum
               );

            //! Constructor used in reading from serialization.
            OBJECT (
               int objtype,
               const MISTRING& SymbolName,
               const FILEPATH& FilePath,
               INT32 ObjectInode
               );

            virtual ERRVALUE SetObjPoint (
               int idx
               );

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

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            SMLSYMBOL *m_symx;                  // Symbol for object X coordinate
            SMLSYMBOL *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

            RVCOBJITEM 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
               );

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

      //! GEOFORMULA::RASTER
      class RASTER : public OBJECT {
         public:

            //! Copy constructor.
            RASTER (
               const RASTER& rhs
               );

            //! Destructor.
            virtual ~RASTER (
               );

            //! Assignment.
            RASTER& operator= (
               const RASTER& rhs
               );

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

            virtual void ClearSymbols (
               );

            virtual void Close (
               );

            virtual ERRVALUE Open (
               );

            void SetContrastType (
               UINT8 conttype
               ) { m_conttype = conttype; }

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

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

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

            RVCRASTINFO m_objinfo;
            DATATYPE m_datatype;             //!< Allowed data type
            UINT8 m_interpmode;              //!< Value interpolation mode (RESAMPLE_... )
            UINT8 m_conttype;                //!< Default contrast type (CTYPE_...)
            bool m_contusetable;             //!< Use contrast table if available
            int m_ohandle;                      //!< Open object handle
            RASTINTERPHANDLE m_interphandle;
            SMLSYMBOL *m_symval;
            SMLSYMBOL *m_symred;
            SMLSYMBOL *m_symgreen;
            SMLSYMBOL *m_symblue;
            CONTPARM m_contparm;             //!< Contrast parameters if needed
            bool m_NeedValue;                //!< Set if need interpolated value
            bool m_DoContrast;               //!< Apply contrast transformation

            //! Construct from RVC object.
            RASTER (
               const FILEPATH& filepath,
               const RVCRASTINFO& objinfo
               );

            //! Constructor used when reading formula definition.
            RASTER (
               INIHANDLE handle,
               int objnum
               );

            //! Constructor used in reading from serialization.
            RASTER (
               const MISTRING& SymbolName,
               const FILEPATH& FilePath,
               INT32 ObjectInode
               );

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

            virtual ERRVALUE SetObjPoint (
               int idx
               );

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

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

      //! GEOFORMULA::VECTOR
      class VECTOR : public OBJECT {
         public:

            //! Default constructor.
            VECTOR (
               );

            //! Copy constructor.
            VECTOR (
               const VECTOR& rhs
               );

            //! Destructor.
            virtual ~VECTOR (
               );

            //! Assignment.
            VECTOR& operator= (
               const VECTOR& rhs
               );

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

            virtual void Close (
               );

            virtual ERRVALUE Open (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            RVC::VECTOR m_VectObj;
            
            //! Construct from RVC object.
            VECTOR (
               const FILEPATH& filepath,
               const RVCVECTINFO& objinfo
               );

            //! Constructor used when reading formula definition.
            VECTOR (
               INIHANDLE handle,
               int objnum
               ):
               OBJECT(OTYPE_VECTOR,handle,objnum)
               { }

            //! Constructor used in reading from serialization.
            VECTOR (
               const MISTRING& SymbolName,
               const FILEPATH& FilePath,
               INT32 ObjectInode
               );

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

            virtual ERRVALUE SetObjPoint (
               int idx
               );

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

         friend class GEOFORMULA;
         }; //! End of GEOFORMULA::VECTOR
         //-------------------------------------------------------------------------

      //! GEOFORMULA::TIN
      class TIN : public OBJECT {
         public:

            //! Default constructor.
            TIN (
               );

            //! Copy constructor.
            TIN (
               const TIN& rhs
               );

            //! Destructor.
            virtual ~TIN (
               );

            //! Assignment.
            TIN& operator= (
               const TIN& rhs
               );

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

            virtual void ClearSymbols (
               );

            virtual void Close (
               );

            virtual ERRVALUE Open (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            RVC::TIN m_TinObj;
            SMLSYMBOL *m_symval;

            //! Construct from RVC object.
            TIN (
               const FILEPATH& filepath,
               const RVCTININFO& objinfo
               );

            //! Constructor used when reading formula definition.
            TIN (
               INIHANDLE handle,
               int objnum
               ):
               OBJECT(OTYPE_TIN,handle,objnum)
               { }

            //! Constructor used in reading from serialization.
            TIN (
               const MISTRING& SymbolName,
               const FILEPATH& FilePath,
               INT32 ObjectInode
               );

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

            virtual ERRVALUE SetObjPoint (
               int idx
               );

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

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

      //! GEOFORMULA::VALUE
      class VALUE {
         public:

            VALUE (
               );

            VALUE (
               const VALUE& rhs
               );

            virtual ~VALUE (
               ) {
               }

            VALUE& operator= (
               const VALUE& rhs
               );

            void ClearSymbol (
               ) { m_Symbol = 0; }

            void CreateSymbol (
               SMLCONTEXT *context
               ) {
               m_Symbol = context->AddSymbol(m_SymbolName,STYPE_Constant);
               m_Symbol->SetValue(m_UserValue);
               return;
               }

            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 UNICODE* SymbolName
               ) { m_SymbolName = SymbolName; }

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

            virtual void WriteDefn (
               INIHANDLE handle,
               int idx
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            MISTRING m_SymbolName;              //!< Name used in formula script
            double m_DefaultValue;              //!< Default value
            double m_UserValue;                 //!< User-specified value
            SMLSYMBOL *m_Symbol;                //!< Symbol in context

            //! Constructor used to read definition.
            VALUE (
               INIHANDLE handle,
               int valnum
               );

            //! Constructor used to create new value
            VALUE (
               const UNICODE *name,
               double dftvalue
               );

            static const SERIALIZER::ITEMDEF* SerialGetItemDef ();

            ERRVALUE SerialRead (
               SERIALIZER& serializer
               ) { return (serializer.Read(SerialGetItemDef(),this)); }

            ERRVALUE SerialWrite (
               SERIALIZER& serializer
               ) { return (serializer.Write("VALUE",SerialGetItemDef(),this)); }

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

      //! GEOFORMULA::EDITOR
   #ifndef WIN32_NATIVE
      class EDITOR {
         public:

            //! Construct editor for specific formula.
            explicit EDITOR (
               GEOFORMULA& formula
               );

            //! Destructor.
            ~EDITOR (
               ) {
               }

            bool CheckValid (
               Widget pageform,
               int scriptpage
               );

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

            void CreatePageObjects (Widget);

            void CreatePageValues (Widget);

            void CreatePageScript (Widget);

            void DisableUpdateContext (
               ) { ++m_UpdateContextDisabled; }

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

            SMLEDITOR* 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_conttypeOM;
               Widget m_usecontabTB;
               UNICODE 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;
               UNICODE m_symname[32];

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

            GEOFORMULA& m_Formula;                 //!< Reference to formula being edited
            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;                      //!< MxTextEdit handle
            SMLEDITOR *m_qehandle;                 //!< Query editor handle
            bool m_IsChanged;
            bool m_HasRaster;
            bool m_ShowObjListDetails;
            bool m_ShowValListDetails;
            UINT32 m_UpdateContextDisabled;
            UNICODE 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*, XmToggleButtonCallbackStruct*);

            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,
               Arg *arglist,
               int argcount
               );

            void ClearMessage (
               ) const {
               MxMsgLineClear(m_MsgLine);
               return;
               }

            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
         //-------------------------------------------------------------------------

      //! Default constructor.
      GEOFORMULA (
         );

      //! Copy constructor.
      GEOFORMULA (
         const GEOFORMULA& rhs
         );

      //! Destructor.
      ~GEOFORMULA (
         );

      GEOFORMULA& operator= (
         const GEOFORMULA& rhs
         );

      //! Filter for input object selection.
      static int FilterObject (
         int fhandle,
         INT32 objinode,
         RVCGENINFO *geninfo,
         void *,
         char *msgkey
         );

      //! Add new "value" symbol to formula.
      ERRVALUE AddValue (
         const UNICODE *SymbolName,          //!< Symbol name
         double value                        //!< Initial value
         );

      //! Create new formula from specified list of objects.
      ERRVALUE CreateFromObjects (
         const RVCOBJITEMLIST& objitems
         );

      //! Display dialog allowing user to select region for extents.
      ERRVALUE DlgSelectExtentsRegion (
         MDLGPARENT dlgparent,
         const REGION2D *testregion = 0               //!< Region to test for overlap with, 0 to allow all regions
         );

      //! Display dialog allowing user to select specific objects to use.
      ERRVALUE DlgSelectObjects (
         MDLGPARENT dlgparent
         );

      //! Evaluate formula for points along specified interval.
      ERRVALUE Evaluate (
         const DPOINT2D& start,
         const DPOINT2D& increment,
         INT32 numvals,
         void *buffer,
         UINT8 *omask
         );

      //! Get extents region.
      const REGION2D& GetExtMapRegion (
         ) const { return (m_ExtMapRegion); }

      //! Get coordinate reference system of first object used in formula (for auto-match).
      ERRVALUE GetFirstObjectCoordRefSys (
         SPATREF::COORDREFSYS& CoordRefSys   //!< Coordinate Reference System returned
         ) const;

      //! Get minimum cell size for all rasters used in formula.
      ERRVALUE GetMinRasterCellSize (
         double& MinCellSize                 //!< Cell size returned, DBL_MAX if no rasters in formula
         ) const;

      //! Get number of objects used in formula.
      int GetNumObjects (
         ) const {
         return (m_Rasters.GetNumItems() + m_Vectors.GetNumItems() + m_TINs.GetNumItems());
         }

      //! Get raster object list.
      const MILIST<RASTER>& GetObjectListRaster (
         ) const {
         return (m_Rasters);
         }

      //! Get TIN object list.
      const MILIST<TIN>& GetObjectListTIN (
         ) const {
         return (m_TINs);
         }

      //! Get vector object list.
      const MILIST<VECTOR>& GetObjectListVector (
         ) const {
         return (m_Vectors);
         }

      //! Get formula output type.
      OUTPUTTYPE GetOutputType (
         ) const {
         return (m_OutputType);
         }

      //! Get formula script.
      const MISTRING& GetScript (
         ) const {
         return (m_Script);
         }

      //! Get transformation from virtual formula object to extents CRS.
      ERRVALUE GetTransToExtCRS (
         TRANS2D_MAPGEN& Trans,              //!< Transformation returned
         bool dooutput = false               //!< Place in output size of transformation
         ) const;

      //! Open objects to use in formula.
      ERRVALUE OpenObjects (
         );

      //! Read previously saved formula definition.
      ERRVALUE ReadDefn (
         const FILEPATH& filepath
         );

      //! Read from serialization.
      ERRVALUE SerialRead (
         SERIALIZER& serializer
         );

      //! Write to serialization.
      ERRVALUE SerialWrite (
         SERIALIZER& serializer,
         const char *tagname = 0
         );

      //! Set coordinate reference system for defining extents.
      void SetExtMapCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) { m_ExtMapRegion.SetCoordRefSys(CoordRefSys); m_Trans.SetOutputMapCoordRefSys(CoordRefSys); }

      //! Set output coordinate reference system
      void SetOutputCoordRefSys (
         const SPATREF::COORDREFSYS& CoordRefSys
         ) { m_Trans.SetInputMapCoordRefSys(CoordRefSys); }

      //! Set transformation from output object to map coordinates.
      void SetOutputTrans (
         const MAT3X3 fwd,
         const MAT3X3 inv
         ) { m_Trans.SetInputTrans(fwd,inv); }

      //! Set transformation from output object to map coordinates.
      void SetOutputTrans (
         const TRANS2D_AFFINE& trans
         ) { m_Trans.SetInputTrans(trans); }

      //! Set output transformation from "output side" of a TRANSPARM.
      void SetOutputTrans (
         const TRANSPARM& transparm
         ) { m_Trans.CopyOutputToInput(transparm); }

      //! Set output transformation from "output side" of a TRANS2D_MAPGEN reference.
      void SetOutputTrans (
         const TRANS2D_MAPGEN& trans
         ) { m_Trans.CopyOutputToInput(trans); }

      //! Set transformation from output object to map coordinates.
      void SetOutputTransIdentity (
         ) { m_Trans.SetInputTransIdentity(); }

      //! Set formula output type
      void SetOutputType (
         OUTPUTTYPE OutputType
         ) { m_OutputType = OutputType; }

      //! Set script to use in formula.
      void SetScript (
         const UNICODE* script
         ) { m_Script = script; }

      //! Start formula evaluation.
      ERRVALUE Start (
         const DRECT2D *extents,
         SCRIPTFLAGS flags = SCRIPTFLAG_None
         );

      //! Stop formula evaluation.
      void Stop (
         );

      //! Write formula definition to specified file.
      ERRVALUE WriteDefn (
         const FILEPATH& filepath
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      OUTPUTTYPE m_OutputType;                  //!< Formula type
      EXTENTSMODE m_ExtentsMode;                //!< Extents mode
      INT32 m_RegionInode;                      //!< Region object inode if extents by region
      SMLCONTEXT *m_Context;                    //!< Query context
      int m_Segment;                            //!< Query segment
      SMLSYMBOL *m_symred;                      //!< Query symbol for red output value
      SMLSYMBOL *m_symgreen;                    //!< Query symbol for green output value
      SMLSYMBOL *m_symblue;                     //!< Query symbol for blue output value
      bool m_AllAffine;                         //!< All transformations are affine
   #ifndef WIN32_NATIVE
      EDITOR *m_editor;
   #endif

      MILIST<RASTER> m_Rasters;                 //!< Raster objects used in formula
      MILIST<VECTOR> m_Vectors;                 //!< Vector objects used in formula
      MILIST<TIN> m_TINs;                       //!< TIN objects used in formula
      MILIST<VALUE> m_Values;
      MISTRING m_Script;                        //!< Formula script expression
      FILEPATH m_RegionFilePath;
      REGION2D m_ExtMapRegion;                  //!< Extents region
      TRANS2D_MAPGEN m_Trans;                   //!< Transformation from output raster to map
      SIMPLE_ARRAY<DPOINT2D> m_ipointbuf;

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

      ERRVALUE AddObjectRegion (
         const OBJECT& object
         );

      SMLSYMBOL* AddSymbol (
         const MISTRING& basename,
         const char* subname,
         bool OnlyIfUsed
         );

      void Clear ();

      void Copy (
         const GEOFORMULA& rhs
         );

      OBJECT* FindObjectByName (
         const UNICODE *symname
         );

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

      const OBJECT* GetFirstObject () const;

      int GetNumNameUses (const MISTRING& symname) const;

      ERRVALUE InitQuery (
         SCRIPTFLAGS flags = SCRIPTFLAG_None
         );

      //! @return true if successful, false if name used by another object or value.
      bool SetObjectSymbolName (
         OBJECT& obj,
         const UNICODE *symname
         );

      //! @return true if successful, false if name used by another object or value.
      bool SetValueSymbolName (
         VALUE& obj,
         const UNICODE *symname
         );

      void StopQuery ();
      #endif // GENERATING_DOXYGEN_OUTPUT

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

DEFINE_ENUM_OPERATORS(GEOFORMULA::SCRIPTFLAGS);

#endif   //!< ifndef INC_MI32_GEOFRMLA_H

---