It seems that C++ programming can be cumbersome for some users. Well, OTB allows you to work also in other programming languages as for instance Python. The Pylab Project which gathers numeric and scientific Python packages such as NumPy, SciPy and Matplotlib is considered as having the same features as some commercial scientific environments. Some people consider that Pylab is even more powerful than these commercial tools, since you get for free the power of a full featured and general purpose programming language as Python.

Recently I needed to quickly plot the temporal profiles of several pixels coming from temporal image series in order to easily assess the impact of a correction algorithm. I have to admit that my first idea was to generate simple ASCII files with the pixel values and then feed these files to Gnuplot. However, I found a more elegant (at least from my point of view) way to do this.

I use the OTB Python bindings in order to read my images (2 GeoTiff files with 49 bands each). Using the “GetPixel” method, I access the pixels I want to plot. Finally I use pylab to plot 2 temporal profiles (before and after correction). Here goes the code.

import sys

if( len(sys.argv) != 5):
    print("Usage: "+sys.argv[0]+" series1 series2 x0 y0")
    exit()

import itk
import otbImages
import otbIO
import pylab

# Types

ImageType = otbImages.VectorImage[itk.D, 2]
ReaderType = otbIO.ImageFileReader[ImageType]

# Pixel coordinates

index = itk.Index[2]()
index[0] = int(sys.argv[3])
index[1] = int(sys.argv[4])

# Import first series
readerBefore = ReaderType.New()
readerBefore.SetFileName(sys.argv[1])
readerBefore.Update()

pixBefore = readerBefore.GetOutput().GetPixel( index )

# Import second series
readerAfter = ReaderType.New()
readerAfter.SetFileName(sys.argv[2])
readerAfter.Update()

pixAfter = readerAfter.GetOutput().GetPixel( index )

# Chek that both series have the same length

if( pixBefore.GetSize() != pixAfter.GetSize() ):
    print("Series have different lengths")
    exit()

# Plot

vectorBefore = \
 [pixBefore.GetElement(i) for i in range(pixBefore.GetSize())]
vectorAfter = \
 [pixAfter.GetElement(i) for i in range(pixAfter.GetSize())]

pylab.xlabel("Date")
pylab.ylabel("Reflectance")
pylab.plot(vectorBefore, label="Raw")
pylab.plot(vectorAfter, label="Clean")
pylab.legend(loc='upper left', shadow=True)
pylab.show()

And here you can see a result example.

Temporal profiles

Of course, you can imagine to make this script a little bit more interactive in order to choose other pixel coordinates, etc., but I hope you grasp the power of this approach. By using the OTB Python bindings and other freely available open source Python goodies (NumPy, SciPy, Matplotlib, rpy) you get the user friendly approach of Octave, Scilab and their commercial counterparts plus the power of OTB (which in turn makes available ITK, OSSIM, etc.).

Isn’t it great?

This image shows the dynamic dependencies of otb: the libraries required by each element. This image was generated using cmake:

cmake . --graphviz=otb-dep.dot
dot -Tpng -ootb-dep.png otb-dep.dot

It is a very useful representation to understand the potential link problems and to find out where some cleaning is required…

This also applies when you’re writing a new OTB program. The hardest step is usually to get it to compile and once it compiles, it usually works (as opposed to standard C programs where it is usually easy to compile but hard to find subsequent errors). This is the advantage of using templates. The drawback is that compiler error message can be somewhat cryptic and hard to decipher.

In the wiki, we’ve started a page to help you find out common OTB compilation errors and corresponding solution. Do not hesitate to fill up this page with you experience and help your fellow OTB users.

As you can see, you can browse OTB source code (library, applications, bindings and software guide). Every change to the source code is automatically available through the server.

Actually we have migrated the OTB source revision system fom Subversion to Mercurial. That means that what you are browsing from hg.orfeo-toolbox.org is the revision system itself!

We have chosen Mercurial because it is distributed (anybody can get a working copy of the repository and the whole history) and easy to use and install on a web server.

From now on, you can get OTB’s development version anytime and anywhere (if you have internet access!).

Quick tutorial:

1. Get a mercurial client from here or by using your OS available tools (eg. apt-get install mercurial).
2. Clone the source tree: hg clone http://hg.orfeo-toolbox.org/OTB for example
3. Use the source code as usual (compile, etc.)
4. In order to update your source tree: hg pull; hg update

By now, only OTB developpers have the rights to submit source code to the repository.

You may get this right if you send us good contributions!