ProjectionParametersDynamicLoad.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/ProjectionParametersDynamicLoad.hh"
#include <dlfcn.h>


using namespace BIAS;
using namespace std;

union ptrCaster{
  void* ptr;
  void* (*fnct)();
};

ProjectionParametersDynamicLoad::~ProjectionParametersDynamicLoad(){
//  if(dynptr_!=NULL){
//    delete dynptr_;
//  }
  if(hndl_ != NULL){
    //int res = 
    dlclose(hndl_);
    hndl_ = NULL;
//    if(res != 0){
//      BIASERR("Something went wrong when trying to close lib!" << res << " " << dlerror() << endl);
//    }
  } else {
    BIASERR("hndl already null, cannot possibly close it")
  }
}


void ProjectionParametersDynamicLoad::InitFactory_(){
  
  /// add other library paths here
#if defined(BIAS_DEBUG) && defined(COMPILE_DEBUG) && !defined(COMPILE_NDEBUG)
//  libPaths_.push_back("/home/ajordt/builds/mip_debug/lib/libMIPProjectionParametersUnderwaterFlatPortD.so");
//  libPaths_.push_back("/home/ajordt/builds/mip_debug/lib/libMIPProjectionParametersUnderwaterDomePortD.so");
//  libPaths_.push_back("/home/ajordt/builds/mip_debug/lib/libMIPProjectionParametersUnderwaterFlatPortSphericalD.so");
  libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterFlatPortD.so");
 libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterDomePortD.so");
  libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterFlatPortSphericalD.so");
#else
//  libPaths_.push_back("/home/ajordt/builds/mip_release/lib/libMIPProjectionParametersUnderwaterFlatPort.so");
//  libPaths_.push_back("/home/ajordt/builds/mip_release/lib/libMIPProjectionParametersUnderwaterDomePort.so");
//  libPaths_.push_back("/home/ajordt/builds/mip_release/lib/libMIPProjectionParametersUnderwaterFlatPortSpherical.so");
  libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterFlatPort.so");
  libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterDomePort.so");
   libPaths_.push_back("/opt/net64/gcc48/underwaterProjection/libMIPProjectionParametersUnderwaterFlatPortSpherical.so");
#endif

  unsigned int libIndex = 0;
  if(className_ == "ProjectionParametersUnderwaterFlatPort"){
    libIndex = 0;
  }
  
  if(className_ == "ProjectionParametersUnderwaterDomePort"){
    libIndex = 1;
  }
  
  if(className_ == "ProjectionParametersUnderwaterFlatPortSpherical"){
    libIndex = 2;
  }
  
  
  hndl_ = dlopen(libPaths_[libIndex].c_str(), RTLD_NOW);
  if(hndl_ == NULL){
     cerr << "Dynamic Load Error: " << dlerror() << endl;
  } else {
    ptrCaster mkr;
    mkr.ptr = dlsym(hndl_,"ppDynLoadMaker");
    if (mkr.ptr == NULL){
      cout << "Dynamic Load Error: Library does not seem to be compatible. No ppDynLoadMaker found." << endl;
      dynptr_ = NULL;
    } else {
      maker_t maker = reinterpret_cast<maker_t>(mkr.fnct);
      dynptr_ = (*maker)();
//      cout << "dynptr from maker " << dynptr_ << endl << flush;
//      cout << "content from maker " << *dynptr_ << endl << flush; 
    }

  //  int res = dlclose(hndl_);
//    if(res != 0){
//      BIASERR("Something went wrong when trying to close lib!")
//    }
//    hndl_ = NULL;
  }
   
}


void ProjectionParametersDynamicLoad::GetFirstBorderPixel(PixelIterator &it){
  dynptr_->GetFirstBorderPixel(it);
}

bool ProjectionParametersDynamicLoad::GetNextBorderPixel(PixelIterator &it){
  return dynptr_->GetNextBorderPixel(it);
}

void ProjectionParametersDynamicLoad::GetFirstEdgePosition(PixelIterator &it){
  dynptr_->GetFirstEdgePosition(it);
}

bool ProjectionParametersDynamicLoad::GetNextEdgePosition(PixelIterator &it){
  return dynptr_->GetNextEdgePosition(it);
}

int ProjectionParametersDynamicLoad::GetSphericalViewingRange(const CoordinateTransform3D& sphericalReferenceFrame,
                                                              double& minPhi, double& maxPhi, double& centerPhi,
                                                              double& minTheta, double& maxTheta){
  return dynptr_->GetSphericalViewingRange(sphericalReferenceFrame, minPhi, maxPhi, centerPhi, minTheta, maxTheta);
}


const bool ProjectionParametersDynamicLoad::
DoIntrinsicsDiffer(const ProjectionParametersBase* p) const
{
  return dynptr_->DoIntrinsicsDiffer(p);
}

bool ProjectionParametersDynamicLoad::
DoesPointProjectIntoImageLocal(const Vector3<double>& localX,
                               HomgPoint2D& x,
                               bool IgnoreDistortion) const
{

  return dynptr_->DoesPointProjectIntoImageLocal(localX, x, IgnoreDistortion);
}


HomgPoint2D ProjectionParametersDynamicLoad::
ProjectLocal(const Vector3<double>& point, bool IgnoreDistortion) const
{
  return dynptr_->ProjectLocal(point,IgnoreDistortion);
}


int ProjectionParametersDynamicLoad::
ProjectLocal(const Vector3<double>& point, HomgPoint2D &p2d,
             bool IgnoreDistortion) const
{
 
   return dynptr_->ProjectLocal(point, p2d, IgnoreDistortion);
}



void  ProjectionParametersDynamicLoad::
UnProjectLocal(const HomgPoint2D& cPos, Vector3<double>& pointOnRay,
          Vector3<double>& direction, bool IgnoreDistortion) const {
  dynptr_->UnProjectLocal(cPos, pointOnRay, direction, IgnoreDistortion);
}

HomgPoint3D ProjectionParametersDynamicLoad::
UnProjectToImagePlane(const HomgPoint2D& pos, const double& depth,
                      bool IgnoreDistortion) const
{

  return dynptr_->UnProjectToImagePlane(pos, depth, IgnoreDistortion);
}


bool ProjectionParametersDynamicLoad::
Distort(HomgPoint2D& point2d) const
{
  return dynptr_->Distort(point2d);
}


bool ProjectionParametersDynamicLoad::
Undistort(HomgPoint2D& point2d) const
{
    return dynptr_->Undistort(point2d);
}



#ifdef BIAS_HAVE_XML2

int ProjectionParametersDynamicLoad::
XMLGetClassName(std::string& TopLevelTag, double& Version) const {
  dynptr_->XMLGetClassName(TopLevelTag, Version);
  return 0;
}

int ProjectionParametersDynamicLoad::
XMLOut(const xmlNodePtr Node, XMLIO& XMLObject) const {  
  dynptr_->XMLOut(Node, XMLObject);
  return 0;
}


int ProjectionParametersDynamicLoad::
XMLIn(const xmlNodePtr Node, XMLIO& XMLObject) {
//  cout << "dynptr " << dynptr_ << endl << flush;
//  cout << "dynptr content " << *dynptr_ << endl << flush;
  dynptr_->XMLIn(Node, XMLObject);

  return 0;
}

#endif // BIAS_HAVE_XML2





/////////////////////////////////////////////////////////////////////////////////////


Matrix3x3<double> ProjectionParametersDynamicLoad::
UnProjectCovLocal(const HomgPoint2D& pos, const Matrix3x3<double>& cov2D,
                  bool IgnoreDistortion, bool Normalize)
{
  return dynptr_->UnProjectCovLocal(pos, cov2D, IgnoreDistortion, Normalize);
}