Slightly improved my Brahmabrot technique.

To the normal mandelbrot bailout added newton bailout conditions. So bailout is:

( (cabs(z) < 4) && (cabs(zold-z) >0.001 ) && (iter < @maxIter) )

This is more like magnet bailout, it reveals more features as it don't allows non escaping orbits to iterate too long so filling everything with white. But it alsou means slight loss of speed. Realy it is much better now. With new bailout and zold variable now I can make Magnet and Manowar buddhas, but tangent formula somewhat dissapeared. Probably more easy for exploring formulas would be to have class switch, but then with my own classes.

Alsou tweeked parameters, so that there are less dots. Decreasing bailout value for unknown reason decreased number of dots a lot. Dots alsou depend on colour parameters. Red dots should be some special orbits, they somewhat depends on random seed. I kind of liked spirals and owerall imperfect looks, but when they are not too much;)

In UF ducks fractal uses rotation like this:

z = exp(1i*parameter/pi*180)*z

And in Mandelbulb3D rotation is by sines and cosines:

SinCos(Iteration_multiplier * rho * Pid180, s, c)

x' = x * c + y * s

y' = y * c - x * s

So gravitation waves inspired Swirlbrot rotation (exp( 1i*(cabs(z)+atan2(z) ) ) *z ) indeed are novel way in fractal world:) I tested it as escape time formula, nice one, it's like rotated LKM's rotated mandelbrot;)

Here is final quality parameter file. It woun't render fast and you 'll see nothing before completion, throught. On my ancient PC it took 2 hours.

Fractal1 {

fractal:

title="Fractal1" width=800 height=600 layers=1

credits="Asdam;12/8/2012"

layer:

caption="Background" opacity=100 transparent=yes

mapping:

center=0/0 magn=1

formula:

maxiter=100 filename="Standard.ufm" entry="Pixel"

inside:

transfer=none

outside:

transfer=linear filename="em.ucl" entry="Brahmabrot"

p_sampleDensity=10000 p_maxiter=200 p_seedinput=-8

p_formula=Mandelbrot p_power=2 p_starpower=7 p_unitvector=-0.5

p_talisadd=1 p_quadfactor=2.5 p_sizescaling=1 p_srcWidth=5

p_srcHeight=4 p_palette="Direct Colouring" p_switchRGB=None

p_ambient=0.12 p_postfn="0- None" p_lightR=0.38 p_scalarR=0.7

p_lightG=0.98 p_scalarG=1.6 p_lightB=0.14 p_scalarB=0.3

gradient:

smooth=yes index=0 color=8716288 index=100 color=16121855 index=200

color=46591 index=300 color=156

opacity:

smooth=no index=0 opacity=255

}

If someone are interested in UF code, here it is, throught Chaos Pro have more normal C style language and complex numbers generated in more usual way like complex(n ,m) instead of n + flip(m):

Brahmabrot {

; This is different from standart Buddhabrot in that

; colours are calculated from progressive curves

; using Wave Trichrome method, who are inspired by RGB Buddhabrots but needs fewer iterations.

; As it don't tests for insdes or outsides of fractal, but mixes buddhabrot and antibuddhabrot.

; Alsou it used both mandelbrot and newton bailout.

; source code for this mostly is taken from Susan D. Chambless buddhabrot.

; and one more loop.

; Some formulas like Swirl transform, Royal, SummonerEye, Gavarun are by Kram1032.

;By Edgar Malinovsky 02.12.2012.

;http://www.fractalforums.com/fractal-programs/problems-with-implementing-budhabrot-in-uf/

;08.12.2012

; Added newton bailout revealing more features.

; Tweeking of parameters, so that there are less dots.

; Changed some formulas for another.

; You may redistribute this algorithm, modify, derivate or use comercialy as you wish as long as you give proper credits.

$DEFINE DIRECT

global:

float increaser=0

float antilightR=1/@lightR

float antilightG=1/@lightG

float antilightB=1/@lightB

int seed = @seedinput

float dataR=1

float dataG=1

float dataB=1

int pwid = trunc(#width)

int phgt = trunc(#height)

;3 arrays for RGB

float pixR[trunc(#width),trunc(#height)] ; offscreen image

float pixG[trunc(#width),trunc(#height)] ; offscreen image

float pixB[trunc(#width),trunc(#height)] ; offscreen image

;calculate buddha loop many times

int superloop=1

int slcounter =0

complex locations[@maxiter] ; collect locations

int cnt = 0 ; Loop counters

float colourcnt = 0 ;colourcounter

int x = 0, int y = 0 ; Loop counters & integer coords

float xc = real(#center) ; Scaling constants

float yc = -imag(#center)

float srcMinX = - (@srcWidth * 0.5)

float srcMinY = - (@srcHeight * 0.5)

float scale = (#height * #magn) / 3*(@sizescaling)

float nsamples =0

int irandX1 =0

int irandY1 =0

float srcX1 =0

float srcY1 =0

complex z =0

complex c =0

complex zold=1

int iter =0

int locindex =0

float dx =0

float dy =0

; Initialize arrays of RGB pixels with neutral colour.

while x < #width

y = 0

while y < #height

pixR[x, y] = @ambient

pixG[x, y] = @ambient

pixB[x, y] = @ambient

y = y + 1

endwhile

x = x + 1

endwhile

; Main buddha iteration loop

nsamples = round(#width * #height* #magn)

cnt = 0

;if sample number is too large, divide single

;loop in many small. 12 divides better than 10, so multiples of 12 is used.

IF @sampleDensity > 497664

nsamples = trunc(nsamples/3456)

superloop=3456

ELSEIF @sampleDensity > 41472

nsamples = trunc(nsamples/288)

superloop=288

ELSEIF @sampleDensity > 3456

nsamples = trunc(nsamples/24)

superloop=24

ELSE

nsamples = trunc(nsamples/4)

superloop=4

ENDIF

nsamples = nsamples * @sampleDensity

while slcounter < superloop ; superloop

while cnt < nsamples ;main buddha loop

; generate random integers (-#randomrange to #randomrange)

irandX1 = seed = random(seed)

irandY1 = seed = random(seed)

; convert to random float numbers

srcX1 = (abs(irandX1) / #randomrange)*@srcWidth + srcMinX

srcY1 = (abs(irandY1) / #randomrange)*@srcHeight + srcMinY

; Mbrot set with random c value

z = 0

c = srcX1 + flip(srcY1)

zold=1

; iteration count and modulus, this don't need large bailout

iter = 0

while ( (cabs(z) < 4) && (cabs(zold-z) >0.001 ) && (iter < @maxIter) ) ;fractal formula loop

zold=z

IF (@formula ==0)

;Mandelbrot

z= z^@power +c

ELSEIF (@formula ==1)

;Talis

z= z^@power/(z^(@power-1) + @talisadd) +c

ELSEIF (@formula ==2)

;Starbrot

z= z*0.5 - z^@starpower + c

ELSEIF (@formula ==3)

;Tricorn

z= conj(z^@power)+c

ELSEIF (@formula ==4)

;BurningSihp

z=abs(z^@power)+c

ELSEIF (@formula ==5)

;8th modulus Mbrot

z=sqr(z)

z=(z^8+z^8)^0.125+c

ELSEIF (@formula ==6)

;Unit Vector - Mbrot

z=z^@power+c

z= z/cabs(z)*@unitvector +z

ELSEIF (@formula ==7)

;Quadratic General

z= sqr(real(z)) + sqr(imag(z))+ flip(real(z)*imag(z)*@quadfactor) + c

ELSEIF (@formula ==8)

;Celtic Mandelbrot

z = z^@power

z = z - real(z) + abs(real(z)) - c

ELSEIF (@formula ==9)

;Rotated Mandelbrot

z=z^@power+c

z=sqr(z)/cabs(z)

ELSEIF (@formula ==10)

;Chebyshev4Axolotl

z = (sqr(z)*(35 * sqr(z) - 30) + 3) / 8 + c

ELSEIF (@formula ==11)

;Mbrot*iters

z=z^@power*iter*0.05 +c

ELSEIF (@formula ==12)

;Talis*iters

z=z^@power*(z^(@power-1)+iter*0.05)+c

ELSEIF (@formula ==13)

;Tricorn*iters

z= conj(z^@power*iter*0.05)+c

ELSEIF (@formula ==14)

;BurningShip*iters

z= abs(z^@power*iter*0.05)+c

ELSEIF (@formula ==15)

;QuadGen*iters

z= (sqr(real(z)) + sqr(imag(z))+ flip(real(z)*imag(z)*@quadfactor) )*iter*0.05 + c

ELSEIF (@formula ==16)

;Manowar

z = z^2 + zold + c

ELSEIF (@formula ==17)

;Multipowerbrot Odd

z= ((((z^3*c+1i)^3)+1i)^3)+1i

ELSEIF (@formula ==18)

;MagnetII

z=sqr((z*z*z+3*z*(c-1)+(c-1)*(c-2))/(sqr(z)*3+3*(c-2)*z+(c-1)*(c-2)+1))

ELSEIF (@formula ==19)

;ChebyshevT4

z = c*(sqr(z)*(sqr(z)*8+8)+1)

ELSEIF (@formula ==20)

;PerpendicularMbrot

z=sqr(real(z)) - sqr(imag(z)) -flip(2*imag(z)*abs(real(z))) + c

ELSEIF (@formula==21)

;Royal Imagination

z=sqr(real(z))- sqr(sqr(imag(z))) + flip( 2*real(z)*imag(z) ) +c

ELSEIF (@formula ==22)

;Swirl Mbrot

z=(exp(flip(cabs(z)+atan2(z)) ) *z )^@power +c

ELSEIF (@formula ==23)

;ConjugateBeholder

z=(z + c) / ( conj(z)- c+ @talisadd )

ELSEIF (@formula ==24)

;Gavarun

z=(cabs(z))^(@talisadd + flip(atan2(z) ) ) +c

ELSEIF (@formula ==25)

;MalinovskyDeco

z=sinh(z)*z^(@power-1) - c^@power

ELSEIF (@formula ==26)

;Multipowerbrot Even

z= sqr( ( sqr( z*z*c +1 )) -1 ) -1

ENDIF

locations[iter] = z

iter = iter + 1

endwhile ;end fractal formula loop

locindex = 1 ;for background contrast starts with 1.

while( locIndex < iter ) ;colour loop

cnt = cnt+1

dx = real( locations[locIndex] ) - xc

dy = imag( locations[locIndex] ) - yc

; Scale to image

x = round(dx*scale + pwid*0.5)

y = round(dy*scale + phgt*0.5)

; Plot the point only if inside image

if x >= 0 && x < pwid && y >= 0 && y < phgt

;colours calculated as RGB curves

colourcnt=colourcnt+1

increaser=recip(sqrt(colourcnt))

dataR = (dataR + increaser )/( @scalarR + abs(pixR[x, y])*antilightR)

dataG = (dataG + increaser )/( @scalarG + abs(pixG[x, y])*antilightG)

dataB = (dataB + increaser )/( @scalarB + abs(pixB[x, y])*antilightB)

pixR[x, y] = pixR[x, y] + dataR

pixG[x, y] = pixG[x, y] + dataG

pixB[x, y] = pixB[x, y] + dataB

endif

locIndex = locIndex + 1

endwhile ;end colour loop

endwhile ;end main buddha loop

;change random seed, increase superloop counter,

;set main loop to 0 and go throught next cycle.

cnt=0

slcounter = slcounter+1

seed = @seedinput + slcounter

endwhile ;end superloop

;now formula will go throught pixels by fractal generator.

init:

int xcrd = 0

int ycrd = 0

float resultR = 0

float resultG = 0

float resultB = 0

float resultAlpha=0

final:

xcrd = #x

ycrd = #y

resultR = abs(pixR[xcrd, ycrd])

resultG = abs(pixG[xcrd, ycrd])

resultB = abs(pixB[xcrd, ycrd])

IF (@postfn==0)

;nothing

ELSEIF (@postfn==1)

resultR=sin(resultR)

resultG=sin(resultG)

resultB=sin(resultB)

ELSEIF (@postfn==2)

resultR=1- resultR

resultG=1- resultG

resultB=1- resultB

ELSEIF (@postfn==3)

resultR=sqr(resultR)

resultG=sqr(resultG)

resultB=sqr(resultB)

ELSEIF (@postfn==4)

resultR=1-sin(resultR)

resultG=1-sin(resultG)

resultB=1-sin(resultB)

ELSEIF (@postfn==5)

float sumR = resultR

float sumG = resultG

float sumB = resultB

resultR=abs(resultR -sqrt(sumG*sumB)*0.5)

resultG=abs(resultG -sqrt(sumR*sumB)*0.5)

resultB=abs(resultB -sqrt(sumR*sumG)*0.5)

ELSEIF (@postfn==6)

resultR= abs( resultR -round(resultR) )

resultG= abs( resultG -round(resultG) )

resultB= abs( resultB -round(resultB) )

ELSEIF (@postfn==7)

resultR=tanh(resultR)

resultG=tanh(resultG)

resultB=tanh(resultB)

ELSEIF (@postfn==8)

resultR=sin((resultR) )*cos((resultG))

resultG=sin((resultG) )*cos((resultR))

resultB=sin((resultB) )*cos((resultR))

ELSEIF (@postfn==9)

resultR=sqr(sin(#pi*resultR))

resultG=sqr(sin(#pi*resultG))

resultB=sqr(sin(#pi*resultB))

ENDIF

; switching colour channels.

IF (@switchRGB==0)

;nothing

ELSEIF (@switchRGB==1)

resultAlpha=resultG

resultG=resultR

resultR=resultAlpha

ELSEIF (@switchRGB==2)

resultAlpha=resultB

resultB=resultR

resultR=resultAlpha

ELSEIF (@switchRGB==3)

resultAlpha=resultB

resultB=resultG

resultG=resultAlpha

ENDIF

;colour mode: direct, using palette, or mixed.

IF (@palette==0)

#color = rgb(resultR, resultG, resultB)

ELSEIF (@palette==1)

#color = gradient(resultG)

ELSEIF (@palette==2)

;gradient is by arithmetic mean of RGB

color gradcolor=gradient( (resultR+resultG+resultB)*0.333333333333333 )

;harmonic of gradient and RGB

resultR=2/( recip (red(gradcolor))+ recip(resultR) )

resultG=2/( recip (green(gradcolor))+ recip(resultG) )

resultB=2/( recip (blue(gradcolor))+ recip(resultB) )

resultAlpha=alpha(gradcolor)

#color = rgba(resultR, resultG, resultB,resultAlpha)

ELSEIF (@palette==3)

; colour mode like of Fractal Explorer.

; uses pallete, but each chanell is calculated seperately.

resultR=red(gradient(resultR))

resultG=green(gradient(resultG))

resultB=blue(gradient(resultB))

resultAlpha=alpha(gradient( resultG))

#color = rgba(resultR, resultG, resultB, resultAlpha)

ELSEIF (@palette==4)

;all waves included.

#color=gradient(3/(recip(resultR) + recip(resultG) + recip(resultB) ) )

ENDIF

default:

title = "Brahmabrot"

render = false

heading

caption = "Use with Pixel aka No Formula."

endheading

heading

caption = "Buddha Block"

endheading

int param sampleDensity

caption = "Sample density/incrse"

default = 100

hint="Main variable. The larger value, the more points hits image, the more detailed will be image. Put relatively small value for fast first calculation, then increase for smooth pic."

endparam

int param maxiter

caption = "Max Iterations"

default = 200

hint = "Maxiter for fractal. Long orbits will stay in certain alredy dense region, but small maxiter will make this too blury."

endparam

int param seedinput

caption = "Lucky Number"

default = -8

hint="Random seed used to calculate random numbers who realy aren't that random. Different seeds marks different firstfound orbits."

endparam

heading

caption = "Formula Block"

endheading

param formula

caption="Fractal Formula"

default=0

enum= "Mandelbrot" "Talis" "Starbrot" "Tricorn" "BurningSihp" "8th modulus Mbrot" "Unit Vector - Mbrot" "Quadratic General" "Celtic Mandelbrot" "Rotated Mandelbrot" "ChebyshevAxolotl" "Mbrot*iters" "Talis+iters" "Tricorn*iters" "BurningShip*iters" "QuadGen*iters" "Manowar" "Multipowerbrot Odd" "MagnetII" "ChebyshevT4" "PerpendicularMbrot" "Royal Mbrot" "Swirl Mbrot" "SummonerEye" "Gavarun" "MalinovskyDeco" "Multipowerbrot Even"

hint= "Fractal formula used for calculation. Mbrot here stands fro Mandelbrot."

endparam

float param power

caption="Power"

default=2

visible = (@formula == 0||@formula == 1||@formula == 3||@formula == 4||@formula == 6||@formula == 8||@formula == 9||@formula == 11||@formula == 12||@formula == 13||@formula == 14||@formula == 22||@formula == 25)

hint="Degree of formula."

endparam

int param starpower

caption="Star Power"

default=7

hint="Star sides = power-1"

visible = (@formula == 2)

endparam

float param unitvector

caption="Unit vector amount"

default=-0.5

hint="Coefficient N for z=z+N*z/|z|"

visible = (@formula == 6)

endparam

float param talisadd

caption="Talis addition"

default=1

hint="In Talis adds value to z z=z^2/(z+add). In another fomulas adds value in respective places. In Gavarun it is real part of complex power."

visible = (@formula == 1||@formula ==23||@formula ==24)

endparam

float param quadfactor

caption="Factor of x*y"

default=2.5

hint="2 is very celtic and 2 is very cosmic."

visible = (@formula == 7||@formula ==15)

endparam

heading

caption = "Pixel input Block"

endheading

float param sizescaling

caption = "Size Scale"

default = 1

hint="Scaling here works as zooming in or out."

endparam

float param srcWidth

caption = "Pixel source Width"

default = 5.0

hint="Input pixel area depends on width and height. Too much is waste of PC resources, not enough will mean that some fractal parts will dissapear. "

endparam

float param srcHeight

caption = "Pixel source Height"

default = 4.0

endparam

heading

caption = "Colour Block"

endheading

param palette

caption = "Colour Mode"

enum= "Direct Colouring" "Gradient Based" "Mixed Harmonic" "Fractal Explorer like" "Gradient by Harmonic"

default=0

hint= "Gradient Based is gradient calculated from green channel, gradient harmonic is gradient calc from mean of all channels. Mixed is harmonic mean between gradient colour (by mean of RGB) and RGB channels. Fractal Explorer like is RGB values calculated seperately from gradient. All exept direct colouring uses gradient and alpha channel."

endparam

param switchRGB

caption = "Switch Colours"

enum ="None" "Switch Red and Green" "Switch Red and Blue" "Switch Green and Blue"

default=0

hint= "Switch colour channels to change image tones in direct mode, so that don't need to change light and scalar of RGB."

endparam

float param ambient

caption = "Ambient Light"

default = 0.12

hint="Greyscale colour value of uniterated pixel. Result then is added / substracted from this."

endparam

param postfn

caption = "Transfer Function"

enum = "0- None" "1- Sin (periodic)" "2- Inverted" "3- Square Power (sharper)" "4- SinInverted (periodic)" "5- Accentuate RGB" "6- Solarisation (periodic)" "7- Hyperbolic Tangent" "8- SineCosineMix (periodic)" "9- Haversine (periodic)"

default = 0

hint="The same as UF, but applied before colour mode, and works with direct colour. Periodic will colour white regions."

endparam

heading

caption = "Info"

text = "Version of Buddhabrot. Use with pixel aka no formula and wait. To increase render quality increase sample density. Difference from standart Buddhabrot is that this version don't test for escaping or non escaping orbits so it is mix of Buddhabrot and Antibuddhabrot, it have mixed mandelbrot and newton bailout and that RGB colours are calculated by Wave Trichrome method. It is alsou faster than most Buddhabrots. It is s suposed to work with plain direct colouring. If with large sample density it becomes too white try periodic transfer funtions. If with very large sample density and resolution it ceases to render, it's becouse fractal exceeded upper limit of integer numbers. http://www.fractalforums.com/fractal-programs/problems-with-implementing-budhabrot-in-uf/"

endheading

heading

caption = "RGB block"

endheading

float param lightR

caption = "Red light"

default = 0.38

endparam

float param scalarR

caption = "Red scalar"

default = 0.7

endparam

float param lightG

caption = "Green light"

default = 0.98

endparam

float param scalarG

caption = "Green scalar"

default = 1.6

endparam

float param lightB

caption = "Blue light"

default = 0.14

endparam

float param scalarB

caption = "Blue scalar"

default = 0.3

endparam

}

Alsou, here is good Buddhabrot links. Goolge search almoust allways gives fractalforums.

This one by ker2x looks great. Throught probably some post processing with reducing image size were used:

http://www.fractalforums.com/programming/some-buddhabrot-questions-techniques/A 3D buddhabrot verson:

http://www.fractalforums.com/images-showcase-(rate-my-fractal)/orbits-inside/ A nova buddhabrot and good discussion about weak point of buddhabrots:

http://www.fractalforums.com/images-showcase-(rate-my-fractal)/orbit-plotted-nova/