3dVolMarchingCubes.cpp

#include <iostream>
#include <queue>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <DGtal/kernel/sets/SetPredicate.h>
#include <DGtal/io/readers/VolReader.h>
#include <DGtal/images/ImageSelector.h>
#include <DGtal/images/SimpleThresholdForegroundPredicate.h>
#include <DGtal/images/ImageLinearCellEmbedder.h>
#include <DGtal/shapes/Shapes.h>
#include <DGtal/kernel/CanonicEmbedder.h>
#include <DGtal/helpers/StdDefs.h>
#include <DGtal/topology/helpers/Surfaces.h>
#include <DGtal/topology/DigitalSurface.h>
#include <DGtal/topology/SetOfSurfels.h>
#include <DGtal/geometry/volumes/KanungoNoise.h>


using namespace DGtal;
using namespace Z3i;
namespace po = boost::program_options;


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>(), "the volume file (.vol)" )
  ("threshold,t",  po::value<unsigned int>()->default_value(1), "the value that defines the isosurface in the image (an integer between 0 and 255)." )
  ("adjacency,a",  po::value<unsigned int>()->default_value(0), "0: interior adjacency, 1: exterior adjacency")
  ("output,o",  po::value<std::string>()->default_value( "marching-cubes.off" ), "the output OFF file that represents the geometry of the isosurface")
  ("noise,n",  po::value<double>(), "Kanungo noise level in ]0,1[. Note that only the largest connected component is considered and that no specific embedder is used.");
  
  
  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 ) )
  {
    std::cout << "Usage: " << argv[0]
    << " [-i <fileName.vol>] [-t <threshold>] [-a <adjacency>] [-o <output.off>]" << std::endl
    << "Outputs the isosurface of value <threshold> of the volume <fileName.vol>  as an OFF file <output.off>. The <adjacency> (0/1) allows to choose between interior (6,18) and exterior (18,6) adjacency." << std::endl
    << general_opt << std::endl;
    return 0;
  }
  if ( ! vm.count("input") )
  {
    trace.error() << "The input file name was defined." << std::endl;
    return 1;
  }
  std::string inputFilename = vm["input"].as<std::string>();
  unsigned int threshold = vm["threshold"].as<unsigned int>();
  bool intAdjacency = ( vm["adjacency"].as<unsigned int>() == 0 );
  std::string outputFilename = vm["output"].as<std::string>();
  double noise ;
  bool addNoise=false;
  if (vm.count("noise") )
  {
    addNoise=true;
    noise = vm["noise"].as<double>();
  }
  
  trace.beginBlock( "Reading vol file into an image." );
  typedef ImageSelector < Domain, int>::Type Image;
  Image image = VolReader<Image>::importVol(inputFilename);
  
  typedef functors::SimpleThresholdForegroundPredicate<Image> ThresholdedImage;
  ThresholdedImage thresholdedImage( image, threshold );
  trace.endBlock();
  
  
  trace.beginBlock( "Construct the Khalimsky space from the image domain." );
  KSpace ks;
  bool space_ok =
  ks.init( image.domain().lowerBound(), image.domain().upperBound(), true );
  if (!space_ok)
  {
    trace.error() << "Error in the Khamisky space construction."<<std::endl;
    return 2;
  }
  trace.endBlock();
  
  typedef SurfelAdjacency<KSpace::dimension> MySurfelAdjacency;
  MySurfelAdjacency surfAdj( intAdjacency ); // interior in all directions.
  
  trace.beginBlock( "Extracting boundary by scanning the space. " );
  typedef KSpace::SurfelSet SurfelSet;
  typedef SetOfSurfels< KSpace, SurfelSet > MySetOfSurfels;
  typedef DigitalSurface< MySetOfSurfels > MyDigitalSurface;
  MySetOfSurfels theSetOfSurfels( ks, surfAdj );
  
  if (addNoise)
  {
    trace.info()<<"Adding some noise."<<std::endl;
    KanungoNoise<ThresholdedImage, Z3i::Domain> kanungo(thresholdedImage, image.domain(), noise);
    std::vector< std::vector<SCell > > vectConnectedSCell;
    trace.info()<<"Extracting all connected components."<<std::endl;
    Surfaces<KSpace>::extractAllConnectedSCell( vectConnectedSCell, ks, surfAdj,
                                               kanungo, false);
    if( vectConnectedSCell.size() == 0 )
    {
      trace.error()<< "No surface component exists. Please check the vol file --min and --max parameters." << std::endl;
      return 3;
    }
    
    trace.info()<<vectConnectedSCell.size()<<" components."<<std::endl;
    
    trace.info()<<"Extracting the largest one."<<std::endl;
    int cc_max_size_idx = -1;
    auto it_max         = std::max_element( vectConnectedSCell.begin(), vectConnectedSCell.end(),
                                           [] (std::vector<SCell >& v1, std::vector<SCell >& v2)
                                           { return v1.size() < v2.size(); } );
    cc_max_size_idx = std::distance( vectConnectedSCell.begin(), it_max );
    theSetOfSurfels.surfelSet().insert( vectConnectedSCell[ cc_max_size_idx ].begin(),
                                       vectConnectedSCell[ cc_max_size_idx ].end() );
  }
  else
    Surfaces<KSpace>::sMakeBoundary(
    theSetOfSurfels.surfelSet(), ks, thresholdedImage,
    image.domain().lowerBound(), image.domain().upperBound() );

  MyDigitalSurface digSurf( theSetOfSurfels );
  trace.info() << "Digital surface has " << digSurf.size() << " surfels."
  << std::endl;
  trace.endBlock();
  
  
  trace.beginBlock( "Making OFF surface. " );
  // Describes how voxels are embedded into Euclidean space.
  typedef CanonicEmbedder< Space > MyEmbedder;
  // Describes how the centroid surface elements is placed in-between embedded voxels.
  typedef ImageLinearCellEmbedder< KSpace, Image, MyEmbedder > CellEmbedder;
  CellEmbedder cellEmbedder;
  MyEmbedder trivialEmbedder;
  
  // The +0.5 is to avoid isosurface going exactly through a voxel
  // center, especially for binary volumes.
  
  //Making sure that we probe inside the domain.
  Image largerImage( Domain( image.domain().lowerBound() - KSpace::Vector::diagonal(2),
                            image.domain().upperBound() + KSpace::Vector::diagonal(2)));
  for(auto p: image.domain())
    largerImage.setValue( p, image(p));
  
  std::ofstream out( outputFilename.c_str() );
  if (addNoise)
  {
    if ( out.good() )
      digSurf.exportSurfaceAs3DOFF( out );
    else
    {
      trace.error()<<"IO error while opening the output file"<<std::endl;
      exit(2);
    }
  }
  else
  {
    cellEmbedder.init( ks, image, trivialEmbedder,
                      ( (double) threshold ) + 0.5 );
    
    if ( out.good() )
      digSurf.exportEmbeddedSurfaceAs3DOFF( out, cellEmbedder );
    {
      trace.error()<<"IO error while opening the output file"<<std::endl;
      exit(2);
    }
  }
  
  out.close();
  trace.endBlock();
  return 0;
}