biasProjectionMapping.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 <bias_config.h>

#ifndef BIAS_HAVE_XML2
#  error You need XML2 to compile this code. Please enable USE_XML2 and recompile BIAS.
#endif // BIAS_HAVE_XML2


#include <Image/ProjectionMapping.hh>
#include <Geometry/Projection.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Geometry/ProjectionParametersSpherical.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <Utils/Param.hh>
#include <iostream>

using namespace BIAS;
using namespace std;


/**
 * @ingroup g_tools
 * @file biasProjectionMapping
 * @relates ProjectionMapping
 * @brief the user can give source image and two projections and using the
 * projection mapping, a new image will be computed, see biasProjectionMapping.cpp
 * @attention so far only implemented for unsigned char images and perspective projection
 * @author sedlazeck
 * @date 05/2010
 */
int main(int argc, char** argv )
{
 
  Param *param = new Param();

  string* sourceImg = param->AddParamString("SourceImage",
                                            "Absolute path to the source Image",
                                            "",
                                            'i');

  string* sinkImg = param->AddParamString("SinkImage",
                                          "Absolute path to the sink Image",
                                          "image_projection_trilinear",
                                          'o');

  string* sourceCam = param->AddParamString("SourceCam",
                                            "Absolute path to the source Camera calibration XML",
                                            "",
                                            'c');
  string* sinkCam = param->AddParamString("SinkCam",
                                          "Absolute path to the sink Camera calibration XML",
                                          "",
                                          's');
  
  bool* rescaleSourceCamToImageSize = param->AddParamBool("RescaleCam",
                                                          "Should source cam be scaled to fit image size?",
                                                          true,
                                                          'r');
  
  param->ParseCommandLine(argc,argv);
  
  
  

  ProjectionMapping<unsigned char, unsigned char> pm;
  Image<unsigned char> src, dst;

  // read projections from files
  BIAS::Projection source_proj;
  int ret  = source_proj.XMLRead(*sourceCam);
  if(ret < 0){
    BIASERR("Error reading Projection:"<<*sourceCam)
    return -1;
  }
  else cout<<"Read source projection:"<<sourceCam<<endl;

  BIAS::Projection sink_proj;
  ret  = sink_proj.XMLRead(*sinkCam);
  if(ret < 0){
    BIASERR("Error reading Projection:"<<*sinkCam)
    return -1;
  }
  else cout<<"Read sink projection:"<<sinkCam<<endl;

  
  
  
  
  
  // load source image
  Image<unsigned char> source;
  Image<unsigned char> sink;
  if (ImageIO::Load(*sourceImg, source)!=0){
    BIASERR("error loading image "<< *sourceImg)
    return -1;
  }
  if(source.GetColorModel() != ImageBase::CM_RGB){
    cout<<"Converting to RGB:"<<endl;
    Image<unsigned char> tmp(source);
    ImageConvert::ToRGB(tmp,source);
  }
  else{
    cout<<"Colormodel is RGB:"<<endl;
  }

  
  if(*rescaleSourceCamToImageSize){
    unsigned int width = source.GetWidth();
    unsigned int height = source.GetHeight();
    
    ProjectionParametersBase* ppb = source_proj.GetParameters();
    ppb->Rescale(width, height);
  }
  

  
  pm.SetSourceCam(source_proj);
  pm.SetSinkCam(sink_proj);
 
  sink.Init(source.GetWidth(),source.GetHeight(),source.GetChannelCount());
  //you can either use lookuptable 
  //pm.PrepareLookupTableMapping(src,dst,MapTrilinear);
  //pm.MapWithLookupTable(src,dst,MapTrilinear);
  //or map without lookuptable
  pm.Map(source,sink,MapTrilinear);
  
  Image<float> disp;
  disp.Init(source.GetWidth(),source.GetHeight(),3);
  pm.GetDisplacementMap(disp,source);
  
  ImageIO::Save(*sinkImg, sink);
  ImageIO::Save("DisplacementImage.mip", disp);

  return 0;
}