/dev/stu » Uncategorized

Cairo with python Ctypes

stu — Mon, 09 Jan 2012 18:11:32 +0000

Uploaded some experiments with python and ctypes to here:

https://gitorious.org/pycairo-ctypes/pycairo-ctypes

This is a really rough proof of concept that the pycairo API can be implemented with ctypes + metclasses.

So far only ImageSurface is supported on the SVG backend, along with Contexts. The nice thing about this is that you can use a pycairo like API on pypy, where things should be faster (in theory).

There’s a test that can be run to show the outputs the same for pycairo and cairo ctypes.

Using PyCha with Django

stu — Fri, 25 Feb 2011 00:10:50 +0000

A quick post on using Python Charts to generate nice SVG charts for your django website (I’ve had the code hanging around for ages – so should just post it). The code is based on the examples there, here I integrate it into Django.

To install you’ll need to do

pip install pycha

Heres the code for a simple view to output a chart directly to SVG:

# views.py

from StringIO import StringIO
from django.http import HttpResponse

import cairo

def colors(request):
    in_req = 1

    svg_buffer = StringIO()

    width, height = (500, 400)
    surface = cairo.SVGSurface(svg_buffer, width, height)

    dataSet = (
     ('dataSet 1', ((0, 1), (1, 3), (2, 2.5))),
     ('dataSet 2', ((0, 2), (1, 4), (2, 3))),
     ('dataSet 3', ((0, 5), (1, 1), (2, 0.5))),
    )

    options = {
       'legend': {'hide': True},
       'background': {'color': '#f0f0f0'},
    }

    #import pycha.bar
    #chart = pycha.bar.VerticalBarChart(surface, options)

    import pycha.line
    chart = pycha.line.LineChart(surface, options)
    chart.addDataset(dataSet)
    chart.render()

    del chart
    del surface

    response = ''
    response = HttpResponse(mimetype='image/svg+xml')
    svg_buffer.seek(0)
    response.write( svg_buffer.read() )
    return response

The basic idea is that – instead of the chart outputting to an svg file, the output goes to a buffer, this is triggered by calling the destructors of the chart and it’s cairo surface. Once the data is in the buffer, it is rewound and played back to the Http Response.

Inline SVG

As is, this won’t work as inline svg, because outputting the XML preamble in the middle of the page will cause problems. Below is an example that let’s you decide if you need the preamble (full SVG output), or not (SVG fragment for inclusion in a page or another SVG):

# Create your views here.

from StringIO import StringIO
from django.http import HttpResponse
from django.shortcuts import render_to_response

import cairo

XML_PREAMBLE = ''

def colors_chart(inline = False):
    """
    Generate colours chart

    Set inline to True to disable the XML preamble
    """
    in_req = 1

    svg_buffer = StringIO()

    width, height = (500, 400)
    surface = cairo.SVGSurface(svg_buffer, width, height)

    dataSet = (
     ('dataSet 1', ((0, 1), (1, 3), (2, 2.5))),
     ('dataSet 2', ((0, 2), (1, 4), (2, 3))),
     ('dataSet 3', ((0, 5), (1, 1), (2, 0.5))),
    )

    options = {
       'legend': {'hide': True},
       'background': {'color': '#f0f0f0'},
    }

    import pycha.bar
    chart = pycha.bar.VerticalBarChart(surface, options)

    #import pycha.line
    #chart = pycha.line.LineChart(surface, options)
    chart.addDataset(dataSet)
    chart.render()

    del chart
    del surface

    response = ''

    if inline:
        svg_buffer.seek(len(XML_PREAMBLE))
    else:
        svg_buffer.seek(0)
    return svg_buffer.read()

def colors_svg(request):
    """ render a pure SVG chart """
    response = HttpResponse(mimetype='image/svg+xml')
    response.write(colors_chart(inline = False))
    return response

def index(request):
    """ render a chart into the template """
    chart_svg = colors_chart(inline = True)

    return render_to_response(
        'shapes_index.html',
        { "chart" : chart_svg },
        mimetype='application/xhtml+xml')

An example project with the above code is available here:
pycha_django

[EDIT 25/2/2011] Fixed PyCha URL

stu — Thu, 30 Sep 2010 23:59:21 +0000

[EDIT: 2010/10/05]

Oops, I’ve been using TCC/LE by JPSoft as my shell… the following doesn’t work in the normal command prompt

[/EDIT]

I just had a look at SET and it lets you set user/system variables:

Display, create, modify, or delete environment variables.

SET [/A /D /E /P /R file... /S /U /V /X] [name[=][value ]]
        file:  One or more files containing variable definitions
        /A(rithmetic)           /S(ystem variables)
        /D(efault variables)    /U(ser variables)
        /E(nv vars)             /V(olatile variables)
        /R(ead from file)       /X override VariableExclude
        /P(ause)

So to set save a variables MYAPP_HOME as the current directory, just do

SET /U MYAPP_HOME=%CD

Wish I’d have looked that up a few years ago, it’ll save a few seconds next time I need to setup some dev sdk

Access files in a Linux virtual machine from Windows

stu — Thu, 21 Jan 2010 04:46:17 +0000

I recently found a neat way of accessing files in a linux VMWare image. This is really useful, as theres never really a good time to break your VMWare image, this is also handy if you don’t want to run the whole machine, but just access the files inside.

There is one caveat:

It only works if the filesystem is ext2 (ext3 works, and ext4 probably works).

Install VMWare DiskMount Utility

Accept the EULA, download and install the VMWare DiskMount utility.

For convenience add the utilities folder to the path:

C:\Program Files\VMware\VMware DiskMount Utility

Do this through the Windows Gui, or even use my addpath utility.

At this point you can mount Windows VMWare images.

The usage is: vmware-mount drive-letter vmdk-image.

Heres how I mount my Ubuntu image to the j: drive

[C:\vmware\Ubuntu]vmware-mount j: ubuntu.vmdk

[C:\vmware\Ubuntu]

No output here indicates success.

At this point everything seems fine, but a crucial piece of the puzzle is still missing; try and view the files and you still can’t:

The next step is to make Windows understand the ext2 filesystem, using a special driver.

Install ext2ifs

Grab ext2ifs from www.fs-driver.org and install.

If the following steps don’t work then you may need to reboot.

Thats it!

You should be now able to access files inside your VMWare image (assuming it’s ext2 and not reiserfs), remount the image and have a go:

In my case I did:

[C:\vmware\Ubuntu]vmware-mount j: ubuntu.vmdk

[C:\vmware\Ubuntu] dir j:

Heres the output – hooray, I can copy my work out of the image !

This is very useful, especially if you do dist-upgrade in ubuntu and can’t access the network.

Bonus tip:

Newer versions of VMWare player let you install VMWare tools from inside the GUI, this is another way to fix the kind of catestrophic problems you can cause yourself by accidentally upgrading the kernel in an image.

Using Java2Python to port a JavaCairo tutorial

stu — Fri, 21 Aug 2009 00:22:15 +0000

I recently came across Java2Python. As I’m interested in Cairo I thought it would be interesting to try porting one of the example tutorials from ZetCode.

I’ll run through the steps involved in porting then try and reach some conclusions at the end .

1. Get setup

This is easiest in Linux, I’m running Ubuntu (in vmware), and installed

antlr 2.x
python2.5.x
sun java6
pygtk
java-gnome

You can install them like this:

# sudo apt-get install antlr python2.5 sun-java6-bin libjava-gnome-java

Then install Python2Java with easy_install

# sudo easy_install-2.5 java2python

To test if it’s working run j2py -i. It should complain there is no file:

# j2py -i
Usage: j2py [options]

j2py: error: -i option requires an argument

If you get any other errors your missing some packages.

2. Get the Java Code from the Simple Example.

Save the ‘simple.java’ example as ‘GSimple.java’

If java-gnome is running ok, compiling and running it you should see a window:

# javac GSimple.java
# java GSimple

Now we’ll run through the code, it’s important to understand what it does before we port it…

package com.zetcode;

import org.gnome.gdk.Event;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;
import org.gnome.gtk.WindowPosition;

/**
 * ZetCode Java Gnome tutorial
 *
 * This program is a simple Java Gnome
 * application.
 *
 * @author jan bodnar
 * website zetcode.com
 * last modified March 2009
 */

public class GSimple extends Window  {

    public GSimple() {

        setTitle("Simple");

        connect(new Window.DeleteEvent() {
            public boolean onDeleteEvent(Widget source, Event event) {
                Gtk.mainQuit();
                return false;
            }
        });

        setDefaultSize(250, 150);
        setPosition(WindowPosition.CENTER);
        show();
    }

    public static void main(String[] args) {
        Gtk.init(args);
        new GSimple();
        Gtk.main();
    }
}

Code Runthrough

Import java-gnome bindings
Create a class that extends org.gnome.gtk.Window
Set the size of the window
Connect the ‘delete’ event to an InnerClass. When a delete event arrives, ‘onDeleteEvent’ is called which in turn calls Gtk.mainQuit().

Gtk.mainQuit() will quit program and cleanup gtk.
set window size
show the window

3. Use j2py to create the initial python code.

The first stage is to generate the python.

# j2py -i GSimple.java > gsimple.py

Output [gsimple.py]:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

class GSimple(Window):
    """ generated source for GSimple

    """

    def __init__(self):
        setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        connect(Window.DeleteEvent())
        setDefaultSize(250, 150)
        setPosition(WindowPosition.CENTER)
        show()

    @classmethod
    def main(cls, args):
        Gtk.init(args)
        GSimple()
        Gtk.cls.main()

if __name__ == '__main__':
    import sys
    GSimple.main(sys.argv)

5. Analyze

Unfortunately j2py is not magic, it’s time to have a look at the code..

Things are missing and others look wrong, heres an initial list of problems:

no imports
‘self’ not specified in class constructor
CamelCase used – this is suspicious, it’s unlikely the cairo bindings work like this
@classmethod is probably not nessacary here
Gtk.cls.main() – This looks particularly suspicious

Indeed – If you try and run it, the missing imports become apparent:

bagside@bagvapp:~/jythongnome$ python gsimple.py
Traceback (most recent call last):
  File "gsimple.py", line 5, in
    class GSimple(Window):
NameError: name 'Window' is not defined

6. Fixing the initial Problems

Some problems are easy to fix, others involve learning the differences between the java and python APIs.

Starting with the easiest…

‘self’ not specified in class constructor

This looks easiest so we’ll tackle it first, heres the new constructor:

        self.setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        self.connect(Window.DeleteEvent())
        self.setDefaultSize(250, 150)
        self.setPosition(WindowPosition.CENTER)
        self.show()

Doing this does emphasize how wrong the CamelCase looks, also the onDeleteEvent being a function in the constructor doesn’t look right, we could probably move it up a level.

No imports

In the java code there is

import org.gnome.gdk.Event;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;
import org.gnome.gtk.WindowPosition;

Googling for Window module and gtk you’ll end up at the pygtk site.
The documentation shows the Window class is in the gtk module. Further research on the site or in the python prompt shows most of the other classes are in the same module too.

# To do research in the python prompt, simply start python and try
import gtk
dir(gtk)
help(gtk)
help(gtk.Window)

It’s worth having a glance at the python help to see if the bindings look the same, start python and try:

import gtk
help(gtk.Window)

…[output snipped]…

 |  set_skip_taskbar_hint(...)
 |
 |  set_startup_id(...)
 |
 |  set_title(...)
 |
 |  set_transient_for(...)
 |
 |  set_type_hint(...)
 |
 |  set_urgency_hint(...)

It’s fairly obvious that CamelCase is not used here, as suspected (remember to change this later…)

As “Window” is quite generic, I’ll move everything into the ‘gtk’ namespace, add

import gtk

To the top of the code, and change all instances of the gtk classes to ‘gtk.ClassName’, e.g. gtk.Window:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.setTitle("Simple")

        def onDeleteEvent(self, source, event):
            Gtk.mainQuit()
            return False

        self.connect(gtk.Window.DeleteEvent())
        self.setDefaultSize(250, 150)
        self.setPosition(WindowPosition.CENTER)
        self.show()

    @classmethod
    def main(cls, args):
        Gtk.init(args)
        GSimple()
        Gtk.cls.main()

if __name__ == '__main__':
    import sys
    GSimple.main(sys.argv)

And try running it:

Traceback (most recent call last):
  File "gsimple.py", line 31, in
    GSimple.main(sys.argv)
  File "gsimple.py", line 25, in main
    Gtk.init(args)
NameError: global name 'Gtk' is not defined

It’s complaining about the ‘main’ class method on GSimple, we can just remove it and move everything into the main method of the module:

if __name__ == '__main__':
    import sys
    Gtk.init(args)
    GSimple()
    Gtk.cls.main()

This still won’t work for sure as ‘Gtk’ is not in the namespace.

The first step is to work out whats going on, consult the java code then the relevant documentation.

[GSimple.java]
public static void main(String[] args) {
Gtk.init(args);
new GSimple();
Gtk.main();
}

OK, the code is the same, what does the java gnome documentation say about Gtk.init ?

init

public static void init(String[] args)

Initialize the GTK libraries. This must be called before any other org.gnome.* classes are used.

Parameters:
args – The command line arguments array. This is passed to the underlying library to allowing user (or window manager) to alter GTK’s behaviour.
Since:
4.0.0

Looking in pygtk there isn’t ‘init’ (it would be confusing having this and __init__ anyway).

Looking in the pygtk documentation there is no ‘init’ method (which makes sense as it could be confused with ‘__init__’. There is however gtk.main:

gtk.main

def gtk.main()

The gtk.main() function runs the main loop until the gtk.main_quit() function is called. You can nest calls to gtk.main(). In that case the call to the gtk.main_quit() function will make the innermost invocation of the main loop return.

Here I confess some prior knowledge, I already had a vague idea the main loop might be involved as I’d worked with gtk before.

So we’ll try gtk.main, and commenting out the line calling main on the class as I’m not entirely sure what it does:

if __name__ == '__main__':
    import sys
    gtk.main()  # Note gtk.main takes no parameters
    GSimple()
    # Gtk.cls.main()

Try running

And… nothing happens – you have to quit with CTRL-C!

It looks like it’s not even getting to the constructor (as there should be errors here, maybe gtk.main() needs to run *after* the GSimple() constructor..

Sure enough:

# python gsimple.py
Traceback (most recent call last):
  File "gsimple.py", line 30, in
    GSimple()
  File "gsimple.py", line 13, in __init__
    self.setTitle("Simple")
AttributeError: 'GSimple' object has no attribute 'setTitle'

Fixing the CamelCase

The pygtk documentation seemed all be underscored_lowercase, it’s probably safe to speculatively change everything to this then fix any errors:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.set_title("Simple")

        def on_delete_event(self, source, event):
            gtk.main_quit()
            return False

        self.connect(gtk.Window.DeleteEvent())
        self.set_default_size(250, 150)
        self.set_position(WindowPosition.CENTER)
        self.show()

if __name__ == '__main__':
    import sys
    GSimple()
    gtk.main()  # Note gtk.main takes no parameters
    #    Gtk.cls.main()

Output:

 python gsimple.py
gsimple.py:12: GtkWarning: gtk_window_set_title: assertion `GTK_IS_WINDOW (window)' failed
  self.set_title("Simple")
Traceback (most recent call last):
  File "gsimple.py", line 28, in
    GSimple()
  File "gsimple.py", line 18, in __init__
    self.connect(gtk.Window.DeleteEvent())
AttributeError: type object 'gtk.Window' has no attribute 'DeleteEvent'

Thats progress! It means the self.set_title call probably works, and there is a self.connect call too.

There is no DeleteEvent in the pygtk documentation… which is not suprising as it looks more java than python.
Better to step back and have a look at self.connect, in the end I googled

gtk connect delete event

And got to a getting started with pygtk page:

36  # When the window is given the "delete_event" signal (this is given
37  # by the window manager, usually by the "close" option, or on the
38  # titlebar), we ask it to call the delete_event () function
39  # as defined above. The data passed to the callback
40  # function is NULL and is ignored in the callback function.
41  self.window.connect("delete_event", self.delete_event)

Note here they have ‘window’ as their delegating, our generated code extends this class.

The signature is slightly different, also instead of ‘on_delete_event’ the function is just called ‘delete_event’, this seems more pythonic so we’ll do the same.

This would also be a good time to move the function into the main class, out of the constructor:

class GSimple(gtk.Window):
    """ generated source for GSimple

    """

    def __init__(self):
        self.set_title("Simple")

        self.connect('delete_event', delete_event)
        self.set_default_size(250, 150)
        self.set_position(WindowPosition.CENTER)
        self.show()

    def delete_event(self, source, event):
	gtk.main_quit()
	return False

And the output:

gsimple.py:12: GtkWarning: gtk_window_set_title: assertion `GTK_IS_WINDOW (window)' failed
  self.set_title("Simple")
Traceback (most recent call last):
  File "gsimple.py", line 29, in
    GSimple()
  File "gsimple.py", line 14, in __init__
    self.connect('delete_event', delete_event)
NameError: global name 'delete_event' is not defined

The first line assertion `GTK_IS_WINDOW (window)’ failed is the important one here; it makes sense, the constructor of the gtk.Window has not been called yet.

Add

gtk.Window.__init__(self)

to the top of the constructor and run.

Traceback (most recent call last):
File "gsimple.py", line 30, in 
GSimple()
File "gsimple.py", line 17, in __init__
self.set_position(WindowPosition.CENTER)
NameError: global name 'WindowPosition' is not defined

And again…

Repeating the same process for WindowPosition and set_position, you’ll find that the set_position line should look like this:

self.set_position(gtk.WIN_POS_CENTER)

And the output…

Huzzah! Success!

Final Source code

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import gtk

class GSimple(gtk.Window):

    def __init__(self):
	gtk.Window.__init__(self)
        self.set_title("Simple")

        self.connect('delete_event', self.delete_event)
        self.set_default_size(250, 150)
        self.set_position(gtk.WIN_POS_CENTER)
        self.show()

    def delete_event(self, source, event):
	gtk.main_quit()
	return False

if __name__ == '__main__':
    import sys
    GSimple()
    gtk.main()

Conclusions

Although Cairo APIs are available for Java and Python they are of course quite different. One implication of this is that if you wanted to use Cairo from a Jython java applet (via native methods) it couldn’t have code 100% the same as a normal python app.
java2python is good, but you still need to put the work in.
Working in this way is also a good way to find differences within implementations of an API.

The Bloggage and slacking

stu — Fri, 07 Aug 2009 01:28:25 +0000

Just been checking out what Mr Palmer has been up to… quite a lot it seems… if I could get further than 2 chapters in 6 months with Getting Things Done maybe I could stop procrastination and start GTD too

And I’ve been checking out some online comics…

My 6 monthlyish check on SayUncle comics blog always makes me want to do some drawing.

Also Quite enjoying the Beartato in space storyline in nedroid.

Toast

stu — Fri, 09 Jan 2009 19:29:36 +0000

Lyrics

Router upgrade nixed xbmc

stu — Sun, 14 Dec 2008 23:26:50 +0000

It turns out my lack of networked media consumption utopia via xbmc was all down to upgrading my router… the xbox was fixed on 10.0.0.x while everything else moved over to 192.168.1.x …so I learned that SMB doesn’t like that at all.

Oh well, one task down… many more todo… maybe I can actually setup my kurobox in the next few days and then some really nice things might be possible.

Noodleglue – found!

stu — Wed, 01 Oct 2008 12:13:38 +0000

For the last few days I’ve been looking for a project called NoodleGlue. I got interested when I wanted to look into generating java wrappings for the Verse library.

If you just want to download Noodleglue skip to the end of the article.

Verse is a network protocol that lets 3d applications talk to each other in realtime, being developed by the Blender foundation. I was wondering how difficult it would be to link the ease of use of processing with the power of Blender.

Processing being a simplified java, I started to look at ways of generating java bindings.

I knew that GTK had switched to generating their java bindings automatically, so started looking at technologies to do this, immediately I found out about noodleglue which seemed to fit the bill.

Slight problem – the site was down and the developers nowhere to be seen, after much searching I realised I should be looking for something written in C/C++ not java, searched for NoodleGlue.tar.gz and ‘bing!’ there it is on one persons website.

I’m uploading it here, although I should probably put it on google code as well.

NoodleGlue.tar.gz

NoodleGlueGenerator.jar

Snapshot of noodleglue.org in in the internet wayback machine.

I must also mention Cibyl, a project for compiling C to java, it worked best for me in linux… currently a bit of a pain to setup but an interesting project nonetheless.

Cibyl Project

Eplilogue – There was a version on the internet wayback machine the whole time, not sure why I didn’t check, however the version I’ve found is newer – at least 18/Apr/2007.

Track all your forum posts in delicious

stu — Sun, 21 Sep 2008 04:11:41 +0000

I’ve been using delicious for a while, but have started bookmarking all my forum posts in there, it should be a lot easier for me to find out whatever I was talking about in the future