ossimImageGeometry.h

Go to the documentation of this file.

//***********************************************************************************************
//
// License:  MIT
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Author:  Oscar Kramer (oscarkramer@yahoo.com)
//
// Description: Class declaration of ossimImageGeometry.
//
//***********************************************************************************************
// $Id: ossimImageGeometry.h 3102 2012-01-18 15:30:20Z oscar.kramer $

#ifndef ossimImageGeometry_HEADER
#define ossimImageGeometry_HEADER 1

#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimObject.h>
#include <ossim/base/ossimDpt.h>
#include <ossim/base/ossimIpt.h>
#include <ossim/base/ossimRtti.h>
#include <ossim/base/ossimRefPtr.h>
#include <ossim/base/ossimPolyArea2d.h>
#include <ossim/projection/ossimMapProjection.h>
#include <ossim/projection/ossimProjection.h>
#include <ossim/base/ossim2dTo2dTransform.h>
#include <vector>
#include <ossim/matrix/newmat.h>
#include <ossim/base/ossimDpt3d.h>
#include <ossim/base/ossimAdjustableParameterInterface.h>

// Forward class declarations:
class ossimDrect;
class ossimIrect;
class ossimGrect;

//***********************************************************************************************
//
//***********************************************************************************************
class OSSIM_DLL ossimImageGeometry : public ossimObject
{
public:
   typedef std::vector<ossim_float64> DeltaParamList;
   
   ossimImageGeometry();
   virtual ~ossimImageGeometry();
   
   ossimImageGeometry(const ossimImageGeometry& copy_this);

   ossimImageGeometry(ossim2dTo2dTransform* transform, ossimProjection* projection);

   bool open(const ossimFilename& image);

   void rnToRn(const ossimDpt& inRnPt, ossim_uint32 inResolutionLevel,
               ossim_uint32 outResolutionLevel,ossimDpt& outRnPt) const;
   
   void rnToFull(const ossimDpt& rnPt, ossim_uint32 resolutionLevel, ossimDpt& fullPt) const;

   void fullToRn(const ossimDpt& fullPt, ossim_uint32 resolutionLevel, ossimDpt& rnPt) const;

   void rnToWorld(const ossimDpt& rnPt, ossim_uint32 resolutionLevel, ossimGpt& wpt) const;
   
   void worldToRn(const ossimGpt& wpt, ossim_uint32 resolutionLevel, ossimDpt& rnPt) const;

   bool localToWorld(const ossimDpt& local_pt, ossimGpt& world_pt) const;
   bool localToWorld(const ossimDrect& local_rect, ossimGrect& world_rect) const;

   bool localToWorld(const ossimDpt& local_pt, const double& h_ellipsoid, ossimGpt& world_pt) const;

   bool worldToLocal(const ossimGpt& world_pt, ossimDpt& local_pt) const;
   bool worldToLocal(const ossimGrect& world_rect, ossimDrect& local_rect) const;

   void setTransform(ossim2dTo2dTransform* transform);

   void setProjection(ossimProjection* projection);

   const ossim2dTo2dTransform* getTransform() const { return m_transform.get(); }
   ossim2dTo2dTransform*       getTransform()       { return m_transform.get(); }

   const ossimProjection* getProjection() const { return m_projection.get(); }
   ossimProjection*       getProjection()       { return m_projection.get(); }

   bool isMapProjected() const;
   
   const ossimMapProjection* getAsMapProjection() const
   { return dynamic_cast<const ossimMapProjection*>( m_projection.get() ); }

   ossimMapProjection*       getAsMapProjection()
   { return dynamic_cast<ossimMapProjection*>( m_projection.get() ); }

   bool hasProjection() const { return m_projection.valid(); }
   
   bool hasTransform() const { return m_transform.valid(); }

   bool isAffectedByElevation() const;

   ossimDpt getMetersPerPixel() const;

   void getMetersPerPixel( ossimDpt& gsd ) const;

   ossimDpt getDegreesPerPixel() const;

   void getDegreesPerPixel( ossimDpt& dpp ) const;

   bool getCornerGpts(ossimGpt& ul, ossimGpt& ur, ossimGpt& lr, ossimGpt& ll) const;

   void getTiePoint(ossimGpt& tie, bool edge) const;

   void getTiePoint(ossimDpt& tie, bool edge) const;

   std::ostream& print(std::ostream& out) const;

   bool operator==(const ossimImageGeometry& compare_this) const;

   const ossimImageGeometry& operator=(const ossimImageGeometry& copy_this);

   ossimDpt decimationFactor(ossim_uint32 r_index) const;

   void decimationFactor(ossim_uint32 r_index, ossimDpt& result) const;

   void decimationFactors(std::vector<ossimDpt>& decimations) const;

   void setDiscreteDecimation(const std::vector<ossimDpt>& decimation_list) 
      { m_decimationFactors = decimation_list; }

   ossim_uint32 getNumberOfDecimations()const
   {
      return (ossim_uint32)m_decimationFactors.size();
   }
   void setImageSize(const ossimIpt& size)
   {
      m_imageSize = size;
   }
   const ossimIpt& getImageSize()const
   {
      return m_imageSize;
   }

   bool getCrossesDateline()const;
   

   void getImageEdgePoints(std::vector<ossimDpt>& result, ossim_uint32 partitions = 25)const;

   void calculatePolyBounds(ossimPolyArea2d& result, ossim_uint32 partitions = 25)const;

   void getBoundingRect(ossimIrect& bounding_rect) const;
   void getBoundingRect(ossimDrect& bounding_rect) const; // Overloaded for drect.
   
   void getBoundingGroundRect(ossimGrect& bounding_grect) const;

   virtual ossimObject* dup() const { return new ossimImageGeometry(*this); }

   virtual bool loadState(const ossimKeywordlist& kwl, const char* prefix=0);

   virtual bool saveState(ossimKeywordlist& kwl, const char* prefix=0) const;

   void setTargetRrds(ossim_uint32 rrds);

   ossim_uint32 getTargetRrds() const;

   void applyScale(const ossimDpt& scale, bool recenterTiePoint);

   virtual bool isEqualTo(const ossimObject& obj, ossimCompareType compareType = OSSIM_COMPARE_FULL)const;



   // If we have an adjustable parameter interface return one.
   //
   // @return a pointer to an ossimAdjustableParameterInterface or NULL if no
   //         adjustable paramters exist
   //
   virtual ossimAdjustableParameterInterface* getAdjustableParameterInterface();
   virtual const ossimAdjustableParameterInterface* getAdjustableParameterInterface()const;
   
   
   // Compute partials from image to ground with respect to the adjustable parameters.
   //
   //
   bool computeImageToGroundPartialsWRTAdjParam(ossimDpt& result,
                                                          const ossimGpt& gpt,
                                                          ossim_uint32 idx,
                                                          ossim_float64 paramDelta=1.0);
   bool computeImageToGroundPartialsWRTAdjParams(NEWMAT::Matrix& result,
                                                           const ossimGpt& gpt,
                                                           ossim_float64 paramDelta=1.0);
   bool computeImageToGroundPartialsWRTAdjParams(NEWMAT::Matrix& result,
                                                           const ossimGpt& gpt,
                                                           const DeltaParamList& deltas);
   
   bool computeGroundToImagePartials(NEWMAT::Matrix& result,
                                     const ossimGpt& gpt,
                                     const ossimDpt3d& deltaLlh);
   
   bool computeGroundToImagePartials(NEWMAT::Matrix& result,
                                     const ossimGpt& gpt);

   ossim_float64 upIsUpAngle(const ossimDpt&) const;
   ossim_float64 upIsUpAngle() const;

   ossim_float64 northUpAngle() const;
   
protected:
   void undecimatePoint(const ossimDpt& rnPt,
                        ossim_uint32 resolutionLevel,
                        ossimDpt& outPt) const;

   void decimatePoint(const ossimDpt& inPt,
                      ossim_uint32 resolutionLevel,
                      ossimDpt& rnPt) const;

   ossimRefPtr<ossim2dTo2dTransform> m_transform;   
   ossimRefPtr<ossimProjection>      m_projection;  
   std::vector<ossimDpt>             m_decimationFactors; 
   ossimIpt                          m_imageSize; // Image width and height

   ossim_uint32                      m_targetRrds; 

   TYPE_DATA
};

#endif /* #ifndef ossimImageGeometry_HEADER */