Much improved version. + Now this allows much larger sample size * screen resolution. (sample size * screen resolution can exeed integer number upper limit). (800*600)*5000=2 400 000 000 when largest possible integer is +2 147 483 647.
(added extra loop, so that nested loop calculates fractal in 12 parts thus 2 400 000 000/12=200 000 000 (<< 2 147 483 647) so allowing integer math.)
+ Better zooming as it woun't loose so much density by puting hits on pixels outside of screen.
+ More formulas and colour switches.
(some from Fractint Ogfrom, alsou Perpendicular Mandelbrot, and looking in mmf and slightly modifying some formulas found that z=formula*iterations*0.05+c can create cool cosmic deities.
Colours nicely improves when going throught sine, becouse all white regions with colour values >1 ar turned back to colours.)
+ Tweaked the coefficients.
+ Removed excess internal variables.
+ You can put lucky number and see, how different random seeds picks different orbits. Standart random numbers aren't too much random, but this nonrandomness allows to show specific orbits, and with same seed they always 'll be the same orbits.
Still haven't managed to implement class switch, becouse it needs formula(z, c) which don't use #pixel variable. Standart class switch uses formula(z) with #pixel inside of pluggin class. But buddhabrot is calculated in global section before programm reads #pixel. Any tips? But I think, now this in enought good condition to be finalised, just need to write some explanations.
This is slightly different from buddhabrot and antibuddhabrot algorithms that it don't divides escaping and non escaping points, so it is both a buddhabrot and antibudhabrot, anyway, most interesting are region in between and so it needs fewer samples to create final shape what is pretty handy if you are dependent on outside aplication and don't want to look on clock too much. Alsou this do not reiterate formula. And colours here are calculated differently than of standart nebulabrot with 3 iteration numbers, colours still depends on how much times pixel is hit by orbit, but colours are calculated as smooth growing curve so that RGB have different curves. Probably last thing pronounces first notable orbits.
Fractal1 {
::+IviZjn2lNVTPuJMQ07Ix/BEnaPssYSgQalPsJra6ltqa3D9Y1EbDYVjN12sJp/67YgkGpKk
QMf8ezb+gGLw8g6TxRJJepXJopfZ2FJN5kk77o155JdCZbnnWhfqgLCrjSCIYWBX6d00ncco
/zkiHxncSRac0UaT0ygBv0opp7A2vatmRNPNxMAMp/ClgM6tg2NAWh2TvIcxR9wwgU3OjG9K
s08si8yVlbIrX9YeSP0qpks1xRNGb/oCmStHOLD5G4sRqEaoHbn38gmDWe2YTfaCym9CN97y
zCFqSp2J5i5uPoiGEu2oFxRmR//HSJ1CweH5vYcdSozc0a8ZjM1tCcfg0AHD/0B9DKxzCskY
jjjyc05VNXMZ5E48UPM6pPUPDap/o77EHv46Ev/0Zjy4VYoBzpAwAMPYnt2gWjap/dBzbs0H
yzKn5BXoSHw5UCa87Rg3ATZUkVGIQ+Hhjhpobxx62gHL7HTb/F8o9XnvBWHKNoEeP2/PLtYl
S2jaa0ioTDpeS6ZdveYH9bTTyAco/oMsezzIFTS35bwLi6HSeDHp7NO89LyzJfYQYlGuk9xA
TqQBfFBta7iKQNC2gnqyrxPgWb3eL4BsBuFbXogl3jN4ZVcUrF4BBNted9GD2p4pXiUzFnp5
JMshs06Nkqi66FvhzqZ/kKSBpuscJAu7muUnituqcLZJwq/hosCPpmv5vvmaztSe9PiiSUw/
FglkokN=
}
Moshiahobrot.ucl:Moshiahobrot {
; This is different from standart Buddhabrot in that
; colours are calculated from progressive curves
; using Wave Trichrome method, who actualy are inspired by RGB Buddhabrots and needs fewer iterations.
; As it don't tests for insdes or outsides of fractal, but mixes buddhabrot and antibuddhabrot.
; source code for this mostly is taken from Susan D. Chambless buddhabrot.
; and one more loop.
;By Edgar Malinovsky 02.12.2012.
::Z/BUlin2luxavtNyxPbD4/DDkveVPsktssTcOdqwh5hODkkm6krtBHSAoIXJxGKSdkU2SC3P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}
Moshiahobrot {
; This is different from standart Buddhabrot in that
; colours are calculated from progressive curves
; using Wave Trichrome method, who actualy are inspired by RGB Buddhabrots and needs fewer iterations.
; As it don't tests for insdes or outsides of fractal, but mixes buddhabrot and antibuddhabrot.
; source code for this mostly is taken from Susan D. Chambless buddhabrot.
; and one more loop.
;By Edgar Malinovsky 02.12.2012.
$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 sina = sin(#angle)
float cosa = cos(#angle)
float srcMinX = - (@srcWidth * 0.5)
float srcMinY = - (@srcHeight * 0.5)
float scale = (#height * #magn) / 3*(@sizescaling)
float nsamples =0
;float tenth =0
int irandX1 =0
int irandY1 =0
float srcX1 =0
float srcY1 =0
complex z =0
complex c =0
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.
IF @sampleDensity > 41472
nsamples = trunc(nsamples/144)
superloop=144
ELSEIF @sampleDensity > 3456
nsamples = trunc(nsamples/12)
superloop=12
ENDIF
nsamples = nsamples * @sampleDensity
;tenth = round(nsamples / 10)
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)
; iteration count and modulus, this don't need large bailout
iter = 0
while (cabs(z) < 4) && (iter < @maxIter) ;fractal formula loop
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)
;Trotsky Dragon
z = sqr(z) + sqr(z)*(z+c) - sin(z+@talisadd) + c
ELSEIF (@formula ==17)
;Multipowerbrot Odd
z= ((((z^3*c+1i)^3)+1i)^3)+1i
ELSEIF (@formula ==18)
;Magnetic
z=(z^real(z)+c)/(real(z)-c)
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
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*cosa - dy*sina) * scale + pwid*0.5)
y = round((dx*sina + dy*cosa) * 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
; if (@progress==true && cnt%tenth == 0)
;$define DEBUG
; print(round(cnt/nsamples*100), " percent")
; endif
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=cos(resultR)
resultG=cos(resultG)
resultB=cos(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 = "Moshiahobrot"
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
;bool param progress
;caption = "Show Progress"
;hint = "Shows how rendering is progressing. So you can see, that it is working or not."
;default = false
;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" "Trotsky Dragon" "Multipowerbrot Odd" "Magnetic" "ChebyshevT4" "PerpendicularMbrot"
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)
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="Adds value to z"
visible = (@formula == 1||@formula ==16)
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
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, 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- Cos (Inv 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 = "RGB block"
endheading
float param lightR
caption = "Red light"
default = 0.39
endparam
float param scalarR
caption = "Red scalar"
default = 0.65
endparam
float param lightG
caption = "Green light"
default = 0.99
endparam
float param scalarG
caption = "Green scalar"
default = 1.5
endparam
float param lightB
caption = "Blue light"
default = 0.15
endparam
float param scalarB
caption = "Blue scalar"
default = 0.3
endparam
}
[/size]
p.s.
If there are someone who are making another Buddhabrot aplication, I think, this could have some ideas what to do.
May 30, 2013, 05:12:18 PM
Dilber MC Theme by HarzeM