SphericalRectification.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 <Image/SphericalRectification.hh>
#include <Geometry/ProjectionParametersGreatCircles.hh>

#include <iostream>
using namespace std;
using namespace BIAS;


#define SUPERPARENT RectificationBase<InputStorageType, OutputStorageType>
#define PARENT RectificationViaProjectionMappingBase<InputStorageType, OutputStorageType>


template <class InputStorageType, class OutputStorageType>
BIAS::SphericalRectification<InputStorageType, OutputStorageType>::
SphericalRectification() : 
PARENT::RectificationViaProjectionMappingBase("SphericalRectification")
{ }

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


template <class InputStorageType, class OutputStorageType>
bool BIAS::SphericalRectification<InputStorageType, OutputStorageType>::
IsInputCameraValid(const BIAS::Image<InputStorageType>& img,
                   const BIAS::ProjectionParametersBase* proj)
{
  const ProjectionParametersSpherical* pps = 
    dynamic_cast<const ProjectionParametersSpherical*>(proj);
  
  if(pps == NULL)
    return false;

  return true;
}


template <class InputStorageType, class OutputStorageType>
int BIAS::SphericalRectification<InputStorageType, OutputStorageType>::
DetermineRectificationParameters_()
{

  Pose poseA = SUPERPARENT::ppBA_->GetPose();
  Pose poseB = SUPERPARENT::ppBB_->GetPose();
  Pose rectPoseA, rectPoseB;
  if(SUPERPARENT::CalculateRectifiedBases(poseA, poseB, 
                                          rectPoseA, rectPoseB, false)!=0)
    return -1;

  delete PARENT::rectPPA_;
  delete PARENT::rectPPB_;
  ProjectionParametersGreatCircles* ppgcA;
  ProjectionParametersGreatCircles* ppgcB;
  PARENT::rectPPA_ = ppgcA = new ProjectionParametersGreatCircles();
  PARENT::rectPPB_ = ppgcB = new ProjectionParametersGreatCircles();
  
  PARENT::rectPPA_->SetPose(rectPoseA);
  PARENT::rectPPB_->SetPose(rectPoseB);

  const ProjectionParametersSpherical* ppsA = 
    dynamic_cast<const ProjectionParametersSpherical*>(SUPERPARENT::ppBA_);
  const ProjectionParametersSpherical* ppsB = 
    dynamic_cast<const ProjectionParametersSpherical*>(SUPERPARENT::ppBB_);
  BIASASSERT(ppsA != NULL && ppsB != NULL);



  //determine angle offset
  HomgPoint3D z(0,0,1,1);
  HomgPoint3D worldOpticalAxisA = poseA.LocalToGlobal(z);

  //  if(camAngleAlpha>M_PI_2) camAngleAlpha = M_PI_2;
  double minThetaA, minPhiA, maxThetaA, maxPhiA;
  if(!ppgcA -> GetAngleInterval(worldOpticalAxisA, 
                                ppsA->GetMaxCamAngle(), 
                                minThetaA, maxThetaA, 
                                minPhiA, maxPhiA) ) {
  cerr<<"phi A = ("<<minPhiA<<", "<<maxPhiA<<")\n";
    return -1;
  }
  
  HomgPoint3D worldOpticalAxisB = poseB.LocalToGlobal(z);  
  double minThetaB, minPhiB, maxThetaB, maxPhiB;

  if(!ppgcB -> GetAngleInterval(worldOpticalAxisB, 
                                ppsB->GetMaxCamAngle(), 
                                minThetaB, maxThetaB, 
                                minPhiB, maxPhiB) ){
  cerr<<"phi B = ("<<minPhiB<<", "<<maxPhiB<<")\n";
    return -1;
  }
//   cerr<<"phi A = ("<<minPhiA<<", "<<maxPhiA<<")\n";
//   cerr<<"phi B = ("<<minPhiB<<", "<<maxPhiB<<")\n";

  //find the smallest common viewing directions
  //parallel boundry rays should be the max/min
  //use the smaller/larger of the values to search
  //all possible match positions
  double commonThetaMin, commonPhiMin, commonThetaMax, commonPhiMax;
  commonThetaMin = (minThetaA<minThetaB) ? minThetaA : minThetaB;
  //propagete the larger here since only common epilines are of interest!
  commonPhiMin = (minPhiA>minPhiB) ? minPhiA : minPhiB;

  //cerr<<"commonPhiMin "<<commonPhiMin<<endl;

  //override angles are applied restrain the fov,
  //use max of min angles:
  if(commonThetaMin<PARENT::thetaMinOverride_) 
    commonThetaMin= PARENT::thetaMinOverride_;
  if(commonPhiMin<PARENT::phiMinOverride_) 
    commonPhiMin= PARENT::phiMinOverride_;

  commonThetaMax = (maxThetaA>maxThetaB) ? maxThetaA : maxThetaB;
  //propagete the smaller here since only common epilines are of interest!
  commonPhiMax = (maxPhiA>maxPhiB) ? maxPhiB : maxPhiA; 
  //override angles are applied restrain the fov,
  //use min of max angles :
  if(commonPhiMax>PARENT::phiMaxOverride_) 
    commonPhiMax = PARENT::phiMaxOverride_;  
  if(commonThetaMax>PARENT::thetaMaxOverride_) 
    commonThetaMax = PARENT::thetaMaxOverride_;


  //determine smallest angular sampling distance:
  //
  //smallest angular sampling step in phi:
  double maxRadius = ppsA->GetRadius();
  if(ppsB->GetRadius()>maxRadius) 
    maxRadius = ppsB->GetRadius();
  double angularSamplingDistancePhi = 1.0/maxRadius;

  //smallest angular sampling step in theta:
  double angularSamplingDistanceThetaA = 
    ppsA->GetMaxCamAngle()/ppsA->GetRadius();  
  double angularSamplingDistanceThetaB = 
    ppsB->GetMaxCamAngle()/ppsB->GetRadius();
  double angularSamplingDistanceTheta =
    (angularSamplingDistanceThetaA < angularSamplingDistanceThetaB) ?
    angularSamplingDistanceThetaA : angularSamplingDistanceThetaB;

  //overall minimal sampling step
  double minAngularSamplingDistance = 
    (angularSamplingDistancePhi<angularSamplingDistanceTheta) ?
    angularSamplingDistancePhi : angularSamplingDistanceTheta ;

  //use angle ranges and minial sampling distance to find common resolution:
  double angleRangeTheta = commonThetaMax - commonThetaMin;
  double angleRangePhi = commonPhiMax - commonPhiMin;
  double numSamplesOnEpiLine = angleRangeTheta/minAngularSamplingDistance;
  double numEpiLines = angleRangePhi/minAngularSamplingDistance;

//   cerr<<"common Theta = ("<<commonThetaMin<<", "<<commonThetaMax<<")\n";
//   cerr<<"common phi = ("<<commonPhiMin<<", "<<commonPhiMax<<")\n";

  ppgcA->SetInternals(commonPhiMin, commonPhiMax,
                      commonThetaMin, commonThetaMax,
                      (unsigned int)floor(numSamplesOnEpiLine), 
                      (unsigned int)floor(numEpiLines));
  ppgcB->SetInternals(commonPhiMin, commonPhiMax,
                      commonThetaMin, commonThetaMax,
                      (unsigned int)floor(numSamplesOnEpiLine), 
                      (unsigned int)floor(numEpiLines));



  return 0;
}

// template <class InputStorageType, class OutputStorageType>
// int BIAS::SphericalRectification<InputStorageType, OutputStorageType>::
// DetermineGreatCircleParametersFromSpherical_(
//                                   ProjectionParametersSpherical* ppsIn,
//                                   Pose& rectPose,
//                                   double& minAlpha,
//                                   double& minBeta,
//                                   double& alphaRange,
//                                   double& betaRange,
//                                   double& relativeAlphaRes,
//                                   double& relativeBetaRes) 
// {
  
// }

namespace BIAS{
template class SphericalRectification<unsigned char, unsigned char>;
template class SphericalRectification<float, float>;
template class SphericalRectification<unsigned char, float>;
template class SphericalRectification<float, unsigned char>;

#if defined(BUILD_IMAGE_CHAR)
template class SphericalRectification<unsigned char, char>;
template class SphericalRectification<char, char>;
#endif

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

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

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

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

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

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

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