Thoughtseed

Converting CMYK to RGB

petit — Mon, 07 Sep 2009 16:50:49 +0000

Representation of CMYK (Values discussed here are in the range [0, 1]) In CMYK, black (K) is a minimum amount of black ink for all three CMY. The CMY components are then scaled inside the remaining range:

1
2
3

C' = (1-K)*C;
M' = (1-K)*M;
Y' = (1-K)*Y;

Black

Cyan

Magenta

Yellow

Ink Contribution (CMKY)

Cyan-Black Contribution

Result:

Magenta-Black Contribution

Result:

Yellow-Black Contribution

Result:

Once we scale the cyan, magenta and yellow components using the black component, we obtain a color on the CMY (no K) model.

Ink Contribution (CMY - no K)

These CMY are negatives of RGB, as in:

1
2
3

R = 1.0 - C;
G = 1.0 - M;
B = 1.0 - Y;

The final color:

webbzr – php to browse a bzr repository from a web page

petit — Thu, 06 Aug 2009 15:55:36 +0000

- You can see webbzr in action here

Latest changes

Version 1.4 (Jun 30, 2010)Fixed a vulnerability where webbzr could be used to list content outside of the webbzr root.
Version 1.3 (Jan 24, 2010) Branches and directories within branches can now be download as a tgz or tbz2 package straight from the bzr repository.
Version 1.2 (Jan 21, 2010) Security fix (thanks to Andrew Bradley)
Version 1.1 (Oct. 6 2009) Fix for repository that are not at the root of a url, for instance: http://www.site.com/~user/bzr/ (thanks to Dr. Rich Wareham)
Version 1.0 (Aug. 5 2009) Initial version

Motivation

Bazaar (bzr) can push and pull branches on a remote server without having to install anything on the server side. This is useful in cases where you have access to a web server without admin privileges (i.e. you could not install WebDAV or setup a svn site). With bzr, you simply upload (sftp) your branch to a directory visible from your web page, and then people download (branch) using http. Next step, I wanted to allow browsing of the branch from the web. This feature is "free" with svn through WebDAV, and there have been extra tools to browse svn and cvs (e.g. ViewVC). For bzr however, all I could find was LoggerHead which works as an actual web server. It has to start a daemon and open ports - pretty much defeating my initial motivation for using bzr. I figured I'd just hack something quick.

webbzr

Features

webbzr is a php script that will:

List the content of a directory and show normal and versioned files
Allow browsing into the repository
Allow viewing or downloading of files in the repository
Allow downloading of branches or directories as a tgz/tbz2 package
Allow browsing of revisions (going back in time)
Display information about the last modifications

Files, not just directories, can be browsed by version. For example:

http://bazaar.enseed.com/app/webbzr/.webbzr/webbzr.php grabs you the latest release of the file
http://bazaar.enseed.com/app/webbzr/.webbzr/webbzr.php?rev=1 would get you revision 1 of the file.

Hiding the Parameters from the URL

Using mod_rewrite, browsing is transparent (you can browse using the actual path in the url). For example, the link to http://bazaar.enseed.com/app/webbzr/ brings you straight into a branch. This is more convenient than using the equivalent url: http://bazaar.enseed.com/.webbzr/webbzr.php?path=app/webbzr/. To make this possible without configuring the web server directly, we use a .htaccess file that redirects requests to the script:

1
2
3

RewriteEngine on
RewriteCond %{REQUEST_URI} !^/\..*$
RewriteRule ^(.*)$ /.webbzr/webbzr.php?path=$1 [L,QSA]

This reads: given that the request uri does not start with a "." (the script in stored in .webbzr/ to avoid recursive redirection), whatever the request was, pass it as an argument named path to webbzr.php.

Formatting the Output

The webbzr.php script actually outputs xml, not html. The xml is transformed on the client side with an xslt (webbzr.xsl) and styled with css (webbzr.css). That means you can change the look if without having to touch the php code at all.

Installing

1. Download

To download:

1	bzr branch http://bazaar.enseed.com/app/webbzr/

2. Configure

Move to webbzr/.webbzr:

1	cd webbzr/.webbzr/

In the config.php file you will have to edit the following variables:

$BZRURL: this should be the url to the root of your web site (i.e. from where the script will run)
$BZRBINARY: how to invoke bzr. This may simply be "bzr" if it's in your path.
$XSLABSOLUTEURL: absolute url to the webbzr.xsl file.
$CSSABSOLUTEURL: absolute url to the webbzr.css file.

Move back to the webbzr directory (cd ..) and edit the .htaccess file. Next to the RewriteRule, make sure the url to the webbzr.php is fine. By default, it expects to be in /.webbzr/webbzr.php

3. Install

Copy the .htaccess file to the root of your browsing directory. Next to it, copy the .webbzr/ directory with the webbzr.php, config.php, webbzr.css, webbzr.xsl and the img/ directory.

4. Try it

And let me know if it works...

Installing Bazaar (bzr) Locally on a Web Host

petit — Tue, 04 Aug 2009 13:15:54 +0000

Context

Bazaar (bzr) is a nifty version control system. I'm still a fan of subversion (svn), but there are things that svn just won't do. For instance, if you want to publish your code to the open world, with svn, you end up with two options:

You host it yourself on a dedicated server
You have it hosted on either a paying site or for free (e.g. on SourceForge or Google Code)

I've been using the first solution for a while (got a dedicated server running in my closet with a dynamic dns), but I was at a point where I wanted to allow faster access to the repository. I host sample code that I give to my students, and when they're all accessing the files at the same time, my internet connection is just not enough. On the other hand, I have a web host, so I figured this is where the repository should be. Except, my web host does not support subversion.

Why Bazaar

Bazaar is lightweight and decentralized. That's what caught my attention. It's meant to be used as a distributed version control tool - meaning it can be used in a decentralized manner. You checkout a branch anonymously, you work in it, you can commit changes to your local branch. Once you're done, you can push back to the remote branch. Or, you can have other people checkout from your local branch and they can work on their side. The best part (as far as I was concerned): pushing a branch can be done over sftp, pulling a branch can be done over http. The server does not need to know anything about Bazaar. For instance. You have a server on which you have ssh access and a web page (e.g. at school).

Basics

You can create a new repository with a cpp file in it:

1
2
3
4
5
6
7
8
9
10
11
12

$~>mkdir myproject
$~>cd myproject
$myproject>bzr init
Created a standalone tree (format: pack-0.92)
$myproject>ls -a
. .. .bzr
$myproject>touch main.cpp
$myproject>bzr add main.cpp
adding main.cpp
$myproject>bzr ci main.cpp -m "my first revision"
added main.cpp
Committed revision 1.

Notice the .bzr directory where Bazaar will keep information about this repository. Then, you'll want to host this branch on your remote server. You do that by pushing your branch:

1 2	$myproject>bzr push sftp://mylogin@myserver.com/~/public_html/mybzrdir Pushed up to revision 1.

If mybzrdir is accessible from the web, people can now checkout (bzr calls it branching) from your repository:

1
2
3
4

$~>bzr branch http://myserver.com/~mylogin/mybzrdir
Branched 1 revision(s).
$~>ls -a mybzrdir/
. .. .bzr main.cpp

There you go. You have a local branch of your remote repository (the server branch). You can work in it, even commit changes (bzr ci) and eventually, diff from the original branch and send the patch to the owner or, if you have access to the server branch, push it back with your local changes.

Identifying yourself

Since Bazaar works anonymously, you'll want to identify yourself when you make changes to the branches. This is slightly different from most other revision control tools that I've used where you have an explicit login which is used both for access and identification. Anonymous access with the other tools that I've used meant you had a dead branch. You could still updated it, but you could not commit your changes. With Bazaar, you can work in your local branch, even if it was checked out anonymously. When you are about to commit changes, you use the "whoami" command to tell who you are:

1
2
3
4

$myproject>bzr whoami "John Doe "
$myproject>bzr whoami
John Doe
$myproject>bzr ci -m "my changes"

By default, whoami will try to use the name associated with your login. This is usually fine, but the email it will guess is most likely not the one you want to use (e.g. you@localhost).

Installing

Local Install on a Web Host

Here are the steps that I followed to install bzr locally (in my user directory without root access) without using gcc. Although you do not need to install it on your server, I still wanted to. The reason being that I cannot find any decent cgi that will let me browse the content of my bzr repository from the web. The easiest way is to install bzr and have it used by a script query and stat your repository from your web page. So again, you do not need to install bzr on the server (for me, that was the whole point of using Bazaar in the first place). Still here's how I got it to install:

1. Log on to Your Server

1	ssh myserver

2. Get the Source

The source code is available from theBazaar Download page at http://bazaar-vcs.org/Download. Under "Source of the stable release for any platform", you'll find a link to the source code:

1
2
3
4
5

$server:~>mkdir bzr-temp
$server:~>cd bzr-temp
$server:bzr-temp>wget http://launchpad.net/bzr/2.0/2.0.5/+download/bzr-2.0.5.tar.gz
$server:bzr-temp>tar -zxvf bzr-2.0.5.tar.gz
$server:bzr-temp>cd bzr-2.0.5

3. Compile the Source Locally Without gcc

My server does not give me access to gcc (they don't really want me to start programming on the web server, I guess installing custom software, even locally, is borderline...). Usually, to install locally (in $HOME), you'd simply run the following command:

1	$server:bzr-2.0.5>python setup.py install --home $HOME

But in this case, I ended up with

1
2
3
4
5
6
7

gcc -pthread -fno-strict-aliasing -DNDEBUG -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fPIC -I/usr/include/python2.4 -c bzrlib/_annotator_pyx.c -o build/temp.linux-x86_64-2.4/bzrlib/_annotator_pyx.o
unable to execute gcc: Permission denied

Cannot build extension "bzrlib._annotator_pyx".
Use "build_ext --allow-python-fallback" to use slower python implementations instead.

error: command 'gcc' failed with exit status 1

Since gcc cannot be used, we'll have to run the "slower" python implementation. This was achieved by adding the suggested arguments:

1	$server:bzr-2.0.5>python setup.py install --home $HOME build_ext --allow-python-fallback

This compiled and installed successfully.

4. Set the PYTHONPATH Environment Variable

Running "bzr" from the command line, I'd get the following error:

1
2
3
4
5
6
7
8

$server:~>bzr
bzr: ERROR: Couldn't import bzrlib and dependencies.
Please check the directory containing bzrlib is on your PYTHONPATH.

Traceback (most recent call last):
File "/home2/enseed/bin/bzr", line 107, in ?
import bzrlib
ImportError: No module named bzrlib

All you need to do is add the path to your local python libraries to the PYTHONPATH environment variable. This can be done in your .bashrc by adding an export directive

1	export PYTHONPATH=~/lib64/python/

(in your case, it might be at some other place than lib64, check it up) Or, simply define the variable when you execute bzr:

1	$server:~>PYTHONPATH=~/lib64/python/ bzr

Installing on Mac OS X

I used fink to install bzr on mac:

1 2	$~>fink install bzr-py25 $~>fink install paramiko-py25

I did not install bzr-py26 becase paramiko, which is used by bzr for for ssh connections, was not available (at the time of this writing) for python 2.6.

Installing on Ubuntu

On Ubuntu, it was relatively painless to install:

1	$~>sudo apt-get install bzr

Automatic login into WordPress

petit — Mon, 03 Aug 2009 13:15:07 +0000

To make a WordPress private, it seemed like using an .htaccess would be the most straight-forward and secure approach. However, you end up having to type in your username name and password twice - once to get access to the web page (web server authentication) and once more to log into WordPress. I googled a bit and ended up on this post by Leon Bukhman. In his case, he wanted automatic login to a "guest" account. I changed the code a bit and got it working with the REMOTE_USER environment variable (this is set by the webserver). The full PHP script for WordPress is available at

http://bazaar.enseed.com/utils/wordpress/plugins/autologin/

You still have to create two accounts:

An entry in the .htaccess file for logging
An account with the same username for the WordPress.

When you log into the website, you will be logged into WordPress with the same username. You can still log-out of WordPress (you'll be directed to the login page) and log-in with a different name (e.g. admin). Here's the script for the plugin:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Loading Images using QuickTime

petit — Sat, 01 Aug 2009 18:25:56 +0000

QuickTime can be used to open a variety of image files on Mac OS and Windows. I have put together a simple C++ class that will open image and read image files. By default, QuickTime will read jpeg, tiff, png, gif, bmp, targa, sgi, pdf (first page) and others such as JPEG 2000 (depending on the version and on what components are installed). Basically, here is how you can proceed to open an image with QuickTime:

Initialize QuickTime

1
2
3
4
5
6
7
8

OSStatus err = noErr;
#ifdef _WIN32
err = InitializeQTML(0); // on windows, call InitializeQTML first
if (err) return err; // QuickTime is probably not installed
#endif // _WIN32

err = EnterMovies();
if (err) return err; // Failed to initialize QuickTime

Obtain a Graphics Importer ComponentInstance

Opening an image file happens in two steps. First find an image importer within QuickTime, then process the file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

OSStatus OpenQuickTimeImageFile(const char *path)
{
//--------------------------------------------------------------------------
// Obtain a file reference
#ifdef _WIN32
const CFStringBuiltInEncodings kNativeEncoding = kCFStringEncodingWindowsLatin1
#else
const CFStringBuiltInEncodings kNativeEncoding = kCFStringEncodingMacRoman;
#endif // _WIN32

CFStringRef cfPath = CFStringCreateWithCString(kCFAllocatorDefault, path, kNativeEncoding);
Handle dataRef = NewHandle(sizeof(AliasHandle));
OSType dataRefType;

OSStatus err = QTNewDataReferenceFromFullPathCFString(cfPath, kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
CFRelease(cfPath);

//--------------------------------------------------------------------------
// Find the image importer

ComponentInstance fileImporter;
err = GetGraphicsImporterForDataRef(dataRef, dataRefType, &fileImporter);
DisposeHandle(dataRef);

Obtain Image Information

Once the image importer is found and loaded, information about the image can be obtained from the image description:

1
2
3
4
5
6
7

ImageDescriptionHandle imageInfo = (ImageDescriptionHandle)NewHandle(sizeof(ImageDescription));
err = GraphicsImportGetImageDescription(fileImporter, &mImageInfo);

int width = (**imageInfo).width;
int height = (**imageInfo).height;

DisposeHandle((Handle)imageInfo);

Load the Image

Finally, loading the image has to be done within a GWorld:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Rect bounds;
bounds.left = 0;
bounds.top = 0;
bounds.right = width;
bounds.bottom = height;

int bpp = 4; // bytes per pixel
int rowBytes = bpp*width;
unsigned char *data = new unsigned char[height*rowBytes];

GWorldPtr buffer = NULL;
err = QTNewGWorldFromPtr(&buffer, k32RGBAPixelFormat, &bounds, NULL, NULL, 0, data, rowBytes);

err = GraphicsImportSetGWorld(fileImporter, buffer, NULL);
err = GraphicsImportDraw(fileImporter);

DisposeGWorld(offscreenBuffer);
CloseComponent(fileImporter);
}

Special Case - 8bit Grayscale Images

In case you are reading an 8 bit grayscale image (with k8IndexedPixelFormat or k8IndexedGrayPixelFormat instead of k32RGBAPixelFormat), you have to know that QuickTime uses a color table that's inverted (black is 255 and white is 0). One option is to invert the grayscale image after it has been drawn in the gworld (i.e. data[i] = 255-data[i];) but a more efficient way is to provide QuickTime with a correct color table before drawing in the GWorld:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

if (format == k8IndexedPixelFormat) // we're in 8 bit grayscale
{
// the default color table is inverted, so let's create
CTabHandle grayCTab = GetCTable(40);// gray clut ID = color clut ID +32

// invert the default color table
for (int i = 0; i < 256; ++i)
{
(**grayCTab).ctTable[i].rgb.red = ~(**grayCTab).ctTable[i].rgb.red;
(**grayCTab).ctTable[i].rgb.green = ~(**grayCTab).ctTable[i].rgb.green;
(**grayCTab).ctTable[i].rgb.blue = ~(**grayCTab).ctTable[i].rgb.blue;
}

err = QTNewGWorldFromPtr(&buffer, k8IndexedPixelFormat, &bounds, grayCTab, NULL, 0, data, rowBytes);
DisposeCTable(grayCTab);
}
}

Loading Images under Windows (an OLE Image Loader)

petit — Sat, 01 Aug 2009 18:25:22 +0000

OLE can be used to open a few of image file formats (JPEG, BMP, GIF but no PNG) on Windows. I have put together a simple C++ class that will open image and read image files. Basically, here is how you can proceed to open an image with OLE (this is actually inspired from this codeproject article):

Obtain an IStream Pointer

Load the file into global memory and create an IStream*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// open the file
HANDLE hFile = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);

// allocate storage to read the file
DWORD dwFileSize = GetFileSize(hFile, NULL);
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwFileSize);
LPVOID pvData = GlobalLock(hGlobal);
DWORD dwBytesRead = 0;

// read the file
BOOL bRead = ReadFile(hFile, pvData, dwFileSize, &dwBytesRead, NULL);
GlobalUnlock(hGlobal);
CloseHandle(hFile);

// create the IStream* from the global memory
LPSTREAM pstm = NULL;
HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pstm);

Import with OleLoadPicture

1 2	LPPICTURE picture; hr = ::OleLoadPicture(pstm, dwFileSize, FALSE, IID_IPicture, (LPVOID *)&(picture));

Obtain Image Information

Once we have obtained the PICTURE object, we can query its size:

1
2
3
4
5
6
7
8
9

long hmWidth = 0, hmHeight = 0;
picture->get_Width (&hmWidth);
picture->get_Height(&hmHeight);

HDC Screen = ::CreateCompatibleDC(0);

int width = MulDiv(hmWidth, GetDeviceCaps(Screen, LOGPIXELSX), HIMETRIC_INCH);
int height = MulDiv(hmHeight, GetDeviceCaps(Screen, LOGPIXELSY), HIMETRIC_INCH);
::DeleteDC(Screen);

Load the Image

Finally, loading the image has to be done within a custom DC:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

HDC hDC = CreateCompatibleDC(0);

BITMAPINFO bmInfo = {0};
bmInfo.bmiHeader.biSize = sizeof(BITMAPINFO);
bmInfo.bmiHeader.biSizeImage = 0;
bmInfo.bmiHeader.biPlanes = 1;
bmInfo.bmiHeader.biBitCount = 32; // or 24 if you don't care about alpha
bmInfo.bmiHeader.biWidth = width;
bmInfo.bmiHeader.biHeight = height;

unsigned char *pixels;
HBITMAP bm = CreateDIBSection(hDC, &bmInfo, DIB_RGB_COLORS, (void**)&pixels, NULL, 0);
HGDIOBJ old = SelectObject(hDC, bm);

RECT rc;
rc.left = 0;
rc.top = 0;
rc.right = width;
rc.bottom = height;

HRESULT hrP =
picture->Render(hDC, 0, 0, width, height, 0, hmHeight, hmWidth, -hmHeight, &rc);

BITMAP b;
SelectObject(hDC, old);
GetObject(bm, sizeof(b), &b);
int rowLength = b.bmWidthBytes;

// allocate a buffer
unsigned char *data = new unsigned char[width*height*4];

// load the texture into the data buffer
GetBitmapBits(bm, b.bmHeight*rowLength, data);

DeleteObject(bm);
DeleteDC(hDC);

Special Case - Loading Alpha Correctly

Older BMP did not support 32 bit with alpha channel. Support for an alpha channel was added in XP I believe. As a consequence, some BMP have been written as 32bit with an unused (at the time) alpha channel that's completely transparent. If you plan on using the alpha channel from the BMP files, it's generally a good idea to check if the entire alpha channel is transparent. In such a case, we would assume that the entire channel should make it fully opaque. This is what the following piece of code does:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// scan to check if the alpha is all transparent
bool allTransp = true;
unsigned char *row = data;

for (int y = 0; allTransp && y < b.bmHeight; ++y)
{
for (int x = 0; allTransp && x < b.bmWidth; ++x)
{
int a = row[x*4+3];
if (a != 0)
allTransp = false;
}
row += rowLength;
}

if (allTransp)
{
// if everything is transparent, make everything opaque
row = data;
for (int y = 0; y < b.bmHeight; ++y)
{
for (int x = 0; x < b.bmWidth; ++x)
{
row[x*4+3] = 255;
}
row += rowLength;
}
}

Fast Fourier Transform in C++

petit — Sat, 01 Aug 2009 18:24:32 +0000

To download:

1	bzr branch http://bazaar.enseed.com/lib/Generic/ look under Math/Fourier.h

This class is a work in progress. It works fine as it is, for most transforms I do are real->complex, and only half of the transform needs to be computed in such a case. So I plan on modifying this code eventually to deal with this case and save half of the computation time. This started when I needed a Fast Fourier Transform that was not GPL'ed. If you can deal with a GPL license, by all means useFFTW instead. In my tests, FFTW is about 35% faster than the current code for vectors size between 1 and 65536. There is still room for improvement in the current code though, as I mentioned above, it's a work in progress...

Forward Transform

Performing a forward transform is done like this:

1
2
3

std::complex<double> data[SIZE];
Fourier::forwardTransform(data, SIZE); // if you don't know SIZE at compile time
Fourier::forwardTransform<double, SIZE>(data); // if you know SIZE at compile time

Expect the second version (where you know SIZE at compile time) to be 2 to 10 times faster than the other (don't foget to turn on compiler optimizations - they will make a huge difference, especially code inlining). The transform is performed in-place

Reverse Transform

Performing a reverse transform is done like this:

1
2
3

std::complex<double> data[SIZE];
Fourier::reverseTransform(data, SIZE); // if you don't know SIZE at compile time
Fourier::reverseTransform<double, SIZE>(data); // if you know SIZE at compile time

Scaling

This is important. The discrete Fourier transform reads like this:

And the reverse discrete fourier transform:

I don't compute the one-over-square-root-of-n term () because often, we don't really care about actual values, but about the distribution. This means however, that the data will be scaled when you do a forward-reverse transform and you have to scale down it yourself:

1
2
3
4
5
6
7
8
9
10
11
12
13

double factor = 1.0 /= sqrt(SIZE);
std::complex<double> data[SIZE];
Fourier::forwardTransform<double, SIZE>(data);
***> for (int i = 0; i < SIZE; ++i) data[i] *= factor;

Fourier::reverseTransform<double, SIZE>(data);
***> for (int i = 0; i < SIZE; ++i) data[i] *= factor;

// Or, sometimes you can wait until the end to scale
double factor2 = 1.0 /= SIZE;
Fourier::forwardTransform<double, SIZE>(data);
Fourier::reverseTransform<double, SIZE>(data);
***> for (int i = 0; i < SIZE; ++i) data[i] *= factor2;

If you think my recursive templates are overkill and you're a pure C fan, think again. Making a template-recursive LU decomposition or Fourier transform is not only fun, it's fast. The Fourier transform here is based on a standard Cooley-Tukey algorithm and it comes in two flavours. You can either call:

1
2
3

std::complex<double> *myData = new std::complex<double>[size];
// ...
Fourier::forwardTransform(myData, size);

or, if you know the size of your vector at compile time (which is often the case), for example, say size = 1024:

1
2
3

std::complex<double> *myData = new std::complex<double>[1024];
// ...
Fourier::forwardTransform<double, 1024>(myData);

Cooley-Tukey is recursive - meaning it will find coefficients for the transform for a vector of size N by solving for a vector of size N/2. The naive implementation could use recursive functions, but get a lot of overhead if you don't inline. If you inline, or if you build a single function which loops, you have less overhead, but you still end up with loops that will have very small iterations (e.g, for (i = 0; i < 4; ++i) ...) and there is still a lot of overhead in the loop. Still, this is the most common implementation you'll find of the Cooley-Tukey algorithm. One possible way to gain speed is to unroll the loop, but it's not easy since the repetition of the loop might be as small as 1 or 2. My solution was to have the size of the loop as a template parameter. The compiler knows how many iterations there are, and it will unroll the loop for you. Additionally, you can unroll small transforms and remove the loop completely. It's the same algorithm in the end, you just have far less overhead If you're not convinced with the theory, here are the timings to compute various Fourier transforms. One version uses the naive loop approach you'll find all over the internet, the other uses recursive templates:

The speed gain decreases as the size of the vector grows (it's normal since the overhead becomes less and less important). In my case, I work mostly with images and I'll rarely use vectors larger than 2048. For that size, the recursive-template implementation is more than 4 times faster...

LU Matrix Decomposition in C++

petit — Sat, 01 Aug 2009 18:24:03 +0000

To download:

1	bzr branch http://bazaar.enseed.com/lib/Generic/ look under Geometry/LUDecomposition.h

A LU decomposition decomposes a matrix M into a Lower and Upper matrix pair such that L×U=M. This representation is useful in many ways - for example, it's easy to solve (L×U)x = b. (for more info, see LU Decomposition on Wikipedia or LU Decomposition on MathWorld. This particular implementation uses the Matrix class and the same philosophy. Since our matrix class has the size specified as a template parameter, the LU decomposition knows the size of the matrix at compile time. Like most LU decomposition algorithms, it will use a recursive method (For a NxN matrix, first solve for a (N^-1)xN matrix...) except that this is done here using recursive templates. The compiler can thus generate the entire unrolled decomposition.

Decomposing a Matrix

Decomposing a matrix in its LU pair is done like this:

1
2
3
4

Matrix4d m;
Matrix4d l, u;
LUDecomposition::decompose(m, &l, &u);
// l is now a lower matrix, u is an upper matrix, l*u = m

Solving Mx=b

You once you have a LU pair, you can solve Mx = b = (L×U)x = b:

1
2
3

Matrix xb; // set this to b initially, you'll get x after
LUDecomposition::solve(l, u, &xb);
// xb now holds x

Matrix Inverse

In the previous example, x and b were vectors (or 1x4 matrices), but they could be nx4 matrices. For example, say we have MX =B where X = M^-1 and B = I, solving for X would be solving for the inverse of our matrix M:

1
2
3

Matrix4d inverse = Matrix4d::identityMatrix(); // set this to b initially, you'll get x after
LUDecomposition::solve(l, u, &xb);
// xb now holds x, which is the inverse of m (or l*u)

Being More Robust

Sometimes, matrices won't be well formed and the LU decomposition will generate large numerical errors. One way to prevent this is to solve for LU = PM where P is a pivot matrix (it changes the orders of the rows in M. When the ultimate goal is to use the decomposition to solve a system, we can live with this solution and obtain better precision:

1
2
3
4
5

Matrix4d m;
Matrix4d l, u;
Point4i p; // pivot
LUDecomposition::decompose(m, &l, &u, &p);
// we now have l*u = p*m.

Now, instead of solving Mx = b, we'll have to solve for PMx = Pb = LUx. In other words, we have to solve for Pb instead of just b. Say we want to inverse our matrix like in the previous example:

1
2
3
4
5
6
7
8
9

Matrix4d pivotMatrix = Matrix4d::zeroMatrix();
for (int i = 0; i < 4; ++i) pivotMatrix[i][p[i]] = 1;

Matrix4d xb = Matrix4d::itentityMatrix(); // this is b
xb = pivotMatirx * xb; // this is Pb

LUDecomposition::solve(l, u, &xb);

// xb is now x, which is the inverse of our matrix

Quaternion Class

petit — Sat, 01 Aug 2009 18:23:28 +0000

To download:

1	bzr branch http://bazaar.enseed.com/lib/Generic/ look under Geometry/Quaternion.h

I used quaternions mainly for rotations around an axis (for example, to implement a trackball that doesn't suffer from the gimbal lock like matrix-based trackballs do).

Rotation of Points Around an Axis

Rotation around an axis is done in three steps. First you create a quaternion q based on the axis and angle of rotation that you want. Then, you create a quaternion pt that will act as the point that you want to rotate. Finally, you multiply: q*pt*q.inverse(). You have to take extra care that the axis that you supply is a unit vector. You will then obtain a unit quaternion, and instead of taking q.inverse(), you can use q.unitInverse() which is faster.

1
2
3
4
5
6
7
8
9
10
11

Point3d axis = Point3d(1.0, 1.0, 0.0).normalized();
Quatd q(axis, 2*M_PI/9); // 40 degrees

Quatd pt(0, 1, 0, 0); // w = 0, x = 1, y =0, z = 0

// do a 360 around the axis
for (int i = 0; i < 9; ++i)
{
pt = q*pt*q.unitInverse();
printf("(%f %f %f)\n", pt.x, pt.y, pt.z);
}

Executing the above code, you should obtain:

1
2
3
4
5
6
7
8
9

(0.883022 0.116978 -0.454519)
(0.586824 0.413176 -0.696364)
(0.250000 0.750000 -0.612372)
(0.030154 0.969846 -0.241845)
(0.030154 0.969846 0.241845)
(0.250000 0.750000 0.612372)
(0.586824 0.413176 0.696364)
(0.883022 0.116978 0.454519)
(1.000000 0.000000 -0.000000)

Obtaining a Rotation Matrix from a Quaternion You can also choose to work with matrices instead and convert a quaternion to a 3x3 or 4x4 matrix:

1
2
3
4
5
6
7
8
9
10
11
12
13

Point3d axis = Point3d(1.0, 1.0, 0.0).normalized();
Quatd q(axis, 2*M_PI/9);
Point4d pt(1.0, 0.0, 0.0, 1.0); // x = 1, y = 0, z = 0 (homogeneous w = 1)

Matrix4d m;
q.to4x4Matrix(&m);

printf("rotation matrix:\n %s\n", m.serialize().c_str());
for (int i = 0; i < 9; ++i)
{
pt = m*pt;
printf("(%f %f %f)\n", pt.x, pt.y, pt.z);
}

And you obtain the following output

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

rotation matrix :
{
{ 0.8830221891, 0.1169777811, -0.4545194805, 0.0000000000 }
{ 0.1169777811, 0.8830221891, 0.4545194805, 0.0000000000 }
{ 0.4545194805, -0.4545194805, 0.7660444379, 0.0000000000 }
{ 0.0000000000, 0.0000000000, 0.0000000000, 1.0000000000 }
}
(0.883022 0.116978 0.454519)
(0.586824 0.413176 0.696364)
(0.250000 0.750000 0.612372)
(0.030154 0.969846 0.241845)
(0.030154 0.969846 -0.241845)
(0.250000 0.750000 -0.612372)
(0.586824 0.413176 -0.696364)
(0.883022 0.116978 -0.454519)
(1.000000 -0.000000 0.000000)

Concatenating Several Multiplications

You can concatenate several multiplcations by simply multiplicating your rotation quaternions together. It's important to make sure that each quaternion is a unit quaternion though. If you created them with a unit axis, it should always be the case.

TrackBall Class (with no Gimbal Lock)

petit — Sat, 01 Aug 2009 18:22:47 +0000

To download:

1	bzr branch http://bazaar.enseed.com/lib/Generic/ look under Geometry/TrackBall.h

A trackball is useful when you display 3D objects and want to let the user change the position of the camera around an object by click-and-dragging the mouse. A trackball simulates a 3D ball in the scene, and rotates as though the user was dragging a point on the surface of sphere. Here is how to trackball computes the rotation:

find the line between the click point and the current point
find the position of these points on the virtual sphere
find the axis of rotation (it is perpendicular to the two points' line)
estimate the angle of rotation based on the distance of the two points on the sphere
represend that rotation using a quaternion. This quaternion can then be used to extract a rotation matrix.

It's quite trivial to use. Say you have a 640x480 window. You would create a TrackBall with radius 240 and a center at (320, 240):

1 2	// create the trackball TrackBall trackball(240, Point2f(320.0f, 240.0f));

When you get a "mouse down" event, you'd tell the trackball to begin tracking:

1
2
3
4
5

// we had a mouse down
void MouseDown(Point2f mousePos)
{
trackball.beginTracking(mousePos);
}

Finally, when the mouse is dragged, you update the trackball and extract the rotation

1
2
3
4
5
6
7
8
9

// we had a mouse drag event
void MouseDrag(Point2f mousePos)
{
Quatf q = trackball.track(mousePos);
Matrix4x4 rotMatrix;
q.to4x4Matrix(&rotMatrix);

// rotMatrix now holds a rotation matrix for our view or object
}

If you are doing OpenGL, you can use this matrix to change your view:

1
2
3
4
5
6
7
8
9

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// setup your view here
// ...

// multiply with our rotation matrix. We have
// to transpose since OpenGL uses column vector matrices
// while we use row vector matrices...
glMultMatrix(rotMatrix.transposed().ptr());