ProjectionParametersFactory.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 <Geometry/Projection.hh>
#include <Geometry/ProjectionParametersFactory.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Geometry/ProjectionParametersPerspectiveDepth.hh>
#include <Geometry/ProjectionParametersProjective.hh>
#include <Geometry/ProjectionParametersSphericalFast.hh>
#include <Geometry/ProjectionParametersSpherical.hh>
#include <Geometry/ProjectionParametersCylindric.hh>
#include <Geometry/ProjectionParametersGreatCircles.hh>
#include <Geometry/ProjectionParametersSphericalSimple.hh>
#include <Geometry/ProjectionParametersZoom.hh>
#ifndef WIN32
#ifdef BUILD_DYNAMIC_LOAD_PROJECTION
#include <Geometry/ProjectionParametersDynamicLoad.hh>
#endif
#endif
using namespace BIAS;
using namespace std;

ProjectionParametersFactory::ProjectionParametersFactory()
{
  ValidClassNames_.push_back("ProjectionParametersPerspective");
  ValidClassNames_.push_back("ProjectionParametersPerspectiveDepth");
  ValidClassNames_.push_back("ProjectionParametersProjective");
  ValidClassNames_.push_back("ProjectionParametersSpherical");
  ValidClassNames_.push_back("ProjectionParametersSphericalFast");
  ValidClassNames_.push_back("ProjectionParametersCylindric");
  ValidClassNames_.push_back("ProjectionParametersGreatCircles");
  ValidClassNames_.push_back("ProjectionParametersZoom");
  ValidClassNames_.push_back("ProjectionParametersSphericalSimple");
  
}
ProjectionParametersFactory::~ProjectionParametersFactory(){
  ValidClassNames_.clear();
}

ProjectionParametersBase*
ProjectionParametersFactory::Create(const std::string& className)
{
  if (className == "ProjectionParametersPerspective")
    return new ProjectionParametersPerspective;
  if (className == "ProjectionParametersPerspectiveDepth")
    return new ProjectionParametersPerspectiveDepth;
  if (className == "ProjectionParametersProjective")
    return new ProjectionParametersProjective;
  if (className == "ProjectionParametersSphericalFast")
    return new ProjectionParametersSphericalFast;
  if (className == "ProjectionParametersSpherical")
    return new ProjectionParametersSpherical;
  if (className == "ProjectionParametersCylindric")
    return new ProjectionParametersCylindric;
  if (className == "ProjectionParametersGreatCircles")
    return new ProjectionParametersGreatCircles;
  if (className == "ProjectionParametersZoom")
    return new ProjectionParametersZoom;
  if (className == "ProjectionParametersSphericalSimple")
    return new ProjectionParametersSphericalSimple;
#ifndef WIN32  
#ifdef BUILD_DYNAMIC_LOAD_PROJECTION
  ProjectionParametersDynamicLoad* ppdl = new ProjectionParametersDynamicLoad(className); 
  if(ppdl->GetDynPtr() != NULL){
    return ppdl;
  }
#endif
#endif
  
  BIASERR("Invalid projection parameters class: " << className);
  return NULL;
}

ProjectionParametersBase*
ProjectionParametersFactory::Create(const CameraData& camData)
{
  ProjectionParametersBase* ppb = NULL;
  if (camData.LensIsSpherical_) {
    //initialize fisheye camera
    ProjectionParametersSpherical* pps = new ProjectionParametersSpherical();
    pps->SetRadius(camData.radius_);
    pps->SetUndistortion(camData.AngleCorrX_, camData.AngleCorrY_, 
                         camData.radius_);
    ppb = (ProjectionParametersBase*) pps;
  } else {
    if (camData.zoomCamera_){
      // initialize zoom camera
      ProjectionParametersZoom* ppz = 
        new ProjectionParametersZoom();
      std::vector<CPDiscreteParam>::iterator it;
      ppz->Clear();
      for (unsigned int j=0; j<camData.knownparams_vect_.size(); j++) {
        ppz->AddZoomStep(camData.knownparams_vect_[j].zoom, 
                         camData.knownparams_vect_[j].focallength,
                         camData.knownparams_vect_[j].kc1, 
                         camData.knownparams_vect_[j].kc2, 
                         camData.knownparams_vect_[j].kc3, 
                         camData.knownparams_vect_[j].kc4);
      }
      ppb = (ProjectionParametersBase*) ppz;
    } else {
      // initialize perspective camera
      ProjectionParametersPerspective* ppp = 
        new ProjectionParametersPerspective();
      // convert fl to meter
      ppp->SetFocalLengthAndAspect( camData.focallengthDef_, 
                                    camData.aspectratio_);
      ppp->SetUndistortion(camData.kc1Def_,camData.kc2Def_,
                           camData.kc3Def_,camData.kc4Def_);
      ppb = (ProjectionParametersBase*) ppp;        
    }
  }
  // Set base parameters
  ppb->SetImageSize(camData.width_, camData.height_);
  ppb->SetPrincipal(camData.principalX_, camData.principalY_);
  double eps = 1e-8;
  if ((camData.aspectratio_ < camData.cellSizeX_/camData.cellSizeY_-eps) ||
      (camData.aspectratio_ > camData.cellSizeX_/camData.cellSizeY_+eps)) {
    BIASERR("Aspect ratio and cellsizes do not match!");
    BIASABORT;
  }
  ppb->SetAspectratio(camData.aspectratio_);
  ppb->SetC(camData.PoseInRigCenter_);
  RMatrix R;
  Quaternion<double> Q;
  R.SetXYZ(camData.PoseInRigPitch_, camData.PoseInRigYaw_, 
           camData.PoseInRigRoll_);
  R.GetQuaternion(Q);
  ppb->SetQ(Q);

  return ppb;
}

ProjectionParametersBase*
ProjectionParametersFactory::Load(const std::string& fileName)
{
#ifdef BIAS_HAVE_XML2
  XMLIO myXML;
  xmlNodePtr rootNode;
  rootNode = myXML.read(fileName);
  if (rootNode==NULL) {
    BIASERR("Projection parameter XML file "<<fileName<<" not found or parse error!");
    return NULL;
  }
  string className = myXML.getNodeName(rootNode);
  if (className == "Projection") {
    BIASERR("Trying to load projection parameters from projection XML file "
            <<fileName<<", trying to read projection instead!");
    Projection proj;
    if (proj.Load(fileName) != 0) {
      if (proj.Size() > 0) {
        return proj.GetParameterCloneWithAbsolutePose();
      }
    }
    return NULL;
  }
  ProjectionParametersBase *ppb = Create(className);
  if (!ppb){
    BIASERR("Unknown projection parameters type "<<className<<" found in XML file "
            <<fileName<<"!");
    return NULL;
  }
  int res = ppb->XMLIn(rootNode, myXML);
  if (res!=0){
    BIASERR("Error reading projection parameters type "<<className<<" from XML file "
            <<fileName<<"!");
    delete ppb;
    return NULL;
  }
  if (ppb) {
    return ppb;
  } else {
    BIASERR("Error reading projection parameters from file "<<fileName
            <<", trying to read camera instead!");
    CameraData camData;
    if (ProjectionParametersIO::ReadCameraData(fileName, camData) != 0){
      return NULL;
    }
    return Create(camData);
  }

#else  // BIAS_HAVE_XML2
  BIASERR("you need XML2");
  BIASBREAK;
  return NULL;
#endif // BIAS_HAVE_XML2
}