gre/dlgmaskedit.h

Go to the documentation of this file.

#ifndef  INC_GRE_DLGMASKEDIT_H
#define  INC_GRE_DLGMASKEDIT_H

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

#ifndef INC_MI32_MG2SIMPL_H
   #include <mi32/mg2simpl.h>
#endif
#ifndef INC_MI32_DRAWGEN_H
   #include <mi32/drawgen.h>
#endif
#ifndef INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif

#ifndef INC_MGUI_DLGSHELL_H
#include <mgui/dlgshell.h>
#endif
#ifndef INC_MGUI_COLORSEL_H
#include <mgui/colorsel.h>
#endif
#ifndef INC_MGUI_FORMRADIOBUTTONS_H
#include <mgui/formradiobuttons.h>
#endif
#ifndef INC_MGUI_TOOLBAR_H
#include <mgui/toolbar.h>
#endif
#ifndef INC_MGUI_SLIDER_H
#include <mgui/slider.h>
#endif
#ifndef INC_MGUI_COMBOBOX_H
#include <mgui/combobox.h>
#endif

#ifndef INC_GRE_UIFORMVIEW_H
#include <gre/uiformview.h>
#endif
#ifndef INC_GRE_UIVIEWCANVAS_H
#include <gre/uiviewcanvas.h>
#endif
#ifndef INC_GRE_UIVIEWTOOL_H
#include <gre/uiviewtool.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
namespace GRE {
   class LAYER_RASTER;
   class GROUP;
   class VIEWABLE;
   class TOOL;
   }
typedef void *MXTHANDLE;
struct MxtAnyCallbackStruct;
struct MrgnManagerCallbackStruct;
#endif // GENERATING_DOXYGEN_OUTPUT


namespace GRE {

class DLG_MASKEDIT : public MGUI::DLGSHELL {
   public:

      DLG_MASKEDIT (
         MDLGPARENT DlgParent = NULL,        
         GRE::LAYER_RASTER *RasterLayer = NULL  
         );

      ~DLG_MASKEDIT (
         );

      void Create ();

      ERRVALUE SelectRaster (
         GRE::LAYER_RASTER *SrcRastLayer = NULL 
         );

   private: 
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_CreateContent ();
      virtual void v_OnCloseRequest ();
      virtual void v_OnCancel ();
      virtual void v_OnOK();

      class MASK {
         public:

            MASK ();
            ~MASK ();

            void Close (
               );

            ERRVALUE CopyToTempFrom (
               const RVC::OBJITEM SrcObjItem 
               );

            ERRVALUE FillAll (
               UINT8 operation   
               );

            ERRVALUE FillRegion (
               const REGION2D& region, 
               bool value           
               );

            UINT8* GetBuffer (
               ) { return (m_buffer); }

            const RVC::RASTER::MAKEPARMS& GetMakeParms (
               ) { return (m_ObjRaster.GetMakeParms()); }

            ERRVALUE GetObjItem (
               RVC::OBJITEM& ObjItem
               ) { return (m_ObjRaster.GetObjItem(ObjItem)); }

            ERRVALUE MakeTemp (
               INT32 NumColumns, 
               INT32 NumLines    
               );

            ERRVALUE Read (
               INT32 line,       
               INT32 initcol,    
               UINT8 *buffer,    
               INT32 numcols     
               ) { return (m_ObjRaster.Read(line, initcol, buffer, numcols)); }

            ERRVALUE Read (
               INT32 line,       
               INT32 initcol,    
               void *buffer,     
               INT32 numcols     
               ) { return (m_ObjRaster.Read(line, initcol, buffer, numcols, RVC::IMAGE::CONVMODE_INT8)); }

            ERRVALUE Write (
               INT32 line,       
               INT32 initcol,    
               UINT8 *buffer,    
               INT32 numcols     
               ) { return (m_ObjRaster.Write(line, initcol, buffer, numcols)); }

            ERRVALUE Write (
               INT32 line,       
               INT32 initcol,    
               void *buffer,     
               INT32 numcols     
               ) { return (m_ObjRaster.Write(line, initcol, buffer, numcols, RVC::IMAGE::CONVMODE_INT8)); }

            ERRVALUE CopyRasterTo (
               RVC::RASTER& TgtRaster  
               ) { return (m_ObjRaster.CopyRasterTo(TgtRaster)); }

            ERRVALUE CopyToNullMask (
               RVC::RASTER& TgtRaster  
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            RVC::RASTER m_ObjRaster;         
            SIMPLE_ARRAY<UINT8> m_buffer;    

            static ERRVALUE OnFillSpan (     
               MGD::CONTEXT_SIMPLE *dc,
               INT32 initcol,
               INT32 lastcol,
               INT32 lin
               );

            ERRVALUE FillSpan (              
               INT32 initcol,
               INT32 lastcol,
               INT32 lin
               );

            ERRVALUE Setup ();
            #endif
         };

      class MASKEDITTOOLINFO{
         public:
            MASKEDITTOOLINFO () {m_pane = new MGUI::LAYOUT_PANE;}
            ~MASKEDITTOOLINFO () {};

            MXTHANDLE GetHandle() {return m_handle;}
            void SetHandle(MXTHANDLE handle) {m_handle = handle;}

            Widget GetMainForm() {return m_mainform;}
            void SetMainForm(Widget mainform) {m_mainform = mainform;}

            Widget GetManualForm() {return m_manualform;}
            void SetManualForm(Widget manualform) {m_manualform = manualform;}

            MGUI::LAYOUT_PANE* GetPane() {return m_pane;}
            void SetPane(MGUI::LAYOUT_PANE* pane) {m_pane = pane;}

         private:
            MGUI::LAYOUT_PANE *m_pane;
            MXTHANDLE m_handle;
            Widget m_mainform;
            Widget m_manualform;
         };

      class MASKEDITTOOLDATA : public GRE::UI::VIEWTOOL {
         public:

            MASKEDITTOOLDATA (
               GRE::UI::VIEW_CANVAS *view
               );

            virtual ~MASKEDITTOOLDATA ();

            Widget GetMainForm() {return m_mainform;}
            void SetMainForm(Widget mainform) {m_mainform = mainform;}

            Widget GetManualForm() {return m_manualform;}
            void SetManualForm(Widget manualform) {m_manualform = manualform;}

            UINT8 GetToolType() {return m_tooltype;}
            void SetToolType(UINT8 tooltype) {m_tooltype = tooltype;}

            MASKEDITTOOLINFO* GetToolInfo(UINT8 tooltype) {return &m_toolinfo[tooltype];}

            DLG_MASKEDIT* GetPdp() {return m_pdp;}
            void SetPdp(DLG_MASKEDIT *pdp) {m_pdp = pdp;}

            INT32 m_BufferPixels;
            REGION2D m_LastRegion;
            bool m_ToolIsCleared;

         private:
            //:> MEMBERS

            MASKEDITTOOLINFO m_toolinfo[8];
            UINT8 m_tooltype;
            Widget m_mainform;                     // Main Form widget
            Widget m_manualform;                // Form widget for manual edit tool form
            DLG_MASKEDIT *m_pdp;

            //:> VIRTUAL METHODS

            virtual bool v_Activate ();
            virtual void v_Deactivate ();
            virtual bool v_Initialize ();
            virtual void v_Suspend ();
            virtual void v_Resume ();

            //:> METHODS

            void UpdateTrans ();

            };

      class VIEWDATA : public MGUI::DLGSHELL {
         public:

            VIEWDATA ();
            ~VIEWDATA ();

            GRE::VIEWABLE* GetViewable() {return m_viewable;}
            void SetViewable(GRE::VIEWABLE *viewable) {m_viewable = viewable;}

            GRE::UI::VIEW_CANVAS* GetLocatorView() {return m_formview->GetViewLocator();}
            GRE::UI::VIEW_CANVAS* GetView() {return m_view;}
            void SetView(GRE::UI::VIEW_CANVAS* view) {m_view = view;}

            GRE::GROUP* GetGroup() {return m_group;}
            void SetGroup(GRE::GROUP* group) {m_group = group;}

            MASKEDITTOOLDATA* tooleditmask;

            GRE::LAYER_RASTER* GetRasterLayer() {return m_rastlayer;}
            void SetRasterLayer(GRE::LAYER_RASTER *layer) {m_rastlayer = layer;}

            GRE::LAYER* GetMaskLayer() {return m_masklayer;}
            void SetMaskLayer(GRE::LAYER *layer) {m_masklayer = layer;}

            GRE::LAYER* GetMarkLayer() {return m_marklayer;}
            void SetMarkLayer(GRE::LAYER *layer) {m_marklayer = layer;}

            COLOR GetMaskIncludeColor() {return m_MaskIncludeColor;}
            void SetMaskIncludeColor(COLOR color) {m_MaskIncludeColor = color;}

            COLOR GetMaskExcludeColor() {return m_MaskExcludeColor;}
            void SetMaskExcludeColor(COLOR color) {m_MaskExcludeColor = color;}

            COLOR GetMarkColor() {return m_MaskMarkColor;}
            void SetMarkColor(COLOR color) {m_MaskMarkColor = color;}

         private:
            virtual ERRVALUE v_CreateContent();

            GRE::VIEWABLE *m_viewable;
            GRE::UI::VIEW_CANVAS *m_view;
            GRE::UI::FORM_VIEW *m_formview;
            GRE::GROUP *m_group;
            GRE::LAYER_RASTER *m_rastlayer;
            GRE::LAYER *m_masklayer;
            GRE::LAYER *m_marklayer;
            COLOR m_MaskIncludeColor;
            COLOR m_MaskExcludeColor;
            COLOR m_MaskMarkColor;
         };

      class THRESHDATA {
         public:

            THRESHDATA ();
            ~THRESHDATA () {};

            double GetUserRangeBegin() {return m_UserRangeBegin;}
            void SetUserRangeBegin(double range) {m_UserRangeBegin = range;}

            double GetUserRangeEnd() {return m_UserRangeEnd;}
            void SetUserRangeEnd(double range) {m_UserRangeEnd = range;}

            DOUBLE_RANGE GetRasterRange() {return m_RasterRange;}
            void SetRasterRange(DOUBLE_RANGE range) {m_RasterRange = range;}

            bool IsInside() {return m_IsInside;}
            void SetInside(bool inside) {m_IsInside = inside;}

            bool IsInteger() {return m_IsInteger;}
            void SetInteger(bool integer) {m_IsInteger = integer;}

         private:
            double m_UserRangeBegin;         
            double m_UserRangeEnd;        
            DOUBLE_RANGE m_RasterRange;      
            bool m_IsInside;              
            bool m_IsInteger;
         };

      VIEWDATA m_viewdata;
      THRESHDATA *m_threshdata;
      
      enum SAVEMODE {
         SAVEMODE_Mask =         0,    
         SAVEMODE_NullMask =     1     
         };

      static int FillSeeded (
         INT32 SeedX,
         INT32 SeedY,
         GTestPointL TestInside,
         GDrawHSpanL gDrawHSpan,
         LPOINT2D *boundpt,                  /* Boundary point returned if desired */
         void *userdata
         );

      INT32 GetRasterNumLins() {return m_RasterNumLins;}
      INT32 GetRasterNumCols() {return m_RasterNumCols;}
      void SetRasterNumCols(INT32 cols) {m_RasterNumCols = cols;}
      void SetRasterNumLins(INT32 lins) {m_RasterNumLins = lins;}

      double GetFillVal(INT32 i) {return m_FillVal[i];}
      double GetFillRange() {return m_FillRange;}
      void SetFillVal(INT32 i, double FillVal) {m_FillVal[i] = FillVal;}
      void SetFillRange(double FillRange) {m_FillRange = FillRange;}

      void SetUserSaved(bool Saved) {m_UserSaved = Saved;}
      void SetSaveMode(SAVEMODE mode) {m_SaveMode = mode;}
      SAVEMODE GetSaveMode() {return m_SaveMode;}  
      bool IsUserSaved() {return m_UserSaved;}

      RVC::OBJITEM GetMaskObjItem() {return m_MaskObjItem;}
      void SetMaskObjItem(const RVC::OBJITEM& objitem) {m_MaskObjItem = objitem;}
      void ClearMaskObjItem() {m_MaskObjItem.Clear();}

      ERRVALUE ObjectViewOpen ();
      void ObjectViewSetupMask ();
      int SetupMask (bool UseSavedMask = false);

      void SetDlgParent(MDLGPARENT DlgParent) {m_DlgParent = DlgParent;}
      MDLGPARENT GetDlgParent() {return m_DlgParent;}

      ERRVALUE SelectMask (
         bool forceselect              // Force selection even if already have one set
         );

      void SetMaskColors ();
      void SetMarkColors ();

      void ReadDefaults ();
      void SaveDefaults ();
      void RunProcess ();

      TRANS2D_MAPGEN GetFirstGeorefTrans() {return m_FirstGeorefTrans;}
      void SetFirstGeorefTrans(TRANS2D_MAPGEN trans) {m_FirstGeorefTrans = trans;}
      void GetTransLayerDispAffine (MAT3X3 OtoD, MAT3X3 DtoO);
      int ObjectViewSetupMaskGeoref();

      //Tool callbacks
      static void TCB_MaskEditToolActivate (MxtAnyCallbackStruct *cbstr, void *vtdp);
      static void TCB_MaskEditToolChange (MxtAnyCallbackStruct *cbstr, void *vtdp);
      static void MaskEditToolSetTrans(MASKEDITTOOLDATA *tdp);
      static void MaskEditToolOp (MASKEDITTOOLDATA *tdp, int op);
      static void RCB_SetTransParm (MrgnManagerCallbackStruct *cb, void *vtdp);
      static void RCB_Mark (MrgnManagerCallbackStruct *cb, void *vtdp);

      //Test cell value function for flood filling
      static int TestInside (INT32 col, INT32 lin, DLG_MASKEDIT* pdp);

      //Drawing function for flood filling
      static int DrawSpan (INT32 start, INT32 end, INT32 lin, DLG_MASKEDIT* pdp);

      MDLGPARENT m_DlgParent;
      GRE::LAYER_RASTER *m_RasterLayer;
      GRE::UI::VIEWTOOL *m_PrevTool;

      RVC::OBJITEM m_MaskObjItem;
      SAVEMODE m_SaveMode;
      bool m_UserSaved;
      bool m_IsDestroyLayer;
      DOUBLE_ARRAY<double> m_FillVal;
      double m_FillRange;
      TRANS2D_MAPGEN m_FirstGeorefTrans;           // Georef transformation for first selected raster
      INT32 m_RasterNumLins;                    // Lines in first selected raster
      INT32 m_RasterNumCols;                    // Columns in first selected raster

      RVC::RASTER m_ObjSrcRaster;
      MASK m_SrcMask;
      MASK m_MarkMask;

      //MGUI:
      ERRVALUE CreateMaskTools (MGUI::LAYOUT_PANE_BASE& ParentPane);
      ERRVALUE CreateMaskDialog (MGUI::LAYOUT_PANE& ParentPane);

      void OnApplyRange ();
      void OnModifyPressed ();
      void OnSelectRaster ();
      void OnMaskSpecify ();
      void OnChangeHighlightColor ();
      void OnSliderChanged ();
      void OnShowManual ();
      void OnExit ();
      void OnToolBar(MGUI::ID cmdid, bool state);

      void MaskEditToolSetup (UINT8 tooltype);

      RVC::UI::FORM_OBJECT_SINGLE m_SrcRasterSelect;

      MGUI::CTRL_GROUPBOX m_colorGroupBox;
      MGUI::CTRL_PUSHBUTTON m_MaskSelect;
      MGUI::CTRL_TEXT m_MaskTextBox;
      MGUI::FORM_COLORBUTTON m_IncludeColorSelect;
      MGUI::FORM_COLORBUTTON m_ExcludeColorSelect;
      MGUI::FORM_COLORBUTTON m_MarkColorSelect;
      MGUI::FORM_EDIT_NUMBER m_IncludeTransparencySelect;
      MGUI::FORM_EDIT_NUMBER m_ExcludeTransparencySelect;
      MGUI::FORM_EDIT_NUMBER m_MarkTransparencySelect;
      MGUI::FORM_SLIDER *m_RangeBeginSlider;
      MGUI::FORM_SLIDER *m_RangeEndSlider;
      MGUI::FORM_SLIDER *m_ValueRangeSlider;
      MGUI::FORM_COMBOBOX m_RangeType;
      MGUI::CTRL_PUSHBUTTON m_ThreshApplyButton;
      MGUI::CTRL_PUSHBUTTON m_ShowManualButton;
      MGUI::CTRL_TOOLBAR m_EditToolBar;
      MGUI::FORM_RADIOBUTTONS m_SetSaveMode;
      #endif
   };
} //end GRE namespace

#endif //INC_MI32_DLGMASKEDIT_H

---