volIntensityScale.cpp

#include <iostream>
#include <DGtal/base/Common.h>
#include <DGtal/io/readers/VolReader.h>
#include <DGtal/io/writers/VolWriter.h>
#include "DGtal/io/writers/GenericWriter.h"
#include <DGtal/helpers/StdDefs.h>
#include <DGtal/images/ImageContainerBySTLVector.h>
#include <DGtal/images/ConstImageAdapter.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;
using namespace Z3i;

namespace po = boost::program_options;


void missingParam ( std::string param )
{
  trace.error() <<" Parameter: "<<param<<" is required..";
  trace.info() <<std::endl;
}


int main(int argc, char**argv)
{

  // 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>(), "Input vol file." )
    ( "output,o", po::value<std::string>(), "volumetric output file (.vol, .pgm, .pgm3d, .longvol) " )
    ( "inMin,m", po::value<int>()->default_value(0), "the min value of the input image." )
    ( "inMax,M", po::value<int>()->default_value(255), "the max value of the input image." )
    ( "outMin", po::value<int>()->default_value(0), "the min value of the output image." )
    ( "outMax", po::value<int>()->default_value(255), "the max value of the output image." );
  
  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;
  }
    //Parse options
  if (parseOK &&  ! ( vm.count ( "input" ) ) ) {parseOK=false; missingParam ( "--input" );};
  if (parseOK && ! ( vm.count ( "output" ) ) ) {parseOK=false; missingParam ( "--output" );};
  

  po::notify ( vm );
  if (!parseOK || vm.count ( "help" ))
    {
      trace.info() << "Apply a linear rescaling of the image intensity from an input intensity interval [InMin, InMax] into an output interval [OutMin, OutMax]." <<std::endl
                   << std::endl << "Basic usage: "<<std::endl
                   << "\t volIntensityScale --input <volFileName> --output <volOutputFileName>  (both files can be independently in vol, pgm3D, p3d format)"<<std::endl
                   << general_opt << "\n";
      std::cout << "Example:\n"
                << "volIntensityScale -i  ${DGtal}/examples/samples/lobster.vol  --inMin 0 --inMax 100 -o lobster0-100.vol \n";
      return 0;
    }



  std::string filename = vm["input"].as<std::string>();
  std::string outputFileName = vm["output"].as<std::string>();
  
  int inMin = vm["inMin"].as<int>();
  int inMax = vm["inMax"].as<int>();
  int outMin = vm["outMin"].as<int>();
  int outMax = vm["outMax"].as<int>();
    
  trace.beginBlock("Loading file");

  typedef ImageContainerBySTLVector<Z3i::Domain, unsigned char>  MyImageC;
  typedef DGtal::functors::Rescaling<int ,unsigned char > RescalFCT;
  MyImageC image = VolReader< MyImageC,  RescalFCT  >::importVol( filename, 
                                                                  RescalFCT(inMin,
                                                                            inMax,
                                                                            outMin, outMax));  
  trace.endBlock();

  
  trace.beginBlock("Exporting...");
  bool res =  GenericWriter<MyImageC>::exportFile(outputFileName, image);
  trace.endBlock();
  if (res) return 0; else return 1;   
}