Packaging and reusing algorithms

Now that I've shown you some little tricks with GGL2 it's time to see how we can package some of these tricks for a later use.

Consider the previous post example, the grid creation:

grid = [as geometry];

width = 100;

height = 100;

foreach x1 in 0 .. 1000 step width {

foreach y1 in 0 .. 1000 step height {

double x2 = x1 + width;

double y2 = y1 + height;

geometry polygon = POLYGON((x1 y1, x2 y1, x2 y2, x1 y2, x1 y1));

add polygon to grid;

}

}

It creates a grid that covers the (0, 0)-(1000, 1000) extent with cells 100x100 big. Having such a piece of code may be useful, but having to change manually the values of the extent or the size of the cell is not handy. The solution are "algorithms":

library ggl.grid;

import ggl.geom;

alg createGrid(double cellWidth, double cellHeight, geometry extent) returns sequenceof geometry {

grid = [ as geometry ];

foreach x in ST_MinX(extent) .. ST_MaxX(extent) step cellWidth {

foreach y in ST_MinY(extent) .. ST_MaxY(extent) step cellHeight {

double x_ = x + cellWidth;

double y_ = y + cellHeight;

geometry polygon = POLYGON((x y, x_ y, x_ y_, x y_, x y));

add polygon to grid;

}

}

return grid;

}

Algorithms are contained in libraries that are declared as seen in the first statement. As we'll use some algorithms defined in the "ggl.geom" library we need to import it with the second statement. The rest of the code is similar to the previous post, but wrapped in the algorithm declaration, which defines the "variable" parts of the code as parameters so that it is possible to call the same algorithm with different values. In this concrete example, the parameters are "cellWidth", "cellHeight" and "extent".

It is possible to "call" the algorithm by naming it and passing the concrete values between parenthesis. For example, we could create a grid to cover the (0, 0)-(10, 1) extent with cells 1x1 big:

import ggl.grid;

myGrid = createGrid(1, 1, POLYGON((0 0, 10 0, 10 1, 0 1, 0 0)));

A last note, GGL2 editor can be connected to GIS instances, such as GearScape (and soon gvSIG), making it possible to reference the layers in the GIS instance by their name. In such scenario, it's very simple to create a grid that covers the whole extent of a layer:

import ggl.grid;

grid = createGrid(100, 100, ST_Extent(myLayer/the_geom));

In a next post we'll see some polymorphic features that are very useful when packaging algorithms. We'll also take a look at the possibility to call Java code from GGL2.