mi32/transmod.h

Go to the documentation of this file.

/***
 * \file transmod.h <mi32/transmod.h>
 * \brief Definitions for TransModel object used in georeference
 *
 * \if NODOC
 * $Id: transmod.h_v 1.4 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: transmod.h_v $
 * Revision 1.4  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.3  2000/11/16 18:25:10  scowan
 * Updated for genator docs.
 *
 * Revision 1.2  2000/11/16 17:50:10  scowan
 * Proper id and log tags inserted.
 *
 * \endif
***/

#ifndef  INC_MI32_TRANSMOD_H
#define  INC_MI32_TRANSMOD_H

#ifndef INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifndef INC_MI32_TRANS2D_H
#include <mi32/trans2d.h>
#endif

//!
//!   TRANSMODEL class.  This class manages the different sections and values in the UINT16 CalibModel field 
//! in the RVCGEOREFINFO struct.  This parameter is also used in some function calls, mainly in TRANSGEN
//! and TRANS2D_MAPGEN classes.  Its main goal is to hide the annoying bit twiddling that the CalibModel variable
//! requires.
//!

class TRANSMODEL {
public:

   // ENUMERATIONS
   
   enum FLAGS {                     //! Translation model flags
      FLAGS_None = 0,
      FLAGS_OrientInvert = TRANS2DMODEL_OrientInvert,
      FLAGS_Piecewise = TRANS2DMODEL_Piecewise
      };

   enum TYPE {                      //! Translation model type, based off of TRANS2DMODEL values
      TYPE_None = 0,
      TYPE_Affine = 1,                 //!< Affine (MAT3X3)
      TYPE_PlaneProj,                     //!< Plane-projective
      TYPE_Bilinear,
      TYPE_Polynomial,
      TYPE_Quintic,
      TYPE_SpaceResect,                //!< Space resection (aerial photography)
      TYPE_Conformal,                     //!< Conformal transformation
      TYPE_RubberSheet                 //!< "Rubber Sheeting" or "Morphing" model
      };

   // CONSTRUCTORS / DESTRUCTOR
   
   //! Default constructor 
   TRANSMODEL (
      UINT16 model = 0                 //!< Old transmodel number (UINT16)
      ) :
      m_Order(0),
      m_Flags(FLAGS_None),
      m_Type(TYPE_None)
      {
      if (model != 0) SetModel(model);
      }

   //! Use default copy constructor
   
   //! Constructor with type
   TRANSMODEL (
      TYPE dfttype
      ) :
      m_Order(0),
      m_Flags(FLAGS_None),
      m_Type(dfttype)
      {}
      
   // OPERATORS
   //! Use default assignment operator
      
   // METHODS

   //! Obtain TRANSMODEL flags
   //!
   //! @return: TRANSMODEL::FLAGS
   FLAGS GetFlags (
      ) const {
      return (m_Flags);
      }

   //! Obtain old translation model combined value
   //!
   //! @return: Translation model combined value
   UINT16 GetModel (
      ) const {
      UINT16 retval = static_cast<UINT16>(m_Order | static_cast<UINT16>(m_Flags));
      retval |= static_cast<UINT16>(m_Type) << 8;
      return (retval);
      }

   //! Obtain translation model order
   //!
   //! @return: Translation model order
   UINT16 GetOrder (
      ) const {
      return (m_Order);
      }

   //! Obtain translation model type
   //!
   //! @return: Translation model type
   TYPE GetType (
      ) const {
      return (m_Type);
      }

   //! Determine translation model orientation
   //!
   //! @return: True if translation model inverted, false if not
   bool IsOrientInvert (
      ) const {
      return ((m_Flags & FLAGS_OrientInvert) != 0);
      }

   //! Determine if translation model is piecewise
   //!
   //! @return: True if translation model is piecewise, false if not
   bool IsPiecewise (
      ) const {
      return ((m_Flags & FLAGS_Piecewise) != 0);
      }

   //! Set translation model using old translation model value
   void SetModel (
      UINT16 model
      ) {
      m_Order = static_cast<UINT16>(model & 0x00FF),
      m_Flags = static_cast<FLAGS>(model & 0xF000);
      m_Type = static_cast<TYPE>((model & 0xF00) >> 8);
      return;
      }

   //! Set translation model flags
   void SetFlags (
      FLAGS flags
      ) {
      m_Flags = flags;
      return;
      }

   //! Set translation model order
   void SetOrder (
      UINT16 order
      ) {
      m_Order = order;
      return;
      }

   //! Set translation model type
   void SetType (
      TYPE type
      ) {
      m_Type = type;
      return;
      }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   FLAGS m_Flags;
   TYPE m_Type;
   UINT16 m_Order;
   #endif // GENERATING_DOXYGEN_OUTPUT
};

DEFINE_ENUM_OPERATORS(TRANSMODEL::FLAGS);

#endif               //!<  #ifndef  INC_MI32_TRANSMOD_H 

---