ExtractROI.cxx

Example usage:

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

Example source code (ExtractROI.cxx):

/*
 * Copyright (C) 1999-2011 Insight Software Consortium
 * Copyright (C) 2005-2022 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 shows the use of the
//  \doxygen{otb}{MultiChannelExtractROI} and
//  \doxygen{otb}{MultiToMonoChannelExtractROI} which allow the
//  extraction of ROIs from multiband images stored into
//  \doxygen{otb}{VectorImage}s. The first one povides a Vector Image
//  as output, while the second one provides a classical
//  \doxygen{otb}{Image} with a scalar pixel type. The present example
//  shows how to extract a ROI from a 4-band SPOT 5 image and to
//  produce a first multi-band 3-channel image and a second
//  mono-channel one for the SWIR band.

//  We start by including the needed header files.
//  \index{otb::ExtractROI!header}

#include "otbImageFileReader.h"
#include "otbImageFileWriter.h"
#include "otbMultiChannelExtractROI.h"
#include "otbMultiToMonoChannelExtractROI.h"


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

  // R\'ecuperation de arguments
  if (argc < 7)
  {
    std::cerr << "Usage: " << std::endl;
    std::cerr << argv[0] << "  inputImageFile outputImageFileRGB outputImageFileLastBand startX startY sizeX sizeY" << std::endl;
    return EXIT_FAILURE;
  }

  //  The program arguments define the image file names as well as the
  //  rectangular area to be extracted.

  const char* inputFilename     = argv[1];
  const char* outputFilenameRGB = argv[2];
  const char* outputFilenameMIR = argv[3];

  unsigned int startX((unsigned int)::atoi(argv[4]));
  unsigned int startY((unsigned int)::atoi(argv[5]));
  unsigned int sizeX((unsigned int)::atoi(argv[6]));
  unsigned int sizeY((unsigned int)::atoi(argv[7]));

  //  As usual, we define the input and output pixel types.

  using InputPixelType  = unsigned char;
  using OutputPixelType = unsigned char;

  //  First of all, we extract the multiband part by using the
  //  \doxygen{otb}{MultiChannelExtractROI} class, which is templated
  //  over the input and output pixel types. This class in not
  //  templated over the images types in order to force these images
  //  to be of \doxygen{otb}{VectorImage} type.

  using ExtractROIFilterType = otb::MultiChannelExtractROI<InputPixelType, OutputPixelType>;

  //  We create the extractor filter by using the \code{New} method of
  //  the class and we set its parameters.

  ExtractROIFilterType::Pointer extractROIFilter = ExtractROIFilterType::New();

  extractROIFilter->SetStartX(startX);
  extractROIFilter->SetStartY(startY);
  extractROIFilter->SetSizeX(sizeX);
  extractROIFilter->SetSizeY(sizeY);

  //  We must tell the filter which are the channels to be used. When
  //  selecting contiguous bands, we can use the
  //  \code{SetFirstChannel} and the \code{SetLastChannel}. Otherwise,
  //  we select individual channels by using the \code{SetChannel} method.

  extractROIFilter->SetFirstChannel(1);
  extractROIFilter->SetLastChannel(3);

  //  We will use the OTB readers and writers for file access.

  using ReaderType = otb::ImageFileReader<ExtractROIFilterType::InputImageType>;
  using WriterType = otb::ImageFileWriter<ExtractROIFilterType::InputImageType>;

  ReaderType::Pointer reader = ReaderType::New();
  WriterType::Pointer writer = WriterType::New();

  //  Since the number of bands of the input image is dynamically set
  //  at runtime, the \code{UpdateOutputInformation} method of the reader must be
  //  called before using the extractor filter.

  reader->SetFileName(inputFilename);
  reader->UpdateOutputInformation();
  writer->SetFileName(outputFilenameRGB);

  //  We can then build the pipeline as usual.

  extractROIFilter->SetInput(reader->GetOutput());

  writer->SetInput(extractROIFilter->GetOutput());

  //  And execute the pipeline by calling the \code{Update} method of
  //  the writer.

  writer->Update();

  //  The usage of the \doxygen{otb}{MultiToMonoChannelExtractROI} is
  //  similar to the one of the \doxygen{otb}{MultiChannelExtractROI}
  //  described above.
  //
  //  The goal now is to extract an ROI from a multi-band image and
  //  generate a mono-channel image as output.
  //
  //  We could use the \doxygen{otb}{MultiChannelExtractROI} and
  //  select a single channel, but using the
  //  \doxygen{otb}{MultiToMonoChannelExtractROI} we generate a
  //  \doxygen{otb}{Image} instead of an
  //  \doxygen{otb}{VectorImage}. This is useful from a computing and
  //  memory usage point of view.
  //  This class is also templated over the pixel types.

  using ExtractROIMonoFilterType = otb::MultiToMonoChannelExtractROI<InputPixelType, OutputPixelType>;

  ExtractROIMonoFilterType::Pointer extractROIMonoFilter = ExtractROIMonoFilterType::New();

  extractROIMonoFilter->SetStartX(startX);
  extractROIMonoFilter->SetStartY(startY);
  extractROIMonoFilter->SetSizeX(sizeX);
  extractROIMonoFilter->SetSizeY(sizeY);

  // For this filter, only one output channel has to be selected.

  extractROIMonoFilter->SetChannel(4);

  using monoReaderType               = otb::ImageFileReader<ExtractROIMonoFilterType::InputImageType>;
  using monoWriterType               = otb::ImageFileWriter<ExtractROIMonoFilterType::OutputImageType>;
  monoReaderType::Pointer monoReader = monoReaderType::New();
  monoWriterType::Pointer monoWriter = monoWriterType::New();

  monoReader->SetFileName(inputFilename);
  monoReader->Update(); // Needed to know the number of channels in the image
  monoWriter->SetFileName(outputFilenameMIR);
  extractROIMonoFilter->SetInput(monoReader->GetOutput());

  monoWriter->SetInput(extractROIMonoFilter->GetOutput());
  monoWriter->Update();

  // \begin{figure}
  // \center
  // \includegraphics[width=0.44\textwidth]{IMAGERY_SSECH.eps}
  // \itkcaption[Initial SPOT 5 image]{Quicklook of the original SPOT
  // 5 image.}
  // \label{fig:IMAGERY_SSECH}
  // \end{figure}
  //
  // \begin{figure}
  // \center
  // \includegraphics[width=0.44\textwidth]{ROI_IMAGERY_RGB.eps}
  // \includegraphics[width=0.44\textwidth]{ROI_IMAGERY_MIR.eps}
  // \itkcaption[ROI of a SPOT5 image]{Result of the
  // extraction. Left: 3-channel image. Right: mono-band image.}
  // \label{fig:ROI_IMAGERY}
  // \end{figure}
  //
  //  Figure \ref{fig:ROI_IMAGERY} illustrates the result of the
  //  application of both extraction filters on the image presented in
  //  figure \ref{fig:IMAGERY_SSECH}.

  return EXIT_SUCCESS;
}