biasBackwardMapping.cpp

#include <Base/Image/Image.hh>
#include <Base/Image/ImageIO.hh>
#include <Geometry/Projection.hh>
#include <Geometry/ProjectionParametersFactory.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Geometry/ProjectionParametersSpherical.hh>
#include <Geometry/ProjectionParametersCylindric.hh>
#include <Utils/Param.hh>
#include <cmath>

using namespace std;
using namespace BIAS;

/** @file biasBackwardMapping
    @brief Conversion between different projections using backward mapping.
    @todo Use BIAS::BackwardMapping class instead of manual backwards mapping!
    @ingroup g_tools
    @author esquivel 11/2011
 */

int main(int argc, char *argv[])
{
  if (argc < 4) {
    cout << "Usage: " << argv[0] << " <input image file> [<output image>] "
         << "<source projection> <output projection>" << endl;
    exit(0);
  }

  // Load source image
  BIAS::Image<unsigned char> srcImage;
  if (BIAS::ImageIO::Load(argv[1], srcImage) != 0) {
    cerr << "Failed to load image \"" << argv[1] << "\"!" << endl;
    exit(0);
  }

  // Create projection factory
  BIAS::ProjectionParametersFactory factory;

  // Create source projection
  const std::string srcFile = argv[argc > 4 ? 3 : 2];
  BIAS::ProjectionParametersBase *srcProj = factory.Load(srcFile);
  if (srcProj == NULL) {
    // Load source projection from file
    BIAS::Projection proj;
    if (proj.Load(srcFile) != 0) {
      cerr << "Failed to load source projection from \"" << srcFile << "\"!" << endl;
      exit(0);
    } else if (proj.Size() != 1) {
      cerr << "Source projection contains " << proj.Size() << " parameters!" << endl;
      exit(0);
    }
    srcProj = proj.GetParameterCloneWithAbsolutePose();
  }
  BIAS::Pose srcPose; // set canonical pose
  srcProj->SetPose(srcPose);

  // Read properties of source projection
  unsigned int srcWidth, srcHeight;
  const unsigned int srcChannels = srcImage.GetChannelCount();
  srcProj->GetImageSize(srcWidth, srcHeight);
  if (srcWidth != srcImage.GetWidth() || srcHeight != srcImage.GetHeight()) {
    cerr << "Source image and source projection have different dimensions!" << endl;
    exit(0);
  }

  // Create output projection
  const std::string outFile = argv[argc > 4 ? 4 : 3];
  BIAS::ProjectionParametersBase *outProj = factory.Load(outFile);
  if (outProj == NULL) {
    // Load output projection from file
    BIAS::Projection proj;
    if (proj.Load(outFile) != 0) {
      cerr << "Failed to load output projection from \"" << outFile << "\"!" << endl;
      exit(0);
    } else if (proj.Size() != 1) {
      cerr << "Output projection contains " << proj.Size() << " parameters!" << endl;
      exit(0);
    }
    outProj = proj.GetParameterCloneWithAbsolutePose();
  }
  BIAS::Pose outPose; // set canonical pose
  outProj->SetPose(outPose);

  // Read properties of output projection
  unsigned int outWidth, outHeight;
  const unsigned int outChannels = srcChannels;
  outProj->GetImageSize(outWidth, outHeight);
 
  // Create output image
  BIAS::Image<unsigned char> outImage(outWidth, outHeight, outChannels);
  outImage.Clear(0);

  Vector3<double> p;

  // ----- BACKWARD MAPPING -----

  // Map source to output image
  for (unsigned int u = 0; u < outWidth; u++) {
    for (unsigned int v = 0; v < outHeight; v++) {
      // compute ray for pixel (u,v) in output image
      BIAS::Vector3<double> ray;
      outProj->UnProjectToRay(BIAS::HomgPoint2D(u,v), p, ray);
      if (ray.NormL2() == 0.0) continue;
      // project ray into input image
      BIAS::HomgPoint2D srcPos = srcProj->Project(BIAS::HomgPoint3D(ray));
      if (!srcPos.IsAtInfinity()) {
        // set pixel in output image
        if ((int)srcPos[0] >= 0 && (int)srcPos[0] < (int)srcWidth &&
            (int)srcPos[1] >= 0 && (int)srcPos[1] < (int)srcHeight) {
          for (unsigned int c = 0; c < outChannels; c++)
            outImage.SetPixel(srcImage.PixelValue((int)srcPos[0] % srcWidth, (int)srcPos[1], (unsigned short)c),
                              u, v, (unsigned short)c);
        }
      }
    }
  }

  // Write output image to file
  const std::string outFilename = (argc > 4 ? argv[2] : "output.png");
  if (BIAS::ImageIO::Save(outFilename, outImage) != 0) {
    cerr << "Failed to save output image to \"" << outFilename << "\"!" << endl;
  }

  // Release memory
  delete srcProj;
  delete outProj;

  return 0;
}