Orfeo ToolBox

https://www.orfeo-toolbox.org/CookBook/
Admin
Orfeo ToolBox is an open-source remote sensing software package that can process high-resolution...
Tokens:563,050
Snippets:3,424
Trust Score:9.4
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install OTB 9.1.0 to custom directory

Source: https://www.orfeo-toolbox.org/CookBook/Installation.html

Example that downloads OTB 9.1.0 and installs it to /home/user/apps/otb.

```bash
bash -c "$(curl -fsSL https://orfeo-toolbox.org/packages/install-otb.sh)" -s "9.1.0" "/home/user/apps/otb"

```

--------------------------------

### Download example image for OTB

Source: https://www.orfeo-toolbox.org/CookBook/First_Steps.html

Download an example image (phr_xs.tif) to $HOME/Data for use in the NDVI computation examples.

```bash
curl https://www.orfeo-toolbox.org/packages/examples/phr_xs.tif -o $HOME/Data/phr_xs.tif
```

--------------------------------

### Run ImageRegionIteratorWithIndex example

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Iterators/ImageRegionIteratorWithIndex.html

Command-line invocation of the compiled example. Takes an input image and an output image path.

```bash
./ImageRegionIteratorWithIndex Input/ROI_QB_MUL_2.tif Output/ImageRegionIteratorWithIndexOutput.jpg
```

--------------------------------

### Set up OTB build environment

Source: https://www.orfeo-toolbox.org/CookBook/CompilingOTBFromSource.html

Create the working directory structure for OTB source, build, and install, and clone the OTB repository.

```bash
$ mkdir ~/OTB
$ cd ~/OTB
$ git clone https://gitlab.orfeo-toolbox.org/orfeotoolbox/otb.git
$ mkdir build
$ mkdir install
```

--------------------------------

### Command-line example: otbcli_Quicklook

Source: https://www.orfeo-toolbox.org/CookBook/Applications/app_Quicklook.html

Runs the Quicklook application from the command line, reading an input image and writing a subsampled output image. Uses default parameters for ROI and sampling ratio.

```bash
otbcli_Quicklook -in qb_RoadExtract.tif -out quicklookImage.tif
```

--------------------------------

### Full src/CMakeLists.txt example

Source: https://www.orfeo-toolbox.org/CookBook/RemoteModules.html

Complete example of the CMakeLists.txt file in the src folder. It builds the library, links dependencies, and adds installation instructions.

```cmake
set(OTBTheModuleName_SRC
    sourceFile1.cxx
    sourceFile2.cxx
    sourceFile3.cxx
    ...
    sourceFileN.cxx)

add_library(OTBTheModuleName ${OTBTheModuleName_SRC})

target_link_libraries(OTBTheModuleName ${OTBModule1_LIBRARIES} ${OTBModule2_LIBRARIES} ... ${OTBModuleN_LIBRARIES})

otb_module_target(OTBTheModuleName)

```

--------------------------------

### Travis CI environment variables for OTB

Source: https://www.orfeo-toolbox.org/CookBook/RemoteModules.html

Example environment variables for Travis-CI to download and install OTB. Used in the install section of travis.yml.

```yaml
env:
  global:
    - OTB_URL=https://www.orfeo-toolbox.org/packages/archives/OTB
    - OTB_VER=7.2.0
    - OTB_OS=Linux64
    - OTB_PKG_EXT=run
```

--------------------------------

### Run MarkovRestorationExample with command line arguments

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Markov/MarkovRestorationExample.html

Command to execute the example with input, initialization, output, lambda, iterations, optimizer temperature, and useRandomValue arguments.

```bash
./MarkovRestorationExample Input/QB_Suburb.png Input/QB_Suburb.png Output/MarkovRestoration.png 10.0 30 1.0 1
```

--------------------------------

### ExtractROI.cxx usage command

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/IO/ExtractROI.html

Command-line usage for the ExtractROI example. It takes input and output file names, start coordinates, and ROI size. The example extracts a 100x100 ROI starting at (0,0) from a 4-band image, producing an RGB output and a mono-channel output for the last band.

```bash
./ExtractROI Input/IMAGERY_SSECH.tif Output/ROI_IMAGERY_RGB.png Output/ROI_IMAGERY_MIR.png 0 0 100 100

```

--------------------------------

### Create an OTB Application with DoInit() in ApplicationExample.cxx

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Application/ApplicationExample.html

Complete source of ApplicationExample.cxx, an OTB application class that derives from otb::Wrapper::Application. It shows the required includes, ITK type declarations, factory macros, and a DoInit() method that sets metadata and declares parameters of various types (image, bool, int, float, string, filename, directory, choice) with defaults and ranges.

```cpp
// This example illustrates the creation of an application.
// A new application is a class, which derives from \subdoxygen{otb}{Wrapper}{Application} class.
// We start by including the needed header files.

#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"

namespace otb
{

//  Application class is defined in Wrapper namespace.

namespace Wrapper
{


//  ExampleApplication class is derived from Application class.

class ApplicationExample : public Application
{
public:
  // Class declaration is followed by \code{ITK} public types for the class, the superclass and
  // smart pointers.

  using Self         = ApplicationExample;
  using Superclass   = Application;
  using Pointer      = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

  //  Following macros are necessary to respect ITK object factory mechanisms. Please report
  //  to \ref{sec:FilterConventions} for additional information.

  itkNewMacro(Self);
  itkTypeMacro(ExampleApplication, otb::Application);


private:
  //  \doxygen{otb}{Application} relies on three main private methods: \code{DoInit()}, \code{DoUpdate()}, and \code{DoExecute()}.
  //  Section \ref{sec:appArchitecture} gives a description a these methods.


  //  \code{DoInit()} method contains class information and description, parameter set up, and example values.

  void DoInit() override
  {

    // Application name and description are set using following methods :
    // \begin{description}
    // \item[\code{SetName()}] Name of the application.
    // \item[\code{SetDescription()}] Set the short description of the class.
    // \item[\code{SetDocLongDescription()}] This methods is used to describe the class.
    // \item[\code{SetDocLimitations()}] Set known limitations (threading, invalid pixel type \dots) or bugs.
    // \item[\code{SetDocAuthors()}] Set the application Authors. Author List. Format : "John Doe, Winnie the Pooh" \dots
    // \item[\code{SetDocSeeAlso()}] If the application is related to one another, it can be mentioned.
    // \end{description}

    SetName("Example");
    SetDescription(
        "This application opens an image and save it. "
        "Pay attention, it includes Latex snippets in order to generate "
        "software guide documentation");

    SetDocLongDescription(
        "The purpose of this application is "
        "to present parameters types,"
        " and Application class framework. ");
    SetDocLimitations("None");
    SetDocAuthors("OTB-Team");
    SetDocSeeAlso(" ");


    // \code{AddDocTag()} method categorize the application using relevant tags.
    // The header file \code{otbWrapperTags.h} in OTB sources contains some predefined tags defined in \code{Tags} namespace.

    AddDocTag(Tags::Analysis);
    AddDocTag("Test");

    // Application parameters declaration is done using \code{AddParameter()} method.
    // \code{AddParameter()} requires the input parameter type
    // (ParameterType\_InputImage, ParameterType\_Int, ParameterType\_Float), its name and description.
    // \subdoxygen{otb}{Wrapper}{Application} class contains methods to set parameters characteristics.

    AddParameter(ParameterType_InputImage, "in", "Input Image");

    AddParameter(ParameterType_OutputImage, "out", "Output Image");

    AddParameter(ParameterType_Bool, "param1", "Example of boolean parameter");
    MandatoryOff("param1");

    AddParameter(ParameterType_Int, "param2", "Example of integer parameter");
    MandatoryOff("param2");
    SetDefaultParameterInt("param2", 1);
    SetMinimumParameterIntValue("param2", 0);
    SetMaximumParameterIntValue("param2", 10);

    AddParameter(ParameterType_Float, "param3", "Example of float parameter");
    MandatoryOff("param3");
    SetDefaultParameterFloat("param3", 0.2);
    SetMinimumParameterFloatValue("param3", -1.0);
    SetMaximumParameterFloatValue("param3", 15.0);

    AddParameter(ParameterType_String, "param4", "Example of string parameter");
    MandatoryOff("param4");

    AddParameter(ParameterType_InputFilename, "param5", "Example of filename");
    MandatoryOff("param5");

    AddParameter(ParameterType_Directory, "param6", "Example of directory name");
    MandatoryOff("param6");

    AddParameter(ParameterType_Choice, "inchoice", "Example of choice parameter");
    AddChoice("inchoice.choice1", "Choice 1");
    AddChoice("inchoice.choice2", "Choice 2");
    AddChoice("inchoice.choice3", "Choice 3");

    AddParameter(ParameterType_Float, "inchoice.choice1.floatchoice1", "Example of float parameter for choice1");
    SetDefaultParameterFloat("inchoice.choice1.floatchoice1", 0.125);

    AddParameter(ParameterType_Float, "inchoice.choice3.floatchoice3", "Example of float parameter for choice3");
    SetDefaultParameterFloat("inchoice.choice3.floatchoice3", 5.0);
  }
};
} // end namespace Wrapper
} // end namespace otb
```

--------------------------------

### SIFTDisparityMapEstimation.cxx source code

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Patented/SIFTDisparityMapEstimation.html

Full C++ source code for the SIFTDisparityMapEstimation example. It includes headers, main function, and pipeline setup for SIFT extraction and matching. The example uses OTB and ITK filters to compute a disparity map from matched SIFT keypoints.

```cpp
// This example demonstrates the use of the
// \doxygen{otb}{KeyPointSetsMatchingFilter} for disparity map
// estimation. The idea here is to match SIFTs extracted from both the
// fixed and the moving images. The use of SIFTs is demonstrated in
// section \ref{sec:SIFTDetector}. The
// \doxygen{itk}{DisplacementFieldSource} will be used
// to generate a deformation field by using
// interpolation on the deformation values from the point set. More
// advanced methods for deformation field interpolation are also
// available.
//
// The first step toward the use of these filters is to include the
// appropriate header files.

#include "otbKeyPointSetsMatchingFilter.h"
#include "otbSiftFastImageFilter.h"
#include "itkLandmarkDisplacementFieldSource.h"


#include "otbImageFileReader.h"
#include "otbImageFileWriter.h"
#include "itkUnaryFunctorImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkPointSet.h"
#include "otbMultiToMonoChannelExtractROI.h"

int main(int argc, char* argv[])
{
  if (argc != 4)
  {
    std::cerr << "Usage: " << argv[0];
    std::cerr << "fixedFileName movingFileName fieldOutName" << std::endl;
    return EXIT_FAILURE;
  }

  const unsigned int Dimension = 2;

  // Then we must decide what pixel type to use for the image. We choose to do
  // all the computations in floating point precision and rescale the results
  // between 0 and 255 in order to export PNG images.

  using RealType        = double;
  using OutputPixelType = unsigned char;

  using ImageType       = otb::Image<RealType, Dimension>;
  using OutputImageType = otb::Image<OutputPixelType, Dimension>;
  // The SIFTs obtained for the matching will be stored in vector
  // form inside a point set. So we need the following types:

  using RealVectorType = itk::VariableLengthVector<RealType>;
  using PointSetType   = itk::PointSet<RealVectorType, Dimension>;
  // The filter for computing the SIFTs has a type defined as follows:

  using ImageToSIFTKeyPointSetFilterType = otb::SiftFastImageFilter<ImageType, PointSetType>;
  // Although many choices for evaluating the distances during the
  // matching procedure exist, we choose here to use a simple
  // Euclidean distance. We can then define the type for the matching filter.

  using DistanceType                              = itk::Statistics::EuclideanDistanceMetric<RealVectorType>;
  using EuclideanDistanceMetricMatchingFilterType = otb::KeyPointSetsMatchingFilter<PointSetType, DistanceType>;
  // The following types are needed for dealing with the matched points.

  using PointType        = PointSetType::PointType;
  using MatchType        = std::pair<PointType, PointType>;
  using MatchVectorType  = std::vector<MatchType>;
  using LandmarkListType = EuclideanDistanceMetricMatchingFilterType::LandmarkListType;

  // We define the type for the image reader.

  using ReaderType = otb::ImageFileReader<ImageType>;

  // Two readers are instantiated : one for the fixed image, and one
  // for the moving image.

  ReaderType::Pointer fixedReader  = ReaderType::New();
  ReaderType::Pointer movingReader = ReaderType::New();

  fixedReader->SetFileName(argv[1]);
  movingReader->SetFileName(argv[2]);
  fixedReader->UpdateOutputInformation();
  movingReader->UpdateOutputInformation();
  // We will now instantiate the 2 SIFT filters and the filter used
  // for the matching of the points.

  ImageToSIFTKeyPointSetFilterType::Pointer          filter1          = ImageToSIFTKeyPointSetFilterType::New();
  ImageToSIFTKeyPointSetFilterType::Pointer          filter2          = ImageToSIFTKeyPointSetFilterType::New();
  EuclideanDistanceMetricMatchingFilterType::Pointer euclideanMatcher = EuclideanDistanceMetricMatchingFilterType::New();
  // We plug the pipeline and set the parameters.

  double secondOrderThreshold = 0.5;
  bool   useBackMatching      = 0;

  filter1->SetInput(0, fixedReader->GetOutput());
  filter1->SetScalesNumber(3);
  filter2->SetInput(0, movingReader->GetOutput());
  filter2->SetScalesNumber(3);

  filter1->SetNumberOfWorkUnits(1);
  filter2->SetNumberOfWorkUnits(1);

  euclideanMatcher->SetInput1(filter1->GetOutput());
  euclideanMatcher->SetInput2(filter2->GetOutput());
  euclideanMatcher->SetDistanceThreshold(secondOrderThreshold);
  euclideanMatcher->SetUseBackMatching(useBackMatching);
  euclideanMatcher->Update();
  // The matched points will be stored into a landmark list.

  LandmarkListType::Pointer landmarkList;
  landmarkList = euclideanMatcher->GetOutput();
  MatchVectorType trueSecondOrder;

```

--------------------------------

### Run IndexedToRGBExample with input and output files

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/BasicFilters/IndexedToRGBExample.html

Command-line usage for the example. It expects three arguments: input indexed image, output RGB image, and output scaled image.

```bash
./IndexedToRGBExample Input/buildingExtractionIndexed.tif Output/buildingExtractionRGB.png Output/buildingExtractionIndexed_scaled.png

```

--------------------------------

### NeighborhoodIterators6.cxx source code

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Iterators/NeighborhoodIterators6.html

Full C++ source code for the NeighborhoodIterators6 example. It builds a distance transform image with added noise and uses an itk::NeighborhoodIterator to find local minima from a seed point. Requires command-line arguments: output image file, start X, and start Y.

```cpp
#include "otbImage.h"
#include "otbImageFileReader.h"
#include "otbImageFileWriter.h"
#include "itkUnaryFunctorImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkNeighborhoodIterator.h"
#include "itkImageRegionIterator.h"
#include "itkFastMarchingImageFilter.h"
#include "itkAddImageFilter.h"









// Some image processing routines do not need to visit every pixel in an
// image. Flood-fill and connected-component algorithms, for example, only
// visit pixels that are locally connected to one another.  Algorithms
// such as these can be efficiently written using the random access
// capabilities of the neighborhood iterator.
//
// The following example finds local minima.  Given a seed point, we can search
// the neighborhood of that point and pick the smallest value $m$.  While $m$
// is not at the center of our current neighborhood, we move in the direction
// of $m$ and repeat the analysis.  Eventually we discover a local minimum and
// stop.  This algorithm is made trivially simple in ND using an ITK
// neighborhood iterator.
//
// To illustrate the process, we create an image that descends everywhere to a
// single minimum:  a positive distance transform to a point.  The details of
// creating the distance transform are not relevant to the discussion of
// neighborhood iterators, but can be found in the source code of this
// example. Some noise has been added to the distance transform image for
// additional interest.

int main(int argc, char* argv[])
{
  if (argc < 4)
  {
    std::cerr << "Missing parameters. " << std::endl;
    std::cerr << "Usage: " << std::endl;
    std::cerr << argv[0] << " outputImageFile startX startY" << std::endl;
    return -1;
  }

  using PixelType                = float;
  using ImageType                = otb::Image<PixelType, 2>;
  using NeighborhoodIteratorType = itk::NeighborhoodIterator<ImageType>;

  using FastMarchingFilterType = itk::FastMarchingImageFilter<ImageType, ImageType>;

  FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New();

  using NodeContainer = FastMarchingFilterType::NodeContainer;
  using NodeType      = FastMarchingFilterType::NodeType;

  NodeContainer::Pointer seeds = NodeContainer::New();

  ImageType::IndexType seedPosition;

  seedPosition[0]              = 128;
  seedPosition[1]              = 128;
  const double initialDistance = 1.0;

  NodeType node;

  const double seedValue = -initialDistance;

  ImageType::SizeType size = {{256, 256}};

  node.SetValue(seedValue);
  node.SetIndex(seedPosition);
  seeds->Initialize();
  seeds->InsertElement(0, node);

  fastMarching->SetTrialPoints(seeds);
  fastMarching->SetSpeedConstant(1.0);

  itk::AddImageFilter<ImageType, ImageType, ImageType>::Pointer adder = itk::AddImageFilter<ImageType, ImageType, ImageType>::New();

  // Allocate the noise image
  ImageType::Pointer    noise = ImageType::New();
  ImageType::RegionType noiseRegion;
  noiseRegion.SetSize(size);
  noise->SetRegions(noiseRegion);
  noise->Allocate();

  // Fill the noise image
  itk::ImageRegionIterator<ImageType> itNoise(noise, noiseRegion);
  itNoise.GoToBegin();

  // Random number seed
  unsigned int sample_seed = 12345;
  double       u           = 0.;
  double       rnd         = 0.;
  double       dMin        = -.7;
  double       dMax        = .8;

  while (!itNoise.IsAtEnd())
  {
    sample_seed = (sample_seed * 16807) % 2147483647L;
    u           = static_cast<double>(sample_seed) / 2147483711UL;
    rnd         = (1.0 - u) * dMin + u * dMax;

    itNoise.Set((PixelType)rnd);
    ++itNoise;
  }

  adder->SetInput1(noise);
  adder->SetInput2(fastMarching->GetOutput());

  try
  {
    fastMarching->SetOutputSize(size);
    fastMarching->Update();

    adder->Update();
  }
  catch (itk::ExceptionObject& excep)
  {
    std::cerr << "Exception caught !" << std::endl;
    std::cerr << excep << std::endl;
  }

  ImageType::Pointer input = adder->GetOutput();

  // The variable \code{input} is the pointer to the distance transform image.
  // The local minimum algorithm is initialized with a seed point read from the
  // command line.

  ImageType::IndexType index;
  index[0] = ::atoi(argv[2]);
  index[1] = ::atoi(argv[3]);

  // Next we create the neighborhood iterator and position it at the seed point.

  NeighborhoodIteratorType::RadiusType radius;
  radius.Fill(1);
  NeighborhoodIteratorType it(radius, input, input->GetRequestedRegion());

  it.SetLocation(index);

```

--------------------------------

### Python example: otbApplication Quicklook

Source: https://www.orfeo-toolbox.org/CookBook/Applications/app_Quicklook.html

Uses the OTB Python API to create and run the Quicklook application. Sets the input and output parameters, then executes and writes the output.

```python
import otbApplication

app = otbApplication.Registry.CreateApplication("Quicklook")

app.SetParameterString("in", "qb_RoadExtract.tif")
app.SetParameterString("out", "quicklookImage.tif")

app.ExecuteAndWriteOutput()
```

--------------------------------

### Image1.cxx: Manually Construct an OTB Image

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Image/Image1.html

Complete example source code for Image1.cxx. It shows how to include otbImage.h, define a 2D image with unsigned short pixels, create the image with New(), and set its region using Index and Size. The example sets the start index to (0,0) and the size to (200,200).

```cpp
/*
 * Copyright (C) 1999-2011 Insight Software Consortium
 * Copyright (C) 2005-2026 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


// This example illustrates how to manually construct an \doxygen{otb}{Image}
// class.  The following is the minimal code needed to instantiate, declare
// and create the image class.
//
// \index{Image!Instantiation}
// \index{Image!Header}
//
// First, the header file of the Image class must be included.

#include "otbImage.h"

int main(int, char* [])
{
  // Then we must decide with what type to represent the pixels
  // and what the dimension of the image will be. With these two
  // parameters we can instantiate the image class. Here we create
  // a 2D image, which is what we often use in remote sensing
  // applications, anyway, with \code{unsigned short} pixel data.
  //
  using ImageType = otb::Image<unsigned short, 2>;

  // The image can then be created by invoking the \code{New()} operator
  // from the corresponding image type and assigning the result
  // to a \doxygen{itk}{SmartPointer}.
  //
  // \index{Image!Pointer}
  // \index{Image!New()}
  //
  ImageType::Pointer image = ImageType::New();

  // In OTB, images exist in combination with one or more
  // \emph{regions}. A region is a subset of the image and indicates a
  // portion of the image that may be processed by other classes in
  // the system. One of the most common regions is the
  // \emph{LargestPossibleRegion}, which defines the image in its
  // entirety. Other important regions found in OTB are the
  // \emph{BufferedRegion}, which is the portion of the image actually
  // maintained in memory, and the \emph{RequestedRegion}, which is
  // the region requested by a filter or other class when operating on
  // the image.
  //
  // In OTB, manually creating an image requires that the image is
  // instantiated as previously shown, and that regions describing the image are
  // then associated with it.
  //
  // A region is defined by two classes: the \doxygen{itk}{Index} and
  // \doxygen{itk}{Size} classes. The origin of the region within the
  // image with which it is associated is defined by Index. The
  // extent, or size, of the region is defined by Size. Index
  // is represented by a n-dimensional array where each component is an
  // integer indicating---in topological image coordinates---the initial
  // pixel of the image. When an image is created manually, the user is
  // responsible for defining the image size and the index at which the image
  // grid starts. These two parameters make it possible to process selected
  // regions.
  //
  // The starting point of the image is defined by an Index class
  // that is an n-dimensional array where each component is an integer
  // indicating the grid coordinates of the initial pixel of the image.
  //
  // \index{Image!Size}
  // \index{Image!SizeType}
  //
  ImageType::IndexType start;

  start[0] = 0; // first index on X
  start[1] = 0; // first index on Y

  // The region size is represented by an array of the same dimension of the
  // image (using the Size class). The components of the array are
  // unsigned integers indicating the extent in pixels of the image along
  // every dimension.
  //
  // \index{Image!Index}
  // \index{Image!IndexType}
  //
  ImageType::SizeType size;

  size[0] = 200; // size along X
  size[1] = 200; // size along Y

  // Having defined the starting index and the image size, these two
  // parameters are used to create an ImageRegion object which basically
  // encapsulates both concepts. The region is initialized with the
  // starting index and size of the image.
  //
  // \index{Image!itk::ImageRegion}
  // \index{Image!RegionType}

  ImageType::RegionType region;

  region.SetSize(size);
  region.SetIndex(start);
}
```

--------------------------------

### Python example: otbApplication.Registry.CreateApplication

Source: https://www.orfeo-toolbox.org/CookBook/Applications/app_HooverCompareSegmentation.html

Creates the application in Python, sets input and output parameters, sets the output pixel type to uint8 (value 1), and executes.

```python
import otbApplication

app = otbApplication.Registry.CreateApplication("HooverCompareSegmentation")

app.SetParameterString("ingt", "maur_GT.tif")
app.SetParameterString("inms", "maur_labelled.tif")
app.SetParameterString("outgt", "maur_colored_GT.tif")
app.SetParameterOutputImagePixelType("outgt", 1)

app.ExecuteAndWriteOutput()
```

--------------------------------

### Run NeighborhoodIterators6 with output and seed coordinates

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Iterators/NeighborhoodIterators6.html

Command-line usage for the NeighborhoodIterators6 example. The first argument is the output image file, followed by the starting X and Y coordinates for the local minima search.

```bash
./NeighborhoodIterators6 Output/NeighborhoodIterators6a.png 100 100

```

```bash
./NeighborhoodIterators6 Output/NeighborhoodIterators6b.png 50 150

```

```bash
./NeighborhoodIterators6 Output/NeighborhoodIterators6c.png 150 50

```

--------------------------------

### Run ScalingFilterExample with input and output files

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/BasicFilters/ScalingFilterExample.html

Command-line invocation of the compiled example. Expects three arguments: input image, rescaled output, and casted output.

```bash
./ScalingFilterExample Input/QB_Toulouse_Ortho_PAN.tif Output/QB_Toulouse_Ortho_PAN_rescaled.png Output/QB_Toulouse_Ortho_PAN_casted.png
```

--------------------------------

### NCCRegistrationFilterExample.cxx source code

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/DisparityMap/NCCRegistrationFilterExample.html

Full C++ source code for the example. It includes necessary headers, main function with argument checking, image types, readers, blurring filters, the NCCRegistrationFilter setup, and channel extraction for the deformation field.

```cpp
// This example demonstrates the use of the \doxygen{otb}{NCCRegistrationFilter}. This filter performs deformation estimation
// by optimising a PDE based on the normalized correlation coefficient. It uses the finite difference solver hierarchy.
//
// The first step toward the use of these filters is to include the proper header files.

#include "otbImageFileWriter.h"
#include "otbImageFileReader.h"

#include "otbNCCRegistrationFilter.h"
#include "itkRecursiveGaussianImageFilter.h"
#include "itkWarpImageFilter.h"

#include "otbImageOfVectorsToMonoChannelExtractROI.h"
#include "itkUnaryFunctorImageFilter.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkCastImageFilter.h"

#include <iostream>

int main(int argc, char** argv)
{

  if (argc != 9)
  {
    std::cerr << "Usage: " << argv[0];
    std::cerr << " fixedFileName movingFileName fieldOutNameHorizontal fieldOutNameVertical imageOutName ";
    std::cerr << "explorationSize bluringSigma nbIterations ";

    return EXIT_FAILURE;
  }

  const unsigned int ImageDimension = 2;

  using PixelType             = double;
  using DisplacementPixelType = itk::Vector<double, ImageDimension>;

  using OutputPixelType = unsigned char;
  using OutputImageType = otb::Image<OutputPixelType, ImageDimension>;

  // Several type of \doxygen{otb}{Image} are required to represent the reference image (fixed)
  // the image we want to register (moving) and the deformation field.

  // Allocate Images
  using MovingImageType       = otb::Image<PixelType, ImageDimension>;
  using FixedImageType        = otb::Image<PixelType, ImageDimension>;
  using DisplacementFieldType = otb::Image<DisplacementPixelType, ImageDimension>;

  using FixedReaderType            = otb::ImageFileReader<FixedImageType>;
  FixedReaderType::Pointer fReader = FixedReaderType::New();
  fReader->SetFileName(argv[1]);

  using MovingReaderType            = otb::ImageFileReader<MovingImageType>;
  MovingReaderType::Pointer mReader = MovingReaderType::New();
  mReader->SetFileName(argv[2]);

  // To make the correlation estimation more robust, the first
  // required step is to blur the input images. This is done using the
  // \doxygen{itk}{RecursiveGaussianImageFilter}:

  // Blur input images
  using FixedBlurType = itk::RecursiveGaussianImageFilter<FixedImageType, FixedImageType>;

  FixedBlurType::Pointer fBlur = FixedBlurType::New();
  fBlur->SetInput(fReader->GetOutput());
  fBlur->SetSigma(std::stof(argv[7]));

  using MovingBlurType = itk::RecursiveGaussianImageFilter<MovingImageType, MovingImageType>;

  MovingBlurType::Pointer mBlur = MovingBlurType::New();
  mBlur->SetInput(mReader->GetOutput());
  mBlur->SetSigma(std::stof(argv[7]));

  // Now, we need to instantiate the NCCRegistrationFilter which is going to perform the registration:

  // Create the filter
  using RegistrationFilterType = otb::NCCRegistrationFilter<FixedImageType, MovingImageType, DisplacementFieldType>;

  RegistrationFilterType::Pointer registrator = RegistrationFilterType::New();

  registrator->SetMovingImage(mBlur->GetOutput());
  registrator->SetFixedImage(fBlur->GetOutput());

  // Some parameters need to be specified to the NCCRegistrationFilter:
  // \begin{itemize}
  // \item The area where the search is performed. This area is defined by its radius:

  using RadiusType = RegistrationFilterType::RadiusType;

  RadiusType radius;

  radius[0] = std::stoi(argv[6]);
  radius[1] = std::stoi(argv[6]);

  registrator->SetNCCRadius(radius);

  std::cout << "NCC radius " << registrator->GetNCCRadius() << std::endl;

  // \item The number of iterations for the PDE resolution:

  registrator->SetNumberOfIterations(std::stoi(argv[8]));
  // registrator->GetDisplacementField();

  // \end{itemize}
  // The execution of the NCCRegistrationFilter will be triggered by
  // the \code{Update()} call on the writer at the end of the
  // pipeline. Make sure to use a
  // \doxygen{otb}{ImageFileWriter} if you want to benefit
  // from the streaming features.

  using ChannelExtractionFilterType                     = otb::ImageOfVectorsToMonoChannelExtractROI<DisplacementFieldType, MovingImageType>;
  ChannelExtractionFilterType::Pointer channelExtractor = ChannelExtractionFilterType::New();

  channelExtractor->SetInput(registrator->GetOutput());
  channelExtractor->SetChannel(1);

```

--------------------------------

### One-line OTB installer

Source: https://www.orfeo-toolbox.org/CookBook/Installation.html

Downloads and installs the latest OTB version into $HOME/otb-OTB_VERSION, then initializes environment variables and GDAL Python bindings.

```bash
bash -c "$(curl -fsSL https://orfeo-toolbox.org/packages/install-otb.sh)"

```

--------------------------------

### Compute multiple radiometric indices with otbcli_RadiometricIndices

Source: https://www.orfeo-toolbox.org/CookBook/recipes/featextract.html

Command-line usage producing an output image with 3 bands: Vegetation:NDVI, Vegetation:RVI, and Vegetation:IPVI in that order. Band numbering starts at 1; the example sets red=3, green=2, nir=4.

```bash
otbcli_RadiometricIndices -in             InputImage
                          -out            OutputImage
                          -channels.red   3
                          -channels.green 2
                          -channels.nir   4
                          -list           Vegetation:NDVI Vegetation:RVI
                                          Vegetation:IPVI

```

--------------------------------

### Run FastNLMeans from Python with otbApplication

Source: https://www.orfeo-toolbox.org/CookBook/Applications/app_FastNLMeans.html

Python example that creates the FastNLMeans application, sets the input and output image parameters, and executes the filter. Requires the otbApplication module.

```python
import otbApplication

app = otbApplication.Registry.CreateApplication("FastNLMeans")

app.SetParameterString("in", "GomaAvant.tif")
app.SetParameterString("out", "denoisedImage_NLMeans.tif")

app.ExecuteAndWriteOutput()
```

--------------------------------

### Source code for LAIAndPROSAILToSensorResponse.cxx

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/Simulation/LAIAndPROSAILToSensorResponse.html

Full source code for the LAIAndPROSAILToSensorResponse example. It includes necessary headers, a custom ImageUniqueValuesCalculator class to get unique image values, and a ProsailSimulatorFunctor functor (partially shown). The code is intended for generating a sensor spectral response image using PROSAIL and Aster data.

```cpp
// The following code is an example of Sensor spectral response image generated using image of labeled objects image, objects properties (vegetation classes are
// handled using PROSAIL model, non-vegetation classes are characterized using \href{http://speclib.jpl.nasa.gov/}{Aster database} characteristics provided by a
// text file), acquisition parameters, sensor characteristics, and LAI (Leaf Area Index) image.
//
// Sensor RSR is modeled by 6S (Second Simulation of a Satellite Signal in the Solar Spectrum) model \cite{Vermote1997}. Detailed information about 6S can be
// found \href{http://6s.ltdri.org/6S_code2_thiner_stuff/6S_Manual_Part_1.pdf}{here}.
//
// Let's look at the minimal code required to use this algorithm. First, the
// following headers must be included.

#include "otbImageFileWriter.h"
#include "otbImageFileReader.h"
#include "otbVectorDataFileReader.h"
#include "otbStandardWriterWatcher.h"
#include "itkImageRegionConstIterator.h"
#include "otbMultiChannelExtractROI.h"
#include "itkOrImageFilter.h"

#include "otbLeafParameters.h"
#include "otbReduceSpectralResponse.h"
#include "otbImageSimulationMethod.h"
#include "otbSpatialisationFilter.h"
#include "otbAttributesMapLabelObject.h"
#include "itkTernaryFunctorImageFilter.h"
#include "itkUnaryFunctorImageFilter.h"
#include "otbVectorDataToLabelMapWithAttributesFilter.h"

namespace otb
{

// \code{ImageUniqueValuesCalculator} class is defined here. Method \code{GetUniqueValues()} returns an array with all values contained in an image.
// This class is implemented and used to test if all labels in labeled image are present in label parameter file.

template <class TImage>
class ITK_EXPORT ImageUniqueValuesCalculator : public itk::Object
{
public:
  using Self         = ImageUniqueValuesCalculator<TImage>;
  using Superclass   = itk::Object;
  using Pointer      = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

  itkNewMacro(Self);

  itkTypeMacro(ImageUniqueValuesCalculator, itk::Object);

  itkStaticConstMacro(ImageDimension, unsigned int, TImage::ImageDimension);

  using PixelType = typename TImage::PixelType;

  using ImageType = TImage;

  using ArrayType = std::vector<PixelType>;

  using ImagePointer      = typename ImageType::Pointer;
  using ImageConstPointer = typename ImageType::ConstPointer;

  virtual void SetImage(const ImageType* image)
  {
    if (m_Image != image)
    {
      m_Image = image;
      this->Modified();
    }
  }


  ArrayType GetUniqueValues() const
  {
    ArrayType uniqueValues;
    if (!m_Image)
    {
      return uniqueValues;
    }

    itk::ImageRegionConstIterator<ImageType> it(m_Image, m_Image->GetRequestedRegion());

    uniqueValues.push_back(it.Get());
    ++it;
    while (!it.IsAtEnd())
    {
      if (std::find(uniqueValues.begin(), uniqueValues.end(), it.Get()) == uniqueValues.end())
      {
        uniqueValues.push_back(it.Get());
      }
      ++it;
    }

    return uniqueValues;
  }


protected:
  ImageUniqueValuesCalculator()
  {
    m_Image = nullptr;
  }
  ~ImageUniqueValuesCalculator() override
  {
  }
  void PrintSelf(std::ostream& os, itk::Indent indent) const override
  {
    Superclass::PrintSelf(os, indent);
    os << indent << "Image: " << m_Image.GetPointer() << std::endl;
  }

private:
  ImageUniqueValuesCalculator(const Self&) = delete;
  void operator=(const Self&) = delete;

  ImageConstPointer m_Image;

}; // class ImageUniqueValuesCalculator


namespace Functor
{

// \code{ProsailSimulatorFunctor} functor is defined here.
//

template <class TLAI, class TLabel, class TMask, class TOutput, class TLabelSpectra, class TLabelParameter, class TAcquistionParameter, class TSatRSR>
class ProsailSimulatorFunctor
{
public:
  /** Standard class typedefs */

  // \code{ProsailSimulatorFunctor} functor is defined here.
  //

```

--------------------------------

### Run SURFExample with command line arguments

Source: https://www.orfeo-toolbox.org/CookBook/C%2B%2B/Examples/FeatureExtraction/SURFExample.html

Command-line invocation of the compiled SURFExample executable. It takes an input image, an output image, and two integer parameters for octaves and scales. The example uses Input/ROISpot5.png and Output/ROISpot5SURF.png with octaves=3 and scales=3.

```bash
./SURFExample Input/ROISpot5.png Output/ROISpot5SURF.png 3 3

```
Tokens:
Raw