MediaWiki - New pages [en]

Manual RenderQualityFlameFractals

2015-07-18T23:23:33Z

Thargor6:

=Introduction=
Even if the construction of flame-fractals can be very easy, it may be a challenging task to get a visually appealing rendered image.
Often, there is too much noise in some parts of the fractal, while other parts lack detail or have too many jagged edges etc.

JWildfire has numerous options to control the render-quality, but there are really many options, and not all apply to all types of fractals in the same manner.
Hopefully, this article will help you to understand what all those options do and how to use them to increase the quality of your fractal.

All the options, we talk about, are located at the "Anti-Aliasing / Filter"-tab.
[[File:Chap11_quality_options.jpg]]

=Spatial oversampling=
Spatial oversampling is probably the most powerful tool to increase the level of detail of your fractals.
It works in a similar way as many artists also create their digital images: they create their image at higher resolution and scale it finally down using some clever algorithm/software. The result usually looks better than it would have, when created at the original size.

The spatial-oversampling-setting in JWildfire is an integer setting. A value of 1 means to render internally at original size, a value of 2 to render at double size, etc.
==Example 1: Spatial oversampling 1 (raw, without any antialiasing)==
[[File:Chap11_quality_oversample1.png]]<br>

==Example 2: Spatial oversampling 2 (raw, without any antialiasing)==
[[File:Chap11_quality_oversample2.png]]<br>
When you compare the both images you will see that the 2nd image looks much "brighter" and has more details (You may save them locally for easier comparison, as the differences are not that huge)

In comparison to the "human" method of spatial oversampling, the oversampling in JWildfire does oversample the raw data (from the fractal algorithm), not the final image

===Memory usage/render times===
Because spatial oversampling increases buffer size in two directions (width and height), the ''memory usage'' increases by factor ''oversampling * oversampling''.
But, the calculation is adjusted in a way, that ''render time'' only increases by factor ''oversampling''.<br>

====Examples====
#Spatial oversample 2: memory-usage 4 times as much, double render time
#Spatial oversample 3: memory-usage 9 times as much, render time three times as long

=Spatial filtering=
Spatial oversampling opens the door to some other nice and powerful feature: the spatial filtering. In the previous paragraph we saw that in spatial oversampling several samples are calculated to generate one final point of the image. But we did not see how this is done.

==Simplest approach==
The simplest approach is to calculate the average of samples generated for each pixel, and use this average as final value.
E.g., when using spatial oversampling of 2, we calculate 4 raw samples per pixel, and use the average of this 4 samples to generate one pixel.
Also this simple approach is some kind of spatial filtering: applying some formula to a number of samples in the neighborhood of the final pixel (using a box-filter in this example).

==Spatial filter kernels==
The ''formula'' applied in spatial filtering is called a filter kernel. JWildfire currently has 14 included filter-kernels. While they often differ only slightly in shape, they may have a huge impact.<br>
[[File:Chap11_filter_kernels.jpg]]

==Spatial filter radius==
The filter radius specifies the size of the zone around the centre of a raw sample which is taken into account to calculate one final pixel.
As a rule of thumb: the larger this zone, the smoother the image, the more time it takes, and the less details you finally have.

===Filter kernel preview===
To help you to choose the right filter and filter radius JWildfire offers a preview of the filter kernel.
There are both a 3d or 2d-preview. While the 3d-preview is prettier, it may be slow on older machines, so you may also chose to have a flat preview. (You can change your preference in the Preference-window by changing the property ''tinaDefaultFilterVisualisationFlat'')

====Filter kernel preview in 3D====
This view shows a grid of cubuids, each one representing a sample. The center cubuid is the center sample.
The higher each cubuid, the higher is the influence of the sample on the final pixel. Usually, the center cubuid has the largest hight, i. e., the highes influence.<br>
[[File:Chap11_kernel_preview_3d_gauss.jpg]]<br>

But, sometimes, filter kernels have also negative parts, you can see this in the previews as "sunken" parts:
[[File:Chap11_kernel_preview_3d_lanczos2.jpg]]<br>

====Filter kernel preview in 2D====
The 2D-preview is faster but can not visualize the shape of the filter kernel as clear as the 3d-view.
It displays the cubuids from a top view. Brighter areas are "higher" areas, i.e. samples with high influence, and dark parts are samples with low influence.<br>
[[File:Chap11_kernel_preview_2d_gauss.jpg]]

Because they are such important, negative parts are displayed in red color.
[[File:Chap11_kernel_preview_2d_lanczos2.jpg]]

==Sharpening/Soften filters==
As a general rule of thumb: filter kernels with negative (red) parts are sharpening details, while filters with only positive parts are softening.

===Example 3: Gaussian filter with radius 1.0===
[[File:Chap11_quality_os2_gaussian1.0.png]]

===Example 4: Mitchell filter with radius 1.0===
[[File:Chap11_quality_os2_mitchell1.0.png]]

===Example 5: Lanczos filter with radius 1.0 and artifacts===
[[File:Chap11_quality_os2_lanczos2_0.9.png]]
As shown in this example, sometimes a sharpening filter can cause nasty artefacts (i. e. pixels in another color). Sometimes you may defend this by using one of the other options mentioned below, but sometimes you can't just this certain filter for the certain fractal.

=Anti-aliasing=
When your fractal shows jagged edges you can get rid of them by using the anti-aliasing-settings.
==Example 6: Fractal without anti-aliasing and without oversampling==
[[File:Chap11_antialias_off.png]]

The anti-aliasing-function adds a small blur-effect when iterating the fractal in order to avoid jaggy edges.
You have two options to control this effect:
#''Antialiasing amount'': specifies how many samples are under influence of this blur-effect (0: no sample at all, i. e. the effect is off; 1: all samples)
#''Antialiasing radius'': specifies the blur-radius. Decrease this value if your fractal gets blurry, increase it, if there are too many jaggy edges.<br>
As a general rule of thumb, setting both values to 0.5 usually yields to good results.

But, please be beware, that antialiasing may reduce details and does wash out colors when overused, so use with care.

==Example 7: Fractal with anti-aliasing (without oversampling)==
[[File:Chap11_antialias_on.png]]

=Sample-jittering (experimental)=
The idea behind sample-jittering is to reduce artifacts, jaggy lines or noise by adding some random behaviour (multipy times).
Usually, when calculating a pixel from sample values (using a filter-kernel) each sample is taken as it is.<br>
[[File:Chap11_jitter_off.jpg]]<br>

With sample-jittering, a random position "in-between" samples is choosen and an interpolated sample is forwarded to the filter.<br>
[[File:Chap11_jitter_on.jpg]]<br>
This can be done multiple times (parameter ''Color oversampling''), finally the everage of all of this jittered samples is computed.

==Example 8: Fractal with some small artifacts due to sharpening==
[[File:Chap11_quality_jitter_off.png]]

==Example 9: Artifacts removed by using sample-jittering==
[[File:Chap11_quality_jitter_on.png]]

This feature is experimental and my change in the future.

=Post noise-reduction (experimental)=
All the options described before, work on the raw samples generated by the flame-fractal-algorithm and apply to the buffer specified by spatial-oversampling-setting.
But, there is one more filter-option, which applies to the already generated image.
If everything wrong, you may use it to reduce artifacts from the final image. It is an adaptive gaussian filter (i.e. softening filter), which looks for pixels with high contrast and tries to soften them.
The parameter ''Noise threshold'' controls the contrast of the softened pixels (0: infinite contrast, i. e. no pixel is softened, i.e. effect is turned off; 1: no contrast, i.e. all pixels are softened, i.e. works like a global gaussian filter). The default setting of 0.35 usually leads to a desired effect of softening single pixels of high contrast and leaving the major part of the image untouched.

==Example 10: Fractal with some small artifacts due to sharpening==
[[File:Chap11_quality_postnoise_off.png]]

==Example 11: Pixels of high contrast seen by the post-noise-filter==
[[File:Chap11_quality_postnoise_debug.png]]

==Example 12: Softened final image==
[[File:Chap11_quality_postnoise_on.png]]

This feature is experimental and my change in the future.

=Customizing initial values=
You may customize the initial values of all of this options to your needs by using the Preferences.
There are the following properties you may change (a short description is supplied in the window itself, so I will not explain them here):
#tinaDefaultAntialiasingAmount
#tinaDefaultAntialiasingRadius
#tinaDefaultColorOversampling
#tinaDefaultPostNoiseFilter
#tinaDefaultPostNoiseFilterThreshold
#tinaDefaultSpatialFilterKernel
#tinaDefaultSpatialFilterRadius
#tinaDefaultSpatialOversampling

FlameFractalTutorial07

2015-07-17T20:58:03Z

Martin Flink:

==PHOENIX JULIA / PERSPECTIVE TUTORIAL==

This is an easy tutorial that gives you a base flame from which you can learn about these two interesting variations and <br/>– even more important – what is possible starting with a very simple combination. Of course, they have to be not just <br/>any two variations, but the possibilities are many. '''MANY''', like all things fractal.

Open JWildfire and click on '''New from Scratch'''.

Go to the '''Gradient''' tab and choose a lighter gradient than the default one. This is only because I know from trying it that <br/>the default will produce a dark fractal that is hard to see.

Now go to the '''Camera''' tab and change '''Zoom''' from 1 to 2.

Next go to the '''Transformations''' tab and click on '''Add'''. This gives you your first transform. Change it from Linear3D to <br/>Phoenix_Julia by clicking on the down arrow to the right of Linear3D on the '''Nonlinear''' tab.

<div class="figure">[[File:Catherine Tut1 pic1.png]]
</div>

<br clear=all>

Click '''Add''' again. Change this Linear3D to Perspective. The image below is what you should see in your viewport now.

<div class="figure">[[File:Catherine Tut1 pic2.png]]
</div>

<br clear=all>

==Now it’s playtime. Things to try:==

*Change the variables of the Phoenix_Julia and the Perspective variations. <br/>You’ll find them in the drop down menu next to the word '''Params''' <br/>below each variation in the Non-Linear tab. <br/>Try giving Phoenix_Julia a power of three, for example. <br/>Be sure to try using negative numbers as well as positive numbers.

*Play with gradients. Different gradients and combinations within a gradient <br/>will highlight different elements of the flame. <br/>Warning: It can be hard to decide!

*Add different final transforms: Click on '''Add Final''' in the '''Transformations''' tab. <br/>Change the final transform from Linear3D the same way you changed the <br/>plain transforms to Phoenix_Julia and Perspective. <br/>You can also try using more than one final. <br/>Final Transforms do their magic on the overall result of all the standard transforms!

*Add in other variations on their own transforms. <br/>Or try adding additional variations to existing transforms. <br/>Sometimes they will work – sometimes not. <br/>With fractal art, when you try something you can get nothing, or mud... or magic!

*Experiment with each transform’s '''Weight''' <br/>(I set the Perspective transform to .75 rather than the default of .5 for examples below). <br/>You can even go into the '''Xaos''' tab, although I didn’t do that for this tutorial. <br/>Change the Xaos weight from 1 to 0, one transform at time – you’ll see some interesting things happen. <br/>It's important to realize that you can use values between 0 and 1 as well and values well above 1 too. <br/>Because this is such a simple flame, it’s easy to see what '''Xaos''' changes can do.
<br/>
<div class="figure">[[File:Catherine Tut1 pic3.jpg]]
</div>

<br clear=all>

==Here are some examples.==

<div class="figure">[[File:Catherine Tut1 pic4.jpg]]
This has a Mobius final using the default Mobius variables, but try making changes to them. <br/>On this one, changing the Perspective angle and distance (in the drop down menu) is also interesting.
</div>
<br clear=all>

<div class="figure">[[File:Catherine Tut1 pic5.jpg]]
This image has two final transforms, Spherical 3D and Perspective. <br/>That means there is a regular transform that is Perspective and also a Perspective final transform.
</div>
<br clear=all>

<div class="figure">[[File:Catherine Tut1 pic6.jpg]]
Five Layerz of the same flame, which has a Polar final transform. <br/>Layerz is a wonderful feature of JWildfire, not covered in this tutorial.
</div>
<br clear=all>

<div class="figure">[[File:Catherine Tut1 pic7.jpg]]
This one has a Loonie final transform. Not the way Loonie usually looks, right?
</div>
<br clear=all>

<div class="figure">[[File:Catherine Tut1 pic8.jpg]]
Mobius final transform and five identical Layerz, moved around.
</div>
<br clear=all>

===Final Thoughts===
Don't forget to '''TWEAK PROPERLY''' before posting your own fractals... <br/>If you decide to use a flame created from any tutorials you find online, as a base.
<br/>Also remember to '''give credit''' (preferably with a link so others may benefit) <br/>to the tutorial that helped you create something nice...
<br/>It's good Fractalizing manners and it keeps everyone happy!

'''Enjoy!'''

Manual Introduction DE

2015-07-08T12:18:41Z

Gerriet Selent: /* About JWildfire */

=Über JWildfire=
JWildfire ist der geistige Nachfolger des preisgekrönten Bildverarbeitungssoftware Wildfire \ 7PPC für den Amiga in den alten Tagen.
Aber, implementiert dieses Mal unter Verwendung einer Hochsprache (Java), mit einem besseren Benutzerschnittstelle, und viele weitere coolen Effekten, Modulen und Features wie flammendene Fraktale.
Hopefully, becoming the product which was initially in mind (Unfortunately, in the old days the computers were not as powerful and some of the concepts of the original software did not work. They were too slow, not stable or both :D)

What does this mean? In short, the primary goal of the software is to be just '''fun''' to the user, by providing nearly endless possibilities to "mess around" to create computer-generated images in a playful way. You may also think of it as a creative computer game with a massive "open-world".

==Open source==
Even if the code is far from perfection, the software is not only free, it is also open source. So everybody is invited to join in order to improve the product. You can join/visit the project at [https://github.com/thargor6/JWildfire GitHub]

==Flame fractal editor==
Currently the most complete feature is the Flame fractal module called TINA.

(“TINA” is a recursive acronym and actually means “TINA is not Apophysis”).

Backed up by JWildfire’s image-processing-capability, TINA is a really powerful and versatile flame fractal software, and additionally... it runs on nearly any platform.

TINA features a powerful and intuitive editor, a simple-to-use morphing-based animation-editor, motion-blur, freely editable motion-curves for almost any property, a gradient-editor, a module were you can create sound-synchronized Flame fractal movies, and much much more.

==Key Features of JWildfire==
#Contains the most complete and versatile Flame fractal editor available
#Has not one but TWO advanced Flame animation modules, one of which allows for sound syncing of any parameters to imported MP3 files
#Almost every parameter in the fractal editor can be keyframed using various interpolation types
#Has many additional ground breaking features and modules such as Bokeh, MutaGen and iFlames
#Comes with various Render Options such as the Interactive (Infinite) Renderer which can also be used for generating random Flames "on-the-fly" and an Intelligent Batch Renderer Engine
#Stunning 3D effects (such as wave3D, water, twirl3d, …)
#3D effect superimposition (e. g. wave3D interference)
#Image compositing (layers, even for HDR images)
#Image generators (perlin noise, cloud generator, plasma, …)
#Many “common” image processing effects in 2D (such as twirl, erode, convolve, …)
#Simple, powerful and visually appealing graphical user interface
#Sunflow renderer integration for high quality rendering (experimental)
#Robust and object-oriented software-design, easy to extend
#Runs on any major platform which features a Java runtime (does not mean that you need a Java plugin for your Web browser)

==JWildfire's Hintergrundgeschichte==
===Der erste Prototype===
JWildfire ist der geistige Nachfolger des preisgekrönten Bildverarbeitungssoftware Wildfire\7PPC für den Amiga in den 90er Jahren.

Im Jahr 2000 schuf Andreas Maschke einen Prototypen, anfänglich für eine neue Wildfire-Anwendung in C ++, war aber nicht zufrieden mit ihm.

Additionally, the development-environment and his computer, were so slow that it seemed too much work to succeed with it as a project... Particularly when having just a little spare time available for the project.

Ten years later Andreas started a new prototype again, but this time coded in Java and with a new computer.

He was immediately hooked!

What a big difference in development-speed, it was pure fun and he used the project primarily to relax.

He ported portions of the old code from the Amiga to Java, this was not his best decision because this code was really poor, according to Andreas... But it was an easy way to start.

==JWildfire online==
#[http://www.JWildfire.org jwildfire.org (Offical blog)]
#[http://www.andreas-maschke.com/?page_id=351 Downloads]
#[http://jwildfire.org/forum/ Official forum]
#[https://www.facebook.com/groups/JWildfireOpenGroup/ Facebook Community]
#[https://plus.google.com/u/0/communities/118391398023168606746 Google+ Community]
#[http://jwildfireart.deviantart.com/ DeviantArt Group]
#[https://github.com/thargor6/JWildfire Repository at GitHub]

List of formulas

2015-06-12T20:41:44Z

Thargor6:

#Formulas/Variations/plugin included in JWildfire 2.60: [http://www.andreas-maschke.de/java/JWildfireVariations260.pdf JWildfireVariations260.pdf]
#Variables of the Synth-plugin: [https://www.dropbox.com/sh/i69h35mkbjsb002/AADRqPhDVFVeEb9kLQEsKr7la/Synth%20Variables.pdf?dl=0 Synth Variables.pdf]

Thanks to Don Town for providing those files

Trashcan

2015-06-04T23:25:24Z

Thargor6: Created page with "=Pages which are outdated or not completed or contain just ideas or whatever= 2. Download and Installation (since 2.51) {{new}}<br>"

=Pages which are outdated or not completed or contain just ideas or whatever=

[[Manual InstallationNew|2. Download and Installation (since 2.51)]] {{new}}<br>

Manual InstallationNew

2015-06-02T21:32:48Z

Thargor6: /* Native DLL's (only for Chaotica-Bridge and Leap-Motion-Controller-support) */

=End of install=
Since V2.51 the installation-process was simplified. In the most cases there is no installation at all.
I. e., you download a *.zip-file prepared for youir needs, extract it at your computer and run the software.

Currently only Windows and Linux is supported, Mac-support is likely to come

==Main installation packages for Windows (without native DLL's)==
[http://www.andreas-maschke.de/java/j-wildfire-win32-2.50R3.zip JWildfire for Windows 32 Bit]<br>
[http://www.andreas-maschke.de/java/j-wildfire-win64-2.50R3.zip JWildfire for Windows 64 Bit]<br>

==Native DLL's (only for Chaotica-Bridge and Leap-Motion-Controller-support)==
[http://www.andreas-maschke.de/java/j-wildfire-dlls-win32-2.50R3.zip Windows 32Bit]<br>
[http://www.andreas-maschke.de/java/j-wildfire-dlls-win64-2.50R3.zip Windows 64Bit]<br>

===Visual C++ Redistributable Packages für Visual Studio 2013 (vcredist_x64)===
When Chaotica can not load the plugins, especially the 64Bit plugins, it may be necessary to install the [https://www.microsoft.com/de-de/download/details.aspx?id=40784 Visual C++ Redistributable Packages for Visual Studio 2013].

==Main installation packages for Linux==
[http://www.andreas-maschke.de/java/j-wildfire-linux32-2.50R3.zip Linux 32Bit]<br>
[http://www.andreas-maschke.de/java/j-wildfire-linux64-2.50R3.zip Linux 64Bit]<br>
Please note that a 32bit package [http://askubuntu.com/questions/454253/how-to-run-32-bit-app-in-ubuntu-64-bit might not work on 64Bit Linux]

Manual LeapMotionIntegration

2015-05-23T09:10:44Z

Thargor6: /* Realtime-display and recording */

=About Leap Motion=
The [https://www.leapmotion.com Leap Motion controller] is a small device which allows you to control your computer through the motion of your hands. I. e., it can detect the motion and position of your hands, even of your fingers, and translate this information into signals which may be processed by further programs in order to give you the illusion to control something by just moving your hands. This was often shown in movies like [http://en.wikipedia.org/wiki/Minority_Report_(film) Minority Report] as pure fiction, but is now really possible up to a certain point.

While it is not really well suited to precisely control things (as it is exhausting to hold your hands freely and move them precisely by only a small amount) it is really fun at larger and "free" movements. So, in JWildfire it is only used to control the floating motion of fractals in order to animate them, but not to construct fractals.

==Integration into JWildfire==
===Linking between motion-signals and fractal-properties===
The Leap Motion controller may be used to animate flame-fractals inside JWildfire to create really awesome videos.
In order to do this you may link motion-input-signals like "position" or "orientation" to certain properties of the fractal.
When you move your hand this causes the change of the signal values which then cause the change of the linked fractal properties.<br>
[[File:Leap_motion_property_linking.jpg]]

===Realtime-display and recording===
The changes are displayed in realtime at the most possible speed. Simultaneously, they are internally recorded at more accurate speed.
After recording all the changes are turned into motion-curves which then are applied to the fractal.
So the motion will be part of the fractal and may even be post-processed, e.g. made more smooth or scaled up/down in the Motion-Curves-Editor.<br>
[[File:Leap_motion_recorded_data.jpg]]

===Rendering===
In order to render the animation, you may either use the internal renderer (slower, but can render any flames) or use the JWildfire-Chaotica-bridge (faster and better quality, but does not render all flames). See the [[Manual ChaoticaIntegration|manual of the Chaotica integration]] for further details.

===Workflow===
The whole workflow is illustrated in the image below:<br>
[[File:Leap_motion_workflow.jpg]]

=Supported Platforms=
Currently, only the Windows-platform is supported, on other platforms the feature is disabled in JWildfire.
Both, Windows 32 Bit and Windows 64 Bit should work, but only 64 Bit was tested yet.

==Installation==
The required drivers are included inside the JWildfire installation, so you will only have to install the device itself and JWildfire.
When using the JWildfire-installer be sure to enable the right driver (64 Bit or 32 Bit), in doubt install them both.
If you use the *.zip-archive of JWildfire, both are included, too.

=Getting started=
#Start JWildfire and connect the device (in any order)
#Load a fractal into the main-editor (the fractal should change when you modify the 1st or 2nd affine transform)
#Enter the "Leap Motion" tab
#Press the "Record"-button on the left
#A small countdown is displayed in order to let you enough time to bring your hands in initial position
#Move your hands in order to change the fractal
#Press the "Record"-button again in order to stop the recording. After that for each animated parameter a motion curve is created and attached to the fractal. You may replay the recorded motion using the "Play"-button at the bottom of the main-editor-area (per default this control is hidden, you must change to animation-editing-mode in order to make it visible)

FlameFractalTutorial06

2015-05-20T20:25:15Z

Jane Spaulding: /* How Can I create my own gradients? */

=How Can I create my own gradients?=

Creating your own gradient to use in your work is the best way to assure you have the perfect color where you want it in your fractal and Jwildfire has given us a great tool for this job. Open a fractal in the editor to start.

In the editor window just above the left corner of the editor screen (where your fractal opens) you will see the “Grdnt” button. When you click the "Grdnt" button, the display window will shrink slightly and the currently loaded gradient will be displayed as a bar across the bottom of the editor window. At the same time, 12 new buttons will be added below the display window.

The gradient bar has 2 arrow indicators below it with a circle of color indicating the color it is pointed at. The arrow indicators can be moved by clicking on the arrow portion and dragging it to the new position. Clicking on the circle below brings up a color selector to modify the color for that spot.<br><br>
[[File:Flametut06_gradient_editing.jpg]]

To start off making a whole new gradient, click on the “Erase” key at the bottom to clear the gradient and give you a solid black bar (which will also make your fractal all black). Position one of the arrow indicators where you want your first color to start, click the circle to bring up the color picker and chose a color for that spot. The tabs across the color picker give you several options for adjusting the color or you can simply use the swatches. You will get a thin line of color in the spot over the arrow.

Once you have your first thin color bar, move the second arrow to the position where you want the next color to start, chose a color and once that is done, click on the “Fade” button under the window. You should now have a wide bar of color that fades from the first to the second color. Select another location on the gradient, another color and continue until you have the gradient you want.

There are many other options.
<ul type="circle">
<li>You may fade all the lines at once using the “Fade All” or you may set the arrows to define a section of the current gradient and click "Copy" then move the arrows to a new position and "Paste" the same color pattern in that area.</li><br>

<li>The large button with "R", and an arrow, brings you back to your original gradient.</li><br>

<li>The "Sort" button will sort whatever is between the two arrows, and may give nuance to 3D settings.</li><br>

<li>The "Mono" button (most of the time) will put the included area into one color family. with variation from light to dark.</li><br>

<li>When you don't want to change the "Xaos" settings of your fractal, the "Erase" will turn the unwanted color black. Place the arrows around the color or colors you wish to change, then click Erase.</li><br>

<li>Remember, if you make changes that you are unhappy with, the undo button on the left side of the editor window will take you back one step at a time. Just click undo until you are back to a point before the change you do not like and start over.</li><br>

<li>Even if you're not quite satisfied with your fractal's appearance, it never hurts to Save. You can open the gradient folder while looking at your gradients to delete duplicates or move gradients into the right folders. Then press "Rescan"</li><br>
</ul>

Play around with the different options to refine your gradient, then go to the "Gradient" Tab at the bottom row (with the Camera, DOF, Color, and so on) and modify your colors in other ways.

When you are happy with your work, be sure to save your gradient. Click on the large "Save" button to the right end of the row of 12 buttons. This should open up your file browser. Select or create a folder for your custom gradients, name your file and save. When you restart JWildfire your new gradient will be available in the gradient library. If you want to use it for another fractal without restarting, go to the "Gradient" tab, and open the Gradient Library section. Click the "Rescan" button to load any new changes.

Manual ChaoticaIntegration

2015-04-25T00:21:35Z

Thargor6: /* Chaotica-side */

=About Chaotica=
Chaotica is an advanced fractal-software, which was designed to create and render flame-fractals in the best quality possible. It creates brilliant images with rich colors and sharp details in little time, and also supports fractal-animations, with very nice motion-blur-effects. Being a commercial product, it is developed and maintained by Glare Technologies.
For a more comprehensive overview over the features please visit the official site [http://chaoticafractals.com/ chaoticafractals.com].

==Integration into JWildfire==
In the current state, Chaotica clearly focuses on the rendering and has a rather minimal user-interface to design and manage flames. This makes it a perfect candidate for an integration into other programs which may benefit from the truly amazingly fast and high-quality-renderer. Additionally, it uses only a very decent amount of memory, launches very quickly and (per default) occupies not much of the screen, so that the integration really can feel smooth.

Please note, that this integration is not meant to replace the JWildfire-renderer, not now and not in future versions. It is just an additional option to be able to deliver the best possible results in a fair amount of time. <br>
[[File:Chaotica_Launcher.jpg]]

===Chaotica Community===
[https://www.facebook.com/chaoticafractals https://www.facebook.com/chaoticafractals]<br>
[https://www.facebook.com/groups/chaotica/ https://www.facebook.com/groups/chaotica]

==Feature differences (examples)==
But, nothing comes without a cost. So, we can't just export all of our flames to Chaotica and become happy by having rendered them in better quality in less time.
Both programs, JWildfire and Chaotica, are very different, and transfering flame-parameters between them is actually a very challenging task.
But, many of those differences are not a fault, or something similar, which may be eventually "solved", many differences are influenced by design, and they will remain.

Some examples:
#Chaotica currently does not support any (Pseudo)3D-feature, so all the 3D-stuff in JWildfire will not translate. Or in simple words: Fractals in Chaotica are always 2D
#JWildfire does not support the loading of any external Apophysis-plugins (and has all plugins integrated), where Chaotica supports both, internal and external plugins. This may lead to different behaviour in certain cases, because there is no garuantee that a certain plugin with the name X will behave in all programs the same. Apo-Plugins were often created in Delphi or C, while JWildfire-plugins are written in Java, and Chaotica probably uses some C-dialect.
#In animations, Chaotica is designed to work on a time-basis, while JWildfire works one a frame-basis (which can be translated in each other, of course).
#While Chaotica can have any variation as "post_" or "pre_"-variation, JWildfire still uses the Apophysis-approach to decide the priority by name (because of compatiblity reasons)
#Chaotica and JWildfire use different models for applying affine transforms
#Anti-Aliasing works different in both program

=The JWildfire-Chaotica-Bridge=
Because of the many differences between JWildfire and Chaotica, exchanging flames between them is a rather challenging task, which is performed by a special layer of software: the '''JWildfire-Chaotica-Bridge'''.
==Components of the Bridge==
The '''JWildfire-Chaotica-Bridge''' consists of the following components:
#'''Chaotica-Launcher''': translates the current fractal of the Main-Editor into the Chaotica-format and launches Chaotica to render the translated flame
#'''Chaotica-Plugin-Translator''': translates the names of certain plugins and plugin-parameters from JWildfire to Chaotica.
##Exchanges certain 3D-plugins by 2D-plugins, e.g. "blade3D" ist translated into "blade", because "blade" works the same when the fractal is in 2D.
##Removes plugins which can not work by design, e.g. "inflateZ_1", which is a displacement into z-directorion, which would have no effect at all
##Forces to use some JWildfire-specific plugins to force that the result looks the same, e.g. renaming "swirl" into "swirl_wf"
##Replacing certain unavailable plugins by replacements which work as much the same as possible, e.g. replacing "dcztransl" by "linear"
#'''JWildfire-Chaotica-Plugin-Pack''': contains about 250 external plugins in Apo-format to help to translate as many flames from JWildfire to Chaotica as possible. They are made from JWildfire-code and are intended to work the same as the plugins with the same name in JWildfire.
Using all of this components, the bridge can currently handle/translate about 384 plugins.
#'''Chaotica-MotionCurve-Translator''': transfers the MotionCurves designed in JWildfire to the Chaotica
#'''Chaotica-Bridge-Random-Flame-Generator''': A meta-random-flame-generator which uses other flame-random-generators and the Chaotica-Plugin-Translator to create flames which will probably translate well to Chaotica
===Usage of Plugins===
Please note, that all plugins are optimized for Chaotica and may not work properly in Apophysis or other programs. So, it is currently recommended to use the JWildfire-plugins only in Chaotica, because that is the only purpose they were made (and tested for).

=Supported Platforms and Chaotica-Versions=
Because both JWildfire and Chaotica are continously evolving, and both programs are available on many different platforms/architectures, it is impossible to test and support any combination of versions/platforms.
==Windows 64 Bit==
This is (currently) the only supported platform. You are welcome to try others, but you are on your own. At least the plugin-pack is only tested for Windows 64 Bit yet.

On '''JWildfire'''-side, you should use '''Java7''' or higher (Java 8 is not required), and be sure to use a '''64 Bit Java''', not the default one which comes with your browser.

On '''Chaotica'''-side any version since '''1.5.5''' should work, be sure to use the '''Windows 64 Bit''' version

==Windows 32 Bit==
This platform is available only because of a special very good friend of the author. It is not tested and not officially maintained, but should work.

=Installation=
==JWildfire-side==
Install the latest JWildfire-version from the [http://www.andreas-maschke.com/?page_id=351 official site] and check the option "Chaotica-plugins"

==Chaotica-side==
#Download Chaotica (64 Bit Windows) from the [http://chaoticafractals.com/download official site] and install it on any location.
#Copy the plugins from the JWildfire installation (folder "plugins64" inside installation-directory) into the plugins-folder of Chaotica (also folder "plugins" inside installation-directory)
#Create a temporary directory for exchanging flames, e.g. "D:\JWF-Chaotica-flames"
(If you want to use the not officially supported 32 Bit version, just install Chaotica 32 Bit and use the plugins from the "plugins32"-folder instead)
===Visual C++ Redistributable Packages für Visual Studio 2013 (vcredist_x64)===
When Chaotica can not load the plugins, especially the 64Bit plugins, it may be necessary to install the [https://www.microsoft.com/de-de/download/details.aspx?id=40784 Visual C++ Redistributable Packages for Visual Studio 2013].

==Configure JWildfire==
#Launch JWildfire and open the Preferences-Window
#Set the value of the property '''tinaIntegrationChaoticaDrawer''' to the actual path of your Chaotica-installation, e.g. "C:\Program Files\Chaotica"
#Set the value of the property '''Set tinaIntegrationChaoticaFlameDrawer''' to the path you created to exchange flame-files, e.g. "D:\JWF-Chaotica-flames"

=Getting started=
#Start JWildfire
#Choose the random-flame-generator '''Chaotica Bridge''' and press the '''Random batch'''-button
#Double-click at a flame at your choice to load it into the main editor
#Choose the desired resolution-profile (the fractal is rendered at this size in Chaotica)
#Click at the Chaotica-Bridge-button at the right side of the preview area
#If Chaotica launches properly, but you get a black/unwanted fractal, the fractal may use a plugin which is still not available. In this case, please chose another flame, then the plugin may be not available yet.

=Which features do no translate=
Here is a (not yet complete) list of the features, which do not translate when using the bridge (and also do not translate when importing flames by using the clipboard).
So, please, before posting a bug, please be sure, that the problem is not already mentioned here:
#Any 3D-stuff, i. e. fractals are always pure 2D in Chaotica
#Most DC-stuff (direct-coloring). I have made some plugins which translate the alteration of color into alteration of density, i.e. the effect is monochrome
#Post-Symmetry
#Bokeh-Effects
#Special-Shading
#ImageMaps as Gradients
#Any Stereo3D-stuff
#Post-Symmetry
#Layerz (only the first layer is translated)
#Color-curves from the channel mixer
#Multiple final transforms (only the first final transform is translated)

=Tips and Tricks=
Here are some advices from Thomas Ludwig, the main developer of Chaotica:
#You can run Chaotica as Administrator to enable advanced memory features (which are why Windows XP support was left out in version 1.5), for up to 15% faster rendering. You notice it most on fast CPUs, eg Intel i7. (Although soon this won't matter as much because of future OpenCL support, it's still nice, especially for realtime animation playback.)
#When rendering animations, it really helps to use Smooth AA mode, with AA level 2 and ultra quality off. The frames converge very fast and it's very friendly for the compression codecs.