volSubSample.cpp

 
#include <iostream>
#include <DGtal/base/Common.h>
#include <DGtal/io/readers/VolReader.h>
#include <DGtal/io/writers/VolWriter.h>
#include <DGtal/helpers/StdDefs.h>
#include <DGtal/images/Image.h>
#include <DGtal/images/ImageContainerBySTLVector.h>
 
#include "CLI11.hpp"
 
 
using namespace std;
using namespace DGtal;
using namespace Z3i;
 
 
void missingParam ( std::string param )
{
  trace.error() <<" Parameter: "<<param<<" is required..";
  trace.info() <<std::endl;
  exit ( 1 );
}
 
template<typename Val, typename Image, typename Point, typename Domain>
Val maxVal(Image const& image, Point const& p, Domain const& domain)
{
  typename Image::Domain dom( p*2, p*2 + Point::diagonal(1));
  Val v=image(p*2);
  for(typename Image::Domain::ConstIterator it=dom.begin(), itend=dom.end();
      it != itend;
      ++it)
    if ( domain.isInside(*it) &&  image( *it) > v) v=image(*it);
  
  return v;    
} 
template<typename Val, typename Image, typename Point, typename Domain>
Val minVal(Image const& image, Point const& p, Domain const& domain)
{
  typename Image::Domain dom( p*2, p*2 + Point::diagonal(1));
  Val v=image(p*2);
  for(typename Image::Domain::ConstIterator it=dom.begin(), itend=dom.end();
      it != itend;
      ++it)
    if (  domain.isInside(*it)&&  image( *it) < v) v=image(*it);
  
  return v;    
} 
template<typename Val, typename Image, typename Point, typename Domain>
Val meanVal(Image const& image, Point const& p, Domain const& domain)
{
  typename Image::Domain dom( p*2, p*2 + Point::diagonal(1));
  int v=0;
  int nb=0;
  for(typename Image::Domain::ConstIterator it=dom.begin(), itend=dom.end();
      it != itend;
      ++it)
    if ( domain.isInside(*it) )
      {
        nb++;
        v+=image(*it);
      }
  return static_cast<unsigned char>( v/nb );
} 
 
 
int main(int argc, char**argv)
{
  
  // parse command line ----------------------------------------------
  // parse command line using CLI ----------------------------------------------
  CLI::App app;
  std::string inputFileName;
  std::string outputFileName {"result.vol"};
  std::string function {"mean"};
  
  app.description("Brutally sub sample a vol file (division by 2 in each direction).\n Basic usage: \n \tvolSubSample  <volFileName>  <volOutputFileName> ");
 
  
  app.add_option("-i,--input,1", inputFileName, "Input vol file." )
  ->required()
  ->check(CLI::ExistingFile);
  app.add_option("-o,--output,2", outputFileName, "Output filename.");
  app.add_option("-f,--function", function, "Function used to the down-sampling: {none,max, min, mean}")
   -> check(CLI::IsMember({"mean", "none", "max", "min", "mean"}));
  
  app.get_formatter()->column_width(40);
  CLI11_PARSE(app, argc, argv);
  // END parse command line using CLI ----------------------------------------------
 
  
  trace.beginBlock("Loading file");
  typedef ImageContainerBySTLVector<Z3i::Domain, unsigned char>  MyImageC;
 
  MyImageC  imageC = VolReader< MyImageC >::importVol ( inputFileName );
  MyImageC  outputImage( Z3i::Domain( imageC.domain().lowerBound(),
                                      (imageC.domain().upperBound()-imageC.domain().lowerBound())/Vector().diagonal(2)));
 
  trace.endBlock();
  Point subvector = Vector().diagonal(2);
  Point p;
  unsigned char val;
  trace.beginBlock("Down-scaling the volume...");
  trace.info()<<"Function= "<<function<<std::endl;
  trace.info() << outputImage.domain() << std::endl;
  //Fast Copy
  if (function == "none")
    for(MyImageC::Domain::ConstIterator it = outputImage.domain().begin(),
          itend = outputImage.domain().end(); it != itend; ++it)
      {
        p = (*it) * 2;
        outputImage.setValue( *it , imageC( p ));
      }
  else
    if (function == "max")
      for(MyImageC::Domain::ConstIterator it = outputImage.domain().begin(),
            itend = outputImage.domain().end(); it != itend; ++it)
        {
          val = maxVal<unsigned char, MyImageC, Point>(imageC, *it, imageC.domain());
          outputImage.setValue( *it , val );
        }
    else
      if (function == "min")
        for(MyImageC::Domain::ConstIterator it = outputImage.domain().begin(),
              itend = outputImage.domain().end(); it != itend; ++it)
          {
            val = minVal<unsigned char, MyImageC, Point>(imageC, *it, imageC.domain());
            outputImage.setValue( *it , val);
          }  
      else
        
      if (function == "mean")
        for(MyImageC::Domain::ConstIterator it = outputImage.domain().begin(),
              itend = outputImage.domain().end(); it != itend; ++it)
          {
            val = meanVal<unsigned char, MyImageC, Point>(imageC, *it, imageC.domain());
            outputImage.setValue( *it , val );
          }
      else
        trace.error() << "Bad function !"<<std::endl;
 
 
  trace.endBlock();
  
  trace.beginBlock("Exporting...");
  bool res =  VolWriter< MyImageC>::exportVol(outputFileName, outputImage);
  trace.endBlock();
  if (res) return 0; else return 1;
}