Option #1:

if eggs >= 10 then buy(sausages, eggs=10);

Option #2:

if sausages > 0 then buy(sausages);
if eggs >= 10 then buy(eggs, 10);

Option #3

buy(sausages);
if eggs >= 10 then buy(eggs, 10);

The 3rd option is dangerous one because it could end up with never-ending run in the city looking for sausages, never buying eggs and never coming back home.

…and more. Why?

Asking me to make shopping, my wife did not stick to the principles of valid inference and correct reasoning. That’s the reason why not everybody can be a programmer :-)

…it’s quite extra-ordinary to have enough courage to shout out:

I don’t speak for my employer. For example, our site is one of those Flashy Internet dead-ends I’d never enter. See? I don’t speak for them.

or may be no courage is needed to criticize bad design ;-) BTW, it must be an old critique by Yossi. Now their website looks good.

I’ve re-re-re-learned the lesson that light conditions in a conference venue is bad and I should always bring a proper strobe. Otherwise, pictures are dark or very grained (high ISO) or blured (mostly, unless your name is Arnold The Steel Grip). Ah, one more thing, don’t buy a DSLR with lens included, it simply is a waste of money. The kit lens is a piece of @#$%^&!, so just buy a body and then buy a proper (read: expansive) lens from Pentax (or Sigma). To quote the classics:

you are awesome
you have awesome camera
but it’s useless
without (proper) lens

Anyway, it’s always nice to have some photolog after events, even if the pictures are of bad quality.

GISLook and GISMeta are plugins for Mac OS X 10.5 that show GIS data in the Finder.

These cool-looking plugins were created by Bernhard Jenny.

I know many GIS users loving products of the forbidden fruit, so I’m spreading the word about these nice looking and, hopefully, well working tools.

A few minutes ago, Suchith Anand announced there will be live streaming transmission available from OSGIS sessions. This is cool!

By the way, does anyone remember a kind of pioneer transmission from FOSS4G 2006 in Lausanne? The videos are still linked but seem to be unavailable. Pity. It would be cool to archive them somewhere on foss4g.org.

Let’s make it straight. What about reversing the direction of flow of support? Should there be any reason to not to ask projects to support OSGeo Foundation? If a project is well funded by 3rd party organizations, it should be a part of fair play to expect a minimal tribulum paid back to OSGeo. Actually, this mechanism has been included as a part of the Project Sponsorship program:

One quarter of the sponsorship amount will be put into the general OSGeo account for any OSGeo use (such as paying hosting costs, general promotion, etc)

Does it apply in case OSGeo member project gets funds through a back door?

There are bills to be paid, there is always a lot of work to get done around OSGeo activities, meaning there are expectations, there are loads of tasks that need to be accomplished in reasonable amount of time, but a limited resources available.

Disclaimer: I was born in socialistic republic that no longer exists, but it does not mean I believe in socialism or that I’d like to see OSGeo being converted into communist party and Tyler flying to North Korea with official visit to give Kim a hug.

I believe in joint responsibility and fair play.

For testing purposes, I built excessive number of overviews for japan.tif dataset using gdaladdo utility:

$ gdaladdo -r average japan.tif 2 4 8 16 32 64 128

The command above produced 7 overviews with the following dimensions:

$ gdalinfo japan_2_4_8_16_32_128.tif | grep -m 1 Ov
Overviews: 7000x7000, 3500x3500, 1750x1750, 875x875, 438x438, 219x219, 110x110

Next, I loaded the whole dataset into PostGIS and WKT Raster enabled database using gdal2wktraster utility written in Python and available to download from the WKT Raster repository:

$ gdal2wktraster.py -r japan.tif -t japan_rb_128 \
  -o japan_rb_128.sql \
  --index --srid 4326 -k -m 128x128 -O -M -v

I’ve invented my favourite convention of naming database tables and here japan_rb_128 remembers what was source dataset (japan), that the output table is in regular blocking mode (_rb_) and size of block (tile) is 128×128 pixels (_128).

You can find meaning of all the switches by displaying usage message:

$ gdal2wktraster.py -h

After, literally, two hours of crunching Japan, the script ended with nice summary. It tells how many input raster datasets have been processed and how many database tables will be generated after japan_rb_128.sql is loaded into database as wall as how many blocks (tiles) will be loaded into output table as rows:

------------------------------------------------------------
 Summary of GDAL to WKT Raster processing:
------------------------------------------------------------
Number of processed raster files: 1
List of generated tables (number of tiles):
1	japan_rb_128 (12100)
2	o_2_japan_rb_128 (3025)
3	o_4_japan_rb_128 (784)
4	o_8_japan_rb_128 (196)
5	o_16_japan_rb_128 (49)
6	o_32_japan_rb_128 (16)
7	o_64_japan_rb_128 (4)
8	o_128_japan_rb_128 (1)

The script generated output file japan_rb_128.sql of size of 1 593 387 714 bytes and it took 2 hours, so it’s not a bad idea to leave it overnight, as I did yesterday :-) Disk space occupied by this dataset will estimate around 750 MB.

The SQL file with japan.tif dump is ready to load into the database, but first extra table needs to be created for metadata of overviews, it is RASTER_OVERVIEWS table:

CREATE TABLE raster_overviews (
  o_table_catalog character varying(256) NOT NULL,
  o_table_schema character varying(256) NOT NULL,
  o_table_name character varying(256) NOT NULL,
  o_column character varying(256) NOT NULL,
  r_table_catalog character varying(256) NOT NULL,
  r_table_schema character varying(256) NOT NULL,
  r_table_name character varying(256) NOT NULL,
  r_column character varying(256) NOT NULL,
  out_db boolean NOT NULL,
  overview_factor integer NOT NULL,
  CONSTRAINT raster_overviews_pk
  PRIMARY KEY (o_table_catalog, o_table_schema, o_table_name, o_column))

The RASTER_OVERVIEWS solution was proposed by Martin Daly and officially approved as a part of WKT Raster Specification, however it’s been decided that:

No provision is provided, or suggested, for creating, updating, or deleting overviews.

That’s why the CREATE TABLE command needs to be issued manually.

Now, everything is ready to load the data.

psql -d japan -f japan_rb_128.sql

Tables with overviews are named according to another but simple convention: o_<LEVEL>_<BASE TABLE> where LEVEL is the integral overview level (factor) and BASE TABLE is name of table in which base raster is stored (japan_rb_128 in this example).

Now, the WKT Raster dataset consisting of base raster and 7 overviews is ready for testing.

List of software environment I used to perform the steps explained above:

• OS: GNU Linux / Ubuntu 9.04 installed as a guest on VirtualBox 2.2.4
• GEOS + PostGIS + WKT Raster: all built and installed from sources available from trunk branches in their SVN repositories.

The underlying type of an enumeration is an integral type that can represent all the enumerator values defined in the enumeration.

It is not specified which particular integral type is used to represent an enumerated type. Given that number of bytes representing fundamental integral types is implementation defined in C++ and only sizeof(char), sizeof(signed char) and sizeof(unsigned char) are guaranteed to be always 1, value reported by sizeof operator applied on enumeration is considered as implementation defined as well. Sometimes one may need to control size of enumerated type in memory, for instance to serialise and de-serialise objects easier.

Some compilers allow to specify underlying type of enumeration. For instance, Microsoft Visual C++ provides dedicated language extension:

enum Color : unsigned char
{
   red, green, blue
};
// assert(sizeof(Color) == 1);

Obviously, this technique is not portable across other implementations of C++ language.

In order to solve this problem in portable way, a simple class template can be defined:

template <class E, class T>
struct enumeration
{
    typedef T type;
    typedef E enum_type;

    enumeration()
        : e_(E())
    {}

    enumeration(E e)
        : e_(static_cast<T>(e))
    {}

    operator E() const
    { return static_cast<E>(e_); }

private:
    T e_;
};

The enumeration class can be used as a portable way to wrap any enumerated type and to specify (or limit) amount of bytes used to represent it. It is also interchangeable with actual enumeration being wrapped:

#include <cassert>

enum Color { red, green, blue };

int main()
{
    enumeration<Color, unsigned char> color(blue);
    assert(sizeof(color) == 1);

    Color c = color;
    assert(c == blue);
}

It’s also possible to provide default argument for template parameter T specifying underlying type of wrapped enumeration. For instance, if most constant values in a project range from 0 to 255, default type value of T can be unsigned char.