HomographyMapping.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "HomographyMapping.hh"
#include <Geometry/RMatrix.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/Geometry/HomgPoint2D.hh>

using namespace BIAS;

template <class InputStorageType, class OutputStorageType>
HomographyMapping<InputStorageType, OutputStorageType>::
~HomographyMapping() 
{}


template <class InputStorageType, class OutputStorageType>
HomographyMapping<InputStorageType, OutputStorageType>::
HomographyMapping() 
: H_(MatrixIdentity) 
{}


template <class InputStorageType, class OutputStorageType>
HomographyMapping<InputStorageType, OutputStorageType>::
HomographyMapping(const HomographyMapping & src) 
{
    (*this) = src;
}


template <class InputStorageType, class OutputStorageType>
HomographyMapping<InputStorageType, OutputStorageType> & 
HomographyMapping<InputStorageType, OutputStorageType>::
operator=(const HomographyMapping & src)
{
     H_ = src.H_;     
     return *this;
}


template <class InputStorageType, class OutputStorageType>
int HomographyMapping<InputStorageType, OutputStorageType>::
GetSourceCoordinates_(const HomgPoint2D& sink,
                      HomgPoint2D& source) const {
  // compute coordinates in source image with backward hoography
  H_.Mult(sink, source);
  source.Homogenize();
  return 0;
}

template <class InputStorageType, class OutputStorageType>
int HomographyMapping<InputStorageType, OutputStorageType>::
GetJacobian_(const HomgPoint2D& sink, Matrix2x2<double>& Jacobian) const {
  // analytic jacobian of homography
  H_.GetJacobian(sink, Jacobian);
  return 0;
}


using namespace std;

template <class InputStorageType, class OutputStorageType>
int HomographyMapping<InputStorageType, OutputStorageType>::
GetBoundingBox(unsigned int /* sourcewidth */, unsigned int /* sourceheight */,
               unsigned int sinkwidth, unsigned int sinkheight,
               int &tlx,  int &tly, 
               int &brx,  int &bry) {

 
  /** 
   // DISABLED: this code does only work for very special homographies, e.g.
   // affine transformations! It breaks if infinty and wraparound effects
   // come into play.


   double dtlx,dtly, dbrx,dbry; 

  // do a forward mapping of the corners of the source image and compute
  // convex hull rectangle

  HomgPoint2D tl(0,0,1), br(sourcewidth, sourceheight,1), bbTL, bbBR;
  HomgPoint2D bl(0,sourceheight,1), tr(sourcewidth,0,1), bbBL, bbTR;
  
  HMatrix HI=H_.Invert();
  bbTL= HI*tl; bbTL.Homogenize();
  bbBR= HI*br; bbBR.Homogenize();
  bbBL= HI*bl; bbBL.Homogenize();
  bbTR= HI*tr; bbTR.Homogenize();

  cout <<"source image corners map to "<<bbTL<<" "<<bbBR<<" "<<bbBL<<" "<<
    bbTR<<endl;

  // min(x) and min(y)
  dtlx=(bbTL[0]); 
  if (bbBR[0]<dtlx) dtlx=(bbBR[0]);
  if (bbBL[0]<dtlx) dtlx=(bbBL[0]);
  if (bbTR[0]<dtlx) dtlx=(bbTR[0]);

  dtly=(bbTL[1]); 
  if (bbBR[1]<dtly) dtly=(bbBR[1]);
  if (bbBL[1]<dtly) dtly=(bbBL[1]);
  if (bbTR[1]<dtly) dtly=(bbTR[1]);

  // max(x) and max(y)
  dbrx=(bbTL[0]); 
  if (bbBR[0]>dbrx) dbrx=(bbBR[0]);
  if (bbBL[0]>dbrx) dbrx=(bbBL[0]);
  if (bbTR[0]>dbrx) dbrx=(bbTR[0]);

  dbry=(bbTL[1]); 
  if (bbBR[1]>dbry) dbry=(bbBR[1]);
  if (bbBL[1]>dbry) dbry=(bbBL[1]);
  if (bbTR[1]>dbry) dbry=(bbTR[1]);
   
  if (dtlx >= double(INT_MAX)) dtlx = INT_MAX;
  if (dtly >= double(INT_MAX)) dtly = INT_MAX;
  
  // br is outside the boundinx box
  if (dbrx>double(INT_MAX)) dbrx = INT_MAX;

  if (dbry>double(INT_MAX)) dbry = INT_MAX;
  
  tlx = ( int)dtlx; 
  tly = ( int)dtly;
  brx = ( int)ceil(dbrx); 
  bry = ( int)ceil(dbry);

  cout<<"bounding box is "<<tlx<<" "<<tly<<" "<<brx<<" "<<bry<<" "<<endl;


  */

  tlx = ( int)0; 
  tly = ( int)0;
  brx = ( int)sinkwidth-1; 
  bry = ( int)sinkheight-1;


  return 0;
}

template <class InputStorageType, class OutputStorageType>
HMatrix HomographyMapping<InputStorageType, OutputStorageType>::
GetChangedHomography() const
{
  HMatrix HTrans;
  HTrans.SetIdentity();
  HTrans[0][2]=offsetX_;
  HTrans[1][2]=offsetY_;
  return H_ * HTrans;
}

namespace BIAS{
// TODO FIXME win32 template instantiation problem (JW)
template class HomographyMapping<unsigned char, unsigned char>;
template class HomographyMapping<float, float>;
template class HomographyMapping<unsigned char, float>;
template class HomographyMapping<float, unsigned char>;

#if defined(BUILD_IMAGE_CHAR)
// TODO FIXME win32 template instantiation problem (JW)
template class HomographyMapping<unsigned char, char>;
template class HomographyMapping<char, char>;
#endif

#if defined(BUILD_IMAGE_USHORT)
template class HomographyMapping<unsigned short,unsigned short>;
#endif

#if defined(BUILD_IMAGE_SHORT)
template class HomographyMapping<short, short>;
#endif

#if defined(BUILD_IMAGE_SHORT)&&defined(BUILD_IMAGE_USHORT)
template class HomographyMapping<unsigned short, short>;
#endif

#if defined(BUILD_IMAGE_INT)
template class HomographyMapping<int,int>;
#endif

#if defined(BUILD_IMAGE_USHORT)
template class HomographyMapping<unsigned short,float>;
#endif

#if defined(BUILD_IMAGE_USHORT) && defined(BUILD_IMAGE_INT)
template class HomographyMapping<unsigned short,int>;
#endif

#if defined(BUILD_IMAGE_DOUBLE)
template class HomographyMapping<double,double>;
#endif
}