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"

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:

  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");
  }

  void DoUpdateParameters()
  {
  }

  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.SetTemporaryDirectory(GetParameterAsString("tmpdir"));

    // Memory configuration
    if (GetParameterInt("tiling") == 0)
      {
      controller.SetInternalMemoryAvailable(0);  // 0 = automatic
      }
    else
      {
      // User
      controller.SetTileWidth(GetParameterInt("tiling.user.sizex"));
      controller.SetTileHeight(GetParameterInt("tiling.user.sizey"));
      controller.SetNumberOfFirstIterations(GetParameterInt("tiling.user.nfirstiter"));
      controller.SetInternalMemoryAvailable(GetParameterInt("tiling.user.memory"));
      }

    // 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.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)