Welcome to Fractal Forums

As I recently released MB3D 1.98 with point-cloud export, I got some questions about the purpose of those point-clouds.

Point-clouds are similar to solid meshes, but both are simplier and faster to generate and usually have a higher resolution (compared to a solid mesh at the same size), i. e. can contain lots of nice details.

There are multiple programs which allow to render this point-cloud-objects (together with any other meshes) and to create really nice images.

From the artist's point of view, this feature is interesting as you can combine fractals with any other object and may use a PBR (physically based rendering engine) for creating fractal art.

Of course, the number of detail is limited (in comparison to a true fractal renderer), but MB3D 1.98 makes a huge step forward.

Here are some examples, all rendered in Houdini (using the free version):

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/torus_houdinic.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/giger_houdini2c.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/knot6_houdini2c.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/tree_houdini2c.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/fractal_houdinic.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/knot4_houdinic.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/mb_houdinic2.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/knot7_houdini.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/knot5_houdinic.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/wallpaper_golden_age2.jpg)

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/shrooms_houdinic.jpg)

The maximum volumetric resolution used so far was 3600 x 3600 x 3600 for the last model.

Cheers!

Andreas

Can't wait to see how these render in Carrara!!

Thanks for the great work, Andreas   :banana: :chilli: :toast: :chilli: :banana:

Super  :thumbsup1:

fabulous!

Here are some examples, generated with V1.99:

(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/houdini_maskc.png)
(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/houdini_heatc.png)
(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/houdini_bulb2c.png)
(http://www.andreas-maschke.com/wp-content/gallery/mb3d-meshes/houdini_gemc.png)

Cheers!

Andreas

The new flag - use ambient picture as light alsou is pretty good.

 Take some bulb or any other fractal.
- Download some beautifull nebula photo. (not part of M3D)
- Rename it to some short name like Nebula1.jpg.
- In the ligh section - > back pic -> Background image
- Use a small image as ambienty colour. (New in v1.9.8)

Then fractal looks as part of the scenery not of something outside. Well, this could be done manualy but single flag does it mutch faster.
I think space photo are especialy good becouse strange unknown structures of ancient aliens looks better when they are on galactic photos.
http://www.fractalforums.com/index.php?action=gallery;sa=view;id=20547 (http://www.fractalforums.com/index.php?action=gallery;sa=view;id=20547)

Bulbtracer have one additional feature. If your PC is slow enought you get a pretty cool animation in "Trace Preview" going throught the slices of fractal.
It is pretty cool with some formulas and not so with others. Generaly it is symmetrical fractals with holes. But then you must not have very fast PC as speed depends on processor speed. And if it is too fast you don't see animation;)

It reminds Fractal Explorer with some fractal type orbit something.  Julia set of mandelbulb:

The point cloud results look wonderful

Thank you kindly Thargor, for these images.  I had no idea what the new feature was, but now I can see clearly how useful these are.   :P

Awesome Thragor! very impressive. I'm going to hyjack your thread a bit with some technical information about point clouds.

I know quite a lot about efficiency and precision for point clouds algorithms that would be good in MB3D... So here is some programming advice for the MB3D superheroes to make faster, smaller, anti-aliased clouds:

it's good to keep all surface corner points with normals like (1,1,-1) throw out all flat points that are facing X-Y-Z normals (1,0,0) and perhaps even edges (1,1,0) normals, to throw out the aliased flat points, i.e. that are held within a plane of your resolution grid, especially for round objects...

Why is that awesome?
It compresses your point clouds size by 97 percent, from 30,000,000 points to 1,000,000 points
the point cloud is fast  to mesh, and the file is 3MB rather than 500MB
the resulting cloud is less aliased, no flat zones and staircases
it's very easy to program

here is one way to do that:

March through all the voxels (resolution grid), x, y, z, and for every solid threshold point which is worth a cloud point, measure the 6 points neighboring it on -x+x, -y+Y, -Z+z, and average those neighbor points, if the space is empty or not, to know which way the point is facing, and delete points which average to zero normals, they are rare noise points, and also disgard all the inside-volume samples which don't have empty space in one of their 6 neighbours.

That's efficient because you only do one read loop through the space in x, y,z, and check the space in all directions from every inside sample in order to obtain the surface edge and the normals in one go, and it's easy to program, about 30 lines. and in the read loop, for every cloud point, you sample the neighbours and find out if it's aliased, if it's flat, if it's a true corner point with a normal of (1,1,1) or a lesser, ridge corner facing towards (1,1,0) for example. I tend to keep only the (1,1,1) points. I have code for this process so i can provide that for you to check out if you want.

So, in one march, you have discovered all the points which lie on the outside of the structure, and you also have precise normals for them, and it less aliased because you have thrown out all the flat zones and only kept the points with the most information.

For anti-aliasing, I also did another algorythm second pass when i had all these corner cloud points without the flat zones: search the nearest point on the voxel layer of x-1 and x+1, where every point in sandwitched in between, and find out what the slope is to one or both of them... this gave me very precise normals when make for nearly perfect anti-aliased round objects from low res point clouds.

To do the anti aliasing and precise normals for all corner points that I kept, i ordered all the points in X, Y, ans Z sequentially, which takes about 1-2 seconds of processing time, and i kept an array to say how many points were on every layer x=1 to x=999, and where every layer starts from so 3 arrays in total: order the point cloud by x, say how many points are on every x layer, and third array to say where x layers start from in the giant point cloud array, so a big array of 1 million points, and two small arrays of 999 points, where value X,20 = 45means there are 45 point sin x layer, and value X,20 starts from big array point 432234, so you start reading point cloud at value 432234, read only 45 points from it, and you have anti-aliase it ... So if we are refining all point in x=20 and that face forwards, we simply read all array data starting points in x=19 and x=20, and find the nearest point on the layer below or above, and use it to construct the anti-aliased normal.

That's one way of doing it within MB3D, and there is a better way:

The above level is for a voxel grid, and within MB3D you have a lot more freedom with access to the formula results. So if i were to do clouds within mandelbulber, i wouldn't use a voxel system to do anti-aliasing and to keep the points with the most information. i would use 3x precision ray-tracing... So, every time you have found an edge voxel with an empty space in one of the 6 neighbors, you sub-raytrace within that small cube to devide that cube again by 100, or you average the exact ISO value of the neighbors to find the points precise position wihtout even raytracing, using just the neighbor point iso values, that avoids all aliasing to begin with, it's much better. for all surface points with >1 empty neighbors, you keep and compare the neighbor ISO values, a surface point of ISOval 0,1023, with -x 0,4041 and +x of -0,1044, you can move that point position on X to exactly (0,1023+0,1044)/2, anti-aliasing allpoints fairly fast on the fly, and exporting true point clouds with decimal points, and not voxel type point clouds, very nice!

So, i'd march through the grid space, check the neighbors of every solid point, throw out all the empty points and the points with 6 neighbors which are not boundaries, and sub-sample the MB3d formula, to get the color and the normal values... for example, you can use true marching cubes type logic within every edge point that you have detected, which has neighbors on 0 and on 1 and definitely contains an edge... you measure the exact position of the ISOsurface on X, Y and Z, and then average the neighbor ISO values to have a very precise position and normal value.

That still leaves the question of how to simplify the resulting giant clouds of marched, because all the points will be fairly precise interpolated, resulting in precise point maps. it would be good throw out a lot of the flat spaces whilst simultaneously keeping all the points of details in the intricate zones, non flat zones... Here is the trick:

Compare every point in the point cloud with the 20 closest points and throw out 10 neighbor points if they have very similar normal values: they are all in a flat zone coding the same information in duplicates. you can use M-nearest neighbor algorithm for that, or by putting the points into layers based on X, Y , Z integer value,(even if the points at that stage have decimal precision), and searching in the layer above and below, for all points in a given distance with the same normal. If they are on the layer above and they all point upwards, you know you have lots of flat zone points and you can eventually get very precise point clouds from MB3D with only 5 percent of the data that is currently used, using very fast algorythms that should only take 5 minutes for 3000x3000x3000 array, and can also subsample all the edge points to get 100x more precise point positions without aliasing.

Ok, to resume that technical info:

The best way in MB3D is to march xyz in one go, compare the 6 neighbors of every point, and average the ISOvalues of grid points to obtain anti-aliased clouds.

Then, simplify the point cloud by comparing neighbors in 3D or in planar nearest neighbor algorythms, and deleting all points which are on the same plane and share the same normal, and keep all points which are in more lacework zones where the neighbors all face to different directions.

result is anti-aliased clouds which are 100 times smaller.

I can recommend cloud-compare program too, it's free and multithreaded poisson mesh algorythm.

I attempted a program where you can occlude all the small voids and holes inside rough ISOsurfaces, and where you can flood-fill the voxel space, so that, you flood fill from an outside zone, it fills in all the  points up the the surface limit, and then multiply the flood fill with the shape to keep only the surface border without the inside complexities... I also wrote an option to detect all void spaces surrounded by more than 15 of of the 24 neighbors, and it turns sponge fractals into dense ones that can be flood filled and emptied and stuff, because otherwise a flood can go through into all endless caves inside the fractal.

I developed a recursive flood fill algorythm that can cope with 1000x1000x1000 voxels in less than 5 minutes with no ram problems.

When i have flood filled the fractal, and i have it's boundary, i can also flood fill from the inside, and dig out the inside of a solidified fractal until it's dug to 5-10 spaces to the nearest voids (the outside zone), and it gives me a hollow shell of the fractal, with no inside voids.

Another feature i did on the program, is that you can take the voxel/point cloud and combine it with a mesh... So you get a super advanced crazy fractal, multiply it with and elephant or a rabbit mesh, and get a rabbit which is totally crazy.

I wanted to finish the program and to send it out to you guys and found myself writing 3 different programs and now i have to integrate them into one program and make instructions and guides, and fix all the bugs,  :'(, and i want to randomize it so that the PC fits the rabbit into various rotations and sizes multiplied with the fractal, and then you can go hi-res on the version which is best. it may be good for cubes and lampshades and mugs and spheres and smartphone sleeves.

This rabbit was a random render and it's ugly, i know!

elephant to voxel

I found an major error in the point cloud output version 1.99, it's 3 lines of code missing. It doesnt always write the boundaries of the point cloud on negative sides of the volume. That's crucial because the point-cloud rendering tool requires bounded surfaces When the the poisson cloud to mesh standard algorithm runs on unbounded clouds, it does a random boundary to compensate:

If you can put an option to export 8bit greyscale stack images, I will be motivated to code a mesh renderer based on marching cubes logic, where every 8bit pixel is the iso surface value of the sampled coordinate, then i can compare boundary pixel values and find fairly exactly where the surface actually is, i.e.improve resolution by 10-100 times, if you export 8bit grey PNG instead of b/w.


If one of you can supervise my thesis, that's cool.

Mandelbulber program (not Mandelbulb3D) already uses floating point distance data when 3D mesh is being exported. There is not needed intermediate step of exporting voxel stack. You can get very smooth surfaces without aliasing. In addition it uses also color data.
3D objects are saved in PLY format which can be loaded in MeshLab.

Mandelbulb3D also creates meshes and point-clouds without the intermediate step of generating voxel stacks.
3D objects are saved in OBJ or PLY format, which can be loaded in Meshlab, too.
Voxel stack stuff is still included for backward-compatibility.

Cheers!

Mandelbulb3D also creates meshes and point-clouds without the intermediate step of generating voxel stacks.
3D objects are saved in OBJ or PLY format, which can be loaded in Meshlab, too.
Voxel stack stuff is still included for backward-compatibility.

Cheers!

Sorry for my ignorance. For what is this this discussion about using voxel stacks when mesh objects can be created directly? What is the reason to use voxel stacks?

There is not much reason, except you have some super-cool external tool, which can do some more "magic", which outperforms the standard Marching Cubes algorithm.
Even size (due to 32bit application) is not a reason, as you may generate the meshes in parts (and finally merge them using a tool, which is supplied in the Mandelbulb3d distribution). The largest mesh I created so far had 170 000 000 polygons.

And I did not start a discussion about voxel stacks, I just posted some examples from the direct mesh export :-)

But, no problem! :D

Cheers!  :beer:

Buddhi, It's awesome to have videos of complex apps. I just tried to render a menger at 400x400 and the result was 40x40 resolution, so it was zoomed to only 10%, so it's a complex app i need a video or a starter guide of some screenshots of the options and processes :) I was very familiar with the previous version and my pc is only 8 threads, i just copy online presets mostly to travel the mandelworlds!!!

Thargor, here is a test of a sphere in version 1.99. the screenshot at the end with semi aliasing. The marching cubes isn't actually using the MB3D fractal formula. It is using a black/white version of it which has lost the gradient of the 3D, The oblique angles arelimited at 45 degrees. marching cubes takes so long because it nearly never has a vertex on an integer position = aliased, the corners of the cube are averaged to find the cube polygon, the vertices always measure the min and max of every cube corner and average the polygon in between at cool angles. To optimize that in MB3D every formula value pt of the cube corners should be computed one time and kept in an array and recalled 8 corners per cube. You probably are calling 8 corners per cube and adding them for the current version, but the input of the 8 corners are not actually the formula in 3d space.

On the right is what the MB3D output of a sphere would look like if the the marching cubes input was the formula equation output, i.e. If you do xx+yy+zz = 1.0. currently it is using true/false of (xx+yy+zz = 1.0)

Try running your marching cubes in MB3D with xx+yy+zz = sphere radius perhaps to debug it, because it should make a perfect sphere first time, which means it is getting 8x times too few samples per cube from the rest of the program.

(https://i.stack.imgur.com/WANeM.png)
On the left is the data that MB3D is sending into the marching cubes code. the input of the marching cubes can directly be the result of xx+yy+zz = 1.0, that's how it performs best.

So in Mandelbulber it uses fractal formula directly in marching cubes algorithm. Results are much better. See attached images of sphere exported to 30x30x30 mesh. There is no aliasing.
It already has this optimization which you mentioned. Every of 8 points from cube is calculated only one and stored in temporary array (only 2 consecutive slices with distance data are stored in memory). It makes calculation of mesh almost 8 times faster.

>>>>>>>>> .STL FILE >>>> https://www.thingiverse.com/thing:2633265 <<<<<<<<

Very nice render. I'm trying to find a bounding box for your mesh, to resize and move the mesh preview?

The Ideal fractal programs already exist for 2D art galleries, it's 10/10 for both programs.

For Meshes... it might be worth writing a new 3D program from scratch, because once you have previewed your formulaic effigies in the 2D fractal program, It's best to piss it out as many compressed and uncompressed file types/ stacks/mesh/cloud because those formulas variables/lightings aren't changing that mesh afterwards... but there are many hi res fractal mesh editing/adding/substracting/things that people will want to do... Maybe, at this time, it would make sense to have a seperate .binary.exe project to both your programs, which can communicate with them, with "Send object to fractal mesh editor" (effigy is a cool name oui? it's an atomic pacific island).

We need 2GB isomap/imagestack arrays going out of the 2D program and into a 3D program, which doesn't need the formulas editing of the 2D, and which can take a bust and boolean map fractals as a light relief onto it, fully chop a fractal in the shape of a vase by boolean also, fill surface holes of cheese fractals, hollow them, and other difficult 3D tasks that someone will want to do on full mandelbulb 3D imagestacks one day, like vector mutation and morphing, different color mapping and colorizing options(vertex/pixel/material), and so forth.

I was pretty good with mandelbulber 1 and i was compiling it for pc. I don't know enough about both programs to know the specialization of both, the differences. 3D fractals has become alot about preset libraries and remixes on web pages. Web is the best distribution for a photo and embedded preset code/file/magnet.

Taking advantage on the 50000 online mb3d presets would be a good advantage for all mandelbulb programs, to copy over MB3D's copy/paste codes. I know it's controversial because the file format has a mb3d header, but lack of cooperation between all fractallers in their math travels would be detrimental... not so to integrate, it, just to add it on the side as another option.


If we dream what would be the best 3d fractal program, It would preview a rotatable object representing the fractal slab, similar to MeshLab rotating.

Someone will do that by 2050:) so i can print myself some fractal false teeth.

in realtime preview, mb3d currently has a fixed box, It's got a swiss army knife meshing page, the number of options is amazing, even though he wrote it all without a marching cubes programmer noticing why his mesh was aliased, and he added Taubin Smooth, which sounds like a urban eel species. Mb3d mesh window is fantastic, and it's not rotatable or hi res or optimized, so in the dream version it is... If I had enough experience and concentration to re-code it, i would do a mesh preview cube which is ray-march detected from the camera rotations uploaded every second into the graphics card as minecraft voxel maps, because we all know the retro attraction of voxel 3D graphics. Minecraft voxels are just much more fun and physical than point cloud maps of quads used by MeshLab for 3D preview.

HD 3D Mesh colors are a quandary/difficult. When the PC is powerful enough to oversample them and color printing arrives everywhere, because colors on 3D mesh requires incredible amounts of intelligence just to do version using per vertex/polygon color arrays, and using material files, the technical adversity of colors is massive in terms of formats and realtime rendering. formats optimize mesh colors in very difficult ways.

While it may be an interesting topic, it kinda gets annoying that you do not stop to hijack this initially art-focused thread with your very opinionated statements.

Suggestion: start your own thread about meshing, marching cubes or whatever and share your thoughts, suggestions, in a constructive way. Blindly asuming things is not a good way to start a discussion.

Or even better: grab the code and improve it! It is open source! Talking is good, but doing is even better ;-)

So what do you want to say exactly?
 - Taubin Smooth is bad?
 - The implementation of Taubin Smooth is bad?
 - It is bad that MB3D has an optional Taubin Smooth option?
 - MB3D is bad?
 - Mankind is bad because they did not prevent that Taubin Smooth was invented?
 - Smoothing is bad, even as optional feature?
 - anything? :D

Cheers!

I'm not sure why do you tell me this? Maybe you think I did not notice it, or suddenly forgot about it, even when I told it to you via email? ;-)
In fact, the problem is well known, which does not automatically mean, that there is somebody who solves it ;-)

But you are invited: grab the source and contribute to it! In MB3D there are nearly no excuses, the code quality can hardly get worse ;-)

Cheers!

Hi, I did look for a guide how to compile MB3D on windows7, I don't know which programs and libraries I need for it? I would be happy to dive into it for a while.

The DE of the BTracer window is essential to find why we can't display/save a color image from BTracer rather than black/white, because DE uses the decimal value of the formula to find the edge, the version that the DE is using in that window is the original formula. Perhaps I can write a single Echo() command from the DE to trace the mixup. I want to write the actual DE values in 8/16 pics, and then I can write a mesh program with very optimized mesh writing from it.

 I wrote a 3D mesh optimizing code for sending architecture fractals to a 3D printer, this is a 2gb file optimized to 92mb:

https://i.imgur.com/tqsUQk3.jpg
(https://i.imgur.com/JVYXKRU.jpg)
https://i.imgur.com/ES3zgZ0.jpg
(https://i.imgur.com/Ugm65uc.jpg)

Returning to the main topic of this thread, this is my trial of rendering mesh objects in Blender. The object was exported from Mandelbulber to PLY file with 6 millions faces. The object was optimized in MeshLab using Quadric Edge Collapse Decimation filter to reduce number of faces to 1 milion.
In Blender there was used Cycles Render with Subsurface Scattering effect.

(http://nocache-nocookies.digitalgott.com/gallery/20/640_09_11_17_8_32_59.png)

Yes sorry Thargor no offence, was humor. The BTracer window is so awesome I'm full of praise for it... And there are options to save a mesh bounding box. incredible. I used your program to process 2 terabytes of point clouds and I programmed a couple of months of clouds because it was fun.

From a Digital Signal Processing point of view, what I said about Taubin, in the current DSP sequence, is similar to changing a color photo black and white, and afterwards running a gaussian blur to recover the bit depth. The DE has more than 6 decimal places, so the result of the DE comparison is 16bit 0.000001+ vertex resolution between any 2 samples. At least I did some detective work on the MC results, It's difficult 3D process to notice.

For the comments about presets, my 8 core 24gb pc is slower than what you have at home, so I do what other normal people do, just surf for preset remix groups with hi-res images and program presets. I spend 80% of the time on 3D fractal program using the zoom of the mesh render window. That's my opinion. I didn't manage to render anything like this thread when I tried. the pc jammed. so I wrote a program based on image stacks. I will try to copy what you are doing, perhaps it takes 32 threads and 64GB. I do know how to optimize DE-iso engines quite a lot so they go 10x faster to generate a fractal mesh, and 0.000001 vertex precision.

(https://i.imgur.com/4pWabrP.jpg)
(https://i.imgur.com/LhjXyZh.jpg)
(https://i.imgur.com/dTMA9O7.jpg)
(https://i.imgur.com/a5Cu46C.jpg)
(https://i.imgur.com/DpsExlI.jpg)`

OK, I see. But, this was not the purpose. Like in image processing, blur/smoothing can sometimes be an useful feature, but it is optional and has nothing to do with the meshing itself.
In general, I think the MC is not the best idea to create meshes from fractals. But, creating more advanced stuff, takes effort and time.
But, maybe it is a good idea to optimize the MC first, when this can be achieved quickly.

Peace!

Andreas

I can run GPU marching cubes on high res image stacks afterwards, which can render a a billion cubes in about 10 seconds, it's 100 times faster than the processor. I alreadhy have a free GPU marching cubes code running on my PC, only task is give it some high res image stacks to run on. It's one of the advantages of saving high res image stacks using 8/16bit pixel depth. 

I'm checking the project for keywords relative to the meshing options. It's quite a steep program to learn pascal!

Here's a program I wrote that can do boolean and hollow options on MB3D image stacks. http://www.fractalforums.com/windows-fractal-software/mandel-meshing-tool-development-build/msg103967/#msg103967

Hi Bib, If i am do similar to your mum's merangue in 1,99, I am processing 30 minutes for a 1000x1000x1000 render, when a GPU program can do it in about 1 minute. That's suggests possible use for an image stack export.

And what if you wanted to combine two 2000x2000x2000 meshes. in boolean meshlab geometry you would be there for about 24 hours for a single file. with the original ISO value stacks it would take 10 minutes on a desktop rather than 24 hours on a 128GB ram 32 core machine.

I just found 5-10 medical image meshing programs which are open source, some of them may be very powerful and reliable and gpu accelerated to 100 times faster than what serial processors can do, so it would be fun to run fractals through some of these:


http://www0.cs.ucl.ac.uk/opensource_mia_ws_2012/links.html

https://www.youtube.com/watch?v=1mYNwJbE7dQ

Those kinds of programs are made for seeing ISO images to differentiate muscles, bones, internal orgams of human MRI slices.

If you can mode v.189 to put greyscale, all those programs can probably give you a new toy to probe inside organs of fractals, from the different DE gradients.

https://www.google.fr/search?q=The+Visualization+Toolkit&num=100&source=lnms&tbm=isch&sa=X&ved=0ahUKEwj8jvz9_dfXAhWHZVAKHfBeDz0Q_AUICygC&biw=895&bih=554


ITK is an open-source, cross-platform system that provides developers with an extensive suite of software tools for image analysis. Developed through extreme programming methodologies, ITK employs leading-edge algorithms for registering nd segmenting multidimensional data.
Apache 2.0 license
FSL Logo   FSL