spatmod/imagefilterfocaltopographic.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGEFILTERFOCALTOPOGRAPHIC_H
#define  INC_SPATMOD_IMAGEFILTERFOCALTOPOGRAPHIC_H

#ifndef  INC_SPATMOD_IMAGEFILTER_H
#include <spatmod/imagefilter.h>
#endif

#ifndef  INC_SPATMOD_IMAGEBUFFER_H
#include <spatmod/imagebuffer.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

// Original defines from gre/lrraster.h
// GRADGRAYSIZE = (RASTGRADMAX+RASTGRADOFFSET)*RASTGRADRANGE+RASTGRADMAX+RASTGRADOFFSET];
// GRADGRAYSIZE = (127 + 128) * 256 + 127 + 128
#define GRADGRAYSIZE 65535

namespace SPATMOD {
namespace IMAGE {

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

class FILTER_FOCALTOPOGRAPHIC : public FILTER {
   public:

      enum SURFACE_FITTING_METHOD {
         SURFACE_FITTING_METHOD_FourNearest =               0,
         SURFACE_FITTING_METHOD_QLSF =                      1, // Quadratic surface, least-squares fit
         SURFACE_FITTING_METHOD_QLSFOverDistance =          2,
         SURFACE_FITTING_METHOD_QLSFOverDistanceSquared =   3,
         SURFACE_FITTING_METHOD_QLSFMatchCentral =          4
         // Don't change numbers as saved as settings.
         };

      enum SLOPE_UNITS {
         SLOPE_UNITS_Percent,
         SLOPE_UNITS_Degrees
         };

      enum SHADING_METHOD {
         SHADING_METHOD_HighContrast =    0,
         SHADING_METHOD_Display =         1
         // Don't change numbers as saved as settings.
         };

      enum CURVATURE_UNITS {
         CURVATURE_UNITS_RadiansPerMeter,
         CURVATURE_UNITS_RadiansPer100Meter
         };

      class SETTINGS {
         public:

            SETTINGS ( ) :
               m_SurfaceFitMethod(SURFACE_FITTING_METHOD_FourNearest),
               m_DoSlope(false),
               m_SlopeDataType(SPATMOD::DATATYPE_FLOAT32),
               m_SlopeUnits(FILTER_FOCALTOPOGRAPHIC::SLOPE_UNITS_Degrees),
               m_DoAspect(false),
               m_AspectDataType(SPATMOD::DATATYPE_SINT16),
               m_DoShading(false),
               m_ShadingDataType(SPATMOD::DATATYPE_UINT8),
               m_ShadingMethod(FILTER_FOCALTOPOGRAPHIC::SHADING_METHOD_Display),
               m_DoProfile(false),
               m_DoPlan(false),
               m_CurvatureDataType(SPATMOD::DATATYPE_FLOAT32),
               m_CurvatureUnits(FILTER_FOCALTOPOGRAPHIC::CURVATURE_UNITS_RadiansPerMeter),
               m_XCellSize(0.0),
               m_YCellSize(0.0),
               m_ElevationScale(1.0),
               m_ElevationAngleOfSun(45.0*DEGTORAD),
               m_DirectionOfSun(50.0*DEGTORAD)
               { }

            ~SETTINGS () { }

            void SetSurfaceFittingMethod ( SURFACE_FITTING_METHOD method ) { m_SurfaceFitMethod = method; }

            void SetSlopeParms ( 
               bool DoSlope, 
               SPATMOD::DATATYPE type = SPATMOD::DATATYPE_SINT16, 
               SLOPE_UNITS units = FILTER_FOCALTOPOGRAPHIC::SLOPE_UNITS_Degrees
               ) {   
               SetDoSlope(DoSlope);
               SetSlopeDataType(type);
               SetSlopeUnits(units);
               }
            
            void SetDoSlope ( bool DoSlope ) { m_DoSlope = DoSlope; };

            void SetSlopeDataType ( SPATMOD::DATATYPE type ) { m_SlopeDataType = type; };

            void SetSlopeUnits ( SLOPE_UNITS units ) { m_SlopeUnits = units; };

            void SetAspectParms (
               bool DoAspect, 
               SPATMOD::DATATYPE type = SPATMOD::DATATYPE_FLOAT32
               ) {   
               SetDoAspect(DoAspect);
               SetAspectDataType(type);
               }

            void SetDoAspect ( bool DoAspect ) { m_DoAspect = DoAspect; };

            void SetAspectDataType ( SPATMOD::DATATYPE type ) { m_AspectDataType = type; };

            void SetShadingParms ( 
               bool DoShading, 
               SPATMOD::DATATYPE type = SPATMOD::DATATYPE_UINT8, 
               SHADING_METHOD method = FILTER_FOCALTOPOGRAPHIC::SHADING_METHOD_Display
               ) {   
               SetDoShading(DoShading);
               SetShadingDataType(type);
               SetShadingMethod(method);
               }

            void SetDoShading ( bool DoShading ) { m_DoShading = DoShading; };

            void SetShadingDataType ( SPATMOD::DATATYPE type ) { m_ShadingDataType = type; };

            void SetShadingMethod ( SHADING_METHOD method ) { m_ShadingMethod = method; };

            void SetCurvatureParms ( 
               bool DoProfile, 
               bool DoPlan, 
               SPATMOD::DATATYPE type = SPATMOD::DATATYPE_SINT16, 
               CURVATURE_UNITS units = FILTER_FOCALTOPOGRAPHIC::CURVATURE_UNITS_RadiansPerMeter
               ) {   
               SetDoProfile(DoProfile);
               SetDoPlan(DoPlan);
               SetCurvatureDataType(type);
               SetCurvatureUnits(units);
               }

            void SetDoProfile ( bool DoProfile ) { m_DoProfile = DoProfile; };

            void SetDoPlan ( bool DoPlan ) { m_DoPlan = DoPlan; };

            void SetCurvatureDataType ( SPATMOD::DATATYPE type ) { m_CurvatureDataType = type; };

            void SetCurvatureUnits ( CURVATURE_UNITS units ) { m_CurvatureUnits = units; };

            void SetXCellSize ( double scale ) { m_XCellSize = scale; };

            double GetXCellSize ( ) { return (m_XCellSize); };

            void SetYCellSize ( double scale ) { m_YCellSize = scale; };

            double GetYCellSize ( ) { return (m_YCellSize); };

            void SetElevationScale ( double scale ) { m_ElevationScale = scale; };

            void SetElevationAngleOfSun (
               double angle                     
               ) { m_ElevationAngleOfSun = angle * DEGTORAD; };

            void SetDirectionOfSun (
               double direction                 
               ) { m_DirectionOfSun = direction * DEGTORAD; };

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            SURFACE_FITTING_METHOD m_SurfaceFitMethod;

            bool m_DoSlope;
            SPATMOD::DATATYPE m_SlopeDataType;
            SLOPE_UNITS m_SlopeUnits;

            bool m_DoAspect;
            SPATMOD::DATATYPE m_AspectDataType;
   
            bool m_DoShading;
            SPATMOD::DATATYPE m_ShadingDataType;
            SHADING_METHOD m_ShadingMethod;

            bool m_DoProfile;
            bool m_DoPlan;
            SPATMOD::DATATYPE m_CurvatureDataType;
            CURVATURE_UNITS m_CurvatureUnits;
   
            double m_XCellSize;
            double m_YCellSize;
            double m_ElevationScale;
            double m_ElevationAngleOfSun;
            double m_DirectionOfSun;
   
            friend class FILTER_FOCALTOPOGRAPHIC;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      FILTER_FOCALTOPOGRAPHIC (
         STAGE *pPreviousStage,
         bool TakeOwnership, 
         const SETTINGS &settings
         );

      virtual ~FILTER_FOCALTOPOGRAPHIC ();

      void SetSeparatePlanValidity (
         bool SeparatePlanValidity
         ) { m_SeparatePlanValidity = SeparatePlanValidity; }

   protected:

      virtual ERRVALUE v_Initialize ();
      virtual ERRVALUE v_PullBegin (const SECTION_ITERATOR& iterator);
      virtual ERRVALUE v_PullSubSection (const SECTION& section, BUFFER& target);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      DPOINT3D m_SunVector;
      double m_xgradscale;
      double m_ygradscale;
      UINT8 m_gradgray[GRADGRAYSIZE];
      UINT16 m_NumOutputs;
      UINT16 m_IdxPlanValidity;
      bool m_SeparatePlanValidity;

      bool m_bNeedFullKernal;
      double m_z[10];

      // Coefficients (don't have to pass them all around if they're members)
      double m_a;
      double m_b;
      double m_c;
      double m_d;
      double m_ee;
      double m_ProfileDenom;
      double m_PlanDenom;

      SETTINGS m_Settings;

      void ComputeSunVector ();
      void ComputeDisplayShadingLookupTable ();
      ERRVALUE ComputeCoefficients ();

      // Computational helper methods
      bool ReadKernel ();
      bool IsKernalLevel ();

      // Methods to compute the specific rasters
      void ComputeSlope (
         SAMPLEITERATOR &Tgt
         );
      void ComputeAspect (
         SAMPLEITERATOR &Tgt
         );
      void ComputeShading (
         SAMPLEITERATOR &Tgt
         );
      void ComputeCurvatureProfile (
         SAMPLEITERATOR &Tgt
         );
      void ComputeCurvaturePlan (
         SAMPLEITERATOR &TgtResult,
         UINT8 *pTgtValidity = 0
         );

      // Kernal storage
      SAMPLEITERATOR* m_itInput;
      SIMPLE_ARRAY<UINT8*> m_pValidInput;

      // Unimplemented
      FILTER_FOCALTOPOGRAPHIC (const FILTER_FOCALTOPOGRAPHIC&);
      FILTER_FOCALTOPOGRAPHIC& operator= (const FILTER_FOCALTOPOGRAPHIC&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

}  // End namespace IMAGE
}  // End namespace SPATMOD

#endif   // INC_SPATMOD_IMAGEFILTERFOCALTOPOGRAPHIC_H

---