lrraster.h

Go to the documentation of this file.

/**
 * \file gre/lrraster.h
 * \brief GRE Raster Layer definitions
 *
 * \if NODOC
 * $Id: lrraster.h_v 1.9 2004/10/11 17:17:08 mju Exp $
 *
 * $Log: lrraster.h_v $
 * Revision 1.9  2004/10/11 17:17:08  mju
 * Add nullmask instance to ioparm.
 *
 * Revision 1.8  2004/10/01 17:20:01  mju
 * Add dlgparent to assignObject.
 *
 * Revision 1.7  2004/09/20 17:38:17  vdronov
 * added fence and pedestal bound structures
 *
 * Revision 1.6  2004/09/16 22:25:31  vdronov
 * added BOUNDPARM
 *
 * Revision 1.5  2004/08/12 19:37:57  vdronov
 * added ClearPedestal method
 *
 * Revision 1.4  2004/06/30 13:29:12  mju
 * Add setobjregion.
 *
 * Revision 1.3  2004/06/28 17:53:52  mju
 * Convert to spatref system.
 *
 * Revision 1.2  2004/03/05 15:12:50  mju
 * Use virtual dtor for dispparm.
 *
 * Revision 1.1  2004/03/04 18:57:31  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_LRRASTER_H
#define  INC_GRE_LRRASTER_H

#ifndef  INC_GRE_LAYER_H
   #include <gre/layer.h>
#endif

#ifndef  INC_GRE_LEGEND_H
   #include <gre/legend.h>
#endif

#ifndef INC_MI32_RELSHADE_H
   #include <mi32/relshade.h>
#endif

#ifndef  INC_GRE_3DFILTER_H
   #include <gre/3dfilter.h>
#endif

#ifndef  INC_GRE_3DBOUND_H
   #include <gre/3dbound.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
namespace MGD {
   class DEVICE_MEM24;
   }
namespace RVC {
   class NULLMASK;
   }
#endif


//===================================================================================================================

#define  RASTGRADMIN      -127
#define  RASTGRADMAX       127
#define  RASTGRADOFFSET    128
#define  RASTGRADRANGE     256

//! Raster Layer class
class GRE_LAYER_RASTER : public GRE_LAYER {
   public:

      enum SUBTYPE {
         SUBTYPE_Single =           0,
         SUBTYPE_Hyperspectral =    1,
         SUBTYPE_MultiCI =          2,
         SUBTYPE_MultiRGB =         3,
         SUBTYPE_MultiHIS =         4,
         SUBTYPE_MultiHBS =         5,
         SUBTYPE_MultiRGBI =        6,
         SUBTYPE_MultiCMY =         7,
         SUBTYPE_MultiCMYK =        8,
         SUBTYPE_External =         9
         };

      // GRE_LAYER_RASTER::DISPPARM
      class DISPPARM : public GRE_LAYER::DISPPARM {
         public:

            class DLG;

            // GRE_LAYER_RASTER::DISPPARM::IOPARM
            struct IOPARM {
               public:
                  UNICODE filename[FILENAME_MAX];  //!< Filename of the object
                  RVC::OBJECTNAME m_GeorefName;    //!< Name of georeference object
                  int fhandle;                     //!< RVC file handle
                  int ohandle;                     //!< RVC object handle
                  RVCRASTINFO objinfo;             //!< Raster object header
                  CONTPARM contparm;               //!< Contrast parameters for this raster
                  RASTSHADEPARM shadeparm;         //!< Relief shading parameters for this raster
                  DATATIPPARMS DataTip;            //!< DataTip parameters
                  double minvalue;                 //!< Minimum raster value from histogram
                  double maxvalue;                 //!< Maximum raster value from histogram
                  bool DoContrast;                 //!< Perform contrasting on this raster, set by OpenRast
                  bool ReadWrite;                  //!< Set if open for read/write
                  bool HasNull;                    //!< Set if has null value
                  bool DiagonalBuffer;             //!< Use RASTMODE_DiagonalBuffer
                  bool IsSubRast;                  //!< Set if this raster is a pyramid sub-raster.  Use rastinfo.parentinode to get actual inode
                  UINT8 IsConstant;                //!< Treat raster as "constant", output value in contparm.outconstant
                  UINT8 DoShading;                 //!< Perform relief shading on this raster
                  INT32 Band;                      //!< Band number for hyperspectral set
                  int (*OpenRast) (IOPARM *);      //! Open raster, read/compute contrast table if needed
                  int (*ReadRast) (IOPARM*, INT32 lin, INT32 col, INT32 numcols, void *rastbuf, UINT8* nullbuf);
                  int (*CloseRast) (IOPARM *);     //! Close the raster
                  int (*SetCacheRect) (IOPARM*, const LRECT2D&);
                  RVC::NULLMASK *m_pObjNull;
                  DISPPARM *dp;                    //!< Point back to DISPPARM
                  void *privptr;                   //!< For use by application, will be copied
                  bool m_HasSaveInfo;
                  mutable FILEPATH m_savefilepath;
                  mutable RVCINODENUM m_saveobjinode;
                  mutable RVCINODENUM m_savecontinode;

                  IOPARM ();
                  IOPARM (
                     const IOPARM& rhs
                     ) { Copy(rhs); }
                  ~IOPARM (
                     ) { Free(); }

                  static ERRVALUE SerializerCB (SERIALIZER&, const SERIALIZER::ITEMDEF*, void*, SERIALIZER::ITEMDEF::ACTION);
                  //! Assignment
                  IOPARM& operator= (
                     const IOPARM& rhs
                     ) { if (this != &rhs) { Free(); Copy(rhs); } return (*this); }
                  //! Close object.
                  void Close ();
               private:
                  #ifndef GENERATING_DOXYGEN_OUTPUT
                  void Copy (const IOPARM&);
                  void Free ();
                  void OnSerialRead();
                  void UpdateSaveInfo() const;
                  friend class DISPPARM;
                  #endif // GENERATING_DOXYGEN_OUTPUT
               }; // End of GRE_LAYER_RASTER::DISPPARM::IOPARM

            // GRE_LAYER_RASTER::DISPPARM::SHADEBUF
            struct SHADEBUF {
               public:

                  UINT8 gradgray[RASTGRADRANGE*RASTGRADRANGE];
                  UINT16 *linebuf;
                  INT32 linebufcols;
                  double *idata0;
                  double *idata1;
                  double nullvalD;

                  SHADEBUF (
                     ) {
                     memset(this,0,sizeof(*this));
                     }
                  ~SHADEBUF (
                     );

               private:
                  #ifndef GENERATING_DOXYGEN_OUTPUT
                  SHADEBUF (const SHADEBUF&);
                  SHADEBUF& operator= (const SHADEBUF&);
                  #endif // GENERATING_DOXYGEN_OUTPUT
               }; // End of GRE_LAYER_RASTER::DISPPARM::SHADEBUF

            // GRE_LAYER_RASTER::DISPPARM::COLORSCALELABEL
            class COLORSCALELABEL {
               public:
                  double CellValue;             //!< Cell value to label
                  MISTRING Label;               //!< Label string

                  //! Default constructor.
                  COLORSCALELABEL (
                     ) :
                     CellValue(0.0)
                     { }

                  //! Copy constructor.
                  COLORSCALELABEL (
                     const COLORSCALELABEL& rhs
                     ) :
                     CellValue(rhs.CellValue),
                     Label(rhs.Label)
                     { }

                  //! Destructor.
                  ~COLORSCALELABEL() {
                     }

                  //! Assignment
                  COLORSCALELABEL& operator= (
                     const COLORSCALELABEL& rhs
                     ) { if (this != &rhs) { CellValue = rhs.CellValue; Label = rhs.Label; } return (*this); }
               }; // End of GRE_LAYER_RASTER::DISPPARM::COLORSCALELABEL class.

            IOPARM ioparm[4];
            IOPARM maskioparm;
            UINT8 dispmode;                  //!< Type of "display" being performed (RASTDISPMODE_xxxx)
            UINT8 ColorBlendMode;            //!< Color blending mode (for RGBI modes)
            UINT8 ColorBlendFactor;          //!< Color blending factor for ratio mode
            UINT8 Transparency;              //!< Layer transparency factor, 0=opaque
            UINT8 UseMask;                   //!< Flag: Set if mask should be used
            UINT8 PreferredZoom1X;           //!< Set if layer preferred for 1X zoom
            bool LoadColMap;                 //!< Load color palette using specified color palette name
            bool UseColMap;                  //!< Set if color palette should be used
            SIMPLE_ARRAY<COLOR> colmap;      //!< Color palette
            RVC::OBJECTNAME m_ColorPaletteName; //!< Name of color palette object to use / load
            INT32 OutTileCols;               //!< Output "raster" tile size, 0 if not needed
            INT32 OutTileLins;
            INT32 NumBands;                  //!< Number of bands in hyperspectral mode
            CBPARMS ColorBalance;            //!< For adjusting color
            UINT8 LegendType;                //!< Type of legend
            UINT8 LegendSampleArea;          //!< Sample area
            UINT8 LegendScaleMinAtTop;       //!< Put minimum value at top
            UINT16 LegendScaleRangeCount;    //!< Number of range boxes for ColorScaleRanges
            LEGENDPARMS ColorSampleLegend;
            double xscale, yscale;           //!< Scale from object coords to meters if no georef info available
            SHADEBUF *shadebuf;              //!< Buffers used in relief shading
            MILIST<COLORSCALELABEL> ScaleLabels;
            double ScaleMin;                 //!< Minimum cell value for color scale legend
            double ScaleMax;                 //!< Maximum cell value for color scale legend
            double ScaleScale;               //!< Default label will be CellValue * ScaleScale + ScaleOffset
            double ScaleOffset;
            double ScaleInterval;            //!< CellValue interval for auto label generation
            bool ScaleMinOnTop;              //!< Flips the legend upside down
            bool ScaleIsAuto;                //!< True if scale is auto-generated, false if manually edited
            UINT8 ScalePlaces;               //!< Number of decimal places for scale
            GRE::TEXTUREFILTER::MODE TextureFilterMode;
            UINT8 AnisotropicLimit;          //!< 2 - 64
            UINT8 MipMapSharpness;           //!< 0 - 100
            GRE::BOUNDPARM m_Pedestal;
            GRE::BOUNDPARM m_Fence;

            DISPPARM ();
            DISPPARM (
               const DISPPARM& rhs
               ): GRE_LAYER::DISPPARM(rhs) { Copy(rhs); }
            virtual ~DISPPARM (
               ) { Free(); }

            DISPPARM& operator= (
               const DISPPARM& rhs
               ) { if (this != &rhs) { Free(); Copy(rhs); } return (*this); }

            #ifndef GENERATING_DOXYGEN_OUTPUT
            static int SerializerCB_ColorPalette (SERIALIZER&, const SERIALIZER::ITEMDEF*, void*, SERIALIZER::ITEMDEF::ACTION);
            static int SerializerCB_ColorScaleLabels (SERIALIZER&, const SERIALIZER::ITEMDEF*, void*, SERIALIZER::ITEMDEF::ACTION);
            #endif // GENERATING_DOXYGEN_OUTPUT

         protected:
            virtual const SERIALIZER::ITEMDEF* SerialGetItemDef (SERIALIZER& serializer) const;
            virtual ERRVALUE SerialRead (SERIALIZER& serializer);
            virtual ERRVALUE SerialWrite (SERIALIZER& serializer, const char *tagname = 0) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            void Close ();
            void Copy (const DISPPARM&);
            void Free ();
            void UpdateSaveInfo () const;

            virtual ERRVALUE v_SetObjItem (const RVC::OBJITEM& objitem, bool replace);
            virtual ERRVALUE v_Validate ();

            friend class GRE_LAYER_RASTER;
            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of GRE_LAYER_RASTER::DISPPARM

      //! Image Sample legend subclass.
      // GRE_LAYER_RASTER::LEGEND_IMAGESAMPLE
      class LEGEND_IMAGESAMPLE : public GRE_LEGEND {
         public:
            //! Individual item in legend.
            // GRE_LAYER_RASTER::LEGEND_IMAGESAMPLE::ITEM
            class ITEM : public GRE_LEGEND::ITEMBASE {
               public:
                  //! Constructor.
                  ITEM (
                     MGD::DEVICE_MEM24 *& SampleMem,
                     const MISTRING& label
                     );

                  //! Destructor.
                  virtual ~ITEM (
                     );

                  //! Draw item.
                  virtual void Draw (
                     const DRAWCONTEXT& dc,           //!< Legend drawing context
                     const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
                     ) const;

               #ifdef WIN32_MFC
                  //! Draw item with label in TreeView (WIN32_MFC).
                  virtual void DrawTreeView (
                     void *hdc,                       //!< Windows device context
                     const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
                     const CRect& rect,               //!< Bounding rectangle including label
                     bool HasFocus                    //!< 'true' if item has "focus"
                     );
               #endif

               private:
                  #ifndef GENERATING_DOXYGEN_OUTPUT
                  MGD::DEVICE_MEM24 *m_pSampleMem;

                  ITEM (const ITEM&);
                  ITEM& operator= (const ITEM&);
                  #endif // GENERATING_DOXYGEN_OUTPUT
               }; // End of GRE_LAYER_RASTER::LEGEND_IMAGESAMPLE::ITEM

            //! Construct legend for layer.
            explicit LEGEND_IMAGESAMPLE (
               GRE_LAYER_RASTER *layer
               );

            //! Add item to legend.
            //! @return TRUE if item added, FALSE if all cells NULL in specified area, < 0 if error.
            int AddItem (
               const LPOINT2D& center,
               const MISTRING& label
               );                               

            //! Get "preferred" item size in pixels.
            //! This is used for rendering legend in user interface (ie. LegendView).
            virtual void GetItemSizePixels (
               LPOINT2D& size                      //!< Size in pixels returned, not including labels
               ) const;

            //! Set item size.
            void SetItemSize (
               INT32 xsize,
               INT32 ysize
               ) {
               if (m_ItemSize.x != xsize || m_ItemSize.y != ysize) {
                  DeleteAllItems();
                  m_ItemSize.x = xsize;
                  m_ItemSize.y = ysize;
                  }
               return;
               }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            LPOINT2D m_ItemSize;

            LEGEND_IMAGESAMPLE (const LEGEND_IMAGESAMPLE&);
            LEGEND_IMAGESAMPLE& operator= (const LEGEND_IMAGESAMPLE&);
            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of GRE_LAYER_RASTER::LEGEND_IMAGESAMPLE class.

      //! Construct instance of this layer type
      static int Construct (
         GRE_GROUP *group,                      //!< Group to contain layer
         GRE_LAYER **retlayer,                  //!< Layer returned
         GRE_LAYER *reflayer,                   //!< Reference layer for insertion
         UINT32 flags                           //!< Creation flags
         );

      //! Register this layer type
      static void RegisterType (
         );

      //! Method to install SML class, called by internal SML function.
      static void SMLClassInstall (
         SMLCONTEXT *context                    //!< SML context
         );

      //! Construct layer and insert into list
      explicit GRE_LAYER_RASTER (
         GRE_GROUP *group,                      //!< Group to contain layer
         GRE_LAYER *reflayer = 0,               //!< Reference layer for insertion
         UINT32 flags = MDISPCREATE_InsertAfter //!< MDISPCREATE flags
         );

      virtual ~GRE_LAYER_RASTER ();

      //! Open object(s) for this layer
      //! @return TRUE if was opened, FALSE if open already, < 0 if error
      virtual int OpenObject (
         UINT32 filemode = RVCFILE_ReadLock,    //!< RVC file access mode
         MDLGPARENT dlgparent = 0               //!< Parent for dialog
         );

      //! Assign layer to use specified object(s)
      ERRVALUE AssignObjects (
         SUBTYPE subtype,                       //!< Raster layer subtype
         const RVC::OBJITEMLIST& objitems       //!< Object item list
         );

      bool CanDoShading (
         ) const;

      //! Retrieve layer-specific display parameters.
      //! @return current parameters
      const DISPPARM& GetDispParm (
         ) const {
         return (m_dispparm);
         }

      //! Retrieve color-sample legend.
      GRE_LEGEND_COLORSAMPLE& GetColorSampleLegend (
         ) {
         return (m_ColorSampleLegend);
         }

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Prompt user to select object(s) for raster layer.
      int PromptObjects (
         SUBTYPE subtype,                       //!< Raster layer subtype
         bool OpenCtrlPanel = false,            //!< Whether or not to show control panel after selection
         MDLGPARENT dlgparent = 0               //!< Parent for dialogs
         );
   #endif

      //! Set color palette to use
      int SetColorMap (
         const SIMPLE_ARRAY<COLOR>& colmap,
         const RVC::OBJECTNAME& ColorPaletteName
         );

      //! Set layer-specific display parameters.
      //!
      //! This is the recommended method for changing how an existing layer is to be
      //! rendered.  Validation will be performed on the specified parameters and
      //! adjustments made to the layer's copy if necessary.  Use of this method
      //! usually result in a ChangeBegin / ChangeEnd message pair, and will also
      //! generate a ChangeObject message if the spatial object used in the layer
      //! is changed.
      ERRVALUE SetDispParm (
         const DISPPARM& dispparm               //!< Parameters to set
         );

      //! Set mask to use.
      ERRVALUE SetMask (
         const RVC::OBJITEM& objitem
         );

      void SetObjRegion (
         const REGION2D& ObjRegion
         ) { m_ObjRegion = ObjRegion; }

      //! Set azimuth and elevation angles for relief shading.
      void SetShadeAngles (
         double AzimAngle,                      //!< Azimuth angle in RADIANS -PI to PI
         double ElevAngle                       //!< Elevation angle in RADIANS 0 to PI/2
         );

      //! Set portion of raster to draw
      void SetVisibleExtents (
         const LRECT2D& rect                    //!< Extents in columns/lines
         );

      //! Update constrast to compute within specified region
      int UpdateContrastFromRegion (
         const REGION2D& region                       //!< Region
         );

      void ClearPedestal (
         ) {if (m_Texture != 0) m_Texture->ClearPedestal(); return; };

   protected:

      DISPPARM m_dispparm;                      //!< Layer-specific display parameters

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      GRE::TEXTURE *m_Texture;

      static void LegendMsgHandler (
         GRAPHICTREEITEM_MSG *msg
         );

   #ifdef X_NATIVE
      static void CB_ActionTool (Widget, void*, void*);
      static void MCB_AdjustShading (MxdAnyCallbackStruct*, GRE_LAYER_RASTER*);
      static void MCB_AutoColorMapApply (MxdAnyCallbackStruct*, GRE_LAYER_RASTER*);
      static void MCB_ColorBalance (MxdAnyCallbackStruct*, GRE_LAYER_RASTER*);
      static void MCB_EditColorMap (MxdAnyCallbackStruct*, GRE_LAYER_RASTER*);
   #endif

      GRE_LEGEND_COLORSAMPLE m_ColorSampleLegend;
      GRE_LEGEND_COLORSCALE m_ColorScaleLegend;
      LEGEND_IMAGESAMPLE m_ImageSampleLegend;
      GRE_ELEMSEARCH m_CellSearchInfo;
      COMPINFO m_CompInfo[4];
      mutable RVC::OBJITEM m_TempObjItem[4];

      ERRVALUE CreateRasterLink (MDLGPARENT dlgparent);
      ERRVALUE Draw2D (GRE_LAYERDC *layerdc);
      ERRVALUE Draw3D (GRE_LAYERDC *layerdc);
      void LegendReadSample (GRAPHICTREEITEM_MSG *msg);
      void OnActionTool (int);
      void SetupLegend ();

      ERRVALUE SetupPyramid (
         const TRANS2D_MAPGEN& tmg,
         LRECT2D *DispUsedRect,
         INT32 *psampleret,
         int *needpyramid
         );

      int SetupShading ();

      //! Overrides from GRE_LAYER.
   #ifdef WIN32_MFC
      virtual void v_AddTreeViewDetails (GRE_MFC_TREEVIEW& TreeView, HTREEITEM hParent, HTREEITEM hInsertAfter);
      virtual void v_AddTreeViewLegend (GRE_MFC_TREEVIEW& TreeView, HTREEITEM hParent, HTREEITEM hInsertAfter);
   #endif
      virtual ERRVALUE v_AssignObject (const RVC::OBJITEM& objitem, MDLGPARENT dlgparent);
      virtual bool v_CanShowDetails () const;
   #if defined(X_NATIVE) || defined(WIN32_MFC)
      virtual int v_ControlPanel (MDLGPARENT dlgparent, UINT32 flags = 0);
   #endif
      virtual void v_DataTipGetDefaultPrefix (int component, DATATIPPARMS& DataTipParms) const;
      virtual const DATATIPPARMS& v_DataTipGetParms (int component) const;
      virtual ERRVALUE v_DataTipSetParms (int component, const DATATIPPARMS& DataTipParms);
      virtual ERRVALUE v_Draw (GRE_LAYERDC& layerdc);
      virtual INT32 v_FindClosestElement (const DPOINT2D& point, double searchdist, double *distret, int component, const UINT8 *SearchSet, GRE_FIND_FLAGS findflags);
      virtual int v_GetComponent (ELEMTYPE ElemType) const;
      virtual MICON v_GetComponentIcon (int component) const;
      virtual COMPINFO* v_GetComponentInfo (int component);
      virtual MISTRING v_GetComponentName (int component) const;
      virtual UINT16 v_GetElemDrawSelectionMode (ELEMTYPE ElemType) const;
      virtual ELEMTYPE v_GetElemType (int component) const;
      virtual bool v_GetGeorefName (RVC::OBJECTNAME& name, int component = 0) const;
      virtual const GRE_LEGEND* v_GetLegend (ELEMTYPE ElemType);
      virtual INT32 v_GetNumElements (ELEMTYPE ElemType);
      virtual const RVC::OBJITEM& v_GetObjItem (int component) const;
   #ifdef X_NATIVE
      virtual MENUITEM* v_GetToolMenu () const;
   #endif
   #ifdef WIN32_MFC
      virtual bool v_HasTreeViewLegend () const;
   #endif
      virtual bool v_HasNullImageCells () const;
   #if defined(X_NATIVE) || defined(WIN32_MFC)
      virtual ERRVALUE v_PromptObject (bool OpenCtrlPanel, MDLGPARENT dlgparent);
   #endif
      virtual const char* v_SerialGetTagName () const;
      virtual void v_SetDftName (bool ReplaceExisting);
      virtual int v_UpdateExtents (bool forceupdate);

      friend class LEGEND_IMAGESAMPLE;

      GRE_LAYER_RASTER (const GRE_LAYER_RASTER&);
      GRE_LAYER_RASTER& operator= (const GRE_LAYER_RASTER&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   }; // End of GRE_LAYER_RASTER


#define  RASTERLEGENDTYPE_SampleArea            0  //!< Piece of the raster
#define  RASTERLEGENDTYPE_ColorScaleContinuous  1  //!< Color scale
#define  RASTERLEGENDTYPE_ColorSample           2  //!< Sample of each color, possibly with labels
#define  RASTERLEGENDTYPE_None                  3  //!< No legend
#define  RASTERLEGENDTYPE_ColorScaleRanges      4  //!< Ranged color scale


//===================================================================================================================

#endif   // INC_GRE_LRRASTER_H

---