longvol2vol.cpp

#include <iostream>
#include <DGtal/base/Common.h>
#include <DGtal/helpers/StdDefs.h>
#include <DGtal/io/readers/LongvolReader.h>
#include <DGtal/io/writers/VolWriter.h>
#include <DGtal/images/Image.h>
#include <DGtal/images/ImageContainerBySTLVector.h>
#include <DGtal/base/BasicFunctors.h>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>

using namespace DGtal;
using namespace Z3i;

namespace po = boost::program_options;

struct CycleFunctor
{
  template<typename TInput>
  inline
  unsigned char operator()(const TInput& aInput) const
  {
     if (aInput == 0)
       return 0;
     else
       return static_cast<unsigned char>(1+NumberTraits<TInput>::castToInt64_t(aInput) % 32);
  }
};


struct LinearFunctor
{
  LinearFunctor(const DGtal::uint64_t vmax, const DGtal::uint64_t vmin):
  myMin(vmin), myMax(vmax) {}
  
  inline unsigned char operator()(const DGtal::int64_t& aInput) const
  {
    return static_cast<unsigned char>( (NumberTraits<DGtal::uint64_t>::castToDouble(aInput - myMin)*255.0 /
                                        (double) (myMax-myMin)));
  }
  
  DGtal::uint64_t myMin,myMax;
};



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

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 longvol filename." )
  ( "output,o", po::value<std::string>(),"Output vole filename." )
  ( "mode,m", po::value<unsigned int>()->default_value(0),"Conversion mode:\n\t 0 = cast (default)\n\t 1 = Linear Scaling\n\t 2 = Grayscale cycle (32 steps, except 0 values)." )
  ;
  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()<< std::endl;
  }
  po::notify ( vm );
  if (!parseOK || vm.count ( "help" ) ||argc<=1 )
  {
    trace.info() << "Converts a longvol (long int) to a vol file (unsigned char)."<<std::endl
    << std::endl << "Basic usage: "<<std::endl
    << "\tlongvol2vol --input <LongvolFileName> --o <VolOutputFileName> "<<std::endl
    << general_opt << "\n";
    return 0;
  }
  
  //Parse options
  if ( ! ( vm.count ( "input" ) ) ) missingParam ( "--input" );
  std::string filename = vm["input"].as<std::string>();
  if ( ! ( vm.count ( "output" ) ) ) missingParam ( "--output" );
  std::string outputFileName = vm["output"].as<std::string>();
  unsigned int mode = vm["mode"].as<unsigned int>();
  
  
  //Main program
  typedef ImageContainerBySTLVector<Z3i::Domain, DGtal::uint64_t>  MyImageC;
  MyImageC  imageC = LongvolReader< MyImageC >::importLongvol ( filename );
  bool res = false;
  
  if (mode == 0)
    res =  VolWriter< MyImageC, functors::Cast<unsigned char> >::exportVol(outputFileName, imageC);
  else
    if (mode == 1)
    {
      DGtal::uint64_t vmax, vmin;
      vmax = *std::max_element(imageC.begin(), imageC.end());
      vmin = *std::min_element(imageC.begin(), imageC.end());
      trace.info() << "Max value = "<< vmax<<std::endl;
      trace.info() << "Min value = "<< vmin<<std::endl;
      res  = VolWriter<MyImageC , LinearFunctor>::exportVol(outputFileName, imageC, true, LinearFunctor(vmax,vmin));
    }
  if (mode == 2)
    res = VolWriter<MyImageC, CycleFunctor>::exportVol(outputFileName, imageC);
  
  if (res)
    return 0;
  else
  {
    trace.error()<<"Error while exporting the Vol.";
    trace.info()<<std::endl;
    return 1;
  }
}