Find it at picflick.

1. Take a facial portrait and detect the position of the face
2. Cut a facial portrait down the center and remove half of the picture so that kids can fill it in themselves.
3. Print a massive amount of JPEGs at once by putting them in a PDF.

I’m in the Eastern Cape, South Africa now, working with orphans and vulnerable children. Alex and I are spending some of our time on art projects in remote rural areas, and one of the projects is an idea we stole from an orphanage in Cape Town: take a digital portrait of a child’s face, crop it down the center, print it and let them draw the other side of the face. Like this one Alex did:

Half-face portrait

The first time we did this, we went out to the rural area, took pictures of about 16 kids and then spent an hour or two processing the pictures and printing. The processing involved:

1. Importing the pictures to Picassa, straightening some of them and cropping others. (Yes, I know Picassa is not Free/Libre, but F-spot (in Ubuntu Hardy) is dog slow to display pictures and doesn’t have the straighten function).
2. Exporting to a directory, then opening each file in GIMP and cropping the right-or-left hand side of the face away.
3. Combine all the JPEG images into a PDF so they’re easy to print.

The second time, we did the project at a school, for 60+ pupils. The straightening/cropping in Picassa took about ten minutes (since most of the pictures didn’t need much work). The open-crop-save-close process in GIMP took about thirty seconds per picture and was both repetitive and highly mouse intensive so that we both got hand cramps after a while.

So, after watching Alex do the process for a second class at the school, I decided there must be a better way: automatic face detection. Lo-and-behold, five minutes of Googling got me to Torch3Vision, an image recognition toolkit with built-in face detection. It definitely works, but it takes quite a little setting up, so here’s a guide.

1. Download Torch3Vision and un-tar it: tar -zxf Torch3vision2.1.tgz
2. Build Torch3vision: cp Linux_i686.cfg.vision2.1 Linux_i686.cfg ./torch3make
3. Build the vison examples for face detection:cd vision2.1/examples/facedetect/
   ../../../torch3make *.cc

So now we have a working set of face-detection programmes. The command line interface isn’t too friendly, so they take a little playing around. For starters, the binaries on my Ubuntu system don’t read JPEG images (although the code seems to be there, the build system is non-standard and didn’t automatically pick up my jpeg libraries. So, I needed to convert my images to PPM format, which is one of those image formats that no-one uses but somehow is the lowest common denominator for image processing command line apps. I use the program ‘jpegtopnm’ from package ‘netpbm’.

Of the three facial detection programs available, I found ‘mlpcascadescan’ to be the most effective and quickest, although they all have similar interfaces so this will basically be the same for all of them. We need to pass the source image and the model file, and we tell it to write the face position and to save a drawing with the face detected:

This command takes about 20s to run on my creaky old laptop, and creates two files. One is a greyscale visualization of the face detected (the original image was colour):

Face detected, more or less

The other file ‘andy.pos’ contains the results of face detection. Line one is the number of detections, then each line has format x y w h, very easy to parse.

I played around with the step-factors in the x and y directions to shave a second or so off the face detection routine, the values I chose were 0.1 and 0.2 respectively (I don’t need any accuracy in the y direction really, since my use is to cut the face down the middle).

Then, since these are portrait photographs, I can speed up face detection by setting a minimum size for the face. I experimented and one sixth of the total image width gave good results – any larger and the face detection would fail with a crash. Adding this constraint provides better than 10X speed up, since the algorithm doesn’t waste time searching for small faces.

So now here’s the final face detection command

And finally, as promised, I’ll tell you how to blank-out one side of the face: of course, using Image Magick. Using the ‘chop’ or ‘crop’ commands didn’t work for this purpose, where I wanted the image to keep it’s dimensions but have one half just be white. So I decided to draw a white rectangle over half of the picture.  I apply the image manipulation to the original JPEG file, not the temporary PPM file that I used to detect the face position.

And here’s the final result:

The script I am using to tie this all together.

After processing all the portraits, I run a quick script to convert the jpegs to PDF and then join them into one master PDF file that I can easily print. The JPEG-PDF conversion uses Image Magick again (convert -rotate 90 file.jpg file.pdf). Joining together many PDFs into one document is easy with ‘pdfjoin’ from package ‘pdfjam’ (pdfjoin $tempfiles –outfile jpg2pdf.pdf). See the final jpg2pdf script.

But perhaps more enjoyable is to see the result after letting my limited creative talents loose:

A work of staggering complexity.

• Uses libnotify instead of xosd, which looks a lot better in GNOME
  at least and should work fine cross-desktop.


• The most drastic action is now to minimize the distracting window
  rather than change virtual desktops, which was quite specific to my
  desktop usage. I have tried to manage the focus with this change too,
  so that the user doesn’t inadvertently send key presses to a different
  window.


• Uses GTK event loop which makes monitoring a lot more efficient.


• More sophisticated usage of libwnck to determine which windows are
  active at whether they belong to a distracting application.


• Simplified some of the code and tried to de-jargonize the config file.

You can download it at http://code.ultrahigh.org/undistract

Recently I was working on my interpolation classes, which are templates, like

template 
class Interpolation1D : public Interpolation
{
public:
    ...
    T GetValue(const T& x)
    {
        // vectors hold interpolation points and values near 'x'
        vector xa(_order), ya(_order);
        ...    // set up the points to interpolate
        return Neville (_order, xa, ya, x);
    }
protected:
    ...
};

The function GetValue(x) retrieved the interpolated value of the function position x. The Interpolation2D class has a similar GetValue(x,y) member. Both of these GetValue functions use Neville’s algorithm to determine the value at the interpolation point, which is a pretty fast polynomial approximation technique. In fact, they basically do exactly the same thing, except the 2-D version builds an intermediate 1-D set of values (using Neville’s algorithm) and then interpolates that in the same manner as the 1-D version.

Naturally I wrote a function to perform the Neville interpolation, and that too had to be templated, in order to be used inside the templated interpolation classes.

template 
T Neville(const size_t& order, const vector& xa,
         const vector& ya, const T& x)
{ ... }

I put the declaration for the Neville function in the header file interpolation.h, and the implentation in interpolation.cpp. Everything compiled just fine (I compiled this into a library) but when I came to link the main program, which used a Interpolation1D instance, the compiler started complaining that it couldn’t find the double version of Neville:

double Neville(const size_t&, const vector&,
       const vector&, const double)

I spent a good while double checking the function declaration was the same as the definition (since the main program did compile, only the linking failed. Using nm to examine the object code in interpolation.o showed that in fact NO version of Neville() was present.

Anyway, to cut a long story short, the answer is one of those C++ things that is obvious after you figure it out: The compiler, when it compiles interpolation.cpp into interpolation.o, only builds creates implentations of templated functions that it sees are being used, in this case, none, since no code within interpolation.cpp calls Neville (or Neville).

The solution was to move the definition of Neville into interpolation.h, which is #included in the interpolation1d.h file. When the compiler builds an object file relying on the Interpolation1D class (ie code which #includes interpolation1d.h and hence interpolation.h) it sees that it needs to create the object code for Neville and does so.

class Interpolation
{
public:
	Interpolation(const string& name, const double& accuracy)
	{
		_name = name;
		_accuracy = accuracy;
		_isBuilt = false;
	}
	virtual void Init(void) = 0;
	virtual void LoadFromFile(const string& filename) = 0;
	virtual void SaveToFile(const string& filename) = 0;
protected:
	string _name;
	double _accuracy;
	bool _isBuilt;
};

I then have a layer of inheritance on top of that, defining the interface for interpolation in two variables

class Interpolation2D : public Interpolation
{
public:
	Interpolation2D(const string& name, const double& accuracy,
		const long& Nx, const long& Ny,
		const double& xmin, const double& xmax,
		const double& ymin, const double& ymax)
		: Interpolation (name, accuracy)
	{

		_grid = new Data2D<double>(Nx, Ny);
		...
	}
	~Interpolation(void)
	{
		cout << "deleting data grid for " << _name << "\n";
		delete _grid;
	}
	// these are implemented here for two-D interpolations
	virtual void SaveToFile(const string& filename);
	virtual void LoadFromFile(const string& filename);
protected:
	Data2D<double>* _grid;
};

This code was working fine. I have the templated 2D data array class Data2D and chose to use doubles for my interpolation data. The inherited _name and _isBuilt variables work fine, as in the debug output line in the destructor.NB: I do implement the SaveToFile and LoadFromFile functions here, which basically just dump the _grid variable to a binary file.

Then I discovered the rather obvious fact that if I want to make a very fine-grained interpolation, that can take a lot of memory. For example, a 5000×5000 grid of doubles is 5000×5000x8 bytes, i.e. 190MB. Too rich for my laptop at least, although not absurd for most of the machines I use for simulation.

One obvious choice would be to use float instead of double as the data type. Of course, this leads to wanting to template the Interpolation class, which I duly did:

template <class T>
class Interpolation
{
public:
	Interpolation(const string& name, const T& accuracy)
	{
		_name = name;
		_isBuilt = false;
		_accuracy = accuracy
	}
	virtual void Init(void) = 0;
	virtual void LoadFromFile(const string& filename) = 0;
	virtual void SaveToFile(const string& filename) = 0;
protected:
	string _name;
	bool _isBuilt;
	T _accuracy;
};

template <class T>
class Interpolation2D : public Interpolation<T>
{
public:
	Interpolation2D(const string& name, const T& accuracy,
		const long& Nx, const long& Ny,
		const T& xmin, const T& xmax,
		const T& ymin, const T& ymax)
		: Interpolation<T> (name)
	{

		_grid = new Data2D<T>(Nx, Ny);
		...
	}
	~Interpolation(void)
	{
		cout << "deleting data grid for " << _name << "\n";
		delete _grid;
	}
	virtual void SaveToFile(const string& filename);
	virtual void LoadFromFile(const string& filename);
protected:
	Data2D<T>* _grid;
};

So, imagine my surprise and confusion when this code no longer works. Specifically, gcc complains about the debugging output in the derived class’ destructor.

./include/aon_interpolation.h:179: error: "_name" was not declared in this scope

The problem, according to the C++ FAQ, is that the variable _name is not dependent on the template, and the compile will not look in the base template class to resolve non-dependent names.

Luckily there’s a really easy fix: change the call to use

this->_name

instead: i.e.

cout << data grid for " << this->_name << "\n";

C++ Is just one of those things that constantly surprises me with weird little things like this, even after 7 years of using it. But it’s still so powerful it’s mostly a pleasure to use.

I have problems with attention. I’ve not been diagnosed with A.D.D. or anything but anyone who spent fifteen minutes in my office would realize that I am either utterly distracted or hyper-focused. These are pretty common traits amongst scientists and programmers – indeed, the tendency to hyper-focus is probably the same thing that programmers call “being in the zone”.

I have designed it to solve a particular problem – I tend to focus on my work once I get started, but I also focus equally well on non-work activities, in particular web browsing. It’s easy for me to let an hour (or eight!!) pass whilst, say, checking Slashdot repeatedly, without realizing that so much time has gone by. I designed undistract to gently pull me out of this focus-on-distraction to give me a chance to focus on my work.

The program works by monitoring what windows are open on my desktop. I use GNOME on Ubuntu Linux (I also test the program in KDE and XFCE) with multiple workspaces (also called virtual desktops). I tend to have them arranged like

• Workspace 1: Browser, Email, IM windows, music player
• Workspace 2: Couple of xterms on local machine
• Workspace 3: SSH & VNC sessions to machines on the cluster at work
• Workspace 4: gvim editing analysis code or LaTeX files.

Clearly, if I am doing useful work, I ought to be spending most (but not all) of my time on Workspaces 3 & 4. Workspace 2 tends to involve distractions but not entirely useless ones, as I do things like update the operating system, tweak configuration, backup my data etc. If, however, I am spending a lot of time on Workspace 1, it is safe to assume that I have become absorbed in some distraction, whether it be Slashdot, MySpace, eBay… whatever it is, I have a thesis to write so it’s probably not helpful.

I do want to allow for those times when I’m in the flow, working on something, and I have to look up some documentation online. What I’m really trying to catch with Undistract are those times when you sit down to work, but just want to check your email, only to find someone emailed you a funny link, which led you to your browser, which led you to hover next to that open tab to Google News… if you have found this page, you know the story!

Undistract maintains a ‘nag level’ which is raised or lowered at intervals depending on whether the user has a browser open on the current workspace or not. The intervals for checking are not uniform, and when the nag level is low the checking occurs slowly, like every 10 minutes. If the user is still using a browser after that interval, then a message appears in front of all the open windows (using xosd) telling them to get to work, and the nag level is raised.

As the nag level increases, the interval between nags becomes shorter, up to a limit, by default 60 seconds. After the nag level passes a certain value, 6 by default, then the user is reminded to work by the xosd message but current workspace is changed. The user is free to change back to the browser and finish what they are doing, but after 60 seconds they will be bounced to a different desktop again.

If you think this could be helpful in helping with your own distractions, try undistract for a bit.