OK. To make the boring stuff a bit more interesting I decided that I will store the fractal data in XML format. There is no particular reason for that apart from the fact that I am a great fan of XML. However it was a good opportunity to have a look at the XML library in QT. Yeah, nothing special. The usual stuff. If you used other XML libraries before, everything will be familiar.

While thinking what data I should actually save I faced a problem with the palette. Actually I was thinking whether I should save the palette or just a reference to the palette file. Finally I decided to put the palette to the fractal description file. This way it is easier it share fractal files, since everything is packed to one file. As a side effect I introduced a very simple XML format for the palette and added a new feature to Arthur that one can load the palette of a fractal.

From now on I will not develop Arthur further until someone starts begging to me to do so I admit there might be lots of design issues with it (it wasn’t actually designed eh eh) and it is far from industrial quality, but it was not the aim. I learned quite much about QT while I was making it and I hope some parts of it can be used as examples to solve your problems.

You can get the sources from here: fractal017

My newton fractals are colored according to the number of necessary iterations to get in a predefined distance with z from one of the roots.

The newton001 fractal is using the f(z) = z^3 – 1 polynomial.
f’(z) = 3z^2

z -> z – f(z) / f’(z) = z – (z^3 – 1) / 3z^2 = (2z^3 + 1) / 3z^2

The roots of f(z) are: 1, -0.5 + 0.86603i and -0.5 – 0.86603i

Here is an image of the fractal:

The newton002 fractal is using the f(z) = z^4 – 1 polynomial
f’(z) = 4z^3

z -> z – f(z) / f’(z) = z – (z^4 – 1) / 4z^3 = (3z^4 + 1) / 4z^3

The roots of f(z) are: 1, i, -1 and -i

Here is an image of the fractal:

You can get the newest sources of Arthur from here: fractal016

Don’t panic!

Usually this error pops up when you have a moc compiler related error. The moc compiler is a QT compiler tool. QT is extending the C++ language by some macros and non C++ language elements like signals slots etc. In order to compile the QT programs with a C++ compiler, these files which contain non C++ elements need preprocessing. The moc compiler should find and process all header files which has QT specific stuff especially signals and slots.

First thing to try:

make clean
manually remove all generated files especially which has suspicious ‘moc’ in their names if make didn’t do that
rm Makefile
qmake
make

OK if the problem still exist, check the project file (*.pro)

Make sure that all header files which contain classes with signals and slots are added to the HEADERS qmake variable. E.g.:

HEADERS += myheaderwithsignalsslots.h \
otherheaderwithsignalsslots.h

Make sure these header files are in the include path. You can add your include directory to the INCLUDEPATH qmake variable. E.g.:

INCLUDEPATH += . ./include

Now try to compile again:

make clean
manually remove all generated files especially which has suspicious ‘moc’ in their names if make didn’t do that
rm Makefile
qmake
make

If the problem still exist, check the header file itself which contains the class in question. Make sure that the class is actually defined in a header file and not in a cpp!

Every class which has signals and slots has to be inherited from QObject directly or indirectly.

Right after the opening curly bracket you should include the Q_OBJECT macro. E.g.:

class ArthurCanvas : public QWidget
{
Q_OBJECT
…

If you have a class that is inherited from QObject but in this class you do not introduce new signals and/or slots you should not include the Q_OBJECT macro.

One more thing you can check if nothing helps. This will not solve the problem, but will help you to investigate. Check the Makefile that qmake generates:

rm Makefile
qmake

Open Makefile in a text editor and look for

compiler_moc_header_make_all:
and
compiler_moc_header_clean:
and the entries after these

They should have references related to your header file in question. E.g. if you had foo.h you should have moc_foo.cpp listed for compiler_moc_header_make_all. If it is not the case, than qmake did not find the header file or the header file has some problem and qmake thinks it does not need to be moc-ed…

Finally, I do not recommend to mess up with including moc generated stuff manually to your makefile unless you know what you are doing. If your project file is correct, qmake will generate a correct Makefile to you.
I hope these will help… Never forget your towel!

Here are the newest sources: fractal015

For each line I do the followings:

1. Simplify the line (white spaces converted to spaces)
2. Split the line to items at each space
3. Remove empty items
4. If we had at least three items remained, try to convert the first three items to integer numbers.
5. If all the three conversion went fine, add the color to the color table

If the file ends before we fill all the 256 colors, the loader fills the rest of the colors with black values.

If the file contains more than 256 color entries than the loader does not read further after the 256th color is loaded.

This way I can handle e.g. GIMP palette files (*.gpl) or anything that fulfills the rule of the algorithm above.

I added a palette folder to the sources and copied two palettes from GIMP as examples.

Here is a Julia fractal rendered with the Firecode.gpl palette:

You can get the sources from here: fractal014

Here is a screenshot about Arthur with its new palette buttons:

Here is an animated GIF. I saved the frames as PNG images from Arthur. I made one forward palette step before saving the next frame. Then I used GIMP to make an animated GIF from the PNGs.

You can get the sources from here: fractal013

I also changed the way of selection a bit. Now the point, where the mouse is pressed first will remain in the center of the selection. This way the user can center the most interesting part in the resulting picture.

Here is a screenshot:

There is no difference in appearance anyway

You can get the sources from here: fractal012

Sources are available here: qimage002

I started googleing around to find some simple examples for showing a QImage and drawing pixels on it with immediate feedback. No luck. Finally I ended up with the cannonfield tutorial coming with qt sources. It has a widget, and a bullet is drawn on the widget while it is moving. It does not use QImage, but good enough for seeing the widget basics, updates etc. So I started to modify it. I removed all unnecessary stuff. I added a QImage as a private attribute. In the paint event handler method I draw the QImage.

I decided to make a moving dot bouncing from the image borders as a demo. I kept the timer from the original example. I connected the timer event to a slot which handles the dot moving and rewriting.
I also simplified the main.cpp. I have only this one widget to show. I got it working pretty fast and the results are convincing. Now, I go on to introduce the selection feature what I used in ArthurCanvas and I also try indexed image instead of the RGB image of the current example.

You can get the sources from here: qimage001

Here is screenshot of the dialog:

Here is a Julia fractal generated by Arthur:

You can get the sources from here: fractal011