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

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

Here is screenshot of the dialog:

Here is a Julia fractal generated by Arthur:

You can get the sources from here: fractal011

You can download Arthur here: fractal010

I also wanted to add some feedback about the drawing in case it takes longer time. I added a slot to ArthurCanvas which redraws the image from the fractal data. The I added a signal to ArthurFractal, which is connected to that slot. This way I can send signals to the canvas  while calculating. I send the signal four times in a session. Maybe later I add some possibility to the ui to change this number.

You can get the source from here: fractal009

OK. So I added the icons to buttons, and had some action signals generated by the menu item and icon interactions. All what I had to do is to connect them to some slots which do something sensible. First of all I wanted to have image saving possibility. When the user clicks the corresponding icon the program should check whether we already have a filename. If yes, we save the file. If not we pop up a save as dialog.

The easiest place for the signal connection would be the ui class, but that is generated so I didn’t want to mess up with that. So, I created a new class for event handling: ArthurActions. It is in the arthur_actions.h file. The class is inherited from QObject in order to introduce slots. So far I added two slots: onSaveImageAs and onSaveImage. I also added a private pointer to the ui and its setUi method, since I need access to the ui elements when handling ui events. E.g. in this case I need access to the pixmap of ArthurCanvas if I want to save it. When adding signals and/or slots you have to use the Q_OBJECT macro. See my former post about the nightmare it can cause eh eh. Especially when you are stupid like me

You can check the implementation of the class in arthur_actions.cpp. You will be surprised how simple it is. Saving the pixmap is the following with QT:

ui->label->pixmap()->save(imageFileName);

The file extension in the imageFileName controls the file format. I checked *.png *.xpm *.jpg *.bmp *.tif so far. All works. I start to like QT OK. Forgetting the vtable game will take long time but this compensates somewhat. I also like the ready made QFileDialog. Really cool.

Whe the implementation was ready I just connected the ui signals to the ArthurCanvas slots in main.cpp and that is it.

Here is an example JPG which I saved with Arthur:

You can download the sources from here: fractal008