Welcome to Fractal Forums

Hi

I was wondering if anyone's ever taken the starting image of the mandelbrot and generated a really large image of it.

This brings me to the next question which is: is there a maximum resolution of files such as bmp and if so what is it?

Obviously the size of the image would be restricted to available ram, or can some programs view huge image files by only decoding part of the image at a time.

How many iterations would be required to prevent the image from having large lakes due to reaching maximum iterations.

So many questions, not enough answers...  Please share your thoughts...

The reason this question has arisen is that I am creating a poster of a zoom into the mandelbrot at 19200x10800 (ten times the size of a Hi Def screen on a TV in both directions) in Fractal Extreme and it's taken over 2 and a half days so far (with AA on) with 700 lines still to go.

Simon

I suppose it does not make much sense, the biggest part of that image would be empty... :-\ The interesting parts of Mandelbrot are in some very specific spots at biiiig magnifications

Hi,

I remember someone posting here a very high resolution zoomable picture of the Mandelbrot set, but I can't find back the link. As DarkBeam said, doing this with the Mandelbrot set is a bit of an overkill, as most of the picture will be empty. However there are "dense" fractals, whose structures fill the plane, so that no matter where you zoom, new details appear. I have a few very large zoomable pictures of these on my website here:
http://algorithmic-worlds.net/expo/expo.php?Collection=Gigapixel&CollSearch=0
These images are 65536x65536 pixels and about 2GB each. Zooming applets such as
http://www.openzoom.org/
http://www.zoomify.com/
allow to split them into small tiles, so that people can explore them without having to download the full image.

Sam

Hello Sam!
I did a 3.3 Gigapixel image of the mandelbulb a couple of years ago: http://mandelwerk.com/

262144 by 262144 (black and white), which is approximately 62 gigapixels:

http://cp4space.wordpress.com/2012/09/09/big-mandelbrots/ (http://cp4space.wordpress.com/2012/09/09/big-mandelbrots/)

There's also a full-colour 65536 by 32768 image of the upper half plane, which (surprisingly) is a larger file (40 megabytes instead of 25).

I think I've got the largest one: 4 terapixels, 2097152 by 2097152 pixels (computed on the smoothed set, to an iteration depth of 65535)

http://fractals.dwscript.net/ (http://fractals.dwscript.net/)

It was meant as way to be able of interactively explore the set from a tablet or simple PC, since everything is pre-computed, exploring from an iPad with the fingers is quite comfortable.

It even comes with an API to request the pre-computed raw iteration depths (http://fractals.dwscript.net/documentation.dws (http://fractals.dwscript.net/documentation.dws)) so you can apply custom palettes or generated large images for prints.

The raw databases are also available, they're heavily compressed, but they're big, obviously (4 terapixel level on is 25.6 GB).

i just answered in your welcome posting, how long did you render it, how many single tiles are in there ?!

Yes, that's the plan eventually.


Not at that level of viewing size, precision and iteration depths, at least not on regular consumer hardware ;)
A fair share of the 256x256 tiles require several seconds of CPU time to compute in interesting areas.

A previous version just rendered everything on the fly server-side, but it had to be limited in terms of iteration depth, or wouldn't be interactive anymore.
For instance this was from the real-time version (384 iterations):
(http://cdn.delphitools.info/wp-content/uploads/2013/12/mandel_level_11_384.jpg)
and this is the same tile from the pre-computed version (65535 iterations)
(http://cdn.delphitools.info/wp-content/uploads/2013/12/mandel_level_11_64k.jpg)

At the deepest level, there are 8192 by 8192 tiles of 256 by 256 pixels, though half of those are mirrored (taking advantage of the symmetry), so that's effectively 32 million tiles, and about 75% are uniform (all pixels the same color).

In practice, 70% of the database size (all tiles are compressed) is taken by just 8% of the tiles, and 1% of the tiles are very chaotic (judging by the low compression ratios)

Rendering took just a few days, but there were about 60 server-class CPU cores churning on it continuously, plus independent users contributions, though at some point the main server was the bottleneck (saturated its network and disk I/O bandwidth).

I haven't gone through the DB to count the actual megaflops involved yet (the computation eliminated some areas based on work from previous levels, so estimating it isn't straightforward)

Have you compared it with the Fractal Algorithm program? ;)
http://www.fractalforums.com/meet-and-greet/new-fractal-programscreensaver/

60 cores!!?  :o
Can you run my program on your 60 cores, pleeeease?
You would be able to create super deep and super dense movies...  ;D
http://www.fractalforums.com/announcements-and-news/kalles-fraktaler-2/

Yeah, please combine the deepzoom of Kalles Fraktaler with the locations of Eric B. Deep zoom close on the bulb borders!

Hadn't, just tried now, but it doesn't seem to have very many iterations by default (not sure, the field is grayed, but the fractal looks more "empty") and it's pausing between zooms here.

Judging from the website, the approach it uses wouldn't have major advantages over the one I used, which was to use results of computations at zoom level 2^N to prepare for level 2^(N+1).


They were contributed cores through a form of "light" distributed computing, so they were a dozen servers plus a bunch of home PC (and even iPads, though their contribution was symbolic :dink:).

I guess such a power (and more) could easily be reached by the members of this forum, by contributing some CPU hours each, just need some interesting project to draw the crowds  :) (mine came from a developer audience, it was basically a testbed for a JIT, server & db software)

For ease of deployment, I used a JavaScript client (this way anyone could contribute from any platform without installing anything).
If you're careful, Chrome and FireFox JIT can get close enough to native compiler speeds. Even if it's only half as fast as the best C++ code, it allows to throw much more than twice the number of CPU cores at the problem.

Just need some way to divide the work into work units, some code to compute work units, and it could be done. I could contribute the server platform, as it's idle these days.

What about the largest image of the mandelbrot ever created that is made of tiles that are on a floor, and people can walk over it.  Has anyone seen that done? 

If I were to do this, I would fill the blank space with lounges to sit in, and maybe Sierpinski Carpets.  :P

http://seryzone.deviantart.com/art/Super-Big-Mandelbrot-30000x22500-408830833

Here, generated in Ultra Fractal. 8 hours.