Linfiniti Geo Blog

Welcome to our first employee!

Tim Sutton — Thu, 02 Sep 2010 08:22:10 +0000

This week we have taken on our first employee! Samantha Booysen will be working as office manager. She will keep things running smoothly so that the geek in residence can focus on coding. She is all set up with an Ubuntu computer to do her work on and we will include her on our training courses so that she starts to learn about FOSS GIS too. Samantha doesn’t have an IT background but she is very interested in social upliftment which is something close to our hearts here at Linfiniti so we are sure she will fit right in. Welcome Samantha, we hope you enjoy working here!

A week in Tanzania

Tim Sutton — Wed, 01 Sep 2010 21:19:54 +0000

I spent most of last week in Dar es Salaam, Tanzania. A lovely tropical country in the heart of Africa. I was there as part of a project I am working to create tools for Biodiversity Informatics practitioners. Of course the tools are based on Free Software: Quantum GIS and openModeller.

The attendees at the workshop were entertained by my talk about what FOSS is and why it is important, an introduction to QGIS slideshow (superbly presented by Marco Hugentobler), and ending with a tour of openModellerDesktop. We also did some live demonstrations of QGIS and openModeller, before going on to discuss details about how these tools can be used to support their Biodiversity Informatics workflows.

The meeting was funded by the Global Biodiversity Information Facility (GBIF) with Juan Bello as their representitive, and hosted by the Tanzanian Commission for Science and Technology (COSTECH).

In case you are unfamiliar with the aims of GBIF, they are facilitating the digitisation (or digitization for our american readers) of the worlds biodiversity records – herbarium records, museum collections and so on. COSTECH provides the local infrastructure and staff for the ‘TanBif’ node in Tanzania.

The meeting also included ‘in-country’ experts in the fields of GIS, Meteorology, Ecology, IT and so on. I think for all of the attendees, the concept of FOSS was a real eye-opener. African economies can’t compare with those in Europe and the USA and the capital outlay for proprietary software that presents an irritation in the Western world is a major burden in the third world. So just knowing that they could dive in and use QGIS was a great revelation.

We finished our workshop a little early on the Friday so Marco and I offered to go along to the COSTECH offices and geo-enable their PostgreSQL species occurrence database and install QGIS on their desktop PC’s running Windows XP. In the space of a couple of hours we were done – the major part of which was spent showing the TanBif staff members how to bring up the PostGIS layer in QGIS, perform simple queries and make maps. Having spent days in the past trying to get proprietary software like Oracle and Arc*** configured, optimised, licensed and generally usable, I was struck by just how easy and quick it is to get someone up and running with a robust enterprise ready PostGIS geospatial datastore and a user friendly Free Software desktop GIS like QGIS.

Thanks to the friendly Tanzanian folks for their hospitality – I look forward to my next visit! Here are some piccies from the trip…

Juan Bello telling us about the cool things you can do with a good Biodiversity Information repository.

The workshop attendees (Marco and Juan out of shot)

Marco showing Godfrey how to use QGIS to bring up their PostGIS Biodiversity dataset.

Godfrey proudly showing off his first map (made with QGIS)!

Marco killing a mosquito – he became something of an expert!

QGIS Mapserver – A WMS Server for the masses

Tim Sutton — Mon, 23 Aug 2010 20:18:50 +0000

Marco Hugentobler recently included his QGIS WMS Server work into QGIS trunk. You may have noticed QGIS being mentioned in Paul Ramsey’s post about the WMS Shootout at OSGEO2010 and thought to yourself “huh? whats that?”. Well let me introduce you….

The QGIS mapserver project implements a WMS server on top of the QGIS
libraries (funded by the EU projects Orchestra, Sany and the city of Uster).

– Marco Hugentobler

Building

You need to be using QGIS Trunk (or a nightly build with OSGEO4W for Windows users). On my Linux system I needed to install the fast cgi dev files:

sudo apt-get install libfcgi-dev

Then just recompile and install QGIS. After its built you will find a new item in the bin dir. On my system I build QGIS into ~/apps so my QGIS Server binary was here:

/home/timlinux/apps/bin/qgis_mapserv.fcgi

Configuration

Since I build my QGIS into a non system dir, I had to tell apache about the library path for my CGI. Something like this:

  ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
  
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    Order allow,deny
    Allow from all
    # Next for QGIS Mapserver
    SetEnv LD_LIBRARY_PATH /home/timlinux/apps/lib

Next I went to the cgi bin dir:

 cd /usr/lib/cgi-bin/

And then I made a project directory. The rule is: one directory per QGIS project you want to serve.

sudo mkdir world
cd world

Next I linked in the qgis cgi:

sudo ln -s /home/timlinux/apps/bin/qgis_mapserv.fcgi .

and then copied in the project file:

sudo cp /home/timlinux/gisdata/QGISProjects/world.qgs .

Symlinking of the project file may work for you – check your apache configs to allow symlinking I guess.

One other thing to do is copy the capabilities document into the world directory. Actually the server still works without it but we want to be neat & tidy right?

sudo cp /home/timlinux/dev/cpp/qgis/src/mapserver/wms_metadata.xml .

Now edit that file and set your details as appopriate.

I guess you are waiting to carry on with the next 25 pages of configuration instructions….right? Wrong! Thats all you need to do!

Testing

First you want to make a nice QGIS project and save the .qgs file in the project directory as outlined above. Here is what my QGIS project looked like:

To test you can point your web browser at your server:


http://localhost/cgi-bin/world/qgis_mapserv.fcgi?SERVICE=WMS&

    VERSION=1.3.0&REQUEST=GetCapabilities

Which makes a capabilities doc something like this:

And how about a nice map?


http://localhost/cgi-bin/world/qgis_mapserv.fcgi?SERVICE=WMS&VERSION=1.3.0&

REQUEST=GetMap&BBOX=-36.215710,6.817432,-9.700450,58.551008&
CRS=EPSG:4326&WIDTH=1077&HEIGHT=552&LAYERS=Continent,Country,Cities&
STYLES=,,&FORMAT=image/jpeg&DPI=96

Which produced this:

And just to be really meta, lets load the WMS source back into QGIS from where it started!

You see the map renders exactly the same as our original project – marvelous!

Things to note

The project should use relative paths (see project properties dialog)…or better yet load your data into PostGIS and forget shapefiles.
Dont forget to copy over your capabilities document and edit it with appropriate details
This is not a ‘robotosed’ GUI ala early versions of ArcIMS which took over your desktop application. Its a full ‘headless’ cgi web service.
You can use all the nice new symbology and labelling features of QGIS to make top quality maps

Thanks to Marco (and those who sponsored him)!

Addendum to notes added Aug 23, 11:17pm (provided by Andreas Neuman)

* QGIS Mapserver (or however it will be called) implements WMS 1.3 only (not WMS 1.1.1)
* GetFeatureInfo should support: text, html, xml
* GetFeatureInfo honors some of the attribute settings of a QGIS layer: hidden attributes are suppressed, column aliases are used if present.
* When doing the GetCapabilities, the answer can be very slow and big, because for every layer, QGIS will return all available CRS. You can limit this list by using adding the following XML elements to the properties section:



21781
4326

QGIS will not remove these settings from the .qgs file after saving it from the desktop version, but currently there is no GUI to do the WMS settings.

* By default, QGIS Mapserver will advertise the maximum extent of all involved layers. This can be overridden by the following setting, again in the section of a .qgs file; replace with your own min/max settings:

* GetLegendGraphics should work, e.g.


http://yourserver/cgi/qgis_mapserv.fcgi?map=/home/qgisprojects/myproject.qgs&SERVICE=WMS&

REQUEST=GetLegendGraphics&FORMAT=image/png&LAYERS=hydrology&WIDTH=400

* QGIS Mapserver can handle multiple project files with one fcgi binary. On a first request of a newly started Apache server, the request will be slower, because the .qgs file has to be parsed, later requests are fast, because there is a cache for more .qgs files. You can use the “map=/home/path/to/your/project.qgs” parameter to specify which project you want to access.

It would be nice if we could expose some of the “hidden” WMS properties in a GUI, somewhere in the QGIS project properties. Maybe a Server-Settings tab.

Thanks for the additional comments Andreas!

Overpainting with Mapnik

Tim Sutton — Sat, 21 Aug 2010 21:00:32 +0000

The problem

I’ve been having a little poke around with Mapnik today (awesome software!). One of the things on my todo list has been to sort out rendering issues with roads we have been having. Our last iteration described roads something like this:

A style…

…and this layer definition…

        
        Freeway30th_style
        
            &dbname;
            0
            &extent;
            &geometry_field;
            &host;
            &password;
            &port;
            &srid;
            (SELECT * FROM "l_roads" WHERE "type" = \
            'Freeway' ORDER BY LENGTH(&geometry_field;) DESC) as "l_roads"
            &datasourcetype;
            &password;

With the idea being to render freeways with a gray outline and orange center. Unfortunately, it doesnt produce good results:

The problem being those little line ends you see making gray splodges at the end of each segment.

The solution

Michael Migurski’s blog discusses this issue a little in this article but doesnt directly explain how to achieve the desired effect. So here is what you do:

First the styles are split into two…

and then the layer is now rendered as two layers, the bottom layer first, then the top:

    
        Freeway30th_style-bottom
        
            &dbname;
            0
            &extent;
            &geometry_field;
            &host;
            &password;
            &port;
            &srid;
            (SELECT * FROM "l_roads" WHERE "type" = \
            'Freeway' ORDER BY LENGTH(&geometry_field;) DESC) as "l_roads"
            &datasourcetype;
            &password;
        
    
    
        Freeway30th_style-top
        
            &dbname;
            0
            &extent;
            &geometry_field;
            &host;
            &password;
            &port;
            &srid;
            (SELECT * FROM "l_roads" WHERE "type" = \
            'Freeway' ORDER BY LENGTH(&geometry_field;) DESC) as "l_roads"
            &datasourcetype;
            &password;

A much cleaner rendering!

Note

This approach consumes more cpu time and hits your database harder than the ‘messier’ approach shown first.

Also you can see in the example above, I have adopted Michaels approach of rendering long lines first.

Have fun with your mapnik maps!

Introduction to PostGIS

Tim Sutton — Tue, 17 Aug 2010 21:50:23 +0000

Horst and I are spending the week up in Johannesburg at the Satellite Applications Center in Hartebeeshoek. We are doing yet another week long training course (I hope I’m not working the poor guy too hard ). This time we are doing:

- Two days QGIS (with a little GRASS)
- One day PostGIS
- Two days geospatial programming with Bash, Python and QGIS

Tomorrow we start with the PostGIS component. Horst and I have been compiling some course notes for the PostGIS module which we are making available to the world as per usual. The pdf still has some rendering issues – we are aware of that. The document tries to walk the reader through the basics of using SQL and then some basic activities with PostGIS and working with geometries.

I hope some of you out there find it useful – let us know if you do! Also if you have any improvements to make, we’d love to hear from you.

Here is a quick pic or two from the course:

A little bit of Ubuntu eye-candy

Tim Sutton — Sat, 14 Aug 2010 21:26:35 +0000

I am always up for a little bit of eye-candy on my desktop. Here is a great theme and icon set:

sudo add-apt-repository ppa:tiheum/equinox
sudo apt-get update
sudo apt-get install gtk2-engines-equinox equinox-theme \
       equinox-ubuntu-theme faenza-icon-theme

Taken from the original article here.

A QGIS Mass Workshop in Franschhoek, SA

Tim Sutton — Sat, 14 Aug 2010 21:05:57 +0000

Today was a great day. Gavin Fleming (http://www.afrispatial.co.za/), Horst Duester (visiting FOSSGIS guru in residence) and myself presented a one day mass QGIS workshop. There were around 110 people present! It was a feat of logistics on the part of Gavin, his wife Bridget and the IT staff and students from the Bridge House school (which played host for the day). 60 pcs running Windows were set up and had Jurgen Fischer’s excellent all-in-one windows installer for QGIS installed on them. People sat ‘two up’ at each computer and watched us walk QGIS through the process of loading vector and raster data, digitising data, doing some simple analysis, and producing a print ready map.

A nominal fee or R150 (around USD15) was charged to cover lunch and tea. The remaining profits were donated to the school to sponsor the purchase of some sensors for monitoring river water quality in a local river. The presentors and organisers all donated their time. Those attendees that couldn’t afford the R150 charge were admitted for free.

To be honest when Gavin proposed admitting around 80 people into the day workshop rather than the originally planned 20 Horst and I thought he was mad (little did we then know the actual turnout would hit 110). But I have to say Gavin and Bridget did a brilliant job and it was such a thrill to look out over a sea of interested and attentive faces all absorbing every morsel of knowledge about QGIS and FOSSGIS they could glean. It definitely left me feeling like it was a worthwhile experience and feeling positive about the demand and interest for FOSSGIS in the Western Cape.

I am off to crash for the night now after a long day, but I will leave you with these pics:

(above photo courtesy H. Duester)

A simple QGIS python plugin tutorial

Tim Sutton — Wed, 11 Aug 2010 13:19:40 +0000

Introduction to Python Plugins and QGIS

Note: This tutorial requires QGIS 1.6 (not yet released at time of writing) or QGIS Trunk r14052 (available from osgeo4w as a nightly build or build it yourself on linux from source).

Generating your plugin

There is an online tool for [creating a plugin http://pyqgis.org/builder/plugin_builder.py]. Simply fill in the blanks and it will generate a simple plugin framework for you. We are going to make a simple
plugin to perform a histogram stretch based on the min max values in the current view extents. Lets start by filling in some details in the plugin builder:

Class name (use CamelCase)     : RasterScale
Short descriptive title        : Raster Local Histogram Stretch
Description                    : Scale the min max of the raster to
                                 the min max within the view.
Version number                 : 0.1
Minimum required QGIS version  : 1.5
Text for the menu item         : Raster
Author/Company name            : Linfiniti Consulting CC
Email address                  : tim@linfiniti.com

After clicking the ‘build it’ link you will see a screen like this:

Generation complete for RasterScale. You can download it here.
What Next?
Unzip the plugin into your QGIS plugin directory and test it.
Modify it by editing the implementation file RasterScale.py
Create your own custom icon, replacing default icon.png
Modify your user interface by opening RasterScale.ui in
Qt Designer (don't forget to compile it with pyuic4
after changing it)
Use the Makefile to compile your Ui and resource files
if you make changes to them (requires gmake)

Click the download link and save it to your local disk.

Testing your plugin

Use your operating system to extract the plugin to your home directory .qgis folder:

/home/[yourname]/.qgis/python/plugins/

If this directory does not already exist, you should create it.

Now open QGIS.

Next do:

Plugins -> Manage Plugins

In the filter box enter

Stretch

Now tick the box next to the plugin to enable it then click ‘OK’. An icon will appear in the plugin toolbar and if you click it, your plugin will run!

Install the plugin reloader plugin in QGIS

Normally when you change a plugin you have to close and reopen QGIS to see the result of your changes. This can become a little tedious. To work around this, you can install the plugin reloader plugin like this:

Start QGIS
Plugins -> Fetch Python Plugins
Repositories tab
Click the 'Add 3rd party repositories button' and click Ok for the message that appears.
Wait a few moments while the repository list is updated.
On the Options tab, check the 'Show all plugins, even those marked experimental' radio button
In the Plugins tab, type reload into the filter box
Select the Plugin Reloader plugin from the list
Click Install, then Ok

Now we want to configure the plugin reloader to reload our raster scale plugin so do this:

Press Shift+F5
Choose rasterscale from the plugin list
Press Ok

Now whenever you press the F5 key, your plugin will be reloaded along with any changes you might have made to it.

First tweaks to our plugin

Lets make our first little tweaks to our plugin – just to test out the development process. Look at the name of your plugin:

click Plugins -> Raster

In the raster submenu you will see our plugin is named “Raster“. Lets rename it to “Raster Scale“. To do this, in Eric, open the RasterScale.py file from the list of files in your project on the left. Now look at the initiGui method and change the line that creates the menu action – it looks like this:

self.action = QAction(QIcon(":/plugins/rasterscale/icon.png"), \
"Raster", self.iface.mainWindow())

Now change it so that it looks like this:

self.action = QAction(QIcon(":/plugins/rasterscale/icon.png"), \
"Raster Scale", self.iface.mainWindow())

You will see above that I have simply added the characters ‘Scale’ to the QAction’s name.

Now save that file and go back to QGIS. Hit the “F5“ key to reload your plugin. Now once again do

click Plugins -> Raster

You should see the submenu is now named ‘Raster Scale’ instead of just ‘Raster’.

This is the general process you should follow when writing a plugin -

Edit code

Save source file

Reload plugin in QGIS (F5)

Test

In the units that follow we will assume that you do this each time we ask you to modify your plugin sources.

First steps into the QGIS api

Writing python plugins in QGIS requires knowledge of three things:

1 Python
2 PyQt – the Python language bindings for the Qt4 framework
3 The QGIS api

A really good resource for learning PyQt is the command prompt reference

Each of these three things is documented and generally searchable with google. We will look at the documentation in a little while. but first lets get our hands dirty and start modifying our plugin.

The first thing I would like to do is outline the functionality that we are going to give our plugin. Here is the logic flow:

Getting and checking the active layer

As a first step, we are going to replace the run() method in RasterScale.py with our own logic – the comments in the code explain step for step what is going on:

# run method that performs all the real work
def run(self):
  # get the currently active layer (if any)
  layer = self.iface.mapCanvas().currentLayer()
  # test if a valid layer was returned
  if layer:
    # test if the layer is a raster from a local file (not a wms)
    if layer.type() == layer.RasterLayer and ( not layer.usesProvider() ):
      # Test if the raster is single band greyscale
      if layer.rasterType()==QgsRasterLayer.GrayOrUndefined:
        #Everything looks fine so show a little message and exit
        QMessageBox.information(None,"Raster Scale","Layer is ok")
        return
  # One of our tests above failed - show and error message and exit
  QMessageBox.information(None,"Raster Scale", \
      "A single band greyscale raster layer must be selected")
  return

Now press F5 in QGIS to reload the plugin (since we have changed its code) and then click the plugin icon with no layers loaded in your project. You should get a message telling you that there needs to be a layer available.

Next add a greyscale raster (e.g. a dem) and then click on the plugin icon again. This time you should get a ‘Layer is Ok’ message.

Computing the min max values within the view extent for the layer

Now we want to answer the question: ‘what is the minimum and maximum value in my current view extent?’ Fortunately its pretty easy to do – using the raster layer computeMinimumMaximumFromLastExtent method e.g.:

# compute the min and max for the current extent
extentMin, extentMax = layer.computeMinimumMaximumFromLastExtent( band )

If for example our current view extent contains pixels with values from 20 to 140, extentMin will now be assigned a value of 20 and extentMax will now be assigned a value of 140. The idea is to then scale the colour assigments made to each pixel to this range, such that a pixel of value 20 will be painted black and a pixel of value 140 will be painted white. The image below tries to explain this better:

Setting the band min and max values

Now what we need to do is tell the raster layer to consider the min max values from the current extent to be the min max values for the whole layer, and then to stretch the colour pallette accross the new min/max value range for the layer.

Ok so to do this we can use the following api calls:

# For greyscale layers there is only ever one band
band = layer.bandNumber( layer.grayBandName() ) # base 1 counting in gdal
# We don't want to create a lookup table
generateLookupTableFlag = False
# set the layer min value for this band
layer.setMinimumValue( band, extentMin, generateLookupTableFlag );
# set the layer max value for this band
layer.setMaximumValue( band, extentMax, generateLookupTableFlag );

This should be self explanatory except maybe the part about a lookup table. Lookup tables are used for creating custom colour pallettes. Since in our case we are not interested in creating a custom colour pallette, we can leave it out of the equation for now by setting it to false.

Extra house keeping

Just a little extra house keeping is needed. First we have to ensure that standard deviations are disabled as it will affect the values given to each pixel. Next we let the raster layer know that we are using a user defined min and max range rather than the true range of the data in the raster. Next we clear any cached image for the raster (used to speed up drawing in some situations). Lastly we tell the layer to redraw itself!

# ensure that stddev is set to zero
layer.setStandardDeviations( 0.0 );
# let the layer know that the min max are user defined
layer.setUserDefinedGrayMinimumMaximum( True );
# ensure any cached render data for this layer is cleared
layer.setCacheImage( None );
# make sure the layer is redrawn
layer.triggerRepaint();

Putting it all together

Lets look at our complete run method now:

# run method that performs all the real work
def run(self):
  # get the currently active layer (if any)
  layer = self.iface.mapCanvas().currentLayer()
  # test if a valid layer was returned
  if layer:
    # test if the layer is a raster from a local file (not a wms)
    if layer.type() == layer.RasterLayer and ( not layer.usesProvider() ):
      # Test if the raster is single band greyscale
      if layer.rasterType()==QgsRasterLayer.GrayOrUndefined:
        #Everything looks fine so set stretch and exit
        #For greyscale layers there is only ever one band
        band = layer.bandNumber( layer.grayBandName() )
        extentMin = 0.0
        extentMax = 0.0
        generateLookupTableFlag = False
        # compute the min and max for the current extent
        extentMin, extentMax = \
                         layer.computeMinimumMaximumFromLastExtent( band )
        # set the layer min value for this band
        layer.setMinimumValue( band, extentMin, generateLookupTableFlag )
        # set the layer max value for this band
        layer.setMaximumValue( band, extentMax, generateLookupTableFlag )
        # ensure that stddev is set to zero
        layer.setStandardDeviations( 0.0 );
        # let the layer know that the min max are user defined
        layer.setUserDefinedGrayMinimumMaximum( True )
        # ensure any cached render data for this layer is cleared
        layer.setCacheImage( None )
        # make sure the layer is redrawn
        layer.triggerRepaint()
        #QMessageBox.information(None, 'Raster Scale', \
          "Min %s : Max %s" % ( extentMin , extentMax ))
        return
  # One of our tests above failed - show and error message and exit
  QMessageBox.information(None,"Raster Scale", \
        "A single band raster layer must be selected")
  return

Testing

Refresh the plugin using the plugin reloader F5 keyboard shortcut. Now zoom to an area on your greyscale raster and then click the RasterScale plugin icon. You should see something happen like that shown below:

Before scaling

After scaling

Exercise

See if you can update the plugin so that it works for RGB and palletted images too!

Exercise Solution

/***************************************************************************
RasterScale
A QGIS plugin
Scale the min max of the raster to the min max within the view.
               -------------------
begin        : 2010-08-05
copyright      : (C) 2010 by Linfiniti Consulting CC.
email        : tim@linfiniti.com
 ***************************************************************************/

/***************************************************************************
 *                                     *
 *  This program is free software; you can redistribute it and/or modify *
 *  it under the terms of the GNU General Public License as published by *
 *  the Free Software Foundation; either version 2 of the License, or   *
 *  (at your option) any later version.                  *
 *                                     *
 ***************************************************************************/
"""
# Import the PyQt and QGIS libraries
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
from qgis.gui import *

# Initialize Qt resources from file resources.py
import resources
# Import the code for the dialog
from RasterScaleDialog import RasterScaleDialog

class RasterScale: 

 def __init__(self, iface):
  # Save reference to the QGIS interface
  self.iface = iface

 def initGui(self):
  # Create action that will start plugin configuration
  self.action = QAction(QIcon(":/plugins/rasterscale/icon.png"), \
    "Raster Scale", self.iface.mainWindow())
  # connect the action to the run method
  QObject.connect(self.action, SIGNAL("triggered()"), self.run) 

  # Add toolbar button and menu item
  self.iface.addToolBarIcon(self.action)
  self.iface.addPluginToMenu("&Raster", self.action)

 def unload(self):
  # Remove the plugin menu item and icon
  self.iface.removePluginMenu("&Raster",self.action)
  self.iface.removeToolBarIcon(self.action)

 # run method that performs all the real work
 def run(self):
  # Allowed drawing styles that can have a local histogram stretch:

  allowedGreyStyles = [ QgsRasterLayer.SingleBandGray,
             QgsRasterLayer.MultiBandSingleBandPseudoColor,
             QgsRasterLayer.MultiBandSingleBandGray,
             QgsRasterLayer.SingleBandPseudoColor ]
  allowedRgbStyles = [ QgsRasterLayer.MultiBandColor ]
  # get the currently active layer (if any)
  layer = self.iface.mapCanvas().currentLayer()
  # test if a valid layer was returned
  if layer:
    # test if the layer is a raster from a local file (not a wms)
    if layer.type() == layer.RasterLayer and ( not layer.usesProvider() ):
      # Test if the raster is single band greyscale
      if layer.drawingStyle() in allowedGreyStyles:
        #Everything looks fine so set stretch and exit
        #For greyscale layers there is only ever one band
        band = layer.bandNumber( layer.grayBandName() ) # base 1 counting in gdal
        extentMin = 0.0
        extentMax = 0.0
        generateLookupTableFlag = False
        # compute the min and max for the current extent
        extentMin, extentMax = \
                          layer.computeMinimumMaximumFromLastExtent( band )
        # set the layer min value for this band
        layer.setMinimumValue( band, extentMin, generateLookupTableFlag )
        # set the layer max value for this band
        layer.setMaximumValue( band, extentMax, generateLookupTableFlag )
        # ensure that stddev is set to zero
        layer.setStandardDeviations( 0.0 )
        # let the layer know that the min max are user defined
        layer.setUserDefinedGrayMinimumMaximum( True )
        # ensure any cached render data for this layer is cleared
        layer.setCacheImage( None )
        # make sure the layer is redrawn
        layer.triggerRepaint()
        return
      if layer.drawingStyle() in allowedRgbStyles:
        #Everything looks fine so set stretch and exit
        redBand = layer.bandNumber( layer.redBandName() )
        greenBand = layer.bandNumber( layer.greenBandName() )
        blueBand = layer.bandNumber( layer.blueBandName() )
        extentRedMin = 0.0
        extentRedMax = 0.0
        extentGreenMin = 0.0
        extentGreenMax = 0.0
        extentBlueMin = 0.0
        extentBlueMax = 0.0
        generateLookupTableFlag = False
        # compute the min and max for the current extent
        extentRedMin, extentRedMax = layer.computeMinimumMaximumFromLastExtent( redBand )
        extentGreenMin, extentGreenMax = layer.computeMinimumMaximumFromLastExtent( greenBand )
        extentBlueMin, extentBlueMax = layer.computeMinimumMaximumFromLastExtent( blueBand )
        # set the layer min max value for the red band
        layer.setMinimumValue( redBand, extentRedMin, generateLookupTableFlag )
        layer.setMaximumValue( redBand, extentRedMax, generateLookupTableFlag )
        # set the layer min max value for the red band
        layer.setMinimumValue( greenBand, extentGreenMin, generateLookupTableFlag )
        layer.setMaximumValue( greenBand, extentGreenMax, generateLookupTableFlag )
        # set the layer min max value for the red band
        layer.setMinimumValue( blueBand, extentBlueMin, generateLookupTableFlag )
        layer.setMaximumValue( blueBand, extentBlueMax, generateLookupTableFlag )
        # ensure that stddev is set to zero
        layer.setStandardDeviations( 0.0 )
        # let the layer know that the min max are user defined
        layer.setUserDefinedRGBMinimumMaximum( True )
        # ensure any cached render data for this layer is cleared
        layer.setCacheImage( None )
        # make sure the layer is redrawn
        layer.triggerRepaint()
        return
  # One of our tests above failed - show and error message and exit
  QMessageBox.information(None,"Raster Scale", \
        "A single band raster layer must be selected")
  return

Complete Plugin

The complete plugin is available here. I will add it to a plugin repository once QGIS 1.6 comes out.

Updated to remove all those semi-colons from the end of lines…..

3 New Case Studies for QGIS

Tim Sutton — Tue, 10 Aug 2010 22:32:49 +0000

Otto Dassau has posted 3 new case studies of QGIS in use in a production environment. It’s always gratifying to see people using QGIS to run their businesses, do their studies and get on with their daily work.

I’m looking forward to seeing more case studies arrive on the QGIS home page – if you are doing something interesting with QGIS, do let Otto know about it!

A week of FOSSGIS training at Linfiniti

Tim Sutton — Sat, 07 Aug 2010 08:27:25 +0000

Its been another great week here at Linfiniti. Last weekend we (the QGIS project) released QGIS 1.5 Tethys – its great to have another release out the door.

Also making my week a good one was the fact that we ran a week long FOSSGIS course here at Linfiniti HQ in Swellendam, Western Cape, South Africa.

The Presenter

Horst Duester – Linfiniti’s ‘FOSSGIS Guru in Residence’ for the months of July and August ran the course. Horst has very kindly donated his time and considerable expertise over his two month sabbatical to the development of FOSSGIS GIS skills in South Africa. The course consisted of 2 days’ QGIS, 3 days PostGIS. With these two projects you can address a huge range of GIS functionality, and having a whole week to dedicate to the topic let Horst really go in depth into the subject.

The Particpants

We had four participants for the course – all of whom have some experience in GIS in general and who wanted to get a deeper understanding of QGIS and PostGIS.

Andiswa Silinga works out of Johannesburg where she runs a small business – GGES (Gemini GIS and Environmental Services) – which provides GIS solutions to government and enterprise customers. GGES also has special skills in the area of Environmental GIS.

Originally from Zimbabwe, Petronella Tizora was a former intern with Linfiniti consulting. Petronella currently works at GGES with Andiswa and is applying her FOSSGIS skills to her daily work.

Sindile Bidla works out of East London in the Eastern Cape, South Africa. Sindile’s small GIS consulting business Intengu Technologies provides solutions – he is currently involved in a project to map informal settlements. Sindile formerly worked for the Dept. Land Affairs where he was the principle instigator of the Gentle Introduction to GIS project which saw the introduction of FOSSGIS into the school curriculum in the Eastern Cape.

Brendon runs a small consulting company – Integrated Geodata – from his offices in Pretoria, South Africa. Brendon’s company provides general GIS consulting services, with a special interest in providing services to the water industry.

The course was really well received by the attendees, and Horst thoroughly enjoyed the work of presenting it. It is really gratifying to see how – with a little training – FOSSGIS can provide a basis for building sophisticated GIS solutions for the enterprise. Better still it provides these entrepreneurs a fantastic edge – the ability to offer their clients a solution that has no vendor lock in with maximum value for money.

In the coming months I am planning to formalise the course content developed by Horst and try to increase my focus on training – the course certainly reaffirmed the notion for me that providing good quality, affordable training is the best way to maximise the penetration of FOSSGIS into the market place.