You are a legend

Contour plugin for QGIS, version 0.9.0

2011-10-10T14:05:00.000+02:00

Based on the last matplotlib revision (1.0.1), the plugin can now directly handle irregular point grid, thanks to the new triangulation function. Beside this, in some situations (few sample points), a prelimary work is to be done on the input datas (look at resampling with spine algorithm or with a krigging function).
In the same time, the plugin now can reuse existing contours plots, just have to select the right layer in the legend and launch the plugin!
Also, you can now select the extend for the contours limits (neither, min, max or both), trying to avoid the errors messages complaining about invalid selected levels.

As always, the plugin is available through the qgis plugin installer or directly on www.pyqgis.org

Contour plot for QGIS - version 0.7.2

2010-09-23T11:53:00.000+02:00

New options for the qgis contour plugin :
- possibility to directly set the resulting layers' names (always in memory, don't forget to save them before qgis exit!)
- a new level computation method : quantile (tired to manually set them :P)
- new resulting attribute "label" with a precision setting, usefull to quickly display levels values on the map without the need to manually change default number precision (normally 10e-4). Really usefull with filled contours in categorized renderer symbology.
As always, the plugin is available through the qgis plugin installer or directly on www.pyqgis.org

Contour plot for QGIS - version 0.7.1

2010-07-27T09:36:00.000+02:00

Just some minor changes in the code :
0.6 : Pass contour.py Qt4 compliant and remove Qt3 signals handling
0.7 : Add more acceptable datatypes (integer, float, ...) from PostgreSQL
0.7.1 : Minor change for checking dependencies with the python plugin installer

Please note : the natgrid package inside matplotlib was updated by Jeff Whitaker and now correctly handle identical points coordinates. No more crashes (I hope) \o/

Requirements:
matplotlib and the natgrid toolkit if the irregular points interpolation fails
numpy
Shapely

Download : Use the internal Qgis plugin installer...

Contour plot for QGIS - version 0.5

2010-03-11T22:51:00.002+01:00

The 0.5 is here! Comes with some great new options with the introduction of filled contours, and the possibility to modify each level individually (just double click in the levels list). Also, it's the first time for me to work with someone at the antipodes (or really near : http://www.antipodr.com/?addr=limoges%2C+france&x=0&y=0), thanks Chris!

Requirements:
matplotlib and the natgrid toolkit if the irregular points interpolation fails
numpy
Shapely

Download : Use the internal Qgis plugin installer...

Usage :

Just follow the included documentation :)

Contour plot for QGIS - version 0.4

2010-02-23T10:51:00.001+01:00

With the great help of Chris Crook, here is an update of the contour plugin for QGIS which now can handle irregular points grids. This is possible via the "griddata" module of the matplotlib package. Please note some pathologicals cases can't be processed with griddata, and you have to install the natgrid toolkit providing a more robust algorithm for triangulation and interpolation. Last but not least, the contour plugin now has a documentation!
Many thanks for your work Chris.

Requirements:
matplotlib and the natgrid toolkit if the irregular points interpolation fails
numpy
Shapely

Download : Use the internal Qgis plugin installer...

Usage :

Just follow the included documentation :)

Contour plot for QGIS - version 0.3

2010-01-04T14:34:00.010+01:00

Here is an update of the contour plot plugin for Qgis. Now handle integer, double and real fields, with a new option for fixing the minimum and maximum contouring values.

Requirements:
matplotlib
numpy
Shapely

or for Debian based systems like Ubuntu, you can directly type in a terminal :

sudo apt-get install python-numpy python-matplotlib python-shapely

Download : Use the internal Qgis plugin installer...

Usage :

Look at the first release or see this screencast :

(sorry for the poor quality of this video, google seems to not like high quality :/ )

Conky on the desktop

2009-11-08T23:30:00.009+01:00

Conky is a highly configurable system monitor, with tons of options and an incredible rendering system (http://conky.sourceforge.net). Here is my desktop with a minimal conky script :

And here is the script to put in your ~/.conkyrc file :

own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager
use_xft yes
xftfont Bitstream Vera Sans Mono:size=10
xftalpha 0.8
update_interval 1.0
total_run_times 0
own_window yes
own_window_transparent yes
double_buffer yes
draw_shades no
draw_outline no
draw_borders no
stippled_borders 8
border_inner_margin 4
border_outer_margin 4
border_width 1
default_color 4582B5
default_shade_color black
default_outline_color black
alignment bottom_left
gap_x 50
gap_y 50
no_buffers yes
uppercase no
cpu_avg_samples 2
net_avg_samples 2
override_utf8_locale no
use_spacer none
format_human_readable yes
short_units yes
default_bar_size 50 10
default_graph_size 16 150
minimum_size 1180 5
maximum_width 1180
show_graph_range no
show_graph_scale no

TEXT
${color #e49c16}HOST : ${color white}$nodename${tab 200}${color #e49c16}CPU : ${color #ffc11f}${cpubar cpu0}${color #FFFFFF} ${cpu cpu0}% at ${freq_g}GHz${tab 200}${color #e49c16}DOWNLOAD : ${color #ffc11f}${downspeedgraph eth0 16,150 8b4b0b ffc11f} ${color white} ${downspeed eth0} k/s
${color #e49c16}DATE : ${color white}${time %Y/%m/%d %H:%M:%S}${tab 200}${color #e49c16}RAM : ${color #ffc11f}${membar}${color #FFFFFF} $memperc% - $mem/$memmax
${color #e49c16}KERNEL : ${color white}$kernel${tab 200}${color #e49c16}SWAP: ${color #ffc11f}${swapbar}${color #FFFFFF} $swapperc% - $swap/$swapmax${tab 200}${color #e49c16}UPLOAD : ${color #ffc11f}${upspeedgraph eth0 16,150 ffc11f 8b4b0b} ${color white} ${upspeed eth0} k/s
${color #e49c16}IP : ${color white}${addr eth0}${tab 200}${color #e49c16}ROOT: ${color #ffc11f}${fs_bar /} ${color #FFFFFF}$fs_used_perc% - ${fs_free /}/${fs_size /}

Contour plot for QGIS

2009-08-03T11:54:00.010+02:00

Qgis plugin for creating contours lines from a regular points grid.

Requirements:
matplotlib
numpy
Shapely

Download : Use the internal Qgis plugin installer...

Usage :
1 - After installing the contour plugin with the installer, go to the menu Plugins > Manage plugins and activate it :

2 - Load input datas from a shapefile or whatever you want, but they must be of type point and on a regular grid :

3 - Open the contour plugin : menu Plugins > Contour > Contour

4 - In the Contour window, select the input layer and the data field from which contours will be based, how many resulting contours levels you want. If you just want to "have a look" at the results, select the "in memory" option, else select storing in a shapefile (write on disk).

5 - Click "OK" and it's done :)

windrose

2008-09-10T11:21:00.026+02:00

A windrose, also known as a polar rose plot, is a special diagram for representing the distribution of meteorological datas, typically wind speeds by class and direction.
This is a simple module for the matplotlib python library, which requires numpy for internal computation.

Requirements:
matplotlib 0.98.3 or above
numpy 1.0 or above
and naturally python :-P

Download : windrose.zip

Example :
Expecting the windrose.py file and all the necessary modules are in the PYTHONPATH, this example use randoms values for wind speed and direction(ws and wd variables). In situation, these variables are loaded with reals values (1-D array), from a database or directly from a text file (see the "load" facility from the matplotlib.pylab interface for that).

from windrose import WindroseAxes
from matplotlib import pyplot as plt
import matplotlib.cm as cm
from numpy.random import random
from numpy import arange

#Create wind speed and direction variables
ws = random(500)*6
wd = random(500)*360

#A quick way to create new windrose axes...
def new_axes():
    fig = plt.figure(figsize=(8, 8), dpi=80, facecolor='w', edgecolor='w')
    rect = [0.1, 0.1, 0.8, 0.8]
    ax = WindroseAxes(fig, rect, axisbg='w')
    fig.add_axes(ax)
    return ax

#...and adjust the legend box
def set_legend(ax):
    l = ax.legend(axespad=-0.10)
    plt.setp(l.get_texts(), fontsize=8)

A stacked histogram with normed (displayed in percent) results :

ax = new_axes()
ax.bar(wd, ws, normed=True, opening=0.8, edgecolor='white')
set_legend(ax)

Another stacked histogram representation, not normed, with bins limits

ax = new_axes()
ax.box(wd, ws, bins=arange(0,8,1))
set_legend(ax)

A windrose in filled representation, with a controled colormap

ax = new_axes()
ax.contourf(wd, ws, bins=arange(0,8,1), cmap=cm.hot)
set_legend(ax)

Same as above, but with contours over each filled region...

ax = new_axes()
ax.contourf(wd, ws, bins=arange(0,8,1), cmap=cm.hot)
ax.contour(wd, ws, bins=arange(0,8,1), colors='black')
set_legend(ax)

...or without filled regions

ax = new_axes()
ax.contour(wd, ws, bins=arange(0,8,1), cmap=cm.hot, lw=3)
set_legend(ax)

After that, you can have a look at the computed values used to plot the windrose with the ax._info dictionnary :
ax._info['bins'] : list of bins (limits) used for wind speeds. If not set in the call, bins will be set to 6 parts between wind speed min and max.
ax._info['dir'] : list of directions "bundaries" used to compute the distribution by wind direction sector. This can be set by the nsector parameter (see below).
ax._info['table'] : the resulting table of the computation. It's a 2D histogram, where each line represents a wind speed class, and each column represents a wind direction class.

So, to know the frequency of each wind direction, for all wind speeds, do:

ax.bar(wd, ws, normed=True, nsector=16)
table = ax._info['table']
wd_freq = np.sum(table, axis=0)

and to have a graphical representation of this result :

dir = ax._info['dir']
wd_freq = np.sum(table, axis=0)
plt.bar(arange(16), wd_freq, align='center')
xlabels = ('N','','N-E','','E','','S-E','','S','','S-O','','O','','N-O','')
xticks=arange(16)
gca().set_xticks(xticks)
draw()
gca().set_xticklabels(xlabels)
draw()

In addition of all the standard pyplot parameters, you can pass special parameters to control the windrose production. For the stacked histogram windrose, calling help(ax.bar) will give :
bar(self, dir, var, **kwargs) method of windrose.WindroseAxes instance
  Plot a windrose in bar mode. For each var bins and for each sector,
  a colored bar will be draw on the axes.

  Mandatory:
  * dir : 1D array - directions the wind blows from, North centred
  * var : 1D array - values of the variable to compute. Typically the wind
  speeds
  Optional:
  * nsector: integer - number of sectors used to compute the windrose
  table. If not set, nsectors=16, then each sector will be 360/16=22.5°,
  and the resulting computed table will be aligned with the cardinals
  points.
  * bins : 1D array or integer- number of bins, or a sequence of
  bins variable. If not set, bins=6 between min(var) and max(var).
  * blowto : bool. If True, the windrose will be pi rotated,
  to show where the wind blow to (usefull for pollutant rose).
  * colors : string or tuple - one string color ('k' or 'black'), in this
  case all bins will be plotted in this color; a tuple of matplotlib
  color args (string, float, rgb, etc), different levels will be plotted
  in different colors in the order specified.
  * cmap : a cm Colormap instance from matplotlib.cm.
   - if cmap == None and colors == None, a default Colormap is used.
  edgecolor : string - The string color each edge bar will be plotted.
  Default : no edgecolor
  * opening : float - between 0.0 and 1.0, to control the space between
  each sector (1.0 for no space)