gre/layerdc.h

Go to the documentation of this file.

#ifndef  INC_GRE_LAYERDC_H
#define  INC_GRE_LAYERDC_H

#ifndef  INC_GRE_VIEW_H
   #include <gre/view.h>
#endif

#ifndef  INC_GRE_GROUP_H
   #include <gre/group.h>
#endif

#ifndef  INC_GRE_LAYERVIEW_H
   #include <gre/layerview.h>
#endif

#ifndef  INC_GRE_LAYERSECTION_H
   #include <gre/layersection.h>
#endif

#ifndef  INC_GRE_GROUPVIEW_H
   #include <gre/groupview.h>
#endif

#ifndef  INC_GRE_3DSCENE_H
   #include <gre/3dscene.h>
#endif

#ifndef  INC_MI32_STEREOVIEW_H
   #include <mi32/stereoview.h>
#endif

#ifndef  INC_SML_CLASS_H
   #include <sml/class.h>
#endif

#ifndef  INC_SPATMOD_IMAGERESAMPLEMETHOD_H
   #include <spatmod/imageresamplemethod.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
namespace MGD {
   class COLORLOCK;
   }
namespace RVC {
   class RASTER;
   class NULLMASK;
   class STYLE;
   class STYLEPATTERN_BASE;
   class STYLEPATTERN_BITMAP;
   class STYLEPATTERN_HATCH;
   class STYLEPATTERN_LINE;
   class STYLEPATTERN_SYMBOL;
   }
namespace SPATMOD {
   class GEOREFERENCE;
   namespace IMAGE {
      class STAGE;
      class STAGE_AUTOPTR;
      }
   }
#endif


namespace GRE {
//===================================================================================================================
class LAYERDC : public POLYLINE::CLIP {
   public:

      LAYERDC (
         LAYER *layer,                             
         GRE::VIEW *view,                          
         MGD::DEVICE *pDevice = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None,
         const TRANS2D_MAPGEN *pTransObjectToDevice = 0  
         );

      LAYERDC (
         GRE::VIEW *view,                          
         MGD::DEVICE *pDevice,                     
         const TRANS2D_MAPGEN& ObjectToDevice,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      // Construct using LAYERSECTION and RENDERTARGET.
      LAYERDC (
         GRE::LAYERSECTION *pLayerSection,         
         RENDERTARGET content,                     
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      virtual ~LAYERDC ();

      void CalcPointDisplacedDualZ (
         DPOINT3D& ptDevice,                    
         DPOINT2D& ptDisplacedL,                
         DPOINT2D& ptDisplacedR                 
         ) const;

      void CalcPointDisplacedLeftZ (
         DPOINT3D& ptDevice,                    
         DPOINT2D& ptDisplaced                  
         ) const;

      void CalcPointDisplacedRightZ (
         DPOINT3D& ptDevice,                    
         DPOINT2D& ptDisplaced                  
         ) const;

      bool CanDrawLayer () const;

      bool CheckColorHighlight (
         COLOR& color,                          
         const RVC::ELEMENT& element,           
         const UNSIGNEDSET *pHighlightSet = 0   
         ) const;

      bool CheckColorLock (
         MGD::COLORLOCK& colorlock           
         );

      bool CheckColorLock (
         MGD::COLORLOCK& colorlock,             
         const RVC::ELEMENT& element,           
         const UNSIGNEDSET *pHighlightSet = 0   
         );

      bool CheckColorLock (
         MGD::COLORLOCK& colorlock,             
         ELEMTYPE ElemType,                     
         ELEMNUM ElemNum,                       
         const UNSIGNEDSET *pHighlightSet = 0   
         ) { return (CheckColorLock(colorlock,RVC::ELEMENT(ElemNum,ElemType),pHighlightSet)); }

      bool CheckColorOverride (
         COLOR& color                           
         ) const;

      // Check if need to override color for specific element.
      bool GRE::LAYERDC::CheckColorOverride (
         COLOR& color,                          
         const RVC::ELEMENT& element,           
         const UNSIGNEDSET *pHighlightSet = 0   
         ) const;

      void ClearAllDrawnSets ();

      // Translate and draw single line.
      int DrawLine (
         const RVC::ELEMENT& element,           
         const POLYLINE& lineObject,            
         LINESTYLE& LineStyle,                  
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      // Translate and draw multiple lines.
      int DrawLines (
         const RVC::ELEMENT& element,           
         const POLYLINELIST& linesObject,       
         LINESTYLE& LineStyle,                  
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      DEPRECATED_MSG("Use DrawLineObject2D") int DrawLineClipped2D (
         const POLYLINE& lineObject             
         ) const { return (DrawLineObject2D(lineObject)); }

      DEPRECATED int DrawLineClipped3D (
         const POLYLINE& lineObject,            
         bool DensifyOnSurface = true           
         ) const;

      int DrawLineDevice2D (
         const POLYLINE& lineDevice             
         ) const;

      int DrawLineObject (
         const POLYLINE& lineObject,            
         LINESTYLE& LineStyle,                  
         RVC::STYLE *pObjStyle = 0              
         );

      int DrawLineObject2D (
         const POLYLINE& lineObject             
         ) const;

      int DrawLineObject3D (
         const POLYLINE& lineObject,            
         bool DensifyOnSurface = true           
         ) const;

      bool GRE::LAYERDC::DrawManagedPointSymbols (
         const RVC::ELEMENT& element            
         );

      int DrawPoint (
         const RVC::ELEMENT& element,           
         const DPOINT3D& ptObject,              
         POINTSTYLE& PointStyle,                
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      int DrawPointObject (
         const DPOINT3D& ptObject,              
         POINTSTYLE& PointStyle,                
         RVC::STYLE *pObjStyle = 0,             
         const RVC::STYLEPATTERN_BASE *pPatternPoint = 0 
         );

      void DrawPointDevice2D (
         DPOINT3D& ptDevice                  
         );

      bool DrawPointObject2D (
         const DPOINT3D& ptObject               
         );

      int DrawPoints (
         const RVC::ELEMENT& element,           
         const POLYLINE& ptsObject,             
         POINTSTYLE& PointStyle,                
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      int DrawPolygons (
         const RVC::ELEMENT& element,           
         const REGION2D& rgnObject,             
         POLYSTYLE& PolyStyle,                  
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      int DrawRegionDevice2D (
         const REGION2D& rgnDevice,             
         POLYSTYLE& PolyStyle,                  
         RVC::STYLE *pObjStyle = 0              
         );

      int DrawRegionObject (
         const REGION2D& rgnObject,             
         POLYSTYLE& PolyStyle,                  
         RVC::STYLE *pObjStyle = 0              
         );

      int DrawRegionObject2D (
         const REGION2D& rgnObject              
         ) const;

      int DrawRegionObject3D (
         const REGION2D& rgnObject              
         ) const;

      int DrawSegmentDevice2D (
         const DPOINT3D& ptDevice1,             
         const DPOINT3D& ptDevice2              
         ) const;

      int DrawSegmentDevice2D (
         double p1x,
         double p1y,
         double p2x,
         double p2y
         ) const { return (DrawSegmentDevice2D(DPOINT2D(p1x,p1y),DPOINT2D(p2x,p2y))); }

      int DrawSegment3D (
         const DPOINT3D& ptObject1,             
         const DPOINT3D& ptObject2              
         ) const;

      int DrawSubRegion (
         const RVC::ELEMENT& element,           
         const SUBREGION2D& srObject,           
         POLYSTYLE& PolyStyle,                  
         RVC::STYLE *pObjStyle = 0,             
         DRAWFLAGS drawflags = DRAWFLAG_None,   
         int StyleScriptSeg = -1                
         );

      int DrawSubRegionDevice2D (
         const SUBREGION2D& srDevice,           
         POLYSTYLE& style,                      
         RVC::STYLE *pObjStyle = 0              
         );

      int DrawSubRegionDevice2D (
         const SUBREGION2D& srDevice            
         );

      int DrawSubRegionObject (
         const SUBREGION2D& srObject,           
         POLYSTYLE& style,                      
         RVC::STYLE *pObjStyle = 0              
         );

      int DrawSubRegionObject3D (
         const SUBREGION2D& srObject            
         ) const;

      ERRVALUE DrawWireframeFlat (
         const REGION2D& rgnObject              
         ) const;

      bool Fill3dFlatPolygon (
         const DPOINT3D *ptsObject,             
         INT32 numPoints                        
         ) const;

      bool Fill3dTriangle (
         const DPOINT3D *tp[3]                  
         ) const;

      int FillSubRegionDevice2D (
         const SUBREGION2D& srDevice            
         );

      double Get3dDepthScale (
         ) const { return (m_pLayerView->Get3dDepthScale()); }

      const GRE::SCENE3D& Get3dScene (
         ) const { return (m_Scene3D); }

      GRE::SCENE3D& Get3dScene (
         ) { return (m_Scene3D); }

      double Get3dSurfaceIncrement (
         ) const { return (m_pLayerView->Get3dSurfaceIncrement()); }

      STEREOVIEW Get3dStereoView (
         ) const { return (m_Scene3D.GetStereoView()); }

      double Get3dZScale (
         ) const { return (m_pLayerView->Get3dZScale()); }

      const REGION2D& GetClipRegion (
         ) const { return (m_ClipRegion); }

      double GetDesignScale (
         ) const { return (m_DesignScale); }

      const LRECT2D& GetDeviceRectUsed () const
         { return (m_pLayerView->GetDeviceRectUsed()); }

      GRE::DRAWFLAGS GetDrawFlags (
         ) const { return (m_drawflags); }

      MGD::CONTEXT* GetDrawingContext (
         ) const { return (m_ggc); }

      MGD::DEVICE* GetDrawingDevice (
         ) const;

      double GetDrawingScale (
         ) const { return (m_DrawingScale); }

      UNSIGNEDSET* GetElemDrawnSet (
         ELEMTYPE ElemType = ELEMTYPE_All
         ) const;

      LAYER* GetLayer (
         ) const { return (m_layer); }

      const GRE::LAYERSECTION* GetLayerSection (
         ) const { return (m_pLayerSection); }

      GRE::LAYERSECTION* GetLayerSection (
         ) { return (m_pLayerSection); }

      const GRE::LAYERVIEW* GetLayerView (
         ) const { return (m_pLayerView); }

      GRE::LAYERVIEW* GetLayerView (
         ) { return (m_pLayerView); }

      bool GetNoDrawActive (
         ) const { return (m_NoDrawActive); }

      const DRECT2D& GetObjectClipRect (
         ) const { return (m_ObjClipRect); }

      const DPOINT2D& GetPixelSizeMM (
         ) const { return (m_PixelSizeMM); }

      GRE::RENDERTARGET GetRenderTarget (
         ) const { return (m_RenderTarget); }

      double GetRotationAngle (
         ) const { return (m_RotationAngle); }

      double GetRotationCos (
         ) const { return (m_pGroupView->GetRotationCos()); }

      double GetRotationSin (
         ) const { return (m_pGroupView->GetRotationSin()); }

      const STEREOSHIFT& GetStereoShift () const
         { return (m_pGroupView->GetStereoShift()); }

      bool GetStereoInterlaceStartRight (
         ) const { return (m_pGroupView->GetStereoInterlaceStartRight()); }

      LAYER_SURFACE* GetSurfaceLayer (
         ) const { return (m_pLayerView->GetSurfaceLayer()); }

      ERRVALUE GetSurfaceZ (
         POLYLINE& plObject                  
         ) const;

      ERRVALUE GetSurfaceZ (
         DPOINT3D *ptsObject,                
         INT32 NumPoints                     
         ) const;

      ERRVALUE GetSurfaceZ (
         const DPOINT2D& spoint,             
         double& z,                          
         bool DoSearch                       
         ) const;

      const TRANS2D_MAPGEN& GetTransLayerDevice (
         ) const;

      const TRANS2D_MAPGEN& GetTransLayerSurface (
         ) const { return (m_pLayerView->GetTransLayerSurface()); }

      GRE::VIEW* GetView (
         ) const { return (m_view); }

      bool HasSurfaceLayer (
         ) const { return (m_pLayerView->GetSurfaceLayer() != 0); }

      ERRVALUE ImageDraw2D (
         SPATMOD::IMAGE::STAGE *pStageInput,
         const LRECT2D* SectionRect = 0,     
         bool bForceAlphaBlend = false    
         ) const;

      ERRVALUE ImageInsertResampleFilter (
         SPATMOD::IMAGE::STAGE_AUTOPTR& PtrStage,        
         SPATMOD::IMAGE::RESAMPLEMETHOD ResampleMethod = SPATMOD::IMAGE::RESAMPLEMETHOD_Nearest 
         ) const;

      ERRVALUE ImageInsertResampleFilterStereo2D (
         SPATMOD::IMAGE::STAGE_AUTOPTR& PtrStage,        
         SPATMOD::IMAGE::STAGE_AUTOPTR& PtrStageTerrain, 
         SPATMOD::IMAGE::RESAMPLEMETHOD ResampleMethod = SPATMOD::IMAGE::RESAMPLEMETHOD_Nearest 
         ) const;

      ERRVALUE ImageInsertZoomFilter (
         SPATMOD::IMAGE::STAGE_AUTOPTR& PtrStage,     
         double *pZoomUsed = 0                        
         ) const;

      bool Is3D () const
         { return (m_pLayerView->Is3D()); }

      bool IsHidden () const
         { return (m_IsHidden); }

      bool IsManagingPointSymbols () const
         { return (m_layer->IsManagingPointSymbols() && !m_layer->IsEditable() && !m_IsStereo && !Is3D()); }

      bool IsStereo () const
         { return (m_IsStereo); }

      bool IsSurfaceUsed () const
         { return (m_pLayerView->IsSurfaceUsed()); }

      void NotifyDrawElementBegin (
         const RVC::ELEMENT& element
         ) const { if (m_NeedNotifyDrawElement) m_view->NotifyDrawElementBegin(m_layer,element); }

      void NotifyDrawElementBegin (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum
         ) const { if (m_NeedNotifyDrawElement) m_view->NotifyDrawElementBegin(m_layer,RVC::ELEMENT(ElemNum,ElemType)); }

      void NotifyDrawElementEnd (
         const RVC::ELEMENT& element
         ) const { if (m_NeedNotifyDrawElement) m_view->NotifyDrawElementEnd(m_layer,element); }

      void NotifyDrawElementEnd (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum
         ) const { if (m_NeedNotifyDrawElement) m_view->NotifyDrawElementEnd(m_layer,RVC::ELEMENT(ElemNum,ElemType)); }

      void Set3dElemScaled (
         bool IsScaled
         ) { m_ScaleToMap3D = IsScaled; }

      void Set3dStereoView (
         STEREOVIEW StereoView
         );

      void SetDrawFlags (
         GRE::DRAWFLAGS drawflags
         );

      void SetDrawingDevice (
         MGD::DEVICE *pDevice
         );

      void SetRenderTarget (
         RENDERTARGET RenderTarget
         ) { m_RenderTarget = RenderTarget; }

      bool SetStereoLeft ();

      bool SetStereoRight ();

      void SetStyleBorder (
         const POLYSTYLE& BorderStyle,          
         RVC::STYLE *pObjStyle = 0              
         );

      void SetStyleFill (
         POLYSTYLE& FillStyle,                  
         RVC::STYLE *pObjStyle = 0              
         );

      bool SetStyleLine (
         LINESTYLE& LineStyle,                  
         RVC::STYLE *pObjStyle = 0,             
         bool TestMultiPass = false             
         );

      // Set style for point, reading pattern if necessary.
      void SetStylePoint (
         POINTSTYLE& PointStyle,                
         RVC::STYLE *pObjStyle = 0,             
         const RVC::STYLEPATTERN_BASE *pPatternPoint = 0 
         );

      void SetStyleScriptContext (
         GRE::SCRIPTCONTEXT_STYLE *pStyleSC
         ) { m_pStyleSC = pStyleSC; }

      ERRVALUE SetupStereo ();

      int TransPoint3D (
         DPOINT3D& pt3d                      
         ) const;

      ERRVALUE TransToDevice (
         POLYLINE& polyline                  
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static SML::AUTOCLASS_NOALLOC_T<LAYERDC> s_SML_AutoClass;

      static void SML_Register ();

      GRE::GROUPVIEW *m_pGroupView;
      GRE::LAYERVIEW *m_pLayerView;
      GRE::LAYERSECTION *m_pLayerSection;
      LAYER *m_layer;
      GRE::VIEW *m_view;
      MGD::CONTEXT *m_ggc;                         // Generic graphic context
      GRE::DRAWFLAGS m_drawflags;                  // Drawing flags
      REGION2D m_ClipRegion;                       // Current clipping region in device coordinates
      DRECT2D m_ObjClipRect;                       // Clipping rectangle in object coordinates
      DPOINT2D m_PixelSizeMM;                      // Device pixel size in millimeters
      double m_DesignScale;                        // Mirrored from LAYERVIEW for SML access
      double m_DrawingScale;
      double m_RotationAngle;                      // Mirrored from GROUPVIEW for SML access
      bool m_OwnGroupView;
      bool m_OwnLayerView;
      bool m_IsHidden;
      bool m_NoDrawActive;                         // Don't draw "active" element
      bool m_ScaleToMap3D;                         // Set if 3D scaling to map
      bool m_NeedNotifyDrawElement;
      bool m_IsStereo;
      bool m_StereoUseMasks;
      GRE::SCENE3D m_Scene3D;
      GRE::RENDERTARGET m_RenderTarget;
      const ZVIEW *m_pZView;
      RVC::STYLEPATTERN_BITMAP *m_pLastPatternBitmap;
      RVC::STYLEPATTERN_HATCH *m_pLastPatternHatch;
      RVC::STYLEPATTERN_LINE *m_pLastPatternLine;
      RVC::STYLEPATTERN_SYMBOL *m_pLastPatternSymbol;
      GRE::SCRIPTCONTEXT_STYLE *m_pStyleSC;
      INT32 m_LastPatternNumBitmap;
      INT32 m_LastPatternNumHatch;
      INT32 m_LastPatternNumLine;
      INT32 m_LastPatternNumSymbol;
      UINT8 m_StereoMaskLeftRGB[3];
      UINT8 m_StereoMaskRightRGB[3];

      void AddManagedPointSymbol (LABELPLACEMENT *pLabelPlacement, const RVC::ELEMENT& element, const POINTSTYLE& PointStyle, const RVC::STYLEPATTERN_BASE *pPattern, const DPOINT3D& ptDevice) const;
      void ImageCalcDeviceGeoreference (SPATMOD::GEOREFERENCE& Georeference) const;
      const RVC::STYLEPATTERN_BASE* ReadFillPattern (POLYSTYLE& PolygonStyle, const RVC::STYLE *pObjStyle);
      const RVC::STYLEPATTERN_BASE* ReadLinePattern (LINESTYLE& LineStyle, const RVC::STYLE *pObjStyle);
      const RVC::STYLEPATTERN_BASE* ReadPointPattern (POINTSTYLE& PointStyle, const RVC::STYLE *pObjStyle);
      void SetupForDrawFlags ();
      void SetupForStereoView ();
      ERRVALUE SetupStereoIn2D ();

      // Not implemented.
      LAYERDC (const LAYERDC&);
      LAYERDC& operator= (const LAYERDC&);
      
      virtual ERRVALUE OnClip (const POLYLINE& PolyLine);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
}  // End namespace GRE

#endif   // INC_GRE_LAYERDC_H

---