Orfeo ToolBox is designed to accommodate both interactive computing on users’ desktops, and terabyte scale processing on many core architectures. This is achieved with a modular software architecture: the so-called OTB sandwich illustrates in Fig. 2.
At the core of OTB is the C++ API, which implements the pipeline. This core model of processing supports multi-threading, streaming and message passing. Thus all applications and filters can process images and scale to the available memory and CPU resources. With additional features like in memory application chaining (to minimize disk I/O), porting code from a development machine and scaling up to a high performance cluster is often trivial.
Monteverdi
Orfeo ToolBox ships with Monteverdi, a lightweight image rendering and processing tool written in Qt and OpenGL. Monteverdi makes use of the Ice rendering engine [18], also available in Orfeo ToolBox which offers:
-
Smooth navigation in very large datasets using GDAL overviews capabilities,
-
Reactive local and global rendering tools such as local contrast enhancement or color-mapping, based on advanced OpenGL features such as floating point textures and OpenGL Shading Language (this work was inspired by the authors of pvflip [19]),
-
Multiple image display with on-the-fly rough registration of any image whose coordinate reference system is understood by Orfeo ToolBox, which include both ground projected and sensor geometry images.
Monteverdi is a day-to-day tool for fast visualization of processing results, which can display images in sensor geometry. Monteverdi also facilitates processing using the applications, which will be the focus of the next section. It does not intend to replace GIS software such as QGIS which are more suitable to edit, display and relate different sources of geographic information (both raster or vector).
Figure 3 shows an example of the kind of rendering you can get by using Monteverdi.
OTB applications
The cross platform, ready-to-use OTB package ships with more than 90 applications. Applications expose existing processing functions from the underlying C++ library, or compose them into high level pipelines. This results in straightforward interfaces for many complex remote sensing algorithms.
For example, the Orthorectification application includes a set of complex pipelines with gives access to a number of rectification functions and parameters which can be easily configured by the user: output cartographic projection, external Digital Elevation Model file, interpolation mode, etc. Other flagship OTB applications follow a similar approach and are designed to work well together.
For instance, a recent addition is a new framework for pixel based classification. This new set of applications clarifies the different steps required to train and fit a classification model. In short they are: select samples in a reference image to be used for learning (and how to select them), extract pixel values from the image, and train a supervised classifier (Support Vector Machines, Random forests, etc.). This way, control is given to the user over each critical step in the design and tuning of a classification pipeline. This is achieved without an excessive increase in complexity, to maintain both rapid prototyping capability and high performance.
Another important design characteristic of applications consists in the indipendency of their code and user interface. This is achieved with the so-called Application Framework. The framework allows multiple interfaces to be provided for each application without code duplication.
Today, OTB applications are available through the following interfaces:
-
The command-line,
-
A GUI interface based on Qt,
-
Python for high level programming and connection with NumPy array,
-
Monteverdi for interactive processing of viewed images,
-
QGIS via the Processing plugin,
-
Zoo-Project [20] through a Web Processing Service (WPS).
Here is one example of how to use Python to run the Smoothing application, changing the algorithm at each iteration:
Additionally, the OTB applications are available in QGIS via a Python plugin which is built on top of the QGIS processing framework [21] making spatial analysis tasks more productive and easy to accomplish.
Two additional features work together to decrease friction between the multiple interfaces: saving application parameters to XML files, and automatic conversion of GUI parameters to Bash for easy copy-pasting.
Scaling up
The same Orfeo ToolBox applications that are available for desktop remote sensing will scale up seamlessly to process larger datasets. Whenever possible, algorithms implemented in Orfeo ToolBox are performing piece-wise processing, which means that if the data are larger, they will take longer to process, with a constant memory budget. This piecewise processing is a key aspect of the ITK processing pipeline on which Orfeo ToolBox strongly relies (piecewise processing is sometimes called streaming in the ITK world). This ability is retained even when combining several algorithms in the pipeline. When there is no obvious way of computing some algorithms piecewise, Orfeo ToolBox also offers adapted versions of these methods, such as for MeanShift segmentation [22] or large scale region growing segmentation [23] which ensures stable results with piecewise or tile-wise computation processing illustrated in Fig. 4.
However, being able to accommodate a memory budget regardless of the size of the data is only a part of the problem. Users usually also want to take advantage of modern CPU architectures as well as High Performance Computing infrastructures (HPC), and Orfeo ToolBox will also do that for them. Whenever possible, algorithms implementation are threaded, mostly using OpenThreads [24], even if specific parts of the code will also use OpenMP [25] directives. Orfeo ToolBox will seamlessly use all cores of the CPU. But as the dataset gets bigger, applications generally moves to an HPC architecture sharing many similar nodes with a shared high-bandwidth storage, and Orfeo ToolBox can also do that. It allows for MPI [3] parallel processing, meaning that the whole pipeline will be replicated across nodes which will produce a piece of the resulting image [26]. An example of use of this capability is the pan-sharpening of a whole Pleiades image (1.6 gigapixels). Spread across 560 mono-threaded nodes, the processing time is cut down to 4.3 min.
One last capability that is very useful to scale up to your data is the inner pipeline connection between applications. Building a processing chain from several applications is very convenient, and will scale-up nicely. But intermediate data must be written to disk and read again by next application. This results in an unnecessary overhead of I/O time if those intermediate results are not meant to be kept. In this case, Orfeo ToolBox allows to connect the inner pipeline between applications, so that piece-wise processing is enabled throughout the chain of applications.