otbLSGRM.cxx

#include "itkFixedArray.h"
#include "itkObjectFactory.h"

// Elevation handler
#include "otbWrapperElevationParametersHandler.h"
#include "otbWrapperApplicationFactory.h"

// Application engine
#include "otbStandardFilterWatcher.h"
#include "itkFixedArray.h"
#include "itkImageSource.h"

// GRM
#include <iostream>
#include "lsrmBaatzSegmenter.h"
#include "lsgrmController.h"

// system tools
#include <itksys/SystemTools.hxx>

namespace otb
{

namespace Wrapper
{

class LSGRM : public Application
{
public:
  /** Standard class typedefs. */
  typedef LSGRM                        Self;
  typedef Application                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  /** Standard macro */
  itkNewMacro(Self);
  itkTypeMacro(LSGRM, Application);

private:

  /* Tiling mode choice */
  enum TilingMode
  {
    TILING_AUTO,
    TILING_USER,
    TILING_NONE
  };

  void DoInit()
  {
  SetName("GenericRegionMerging");
  SetDescription("This application allows to use the Generic Region Merging library "
      "(GRM) and provides currently 3 homogeneity criteria: Euclidean Distance, "
      "Full Lambda Schedule and Baatz & Schape criterion.");

  AddParameter(ParameterType_InputImage, "in", "Input Image");
  AddParameter(ParameterType_OutputImage, "out", "Ouput Label Image");
  SetDefaultOutputPixelType("out", ImagePixelType_uint32);

//  AddParameter(ParameterType_Choice, "criterion", "Homogeneity criterion to use");
//  AddChoice("criterion.bs", "Baatz & Schape");
//  AddChoice("criterion.ed", "Euclidean Distance");
//  AddChoice("criterion.fls", "Full Lambda Schedule");

  AddParameter(ParameterType_Float, "threshold", "Threshold for the criterion");

  AddParameter(ParameterType_Int, "niter", "Maximum number of iterations");
  SetDefaultParameterInt("niter", 75);
  MandatoryOff("niter");

  AddParameter(ParameterType_Int, "speed", "Activate it to boost the segmentation speed");
  SetDefaultParameterInt("speed", 0);
  MandatoryOff("speed");

  // For Baatz & Schape
  AddParameter(ParameterType_Float, "cw", "Weight for the spectral homogeneity");
  SetDefaultParameterFloat("cw", 0.5);
  MandatoryOff("cw");
  AddParameter(ParameterType_Float, "sw", "Weight for the spatial homogeneity");
  SetDefaultParameterFloat("sw", 0.5);
  MandatoryOff("sw");

  // For large scale
  AddParameter(ParameterType_Directory, "tmpdir", "temporary directory for tiles and graphs");
  AddParameter(ParameterType_Choice, "tiling", "Tiling layout for the large scale segmentation");
  AddChoice("tiling.auto", "Automatic tiling layout");
  AddChoice("tiling.user", "User tiling layout");
  AddParameter(ParameterType_Int, "tiling.user.sizex", "Tiles width");
  AddParameter(ParameterType_Int, "tiling.user.sizey", "Tiles height");
  AddParameter(ParameterType_Int, "tiling.user.nfirstiter", "Number of first iterations");
  AddParameter(ParameterType_Int, "tiling.user.memory", "Available memory");
  AddChoice("tiling.none", "No tiling layout");
  }

  void DoUpdateParameters()
  {
  }

  /*
   * Return a prefix for temporary files
   */
  std::string GetTemporaryFilesPrefix()
  {

    // Get output filename (without extension)
    std::string outfname = GetParameterString("out");
    std::string outbfname = itksys::SystemTools::GetFilenameWithoutExtension(outfname.c_str());

    // Get specified temporary directory
    std::string tmpdir = GetParameterAsString("tmpdir");
    if (!tmpdir.empty())
      {
      // A temporary directory is specified: we check that it ends with a POSIX separator
      if (tmpdir[tmpdir.size()-1] != '/')
        {
        // If not, we add the separator
        tmpdir.append("/");
        }
      }
    std::string prefix = tmpdir + outbfname;
    return prefix;
  }

  void DoExecute()
  {
    /*
        To add:
        internal memory available
        If we have to do the image division
        if we have to clean up the directory
        the output directory in case the global graph cannot fit in memory

     */

    using ImageType = otb::VectorImage<float, 2>;
    using SegmenterType = lsrm::BaatzSegmenter<ImageType>;
    using ControllerType = lsgrm::Controller<SegmenterType>;

    ImageType::Pointer inputImage = GetParameterFloatVectorImage("in");

    ControllerType controller;
    controller.SetInputImage(inputImage);
    controller.SetTemporaryFilesPrefix(this->GetTemporaryFilesPrefix());

    // Tiling mode
    int inputTilingMode = GetParameterInt("tiling");
    if (inputTilingMode == TILING_AUTO)
      {
      controller.SetTilingModeAuto();
      }
    else if (inputTilingMode == TILING_USER)
      {
      // User
      controller.SetTilingModeUser();
      controller.SetTileWidth(GetParameterInt("tiling.user.sizex"));
      controller.SetTileHeight(GetParameterInt("tiling.user.sizey"));
      controller.SetNumberOfFirstIterations(GetParameterInt("tiling.user.nfirstiter"));
      controller.SetInternalMemoryAvailable(GetParameterInt("tiling.user.memory"));
      }
    else if (inputTilingMode == TILING_NONE)
      {
      controller.SetTilingModeNone();
      }
    else
      {
      otbAppLogFATAL("Unknow input tiling mode!");
      }

    // MPI configuration
#ifdef OTB_USE_MPI
    if (myrank==0)
      std::cout << "Number of MPI process : " << nprocs << std::endl;
    controller.SetNumberOfProcess(nprocs);
    controller.SetProcessRank(myrank);
#endif

    // Specific parameters
    lsrm::BaatzParam params;
    params.m_SpectralWeight = GetParameterFloat("cw");
    params.m_ShapeWeight = GetParameterFloat("sw");
    controller.SetSpecificParameters(params);
    float thres = GetParameterFloat("threshold");
    controller.SetThreshold(thres*thres);
    controller.SetNumberOfIterations(GetParameterInt("niter"));

    // Run the segmentation
    controller.SetDebug(true);
    controller.RunSegmentation();

    // Output images
    UInt32ImageType::Pointer labelImage = controller.GetLabeledClusteredOutput();;

    // Set output image projection, origin and spacing for labelImage
    labelImage->SetProjectionRef(inputImage->GetProjectionRef());
    labelImage->SetOrigin(inputImage->GetOrigin());
    labelImage->SetSpacing(inputImage->GetSpacing());
    SetParameterOutputImage<UInt32ImageType>("out", labelImage);

  }

  void AfterExecuteAndWriteOutputs()
  {
  }

}; // app class
} // end of namespace wrapper
} // end of namespace otb


OTB_APPLICATION_EXPORT(otb::Wrapper::LSGRM)