Welcome to Fractal Forums

Today I started to write my own fractal program, named FractKali  :D

My idea is to make a multi-formula 2D fractal generator, with the possibility of making combinations and some transformations, pretty much like Mandelbulb3D does, but only for 2D fractals and with a limited amount of formulas and transforms that I've been exploring lately.

I will use this thread for posts about progress, news, and future releases. Also I'd like to hear suggestions.

Once finished, this software will be available for everyone as freeware

Wish me luck!

Best of luck! Don't expect to sleep much. :)

Thanks, Ken! I hope that sleep deprivation and caffeine abuse don't kill me  ;D

I think the way the formula & transforms data will be displayed and entered should be really practical, allowing "infinite possibilities" of combinations ;)

The generation algorithm includes iteration count for each formula and configurable loops. Pretty much as Mandelbulb 3D "Repeat from here", but with the possibility of multiple loops with specific number of iterations. (Please note that the comparisons are about the interface and methods, but this is 2D and I can't even think of making something as great as Jesse's M3D!)

For Julias, I will implement a global parameter for all the formulas, and a parameter override on each one.

The _Exponentiation transform will serve for making mandala-like images, so this will be also the Mandala Generator program wich I said I was planning to do.

Just a quick preview of the sheet for data entry (columns without headers are formula specific params, the header text is displayed when editing or selecting the row)

No!!! Stop now, it's too hard and it's already plenty of every possible 2D, 3D, 4D fractal program already :dink:

(Good luck crazy boy ;D )

But first look at the image, and then tell me in wich program I can find such "Mandelbrot on Reals" + 2D Mandelbox combination :kissmyass:

Anyway, I feel honored for such a genius wishing me luck! Thanks!  :D

(Also you are pretty much crazier, but I have to admit my condition a bit  :headbatting:)

Indeed! A sign that somebody is still mentally okay somewhere! :-\ :tongue1: :tongue1:

 :rotfl:

@kali, what i think is still needed is a rule definition set, or a simple system to define hybrid combinations, i had once
different methods in mind, e.g. say one formula is taken:

default formula
[block]
 [start][end]3 mod itCount =0 formula1
 [start][end]3 mod itCount =0 formula1
 [start][end]5 mod itCount =0 formula2 ( the latter defined would get taken if same )
[/block]


something like this, i mean we need a general way to define how hybrid formulas can be described, in a way we cover most of the possible solutions with the possible settings,
i just mean, alternation is just one form how one could create a hybrid form out of existing formulas!

Sorry to lower the conversation to simpleton level, but please remember us mathematical braindeads when you're making this.   :dink:

@Christian, I'm doing only alternation at first, but I was also thinking of another forms of combinations. It's a good idea to have a rule for hybrid definitions. I'll keep in mind that, thanks!

@Erisian: Don't worry about that, I'll make it as intuitive and easy to use as I can ;)

What system are you writing for?

Linux?  Mac?  Windows?  Etc?


If it will have an option for putting image textures in orbit traps...

Well... you know!   :devil:

Best of Luck with the efforts.  If your brain melts and drips out your ears, don't worry.  It's normal. 

@kali to use images is easy, just make an formula that uses an image as input, and let it transform the input value by r/g values, either add or mul ;)

concerning the hybrid iteration definition i am looking forward to it, i must search my test program for it, i did post it in the forums ages ago ;)
but it had an attempt on how to visually define the iteration loop rules...

@Sock, to answer your question: Windows. Thanks for suggestion, one thing I want to implement is the coloring method that Fractal Ken uses frequently, wich is pretty much what Christian pointed, I think... but if you are talking about placing image samples directly into the fractals, mmm... I'm not sure :)

@Chris, please let me know if you find something when you have the time, thanks!

Well, I'll continue melting my brain... I'm using earplugs, just for the case :)

damn it the binary seems to be lost :(
this was the thread for the program, too bad no screenshots
http://www.fractalforums.com/general-discussion/experimental-release-of-fractalter-!/

the basic idea was to print it like a zoomable timeline, each formula represented with an real time rendered icon,
and those formulas could be "stacked" on the timeline with certain properties

damn it, i gotta go and write such a program .... needed to find somethin private programmin fun anyway ;) lets see what i can come up with...

That's ok, I found some useful info in that thread anyway! thanks!

And go start writing that! Maybe we can make a race to see who finish our self-made fractal software first ;) (just kidding)

I'd probably lost anyway, because I'm encountering some troubles as I'm not a very experienced programmer, but I think I will make it, sooner or later O0

Don't forget those formulas

; --- Samuel Monnier ducks. Never escapes (all inside)
z = real(z) + flip(abs(imag(z)))
z = log(z+pixel)

; --- Barnsley generalized
; --- default values re1=1, re2=0, re3=0, fac1=(1,0), fac2=(0,0), fac3=(0,0)
; symmode=false, bartype=0
if bartype==1
condition = real(z)*imag(c)*re1 + imag(z)*real(c)*re2
else
condition = real(z)*re1 + imag(z)*re2
endif
c = pixel

if condition  > re3
z = (z + fac1) * c + fac2
else
if symmode
c= conj(pixel)
endif
z = (z - fac1) * c + fac3
endif

If you need others ask :)
flip(z)=z*(0,1)
conj(z)=real(z) + flip(-imag(z))

This is the UF public database, you can also pick what you need. :dink:

http://formulas.ultrafractal.com/cgi/formuladb?browse

Thanks Luca!

I'm familiar with complex numbers formulas, as I use UltraFractal a lot... but the tricky part will be only using real variables, because I don't want to implement a complex number library (they a re also not needed for most of the formulas I will use). Can you help me, at least, with the Ducks formula using real variables?

Let me step in until Luca returns . . .

No!!! Easy handling of complex numbers is important for most traditional formulas.

If you must use only reals, here's a way to deal with the complex logarithm function for the ducks formula [I think :)].

Suppose z = (x, y) is complex. 
Let r = sqrt(x*x + y*y) and t = atan2(y, x). 
Then log(z) = (log(r), t).

Note 1: log(r) represents the usual natural logarithm operating on reals.
Note 2: The complex logarithm function isn't uniquely defined, but this method should provide the principal value.

Supporting links:
Principal value of the complex logarithm (http://en.wikipedia.org/wiki/Complex_logarithm#Definition_of_principal_value)
Polar form of a complex number (http://en.wikipedia.org/wiki/Complex_number#Polar_form)
Definition of atan2 (http://en.wikipedia.org/wiki/Atan2#Definition)

:no:

How can you think to write a fractal program that does not handle complex numbers? It's really impossible ;D

So be serious, go here http://www.cplusplus.com/reference/std/complex/ and back to work :tease:

Hey guys, don't be so upset!  :rotfl:

I think I know what I'm doing, just wanted a little help with log function, so thank you Ken!

This is not a very "traditional formula" software, and also I don't want to include a crazy amount of formulas, neither a lot of variations.
I want to do something a bit different, since, as Luca said well, there are plenty of freeware fractal programs available for traditional formulas and well known 2D fractals. I stated before that there will be a very limited amount of formulas availaible, but the way of doing combinations should make a good variety of results.

Also this isn't C++, Luca. It's VB.NET, so optimizing for speed will be very important. A while ago I tried using a complex class, just for Mandelbrot, when I wrote a very rudimentary render for "KaliLinComb" (before Jesse's implementation), and the perfomance was not good (I know, I know... I should use C++)

Let's see what happens... For the moment, I'm dealing with some issues in that DataGridView control, but I think I'm almost winning the battle.

Thanks for comments, I really appreciate them!

No, you should use Fortran. ;D There's a complex data type, so fractal arithmetic can be performed naturally. Just don't try to write a GUI!

Fortran will rise again. :laugh:

What about this (http://software.intel.com/en-us/forums/intel-visual-fortran-compiler-for-windows/)?

Or maybe this (http://es.wikipedia.org/wiki/Archivo:FortranCardPROJ039.agr.jpg) :D

Visual Fortran might actually be good for writing fractal software. I'm not at all familiar with it. (I use the free g95 (http://www.g95.org/docs.shtml) compiler.)

I used punched cards in the first computer science course I took in college. The programming language wasn't Fortran, but rather a PL/I (http://en.wikipedia.org/wiki/PL/I) dialect.

Why you fight against the milestones of informatics? ;)
I used Vb many times. Vb uses massively dlls and is the slowest language ever, whenever you need speed you lose your time :(
The only fast language is C, afaik, that naturally supports assembly :) and you can obtain awesomely fast routines
I tried to write a Win program in pure C but create an interface in C is too time consuming :)

As I said before, I'm not a very experienced programmer, I wrote mostly programs for handling databases, early with DOS Foxpro and Qbasic, then VB6 using SQL and lately VB.NET - I know some little C, but very little experience as I never really needed to implement something with it. So I'm not ready for writing this in C++,  and learning it will make me spend too much time now. Maybe some day I will do it, but as for now I'll try to make a decent program using VB, optimizing as much as I can. After all, this isn't 3D raytracing or such... also I'm using some tips & tricks, like not using standard methods for drawing to the screen as I agree they are really slow in VB.

Just trust me and wait...   :)

Didn't have much time today for coding, but thanks to Ken (and in spite of Luca's discouragement) I already implemented Ducks using only real variables with good results. I ran a test with a 2-color coloring method, just to check if patterns are right, and they are indeed :)
The original non-antialiased image is 3712 x 1500 pixels, and the rendering time was 45 seconds on my Phenom 9550. 
The number of iterations used for the formula were 25.

(http://img25.imageshack.us/img25/2742/fractkaliduckstest2.jpg)

I think I can do some more optimization, tough ;)

Looks good, Kali! I'm glad I was able to help.

Nice work, Kali!


Visual Basic is quite slow. There are some very fast basic compilers such as Powerbasic (for Windows) and Purebasic(for Windows,Mac and Linux)  These are not free however but produce fast and small executables. There is also a basic to c compiler bcx ( windows freeware).


Powerbasic and bcx use qbasic like syntax. If you also want to learn C then bcx is your choice since it ouputs c code. Purebasic outputs fasm asm code. I personally have used Powerbasic (since 1997)  but it is quite expensive.

http://bcx-basic.sourceforge.net/

So C is not the only fast language... ;D

Kali, let me suggest you choose the computer programming language that you find the easiest. A language such as VB.NET will not be much slower that C++, due to quite efficient modern JIT compilers. (The old VB6 was slow, but that was a completely different language).

Take a look at the Computer Language Shootout: http://shootout.alioth.debian.org/u32/benchmark.php?test=mandelbrot&lang=all
 - C/C++ is only about 33% faster than Java for a Mandelbrot. And a .NET compiled language like VB.NET will probably be around the speed as Java.
 
If you really are going for speed, you will want to (1) multithread your code, (2) use SIMD instruction (SSE/MMX), (3) or use the GPU.

@fractalmind: Thanks! I will look for the compilers you pointed, even when I think I should continue with VB.NET for this project, I will definitely try BCX as it will be useful for future projects that I have.

@Syntopia: Indeed, there's a huge difference in performance between VB6 and VB.NET, maybe this leads to confusion about how fast VB really is.
Off course still not the optimal for doing this, but I'll research about multithreading (one of the things you pointed), as I know that it can be done with VB.NET

Thanks both for the info & suggestions!  :beer:

http://www.devx.com/DevX/10MinuteSolution/20365 :dink:

Tante grazie, Luca!

I was already into this, but isn't as easy as it seems, at least for implementing here... there's too much restrictions in handling variables, and having too many variables and a huge array of data, I'm being forced to add complexity into the code or maybe adding public shared variables that slows downs each thread and don't make the difference against my already optimized single-threading solution (I optimized the original code a lot, about half the time required for rendering in full size the image I posted before)
I suppose I'm doing something wrong, tough...  :embarrass:.
I'll keep trying to figure out how to make multithreading fit well into this  :headbatting:

Thanks again,

Guys, I did some adjustements to original calculation and rendering method, and ran a comparison test without using multithreading (see images below).
Also I implemented an exponential smoothing coloring method for this, running exactly the same in UF5 (I used Sam's formula in sam.ufm)
Off course I disabled UF5's antialias.

So, after this results, I think I'm not going to get into the complications of threading as for now...
just wanted to see if speed could really be a problem with VB.NET and I guess Syntopia was right... :)

It seems that this might work after all, let's see what happens with combinations and such,
but It's a matter of optimizing carefuly each line of code and the use of variables in the calculation and rendering parts.
However, now I will focus on GUI... I have a lot of work to do yet!

IMAGES:

(http://img820.imageshack.us/img820/4964/duckscompareuf5.jpg)

(http://img849.imageshack.us/img849/4169/duckscomparekali.jpg)


TEST RESULTS:

(http://img709.imageshack.us/img709/1699/comparisonl.jpg)

:dance::dance::dance::dance::dance::dance::dance::dance::dance::dance::dance::dance:

Using winapi you can call CreateThreadEx, but it is hard to handle

http://www.purebasic.fr/english/viewtopic.php?t=34936 ^-^

Mmmm... not gonna get into that for now... speed is fine, as you can see.
Thanks anyway!

For comparison, if I run the Ducks fractal on a GPU such as the Nvidia 9800GTX with similar resolution (1250x750 at 25 iterations with 2x2 anti-alias), I get ~20 frames per second, or 50ms per frame.

I still think VB.NET is a perfectly fine way to proceed, though. You can build your GUI and fractal implementations, and, if you at some point want to go for speed, you can probably translate the fractal code to DirectX HLSL and control it from the VB.NET gui.

And btw, .NET has very nice threads (System.Threading) - no need for native winapi calls :-) For these kinds of systems, you should be able to get a speedup roughly propertional to the number on cores of your CPU.

Wow! that's really fast... I'll try speeding up either with m.threading or GPU but once the program is almost finished. I was worried about VB being too slow with normal code, but as I achieved UF5 speed I think I can continue this way, release a normal version once finished, and then look for the optimizations. Also I must buy a new card if I wish to test GPU, my 9600GT just melted :(

Thanks for the info!

Ok, I've posted some ugly b/w images that were only for testing purposes, so I wanted to show a sample image of what actually could be done.

This is a Julia of an hybrid that combines Ducks+Ballfold+Mandelbrot (should I call it "circle fold" in 2D?)

Still no color palette implemented, so I used PS to color the original monochrome image.

Hope you like it!

Full-size here (http://www.deviantart.com/download/205640943/strange_feelings_by_fractkali-d3eflkf.jpg)

(http://nocache-nocookies.digitalgott.com/gallery/6/3869_20_04_11_4_39_12.jpeg)

Very nice pattern.

Then we'd have to call a 2D mandelbox a mandelsquare.  :)

Thanks!


Why not? or Amazing Square! I think I'll use those names in the program :)

Formula combining in 2D - excellent idea!!!  Can't wait to get stuck into those Julias!  :happy:

Thanks, I wish I have more time for this, but be patient... I'll finish it sooner or later :)

I'm currently working on a dynamic interface that allows changing all parameters on-the-fly, previewing the results inmediately.
This is really important to help finding interesting things inside this hybrids that are very sensitive to small changes in params.
I will post more pics & info as I make some progress, any comments are truly appreciated!

Hi There ;D

Looks nice the preview .. have you a website for your projekt ?

Hi Bogus. No I haven't, I'll post related info, pics an news here in this thread.
Thanks for your interest!

Finally I managed how to use multithreading! The speed is nice, but I expected a little more, though. I think I must optimize the calculation method for alternating formula loops because they are the "bottleneck", as plain formulas or consecutive formulas works much faster.
Also I implemented a nice exploration interface, using only mouse buttons and shift key. I'm uploading a demo of how it works and I'll post it later.
I had some ideas for realtime parameter tweaking in the explorer window and I'm working on it. Once finished this interface, I'll focus on coloring.
I think I will be able to release the first beta (very beta) version in a couple of weeks... or maybe sooner if I can spend some more time on this!

This is the video to show how I implemented the way of "exploring" and moving around the set.
The formulas used here are very simple, just regular Mandelbrot mixed with the patterns of "Mandelbrot on real numbers", because it's not my intention to show the program's fractal generation potential in this video, just how the navigation mode is likely to be, and to receive some feedback on it. I wanted to show a well-known shape fo this preview, and also good for showing the Julia mode.
Also, as I'll take care of colors later, this is only b/w so not very suitable for really showing what's my program will capable to do (the images already posted were colored in photoshop, as I stated before). I'll post a new video after making some more progress on the GUI, and I'll show more complicated generation algorithms, with the posibility of tweaking "on the fly" all the params by using the mouse to fine-tuning them in order to get nice results.

http://www.youtube.com/watch?v=SJe4GCB7xtA&feature=youtube_gdata

Some details:

The default mode is "moving": just moving the mouse and left click to pan into the selected direction (the new center of the image will be the place where the arrow is pointing). For zooming, you have to press shift key, then size the zooming rectangle with shift pressed. Left click will zoom-in (makes the area of the rectangle the size of the whole previewing area), and right click to zoom-out (makes the previewing area the size of the selected rectangle).
For Julias, sustaining right click while moving will show a small preview of the resulting set, then releasing it to enter Julia mode of the selected parameters.

It's easy and very intuitive. Now I'm working on rotation of the image, and then I will make the toolbar for tweaking in real-time the parameters of all the formulas entered in the algorithm designing screen. I think this will be a cool feature.

Ok, enough talking, must keep working!

Excellent on the Julias.  I was going to suggest that, having used Fractal Studio for a while.  Finding Julia seeds can be difficult on a trial and error basis so a visual method is very useful.  I was also going to mention Sterling2's fractal dimension filter - how beautifully it renders the fractals.  I have only one criticism of Sterling2 - you can't create a simple Mandelbrot with it!  If I could produce a Mandelbrot with S2's fractal dimension setting, I would be extremely happy.  If you could create a filter like this, IMO you would have the ultimate fractal generator.

Actually, having watched your video, I think you are already on the way to the ultimate.  Keep up the good work Kali!.   :happy:

Here's something I don't believe other Fractal Generators have got - how about a formula writer for rendering modes (orbit traps, tentacles etc).  Users could submit their new formulas for inclusion in the next release leaving you free to concentrate on bug fixing and new features.

Thanks Erisian for your comments and suggestions. But believe me this is not going to be the "ultimate fractal generator" :)
I think it maybe will be still something nice and original, mainly because I'm looking more on features other programs doesn't have, and not in a crazy amount of features, coloring modes, formulas and so on. I want this to be something different, and pointed to specifics types of fractals and off course the combinations. Off course some things will be taked from other programs, tough, and I will look forward to that Sterling filter you mentioned to see what I can do ;)
Also the posibility of writing custom formulas or coloring methods is something I have in mind, and I will look later how I can do it.

Regards,

Never used ultrafractal? :D

Darkbeam - I never use commercial software when there's good freeware available.  Actually, I think Chaos Pro has the ability so I was probably wrong anyway.

Kali - OK, maybe not the ultimate, but it looks like you're going to have all the major functions that I like in a fractal generator.  Most of them just have one or two of those functions and formula combining will be something totally new in 2D as far as I am aware.  I'm looking forward to playing with it anyway!

Actually, my program won't be freeware. It will be "Darkbeamware", which means "free for everyone except Darkbeam" ;D


I hope I'll be able to satisfy your expectations!

I was a little away from the project in the last days, because of beign playing with my recent formulas, so the first beta release will be a little delayed. But the good part is that it will include this new "toys" I discovered ;)

Well you're working pretty quickly considering you've only been at it for one month.  The rendering in the video looks pretty good too.  I only hope I can do it justice when it comes out!   :toast:

Well, after some days of putting this project on stand-by I resumed today. Added my Kaliset formula (had to ask for permission to myself :D)
and this are some quick samples of combinations of it with Mandelbrot (Still using PS Gradients for coloring)

(http://img19.imageshack.us/img19/1125/fractkali2.png)

(http://img813.imageshack.us/img813/8591/fractkali1.png)

(http://img706.imageshack.us/img706/37/fractkali3.png)

(http://img28.imageshack.us/img28/8733/fractkali4.png)

(http://img850.imageshack.us/img850/9156/fractkali5.png)


As for the GUI, I'm rewriting some stuff I don't like much, before I continue to the more advanced part of the navi options and parameter tweaking.

A lot of work to do yet, but everything goes fine ;)

 Are you going to make him pay in custom-formulas ?¿? :D

That's a good idea! ;) - Or he can pay with just a little help... I'm looking on how to implement fractional complex powers and I don't want to bother my friend Fractal Ken again. But Luca is always very very busy, you know... no time for me  :sad1:

Feel free to "bother" :) me. I sent you a PM a few weeks ago about raising a complex number to a complex power. In case you've lost it . . .

**************************************************************************************************

Suppose c = (a, b) and z = (x, y) are complex.
Let r = sqrt(a*a + b*b) and t = atan2(b, a).
Let v = (r^x)*exp(-y*t) and w = y*log(r) + x*t.
Then c^z = (v*cos(w), v*sin(w)).

Note 1: You can factor v out of the last expression for improved efficiency.
Note 2: log(r) represents the usual natural logarithm operating on reals.
Note 3: c^z actually has multiple values, but I don't expect any practical difficulties.

Supporting link: Exponentiation - Computing complex powers (http://en.wikipedia.org/wiki/Exponentiation#Computing_complex_powers)

**************************************************************************************************

Are you looking for something different now?

Off course I received the PM, Ken! and I replied back to thank you... but to be honest I didn't put this into my program yet, I'm about to do it  :embarrass:
In fact, I almost didn't write any new code since then because I spent almost all of my "fractal time" available (that's equivalent to 50% of my very limited free time :)) in doing some researchs on formulas. That was fruitful, because I discovered "Kaliset" (with lots of variations), and also the simplified KIFS. Off course both formulas will have a 2D version included in my program (btw, I just realized that Jesse included the simple KIFS method in the last Mandelbulb3D release, in a formula named genIFS)

So now that I'm about to write the complex powers part, I also want to include fractional powers, including fractional complex powers. But I'm looking at the method you sent me, and could it be that I can use any fractional number in the calculation? and just set imaginary part to 0 if I want to raise a non-complex value to a non-complex fractional power?

That approach should work fine. However, if b = 0 or y = 0, it's possible to simplify the expressions and do the computation a little more efficiently. I have no time right now, but I'll look at this issue later today or tomorrow.

Kali, I was thinking I could find clever simplifications, but I haven't succeeded.

You can certainly use basic algebra to make computational improvements, though I'm not sure it's worth the trouble of dealing with special cases. For example, in the case y = 0 [complex number to a real power], you can use v = r^x and w = x*t.

I've been away from the net for a while.  How's it going Kali?

Hi and welcome back, Erisian. I was too busy in the last months, so no much progress yet :(

Thanks for your interest