ossim2dTo2dMatrixTransform.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// License:  MIT
// 
// See LICENSE.txt file in the top level directory for more details.
//
// Author:
//
// Description: 
// 
//----------------------------------------------------------------------------
// $Id$
#ifndef ossim2dTo2dMatrixTransform_HEADER
#define ossim2dTo2dMatrixTransform_HEADER 1

#include <ossim/base/ossim2dTo2dTransform.h>
#include <algorithm>

class OSSIM_DLL ossim2dTo2dMatrixTransform : public ossim2dTo2dTransform
{
public: 

   ossim2dTo2dMatrixTransform();
   
   ossim2dTo2dMatrixTransform(const ossimDpt* input,
                            const ossimDpt* output, 
                            ossim_uint32 arraySize)
   {
      setFromPoints(input, output, arraySize);
   }
   
   ossim2dTo2dMatrixTransform(const ossimDpt& in1, const ossimDpt& in2, const ossimDpt& in3, const ossimDpt& in4,
                            const ossimDpt& out1, const ossimDpt& out2, const ossimDpt& out3, const ossimDpt& out4)
   {
      setFromPoints(in1, in2, in3, in4, out1, out2, out3, out4);
   }
   
   ossim2dTo2dMatrixTransform(const ossim2dTo2dMatrixTransform& src);
   
   virtual ossimObject* dup()const{return new ossim2dTo2dMatrixTransform(*this);}
   
   const ossim2dTo2dMatrixTransform& operator =(const ossim2dTo2dMatrixTransform& src)
   {
      if(this == &src) return *this;
      
      ossim2dTo2dTransform::operator =(*this); // call base classes equal operator
      std::copy(src.m_coefficientsXTerm, src.m_coefficientsXTerm+4, m_coefficientsXTerm);
      std::copy(src.m_coefficientsYTerm, src.m_coefficientsYTerm+4, m_coefficientsYTerm);
      std::copy(src.m_inverseCoefficientsXTerm, src.m_inverseCoefficientsXTerm+4, m_inverseCoefficientsXTerm);
      std::copy(src.m_inverseCoefficientsYTerm, src.m_inverseCoefficientsYTerm+4, m_inverseCoefficientsYTerm);
      
      return *this;
   }
   
   void setFromPoints(const ossimDpt& in1, const ossimDpt& in2, const ossimDpt& in3, const ossimDpt& in4,
                      const ossimDpt& out1, const ossimDpt& out2, const ossimDpt& out3, const ossimDpt& out4);

   void setFromPoints(const ossimDpt* input,
                      const ossimDpt* output, 
                      ossim_uint32 arraySize);
 
   virtual void forward(const ossimDpt& input,
                        ossimDpt& output) const
   {
      output.x = (m_coefficientsXTerm[0] + 
                  m_coefficientsXTerm[1]*input.x + 
                  m_coefficientsXTerm[2]*input.y + 
                  m_coefficientsXTerm[3]*input.x*input.y);
      output.y = (m_coefficientsYTerm[0] + 
                  m_coefficientsYTerm[1]*input.x + 
                  m_coefficientsYTerm[2]*input.y + 
                  m_coefficientsYTerm[3]*input.x*input.y);
   }
   
   virtual void forward(ossimDpt&  modify_this) const
   {
      double saveX = modify_this.x;
      modify_this.x = (m_coefficientsXTerm[0] + 
                       m_coefficientsXTerm[1]*modify_this.x + 
                       m_coefficientsXTerm[2]*modify_this.y + 
                       m_coefficientsXTerm[3]*modify_this.x*modify_this.y);
      modify_this.y = (m_coefficientsYTerm[0] + 
                       m_coefficientsYTerm[1]*saveX + 
                       m_coefficientsYTerm[2]*modify_this.y + 
                       m_coefficientsYTerm[3]*saveX*modify_this.y);
   }
   
   virtual void inverse(const ossimDpt& input,
                        ossimDpt&       output) const
   {
      output.x = (m_inverseCoefficientsXTerm[0] + 
                  m_inverseCoefficientsXTerm[1]*input.x + 
                  m_inverseCoefficientsXTerm[2]*input.y + 
                  m_inverseCoefficientsXTerm[3]*input.x*input.y);
      output.y = (m_inverseCoefficientsYTerm[0] + 
                  m_inverseCoefficientsYTerm[1]*input.x + 
                  m_inverseCoefficientsYTerm[2]*input.y + 
                  m_inverseCoefficientsYTerm[3]*input.x*input.y);
   }
   
   virtual void inverse(ossimDpt&  modify_this) const
   {
      double saveX = modify_this.x;
      modify_this.x = (m_inverseCoefficientsXTerm[0] + 
                       m_inverseCoefficientsXTerm[1]*modify_this.x + 
                       m_inverseCoefficientsXTerm[2]*modify_this.y + 
                       m_inverseCoefficientsXTerm[3]*modify_this.x*modify_this.y);
      modify_this.y = (m_inverseCoefficientsYTerm[0] + 
                       m_inverseCoefficientsYTerm[1]*saveX + 
                       m_inverseCoefficientsYTerm[2]*modify_this.y + 
                       m_inverseCoefficientsYTerm[3]*saveX*modify_this.y);
   }
   
   virtual bool saveState(ossimKeywordlist& kwl,
                          const char* prefix = 0)const;
   
   virtual bool loadState(const ossimKeywordlist& kwl,
                          const char* prefix = 0);
   
   virtual std::ostream& print(std::ostream& out) const
   {
      ossim2dTo2dTransform::print(out);
      out << "xTerm: " << m_coefficientsXTerm[0] << ", " << m_coefficientsXTerm[1] << ", "
          << m_coefficientsXTerm[2] << ", " << m_coefficientsXTerm[3] << "\n";
      out << "yTerm: " << m_coefficientsYTerm[0] << ", " << m_coefficientsYTerm[1] << ", "
          << m_coefficientsYTerm[2] << ", " << m_coefficientsYTerm[3] << "\n";
      
      out << "xInverseTerm: " << m_inverseCoefficientsXTerm[0] << ", " << m_inverseCoefficientsXTerm[1] << ", "
          << m_inverseCoefficientsXTerm[2] << ", " << m_inverseCoefficientsXTerm[3] << "\n";
      out << "yInverseTerm: " << m_inverseCoefficientsYTerm[0] << ", " << m_inverseCoefficientsYTerm[1] << ", "
          << m_inverseCoefficientsYTerm[2] << ", " << m_inverseCoefficientsYTerm[3] << "\n";
      
      return out;
   }
   
protected:
   ossim_float64 m_coefficientsXTerm[4]; // constant, linear x, linear y, cross xy
   ossim_float64 m_coefficientsYTerm[4]; // constant, linear x, linear y, cross xy

   ossim_float64 m_inverseCoefficientsXTerm[4]; // constant, linear x, linear y, cross xy
   ossim_float64 m_inverseCoefficientsYTerm[4]; // constant, linear x, linear y, cross xy
   TYPE_DATA;   
};

#endif