For those who haven’t heard of Tinyproxy, it is a light-weight HTTP proxy daemon for POSIX operating systems, written with special consideration for users with low resources such as embedded applications. It can be modified easily too.

WIP screenshot of Transmission GTK UI on Windows

On a related note, it’s easy to build a GCC cross compiler under Linux to build win32 apps. One can build GTK+ apps and make installers for them, all from the comfort and elegance of Linux. However, an up-to-date document of the process and some gotchas to help the programmer would be helpful and I’ll post a link to such a document shortly.

Hylke Bons drew a new logo for Banu yesterday. I had requested him for a cuddly brown bear, and adapting Linus’s words for Tux, said the bear should look contented and happy, as if it’s just had a lot of honey Hylke replied within 2 hours with this logo image which is the sweetest bear I’ve ever seen. It even seems to be hiding a jar of honey behind it It’s amazing he created it in so little time. Thank you Hylke!

Banu bear hiding honey

[muks@jurassic ~]$ uname -a
Linux jurassic 2.6.24.4-64.fc8 #1 SMP Sat Mar 29 09:15:49 EDT 2008 x86_64 x86_64 x86_64 GNU/Linux
[muks@jurassic ~]$ history | awk '{a[$2]++}END{for(i in a){print a[i] " " i}}' | sort -rn | head
326 ls
168 cd
92 git
74 clear
66 joe
30 grep
28 svn
15 ssh
15 cat
13 cp
[muks@jurassic ~]$

I seem to use clear a lot!

Eek! Look at all that terrible code. Anyway, main() implements a well-known algorithm. Can you figure out what it is?

#define REMAINDER(dividend, divisor)
                   (((dividend) < 0) ?
                    (divisor) - 1 - ((-(dividend) - 1) % (divisor)) :
                    (dividend) % (divisor))

Update: The macro assumes a positive divisor. Our divisor was always a constant positive integer literal.

Morten Welinder found an underflow situation in the code above when INT_MIN is used as the dividend, which may fall in yet another undefined part of the C specification. Basically in the sub-expression (-(dividend) - 1), -(dividend) == (dividend) when dividend == INT_MIN. And INT_MIN - 1 will underflow (and wrap-around to INT_MAX in the case of most microprocessors’ two’s complement registers), and this behaviour is not defined in C. Although it’ll work fine on most general purpose CPUs, because this is undocumented, there may be issues if gcc tries to reduce it at -O2 if both dividend and divisor are constants. More correct code with Morten’s patch is:

#define REMAINDER(dividend, divisor)
                   (((dividend) < 0) ?
                    (divisor) - 1 - ((-((dividend) + 1)) % (divisor)) :
                    (dividend) % (divisor))

It won’t overflow over INT_MAX in this case, as dividend is less than 0 when that sub-expression is used. So now, we have 4 authors.

GIMP toolbox

Here is an example with rotation, using the excellent Wilber splash draft by Paul Davey and Jimmac (still no window decoration in the screenshots):

Wilber before

Wilber during

Wilber after

The shapes below are from a GTK+ test program which uses Cairo to draw, but when I took screenshots, the window decoration disappeared (maybe because of desktop effects). The black polygon is the transformed quadrilateral and the green rectangle is the computed result. The function also accepts an aspect ratio to provide a properly sized rectangle.

Last week, the Fractal Explorer plug-in of GIMP had a bug like this. The code for handling the loglog checkbox was added back in 1999. It has never worked on the complete classic Mandelbrot set (or if it ever did work, that must have been due to a bug in some other product). Looks like nobody used it like that. Kevin Cozens was porting the plug-in to GEGL when he discovered that it crashed with the loglog setting (#372671).

GIMP Fractal Explorer plug-in

For a Mandelbrot set, the classic method of rendering the set is to map the escape loop counter (once the modulus has escaped) directly to a colormap. This counter is an integer and the method causes banding due to non-smooth shading. The loglog implementation uses a method by Linas Vepstas to renormalize the escape loop counter by finding out how far away the integer counter has strayed outside the escape radius. It involves calculating a double log to map z^(2^i) to i, i.e., log (log (|z|^(2^i))) / log (2). The final divide by log (2) is so that the outer logarithm is done to the base 2 to reduce the 2^i to i. For reference, the end-result normalized loop counter is calculated as: mu = N - log (log (|Z(N)|)) / log (2) where N is the integer escape counter.

The problem with this method was that in the “inner lake” of the Mandelbrot set, where for example c can be 0 + 0i, the loop always exits after a full run with the loop counter at the maximum value, and |z| < 2.0. When |z| < e, the double log starts returning negative values. When |z| < 1, the double log returns inf. This is then subtracted from N and the resulting value mu is used to lookup RGB values for the point from the colormap array. This caused the plug-in to crash (when inf is used or mu exceeds the length of the colormap array).

So what we did to fix this was check to see if |z| < e at the end of the escape loop and clamp mu to N - 1 in that case. The result:

Classic smoothing (or lack of it)

loglog smoothing

Open them in two tabs to see how they differ. Of course, as we still use entries directly from a colormap (after rounding), it isn’t as smooth as we’d really like, but interpolation using the real values should be an exercise for another day. Now fixing the actual bug was a 2-line if condition. Imagine hours spent studying the algorithm used, and a 2-line fix (and perhaps this lousy blog post). The plug-in still needs to be fixed as it’s got the code for the fractal algorithms repeated for the actual filter and for the dialog’s preview, which needs to be moved to a common function, and we’d like to implement the really smooth shading as well.

Do you find all this cooking interesting? Do you want to be a GIMP developer? Come and participate by picking an open bug and hacking it into submission. Join #gimp on irc.gimp.org to talk to developers, or the gimp-developer mailing list. Or you may want to try #gegl if you think you’ve got the skills.