Quickstart

Start up giplt and enter the following lines:

from ost.img import *

This will import the basic image processing classes.

im=CreateImage(Size(200,200))

This will create an empty, 2D image, with a height and width of 200 pixels, whose origin (ie the pixel with the coordinates <0,0>) is in the top-left corner.

v=Viewer(im)

A viewer window will pop up (see below), showing a white frame on a black background. The inner area of the white frame is the image, which is empty. Let us fill this with random values.

rand_alg = alg.Randomize() # create algorithm object
im.ApplyIP( rand_alg ) # apply algorithm object in-place

As you can see, applying an algorithm is conceptually a two-step process. First, an instance of an algorithm class is created, yielding an algorithm object (in this case rand_alg). In a second step, the algorithm object is applied to an image, either in-place, modifying the image, or out-of-place, leaving the original image untouched, and returning the result as a new image. Note that the in-place/out-of-place logic is decoupled from the algorithm object.

Now that we have some (noisy) data present, let us run another algorithm, this time a gaussian filter with a sigma of 4 pixel.

im.ApplyIP( alg.GaussianFilter(4.0) ) # apply temporary algorithm object in-place

As you can see, it is not always necessary to create an independent algorithm instance first, in many cases a temporary object will suffice (this applies to the randomization algorithm as well, im.ApplyIP(alg.Randomize()) would have been fine).

Having algorithms as instances is very useful, however, since it makes the algorithm stateful, meaning the algorithm can “remember” values prior to and after applying itself to an image. For example, to gather statistics about the image, the Stat algorithm can be employed as follows:

stat=alg.Stat()
im.ApplyIP(stat)
print stat.GetMean()

Here, the algorithm object is required to live beyond the ApplyIP call, in order for the results to be retrieved from it.