robot campfire » english

Using HSV to build a traffic light

David — Sun, 27 Sep 2009 21:19:36 +0000

A small tip for anyone working on some sort of data visualization. If you have values that lie between 0.0 and 1.0 (or 0% and 100%, or $some_value and $some_other_value), you can use a simple interpolation in the HSV (or HSB) color space to get a nice “traffic light” range of colors from red to green via yellow in the middle, which is fine for displaying something that is “OK” if the values are low and gets “critical” or “dangerous” for higher values (or vice versa). Just set the saturation and value (or brightness) parameters to 100% and use your data to vary the hue between 0° (which means red) and 120° (which is green). Since yellow sits right in the middle of that scale at 60° this gives you a smooth transition from red to yellow to green, which may look like this:

hue scale from 0° to 120°

Now this might be common knowledge, but i just stumbled upon it some time ago and thought it was a useful tidbit that i wanted to share.

Quest for a working Android on the FreeRunner

David — Mon, 22 Jun 2009 21:44:33 +0000

So, i have been trying again to turn my Openmoko FreeRunner into a usable device, despite its uncertain future. One that you can really use to make calls, send/receive SMS, surf the web (over WiFi or GPRS) and do other things you should normally be able to expect from a working smartphone. This is a little write-up of how far i’ve gotten in that quest.

Since i have repeatedly been frustrated by the apparent lack of progress in getting a usable (from the standpoint of someone willing and wanting to do some application level tinkering but not wanting to do any lower level hackery) platform using the Openmokos “native” distributions (SHR, Om200x etc.), i turned to Android. This has made quite some steps since i tried one of the first Koolu beta versions, but it doesn’t seem to be totally there yet, either.

I first tried using Koolu beta 7 and was quite impressed by how many things worked out of the box (WiFi, sending SMS). But, alas, some things also did not work, receiving SMS for example. The phone just didn’t do anything when it was supposed to have received (according to a delivery report on the sending phone) a message.

I then tried the images by Michael Trimarchi (mostly for trying out something based on the newer cupcake development branch of Android), and they are definitely going in the right direction. I can even receive SMS with them. Haven’t tried using GPRS, yet. Strangely, the freerunner-v14.6-cupcake image worked better for me than the newer freerunner-cupcake-snapshot-v6. The latter gives me a lot of crashing applications (com.android.media right at startup, and seemingly in a loop, com.android.phone after ending a phone call, the settings app when trying to enter the “Wireless” settings…) and i haven’t managed to get WiFi working on both of them.

All in all there still sadly is no Android-on-FreeRunner image where everything i need “just works”(tm). But, seeing all the development happening right now, i am confident hoping that a cupcake based image where all the important stuff works is not too far off.

Using a custom smart pointer with Boost.Python

David — Sat, 13 Jun 2009 18:35:25 +0000

I’m currently working on creating a python wrapper for XCF using Boost.Python. During that project i stumbled upon the problem that i was wrapping some classes that used a custom smart pointer (i.e. not one from the boost library). Boost.Python is quite good at wrapping classes using smart pointers, but it has to know some things about the smart pointer used first.

Most importantly, it has to know how to get the “raw” pointer from the smart pointer and how to determine the type of the object that is being pointed to (given the type of the smart pointer). Finding documentation about telling Boost.Python how to work with an unknown type of smart pointer wasn’t easy (which is why i am blogging this), but fortunately at some point i stumbled upon this. It’s from the documentation of the Py++-package, but you don’t have to be using Py++ to use the technique described in there.

You have to keep a lot of things in mind when implementing this (especially when the class your smart pointer is pointing to might also have some derived subclasses, in which case you should really take a look at the original example), but in essence it all boils down to this. In that case, IceUtil::Handle is the smart pointer i am working with. This class is coming from Ice, so if you’re also using that, you might try creating something similar.