ossimSensorModel.h

Go to the documentation of this file.

//*****************************************************************************
// FILE: ossimSensorModel.h
//
// License:  See top level LICENSE.txt file.
//
// AUTHOR: Oscar Kramer
//
// DESCRIPTION:
//   Contains declaration of class ossimSensorModel. This is the base class to
//   all sensor model-related projections including replacement models such as
//   coarse grids and polynomial models. This base class supports adjustable
//   parameters for registration adjustment.
//
//   Important note to sensor model implementors: In order to avoid a separate
//   set of "initial adjustable parameters," this design assumes ALL initial
//   values are 0. When designing the derived-class model, insure that the
//   adjustable parameters are 0-based. This applies to theAdjustableParams
//   array declared in this base class only. The derived classes can declare
//   their own adjstable params that are more descriptive and that can be
//   assigned an initial value that is non-zero, but that are linearly related
//   to the adjustable params of this class. In that case, the updateModel()
//   method will compute the derived-class's parameters based on
//   theAdjustableParams array, after an adjustment is made.
//
// LIMITATIONS: None.
//
//*****************************************************************************
//  $Id: ossimSensorModel.h 23297 2015-05-05 20:32:16Z dburken $

#ifndef ossimSensorModel_HEADER
#define ossimSensorModel_HEADER 1

#include <ossim/projection/ossimProjection.h>
#include <ossim/projection/ossimBilinearProjection.h>
#include <ossim/projection/ossimOptimizableProjection.h>
#include <ossim/base/ossimEcefRay.h>
#include <ossim/base/ossimString.h>
#include <ossim/base/ossimPolygon.h>
#include <ossim/base/ossimDrect.h>
#include <ossim/base/ossimCommon.h> /* for ossim::nan() */
#include <ossim/elevation/ossimElevSource.h>
#include <ossim/base/ossimAdjustableParameterInterface.h>
#include <ossim/matrix/newmat.h>
#include <ossim/matrix/newmatap.h>
#include <ossim/base/ossimException.h>
class ossimKeywordlist;
class ossimTieGptSet;

/*!****************************************************************************
 *
 * CLASS:  ossimSensorModel
 *
 *****************************************************************************/
class OSSIMDLLEXPORT ossimSensorModel : public ossimProjection,
                                        public ossimOptimizableProjection,
                                        public ossimAdjustableParameterInterface
{
public:

   enum CovMatStatus
   {
      COV_INVALID = 0,
      COV_PARTIAL = 1,
      COV_FULL    = 2
   };

   enum DeriveMode
   {
      OBS_INIT =-99,
      EVALUATE =-98,
      P_WRT_X = -1,
      P_WRT_Y = -2,
      P_WRT_Z = -3
   };
   
   ossimSensorModel();
   ossimSensorModel(const ossimSensorModel& copy_this);
   ossimSensorModel(const ossimKeywordlist& geom_kwl);

   const ossimSensorModel& operator=( const ossimSensorModel& rhs );

   virtual ossimObject* getBaseObject();
   virtual const ossimObject* getBaseObject()const;
   
   virtual ossimGpt origin()            const {return theRefGndPt; }
   virtual ossimDpt getMetersPerPixel() const {return ossimDpt(fabs(theGSD.x),
                                                               fabs(theGSD.y));}
   
   virtual const double& getNominalPosError() const { return theNominalPosError; }

   virtual const double& getRelativePosError() const { return theRelPosError; }

   virtual void setNominalPosError(const double& ce90) { theNominalPosError = ce90; }

   virtual void setRelativePosError(const double& ce90) { theRelPosError = ce90; }

   virtual void  lineSampleToWorld(const ossimDpt& image_point,
                                   ossimGpt&       world_point) const;
   virtual void  worldToLineSample(const ossimGpt& world_point,
                                   ossimDpt&       image_point) const;

   virtual void lineSampleHeightToWorld(const ossimDpt& lineSampPt,
                                        const double&   heightEllipsoid,
                                        ossimGpt&       worldPt) const = 0;
   virtual void imagingRay(const ossimDpt& image_point,
                           ossimEcefRay&   image_ray) const;

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

   void setRefImgPt(const ossimDpt& pt);

   void setRefGndPt(const ossimGpt& pt);
   

   void setImageRect(const ossimDrect& imageRect);
   void setGroundRect(const ossimGpt& ul,
                      const ossimGpt& ur,
                      const ossimGpt& lr,
                      const ossimGpt& ll);
   ossimDpt imageSize() const { return theImageSize; }
   void setImageSize(const ossimDpt& size){theImageSize = size;}
   virtual void adjustableParametersChanged()
      {
         updateModel();
      }
   virtual void updateModel() {}

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

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

   virtual bool insideImage(const ossimDpt& p) const
      {
/*          return( (p.u>=(0.0-FLT_EPSILON)) && */
/*                  (p.u<=(double)(theImageSize.u-(1-FLT_EPSILON))) && */
/*                  (p.v>=(0.0-FLT_EPSILON)) && */
/*                  (p.v<=(double)(theImageSize.v-(1-FLT_EPSILON))) ); */
         // if it's close to the edge we will consider it inside the image
         //
         return theImageClipRect.pointWithin(p, 2.0);
      }

   static void writeGeomTemplate(ostream& os);

   virtual bool operator==(const ossimProjection& proj) const; //inline below

    const ossimString&   getImageID()               const { return theImageID; }
    const ossimDrect&    getImageClipRect()         const { return theImageClipRect; }

   virtual ossim_uint32 degreesOfFreedom()const;
   inline virtual bool needsInitialState()const {return true;}
   virtual double optimizeFit(const ossimTieGptSet& tieSet,
                              double* targetVariance=0);

   virtual ossimDpt getForwardDeriv(int parmIdx, const ossimGpt& gpos, double hdelta=1e-11);

   virtual ossimGpt getInverseDeriv(int parmIdx, const ossimDpt& ipos, double hdelta=1e-11);

   virtual ossimSensorModel::CovMatStatus getObsCovMat(
      const ossimDpt& ipos, NEWMAT::SymmetricMatrix& Cov,
      const ossim_float64 defPointingSigma = 0.5) const;

   virtual bool isAffectedByElevation() const { return true; }

   void computeGsd();

   virtual bool getImageGeometry( 
      const ossimString& /* key */, const ossimString& /* value */, 
      ossimKeywordlist& /* geomKwl */ ) const { return false; }

protected:
   virtual ~ossimSensorModel();

   
   virtual ossimDpt extrapolate (const ossimGpt& gp) const;
   virtual ossimGpt extrapolate (const ossimDpt& ip,
                 const double& height=ossim::nan()) const;

   void buildNormalEquation(const ossimTieGptSet& tieSet,
                                      NEWMAT::SymmetricMatrix& A,
                                      NEWMAT::ColumnVector& residue,
                                      NEWMAT::ColumnVector& projResidue,
                                      double pstep_scale);

   NEWMAT::ColumnVector getResidue(const ossimTieGptSet& tieSet);

   NEWMAT::ColumnVector solveLeastSquares(NEWMAT::SymmetricMatrix& A,  NEWMAT::ColumnVector& r)const;

   NEWMAT::Matrix invert(const NEWMAT::Matrix& m)const;

   ossimIpt       theImageSize;       // pixels

   ossimDpt       theSubImageOffset;  // pixels
   
   ossimString    theImageID;
   ossimString    theSensorID;
   ossimDpt       theGSD;             // meters
   ossim_float64  theMeanGSD;         // meters
   ossimGpt       theRefGndPt;        // should be image center
   ossimDpt       theRefImgPt;        // should be image center
   ossimPolygon   theBoundGndPolygon;
   ossimDrect     theImageClipRect;
   ossim_float64  theRelPosError;   // meters, relative to other models in the set
   ossim_float64  theNominalPosError; // meters

   ossimDpt theParWRTx;
   ossimDpt theParWRTy;
   ossimDpt theParWRTz;
   
   ossimDpt theObs;
   ossimDpt theResid;

   ossimRefPtr<ossimProjection> theSeedFunction;
   
   mutable bool theExtrapolateImageFlag;
   mutable bool theExtrapolateGroundFlag;
   
TYPE_DATA
};

//================= BEGIN INLINE DEFINITIONS =================================

//*****************************************************************************
//  OPERATOR == 
//*****************************************************************************
inline bool ossimSensorModel::operator==(const ossimProjection& proj) const
{
   // const  ossimSensorModel* model
   //    = PTR_CAST(ossimSensorModel, (const ossimProjection*) &proj);
   const ossimSensorModel* model = dynamic_cast<const ossimSensorModel*>( &proj );
   if ( (!model) ||
    (theSensorID != model->theSensorID) ||
    (theImageID != model->theImageID) ||
    (theSubImageOffset != model->theSubImageOffset) )
      return false;

   return true;
}

#endif