heightfield2vol.cpp

#include <iostream>
#include <fstream>
#include "DGtal/base/Common.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/io/writers/VolWriter.h"
#include "DGtal/io/readers/GenericReader.h"
#include "DGtal/images/ConstImageAdapter.h"
#include "DGtal/kernel/BasicPointFunctors.h"


#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>

using namespace std;
using namespace DGtal;


namespace po = boost::program_options;

// Defining a Helper to get the 3D point functor from an 2DImage 
template<typename TImage2D, typename TPoint3D >
struct Image3DPredicatFrom2DImage{
  typedef  TPoint3D Point3D;
  typedef HyperRectDomain<Z3i::Space>  Domain;
  typedef typename TImage2D::Value Value;
  Image3DPredicatFrom2DImage(DGtal::ConstAlias<TImage2D> anImage, double aScale, 
                             unsigned int maxHeight,
                             unsigned int fg, unsigned int bg
                             ):myImageRef(anImage), 
                               myScale(aScale),
                               myMaxHeight(maxHeight),
                               myBG(bg), myFG(fg){    
  }   
  inline
  unsigned int operator()(const Point3D &aPoint)  const {
    functors::Projector<SpaceND<2, typename TImage2D::Integer> > projXY;
    return  (*myImageRef)(projXY(aPoint))*myScale >= aPoint[2] ? myFG: myBG  ;    
  }
  
  inline
  Domain domain() const {
    return Domain(Z3i::Point(0,0,0), Z3i::Point(myImageRef->domain().upperBound()[0],
                                                myImageRef->domain().upperBound()[1],
                                                myMaxHeight) );
  }
  CountedConstPtrOrConstPtr<TImage2D> myImageRef;
  double myScale;  
  unsigned int myMaxHeight;
  unsigned int myFG;
  unsigned int myBG;
};



int main( int argc, char** argv )
{
  typedef ImageContainerBySTLVector < Z3i::Domain, unsigned char > Image3D;
  typedef ImageContainerBySTLVector < Z2i::Domain, unsigned char> Image2D;

  typedef DGtal::ConstImageAdapter<Image3D, Z2i::Domain, DGtal::functors::Point2DEmbedderIn3D<DGtal::Z3i::Domain>,
                                   Image3D::Value,  DGtal::functors::Identity >  ImageAdapterExtractor;

  // parse command line ----------------------------------------------
  po::options_description general_opt("Allowed options are: ");
  general_opt.add_options()
    ("help,h", "display this message")
    ("input,i", po::value<std::string>(), "heightfield file." )
    ("output,o", po::value<std::string>(), "volumetric file ") 
    ("scale,s", po::value<double>()->default_value(1.0), "set the scale factor on height values. (default 1.0)")
    ("volZ,z", po::value<unsigned int>()->default_value(255), "set the Z max value of domain.")    
    ("foregroundValue,f", po::value<unsigned int>()->default_value(128), "specify the foreground value of the resulting voxel." )
    ("backgroundValue,b", po::value<unsigned int>()->default_value(0), "specify the background value of the resulting volumetric file.");
  
  bool parseOK=true;
  po::variables_map vm;
  try{
    po::store(po::parse_command_line(argc, argv, general_opt), vm);  
  }catch(const std::exception& ex){
    parseOK=false;
    trace.info()<< "Error checking program options: "<< ex.what()<< endl;
  }
  po::notify(vm);    
  if( !parseOK || vm.count("help")||argc<=1)
    {
      std::cout << "Usage: " << argv[0] << " [input] [output]\n"
                << "Convert a 2D heightfield image into a volumetric file. "
                << general_opt << "\n";
      std::cout << "Example:\n"
                << "heightfield2vol -i ${DGtal}/examples/samples/church.pgm -o volResu.vol -s 0.3 -z 50  \n";
      return 0;
    }
  
  if(! vm.count("input") ||! vm.count("output"))
    {
      trace.error() << " Input and output filename are needed to be defined" << endl;      
      return 0;
    }
  
  string inputFilename = vm["input"].as<std::string>();
  string outputFilename = vm["output"].as<std::string>();

  trace.info() << "Reading input file " << inputFilename ; 
  Image2D inputImage = DGtal::GenericReader<Image2D>::import(inputFilename);  
  double scale = vm["scale"].as<double>(); 
  unsigned int  maxZ = vm["volZ"].as<unsigned int>();
  trace.info() << " [done] " << std::endl ; 
  
  unsigned int foregroundValue = vm["foregroundValue"].as<unsigned int>();
  unsigned int backgroundValue = vm["backgroundValue"].as<unsigned int>();
  
  typedef Image3DPredicatFrom2DImage<Image2D, Z3i::Point> HeightMapVol;
  Image3DPredicatFrom2DImage<Image2D, Z3i::Point> image3Dpredicate(inputImage, scale, maxZ, foregroundValue, backgroundValue);  
  trace.info() << "Processing image to output file " << outputFilename ; 
    
  VolWriter<HeightMapVol>::exportVol(outputFilename, image3Dpredicate);

  trace.info() << " [done] " << std::endl ;   
  return 0;  
}