Brahmabrot a simplified and expanded Buddhabrot

[Alef]

I was trying to implement Buddhabrot in Ultra Fractal.
Objectives were: 1 - to have more control over colours than in free buddhabrot renderers, 2 - to have more colour effects than UF single channel colour buddhabrots using gradient, 3 - to have more formulas to play width, 4 - to have something new, 5 - smoothness and 6 - speed.

Mostly I just used code from Susan D. Chambless Buddhabrot IV, becouse it is working, throught only 1 channel.

Partialy objectives are achieved, it have colours and formulas and new thing is limit being low iteration number, but it have certain problems:

Buddhabrot sample density is limited to 31690. If I use larger sample density, say 31691, it simply ceases to render and on screen shows colour of zero index. Is this becouse of some Ultra Fractal limitations of arrays or becouse of not enought memory?

Second  problem is zoom, when zooming in by just few clicks it allways looses density to almoust zero. This can be owercomed by much higher sample density, but then it becomes extremely slow. Maybe something must be done with source pixels?

Third, random number generator is not enought random. Throught it can have cool spiral orbits, but with same seed it don't looks random at all.


Maybe Buddhabrot naturaly would go with classes. Throught not all formulas goes with buddhabrot, and not all formulas with buddhabrot have interesting mandelbrot set and probably without .ulb it is faster and classes aren't very user friendly.

Formula is like this:

Code:

Moshiahobrot {
;code mostly taken from Susan D. Chambless buddhabrot.

$DEFINE DIRECT
global:

float antilightR=1/@lightR
float antilightG=1/@lightG
float antilightB=1/@lightB
  int seed =  random(777)  ; Seed for random numbers
  ; for colours
    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

  complex locations[@maxiter]       ; collect locations
  int cnt = 0                         ; Loop counters
  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 transx = pwid * 0.5
  float transy = phgt * 0.5
  
  float srcMinX = - (@srcWidth * 0.5)
  float srcMinY = - (@srcHeight * 0.5)
  float  scale = (#height * #magn) / 3*(@sizescaling)

  
; Initialize arrays of RGB pixels
  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 iteration loop
  int nsamples = round(#width * #height* #magn * @sampleDensity)
  int tenth = round(nsamples / 10)
  cnt = 0
  
  while cnt < nsamples
    ; generate random integers (-#randomrange to #randomrange)
    int irandX1 = seed = random(seed)
    int irandY1 = seed = random(seed)

    ; convert to random float numbers
    float srcX1 = (abs(irandX1) / #randomrange)*@srcWidth + srcMinX
    float srcY1 = (abs(irandY1) / #randomrange)*@srcHeight + srcMinY

    ; Mandelbrot set with random c value
    complex z = 0
    complex c = srcX1 + flip(srcY1)


    ; iteration count and true modulus, this don't need large bailout
    int iter = 0
    while (cabs(z) < 4) && (iter < @maxIter)
  

IF (@formula ==0)
z= z^@power +c
ELSEIF (@formula ==1)
z= z^@power/(z^(@power-1)+1) +c
ELSEIF (@formula ==2)
z= z*0.5 - z^@starpower + c
ELSEIF (@formula ==3)
z= conj(z^@power)+c
ELSEIF (@formula ==4)
z=abs(z*z*z)+c
ELSEIF (@formula ==5)
z=sqr(z)
z=(z^8+z^8)^0.125+c
ELSEIF (@formula ==6)
z=z^@power+c
z= z/cabs(z)*@unitvector +z
ELSEIF (@formula ==7)
       float zx=real(z)
       float zy=imag(z)
z= sqr(zx) + sqr(zy)+ flip(2.5*zx*zy) + c
ELSEIF (@formula ==8)
z = z^@power
z = z - real(z) + abs(real(z)) - c
ELSEIF (@formula ==9)
z=z^@power+c
z=sqr(z)/cabs(z)
ELSEIF (@formula ==10)
z = sqr(z) + (z+c)*z*z - sin(z+1) + c
ELSEIF (@formula ==11)
z= ((((z^3*c+1i)^3)+1i)^3)+1i
ENDIF

        locations[iter] = z
      
      iter = iter + 1
    endwhile
    
      int locindex = 2 ;for background contrast starts with 1.

      while( locIndex < iter )
      cnt = cnt+1
      
        float dx =  real( locations[locIndex] ) - xc
        float dy =  imag( locations[locIndex] ) - yc

      ; Scale to image
        x = round((dx*cosa - dy*sina) * scale + transx)
        y = round((dx*sina + dy*cosa) * scale + transy)

      ; Plot the point only if inside image
        if x >= 0 && x < pwid && y >= 0 && y < phgt

        ;colours calculated as RGB waves
         dataR =  (dataR +recip(sqrt(cnt)) )/( @scalarR + abs(pixR[x, y])*antilightR)
         dataG =  (dataG +recip(sqrt(cnt)) )/( @scalarG + abs(pixG[x, y])*antilightG)
         dataB =  (dataB +recip(sqrt(cnt)) )/( @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

  endwhile


;now formula will go throught pixels.
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])

 ; switching red and blue.
	IF (@switchRB==true)
  resultAlpha=resultB
	resultB=resultR
	resultR=resultAlpha
  ENDIF


;colour mode: direct, using palette, or mixed.
IF (@palette==0)

       IF (@naturalise==true)
       resultB=resultB*0.8
       ENDIF

#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) )
	
       IF (@naturalise==true)
       resultB=resultB*0.8
       ENDIF			
				
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))

       IF (@naturalise==true)
       resultB=resultB*0.8
       ENDIF

#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 = "Buddha Block"
endheading

float param sampleDensity
caption = "Sample Density"
default = 100.0
hint="The larger value, the more points hits image, the more detailed will be image."
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

;float param bailout
;caption = "Bailout"
;default = 4
;hint="This don't requires large bailout, cos points with large value will be outside of image."
;endparam

int param maxiter
caption = "Max Iterations"
default = 25
hint = "Maxiter for fractal. Long orbits will stay in certain alredy dense region."
endparam

heading
caption = "Pixel input Block"
endheading

float param sizescaling
caption = "Image Scale"
default = 1
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 = "Formula Block"
endheading

param formula
caption="Fractal Formula"
default=0
enum= "Mandelbrot" "Talis" "Starbrot" "Tricorn" "Bird Of Prey" "8th modulus Mbrot" "Unit Vector - Mbrot" "Quadratic General" "Celtic Mandelbrot" "Rotated Mandelbrot" "Trotsky Dragon" "Multipowerbrot Odd"
endparam

float param power
caption="Power"
default=2
visible = (@formula == 0||@formula == 1||@formula == 3||@formula == 6||@formula == 8||@formula == 9)
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

heading
caption = "Colour Block"
endheading
  
param palette
	caption = "Colour Mode"
	enum= "Direct Colouring" "Gradient Based" "Mixed Harmonic" "Fractal Explorer like" "Gradient by Harmonic"
	default=3
	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 switchRB
	caption = "Switch Red and Blue"
	default=false
	hint= "Switch Red and Blue channels."
endparam

float param ambient
caption = "Ambient Light"
default = 0.25
hint="Starts colour calculation with this value + 1/ iteration. Density of colour wave depends on this, lowest is somewhere -2.5."
endparam

param naturalise
	caption = "Naturalise Colours"
	default=false
	visible = (@palette == 0||@palette == 2||@palette == 3)
	hint="Removes unnatural blue tint of non-gradient methods."
endparam

float param lightR
caption = "Red light"
default = 0.7
endparam

float param scalarR
caption = "Red scalar"
default = 0.7
endparam

float param lightG
caption = "Green light"
default = 1.2
endparam

float param scalarG
caption = "Green scalar"
default = 1.2
endparam

float param lightB
caption = "Blue light"
default = 0.25
endparam

float param scalarB
caption = "Blue scalar"
default = 0.25
endparam
}

And parameter:

Code:

Fractal1 {
::WNVxign2lJ1yutNMQw7Gw/DE6etJZsUcTAPU3g2eJAFpH6xgNUUSEliUYJVtd/67S9I1A94O
  D3Z2Z52ggOBuH2uhxS2kzoK+yMkogd2Wn6UVH4sOjttLpOckzcwVDGVicHa0UbTRVxni1Q/j
  CxeZ1eJXIL2uZ6dT6qhhkN4VFnA9vaxwovugFGAtNdVJ4cWCBfcAQjPpuaib30DDDWf7c3Eq
  BV89cWP06zG3Ew+RHMR3DXsZ+sONWnxD9UG+RC81AWvbspvgRKgXVFf3ex4oJz6j2azckzO3
  Qt7Dez2Nhx0/T5seDg3I+zhYnF6Cvhh0uRt7dDuloIrxwrRofwZeyQWShtkGyhXHwQLaixcW
  py1EILzv3+HTUDkntzrYCC1/c6jocu4bL/FU1yiQ9MlWjLbbW+wZSt7WaOB4Mw9U1o3m+tRn
  Co6D8dZ9GAnJloQ9kFJC2nDuwISuvO/ntJd3LnoFEVB9vZzfSUzZ58QaEpZNampd5B7FFRu0
  MFEAnAWZ/qSsT+O1a1E1J6dyyb7cFpFh6svT/Lx+QgWG5dnlS9FFnpphGVHvXUJPecBNfPMj
  LqESxxyyFCJnPdWNxdoq8jiFi7+XHlV0tw8B6teShc1y1zXZJNf/FYl6QoK=
}

Moshiahobrot.ucl:Moshiahobrot {
;code mostly taken from Susan D. Chambless buddhabrot.
::ErszGin21qVevttRW8/OGwfHeQe3uiSyyW2xNZriW4yYHVDEnmVud3GUkAMickE3QRqSSFLJ
  kP87v3cQOUHuF7hCiF58On39M2Hf0f6mbfzdv7W6m7Gd7r/pjPaac6YR83d8RHf0k4URBJSK
  iijmOrY0gendt+pdgNsE2wdg5XCz/4jIKKpgylyQaARZikw05NfxLehHR9pH4lnkmZWnSWOf
  sMLnpqva9g040l6FISLmQRhAa22LNc3l85l0Ly6wiHjYdoIbZSQzTwLFz8cgObaRF0ZSW9Vg
  VKzlkILTsOXpUjGq2XaBtIa1oftGP7UnHfk3LpTmkHkJlJU0cxUZNyH+fH5+/HQOzgg05Lil
  ro40ARRUaS+ve9cxqoCZ2HJ9n+s5PWGUUhj1fGkwGrzpD9pP9200Fg+lJFGHKT2KmoOqHXvL
  9bRE9NMiypSOMINLMvabvKQFMJFxNPJQyY75wlHCExRJTBVJ5FIq0hw1MhnyWhSCrAmHlIAY
  8VzTEJTjlOwCSzZY4rdhVgo3cerpiwaRn39qtAybWVAWJQHpmFcfUyvw6F18a82/k9jaM92G
  tPUh2Pocw7gHljdvEoZDBAGng9biHdGdZLQa0GZu2C5pjEO+o+0dJRFRYxNSbke6EOQnjwkx
  KL4jziAjXRvi0ha6cHlfU/oGh1MCaRrXm05Ir6Qr/IQ+ax8xRw07Ac4TB0/gAZRvmaTmEfZS
  oSD0vx+jVWgWQMA8uu+y9iIkQgQAVoNixTXYjTTyFcyRO4RGiGDNJXspUvzM2Usw1aUvRmkH
  Vs2zyhConzKJvkfnR9OXhjJByGKo1OexXVKc9+oPNVmw6o0Wk0kUkTNP9E9S4nTlURK5+uTt
  tIe5fpHHbrrDbKDzvtNaf4goZ1HkW9FZWBLPjGpj8cKe7E0qEbTx48mGtgjDrpntqC6bbzG2
  iJfoOT+wBYiJlwylPUpz3DUlxjzS5WRF0jRQYGlPg+iIepJqxWUcTVUtdJuyhe/0GKW0imK9
  SZXsSpKYSVDDdED5GKSaea4y4l5doiZR5UYayfBmL2GHLygnbsICt5Kc8EgRbnX1Mg3/b8QE
  yz9ov5bomKseFxltvzWJjVm7eDqQgGVzXGjaWD4AuNDoNf66FpPCKaHc8R3+2HudL06VHtza
  u5TN1PeaPv2wifA6uwQXLUHC1mA9oobmRU0+p5SNNIS6f10KQvDw/nrwVt3bh/dI0uShW+vl
  BTE/E47Lbj/79pz727irOAVfrCXrKwIxblzMm6WXvElF/C6Aiu+t3sXO8CPb5IT46mVDUNm2
  sDg1DUNe06HpU1Vec0K/0aPTY1Fdvq1mVtwCH089SmDUlvy8Gs+GJDK5dg5NPAY/M6vuntv2
  EaNB7PU5cjCoxFSr5m2Bes7Bii7fuRFwcAp2zEq1Ef28pLbF0uXk3nu0r6LQ27u5u3Yzs4PV
  jpoHRB7XLQ73msG1XHorQJqJqhaiQVBuRxFUfewuxigPPVVxmDNRn7cUuABzF56KG96WpRKm
  2kZydKm8KtcLd66C84nt7tteWOj6qypYc2eWO+Ri9brC2hKutnaQuDT16gKFVPPkq9Q5wj6P
  rK7P1McVL1EOnC23inDyDt20TS02MfTV4sqxbFhqxmazEysYHCX75qLvPGlgLmJpFpsPINJe
  NFNB+j8oQ52KIAsi+b8ciocHbiVDYhnXXuKPtBPZlboSfzpGIoGBIkrAFaF5qpZeU8FbjV1H
  1hJY7ZT9TtzkBcp9fLroJ8dI1x7smoHP4kIbkJtqacGvWVHWybL2OsktDfa2OsitD3htD3mt
  +ls1/pZrfFb93ht+euGsdmRz5l2ab0OIP0F5h1Qe4OI77isfNk9dVEksGNpWO/dmM0yHVJ21
  CRQXqs0pZy88BDUdbRYBsG/ZzIYIQBb2/UocSUiku5W/fum+tIDxhN1RzgqzsTf1q35n71ha
  QLkZ8JFa4tjaaXoqEj7sm6BD6nk+IZL99YUcMNNFx/Qe8kK6hrRVlI0n574v4z2kFq79rOmU
  5b6sfsNXGXMa3lGu7S+7u03HvYmYw5qD7j0W+Y/kVinsifxIwTWf8RVyqKqHQ7ow5jeWEGWh
  ww9igfFC+bhAkYfKHFXDmxnYLjzUR13xYgMYVemqxhG8Ift3V5Gc3MGZAsNPZWZU5KjG4gPT
  eZzF4f01K4J0kfHFGhMqiO0ycWbWgqYFFyOEaNMHeqwumZrMA0jWVGWoAlIKWmhzRlLdUX1n
  6anPGX6llwKVoTY1hbilNdcTj23x6htPoTeLbsWqNcb1SGMNTEyHWywlhHgGe6NqvFZCTnOe
  NOBI62NXWEFQzliEzRBP+INvVsW94gShQWlttRcttqK2nXW/jqHZ/Zis5pJQCg5lin99KJV6
  5uAF0IVZOWEhNLltHmXSX+zgqHzXDdDrR3U+qPOMlDdp0vGlcc4hJ0XT4/zCAe2zAvem6nuB
  4C+nOaBwxNMRc44kOOs5A+feS8+kTSAFH9ZJ7UeTmIoQET3uaBklMrLj4yccIWQMoG5FjXWQ
  SRwMKYmIRiabR165mLXoO4a86ulFTGYdiOxmj8qqlMoyZVL6tqYygSniDC+VIstRTHf6wn/v
  lw+UeC633V8cP447DbreKFMTUQ8yQVVnT2Kd7yzauVs/Oh07GqSM/rNX9xHhuiCAW1GoIqQd
  xRNuPNfWkYWKfc5G6yto1LvJnIizl6jZOTCdJZKKKIWoOyLI0fZY4MB5jm1fGECqKxy2GahI
  TMnqdnJ1YxDKIkBUjSNEwQD5uozFaUUMoxPhRIVHeOTf89OqhKnjAV9kl50sI8D1AlOwClF4
  s2I2U1KesZizualVpbsqOONN2op2RLqrkzQT93bg0QrS21hgBQtFjbigUCLPwrdpHSp1pLRa
  SCfLLsqJ4z7z49Ya2nZSQ8USaR3abejl3VL77aRLvCh+u+D9igR9r40zxbWbY5lRkJ/tlo3X
  e9LkoDffnW7p6EQawKLepJEIqGeH1MKtm9dVU11rr0SzFMXzYevYFdn9iTyrtpv4qKb79aSV
  XA/Edppu0bTVmrxRK9DqDOtGOPRCFIzK4r3TEj6NrhbPJXiN5UIitd27LQ+98cZgPLQBu/AR
  zV3oaNucHbN0n+qegcdFoGrM3E2e0mcUhOQSKw1Y3VcWRFD3id/g5mYPE/0wrxwnXnh73E9G
  zMt738oFvZu3S6G0w2UxQdlYHoE5y5KPt9u6aQN+Ju0M++BcMc7SZRBpZJ4J/IMr6POBpiy1
  41XiAUzNtR3bQ+nxg10/QfDOnWu6ffpIkD4CohqLXNGr9aZMvQNpPKtQ1JruKhvy/8a6mMx0
  UWNuH6fk6GUUXw4PGG24weYzF2UaReP/ujd4ijP6LR5Rj13hvztmQn/1v6+av6veZ9X/26v+
  y6vy37z+zQLv7OHVkt90265LsViVQ5CA8tlbuvwGHcTch3hNNVX2mjwVOQzVwJmzXrqjScq6
  3miWPedqcykoA1ckvTVmYzgNtfXrNn91Nf9wK03697Hr/a94R7LUnbFacs6+4Y6sdp8eMYFI
  8ZmI8bUHzg0ABbQM0Q7Iw+icZIHUxH4g+BzUyYhtnHTNomLlYw9S0hss2oLxzKL02Chb5UO5
  tzYbTySnTqxwUz1hB76UhX5Y7bTsmM7xF4pYMEn3l07FQRJ1K8GLLeklSFf0WrmYn4cuDP7x
  Cc44eNGsEY0UtnOwko2dnWidpvHKqclcRh5sfGdgbDrm1t2RTUDVa1it7jYyfMHWteYwDqVp
  Rmj36D9z1FZaubdT7B7qt+TUap8XPmjk/e9a0b3pK/5dv4K3cY0C1Y/tGOmFqu+qfrF6m+tp
  enV975ordQN2VZomHeFNcXAtMnAHYi7QxowQuaKn805yHnJxwYneR3r2vVsao862x3VuuJ5J
  ffmR3MdTWpt+pzrXU/V+gQaHQjRy5p8A4LTM6h6+Iw8x8FWOBzmlcaZYBOl8s0wn0tY/LowZ
  fwu2494RexTMZg+KI3hN61/jzH7fzGOsZoKXfX9pX3L+90n9xo9oRPJns/li4O4KbvjPQI7T
  rR7hR71EVnT/bAwg7SH=
}

[Alef]

A bitt tweaked implementation. Here are Mandelbrot and Talis. This shows fractal orbits as fethers;)
Throught this still ave mentioned problems and don't have quality I wanted.
I would like to have any suggestions of whatever kind.

[cKleinhuis]

hi there,

so, rendering inside ultrafractal leaves you with a lot of invisible action that is going on

increasing the quality of your output basically the only thing left to do, is to use MORE and even MORE checked starting values,
the more iterations you use the more clearer the final image becomes!

[Alef]

Main problem with UF buddhabrot version is that it is implemented in sneakish way in iterations done in global section, so it just can't be rendered in a flow as in dedicated soft.
Should try to increase visual qualities;)
So far all other UF buddhabrots are map based, its easy to make but don't looks cosmic as original ones.

[Alef]

Mostly spent time on coding and then made some fast renders.

Now this slightly faster and with more RGB colour channel switches, one more colour transform and more formula variables, throught zooming still are so so.

Red dots on mandelbrot picture should be some some notable orbits. Position of red dots depends on Random Seed, and with the same random seed spirals allways are in the same places.

Here are two mandelbrots with different random seed and mandelbrot with 8th power modulus.

AntiBuddhabrot seems to be stronger than Buddhabrot becouse escping orbits escapes pretty fast, but non escaping iterates much longer thus generating more antibuddhabrot (non escaping only) like picture. But here mixed version goes pretty well.
p.s.
My monitor seems to be a bitt dark;) Well, any comments about this are strongly welcomed cos I alone with just my opinion won't manage make this good.

[cKleinhuis]

yeah, i hope you base your programming on the dynamical formula system, so that a formula can be exchanged and display its buddhabrot form,
this is what bugs me most of the programs around, that there is no possibility to switch the formula

and since you are working in ultrafractal, please please please implement it using the object formulas, this would be awesome to play with, even with no live updating of the formula ....

[Alef]

I alsou was thinking, that having object formula switch in buddhabrot would be pretty good feature. There are formula switch, but object database is 100 times larger. Throught some object using formulas are nightmare from usability point of wiev, and some  formulas with buddhabrot turns out extremely slow. And this was alsou intended that it would work in Chaos Pro.
So I was thinking about uplooading to UF database two versions, one using object formula switch and another with usual user easy switch.

x=x^2+y^2 +cx
y=x*y +cy



z=z/2-z^6 +c


z=z^2+c
z=z - 0.5* z/cabs(z)

[kram1032]

haha, wow, it's a bomb, a fat star and a fat BBrot.

[cKleinhuis]

no, the first one is a fish

[Alef]

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.

Code:

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
  +OzsP4uUkJHaNQkEndmZndetzsLzJH/Dv8Vv+u39K4l3d/rexHP54Fxpz8j/pTOeecqfBElE
  kJ8zFZTuQDyPpIKOaxyi7nM88bl/6gxmaGb6Bj5ZGz7kjBcKKgchIEmAwt0PiSWvpgGBAJlh
  +F+4kVF00DB5RgkAJ2u+xIitFZbSCafK+QxyOWjucRR5oLFkExDT/b8IwPLzfXOMPNDufKLq
  yJad027/NHeemLP+MSOkOfeOq7EJQ0K/FCHyn+/H5e/PQOvmC8jD2E7XIgZbCDX6DxpprhV+
  J7gioVicj5YzaRGNmUDzgiDS3kUIyAyTggGkuadsYLyjA/io0k8f72V+bjQU+MI/bMiTcsIo
  oEHN7CSIV/FQT/NGeDJaq5Mvc5jcMdTWDkPWNqkK9ctlQ9M+n7OkqKzE8jEiiF4CNINNL0aq
  3GQuoY4Qc7TDEE2ds4yHQlbUyCkqk8C0X3iwdEh9JDhhwyBzjS8xhxvafqfyiYRH7FbONG+l
  9YW0mF82ok/Nxdo9t4T/LyhA6CXM46OVR7Tlo9LsnyB4B54aQgop9lQMOFl6kOw5wouIpR7F
  5y1pFZJ5+knQO7ZgqCJ0CchuEUwIdfUmfS4/e4Bg+ECSBzIuloZA9JDItj3+KPH4watrq8R0
  BMKJERymrhbdnlwdGJ5kjHD3lEVEhL29Cdqg05UmAKEUEnDPGhLwExmiM/Ylf5Ai2HXGhaxt
  wPDyAUZGH21T+TJC7IEk6ZJYQmZZ7ZwuPjIfr/qZRoS0awpfrB9acQaq3B9AV6SRSILBynoo
  jt6B1DRDgPzmT4t+RJ6EGkaljk5UH04lWfIDjhCVZlIXH5iT7DxmKZcrSDHNHkEDJbWNDtXR
  5QRaKE7ntQcGEG9QUogiMWQC7YOZFKKc+q8V+xxDghXqQLHmJKIbexS/EY4Fol4uXj7nw8/l
  ik8oidwfDua4VP9yTO2SolJP1AOf4VXhSqVCwru6kjf1b+wrqjbju66n8NZ2lu8Cn5X9uXe3
  rpEoWUVqD7WZOwVtMOSrcNYeOuG7Q8RavKTP/zlZvJjn5BdmDJ+kh4nLnXY8KLjsGdi+FiEy
  iLAKUNdlO5YO0u/pSQ4nLEodDsfWvNrKmfieHeJKtpnsR5TNiiWOw0qPIyKo5RJJqkPsnTuE
  NZmDM/l/s82q5myd5IZdLTU2TnB1Q+ncJ/TNQuKBqm+PVKnvdWWKVPThM9gSWDgH8j3oi42X
  mJg2YQK09w1T062sIYtsLj3Y7LWEVIsKNcT8m8zQXdMgJMN5viqBS3xxNwM/IMVkK4XmG0Nx
  T7Aa9tvD6AcVH4H/Rodk0xh2/+Oebtxzz8DKw0aYxPrwKGgSPIOuq9t6BmMhcDH/WUwEx0a/
  kj3PB2/lbXn+Iy0eBmoHbaol44Pi5WzdQ/827/Sb5P7ja+ewtFEO+hhdaiTUE24PU4nVO3dx
  d1wd6QmibEnpkDoeyHxCSWUQaWCTN6n9farlnONMpUKixebySwUTfIa5aiSWn+doj2sd8Nob
  hyEK9WIqz/9M0iQ/CZyN9w/15LXMY4lX3AneCxpfF3gC+nY9VYFq9L5lWKISJ9x5K7d3b3gE
  8gE/e7rlvPl47/YjfI51FAT5o/YmPkIyF/svDZaoH5SawHVOvqR7qA392fHZ0cfa+60oF4Ga
  GfhImmOHvIo0vQ9EuIVTByNaNZEn+Nw8nRM/+0CMBWoL3rolk6ftmqefW2R/FLFz2lvU8wVP
  fLulfRsU2aLZQ32juGTiLfAlqRXQi6IKJyNNqBGyRDs5rbksa3Sxjhge0XcdjxSXaCmqhcnI
  qeGm1kH6Q7AiS25GW097zGnIklRrtYldgyfCOdt2jE9Ft4S7/PdH7YrYbyw8EpyItI/r7gXm
  5vINRauVG4eg2svvXAZvpq433zOrVTsmD0e7G0tnVE8uG/9wQ5aD/b/XG1No3woOfZUnyvqn
  X3IzAvIRgBRqcIqFPKWnrVE9Dawx+ZOO2f8K5aMorxpW99N9uBFi6Zylc0x7FZrxaIjouMzc
  SuZFqabqg+sp6SjRyOsWr+0lMpb2qsjTZ3mYqhyBV74xfxV16W0LMG/F002bySkUzhqhBYIu
  dImxcmfwXXwVhRRDYR/54+84GMFqOBGOoUG5pqNxk7Ym8zS5pjuDVrJUXUM+ZvhaQlLnwtmm
  OtW3aG/ZgUobDswnK2nb6vZ83FUKpyGX563MH0g8vtmiObHutL3Kafk9dpGW7QJ5Y66xHySX
  djklNcUSK3hbPiUiJOkucRhi0S559YWVs0GBsOl6cLNJeHgdKEhFEjdDURIxB2C/NqpesOGS
  PzH5D+7dGoUfW0EZ7BpMD5g5ERCB/cu5ugNZPIyLR1cgDTM/q0OBWHQWmIgKg73zKabwsjlS
  ReMWk1pt8X9KJGwoUs0fUa8zuXt5WZzgYUh5M3qywpGGOtJGOtkhTPghTryQPDD9aihelM07
  AG61xWRfQXtWP0TqROA5p2IP1B5pHgsnNyeOI7ZLIUWp5OpQuTFeb+pKbxYLfLcrzs0FZi88
  JTwe7Ek/EaW/LqmyQPMKr3PEKmHlIgX+KvfdqFDQBMDdhbLDFQ6OX3wV3hXcRnzgWA2cGdiQ
  t6YRmSU1CrbmLn8HutszjXXfcIvDWydppaHh6t6Mjt1qhRVTknhUQtwwMjHATPcB38xiUM2E
  XQU7PJitFQwugYBm6jiQw2MsOnwymSpAGV3dlnwLt7Zs5o6cXlWdtiiSS6jmM1PGFH7IEqDj
  Z2OTSdVLrp0pxEhV8+T0X0x3lFKbFiPJQzTy+IRbMuZ89HCa6hg8OE0zjXv0XeyoorAfA6ge
  GPdL9gaCPF7pvcuKjzxRPjx5zd0IMtEhp1igXJCeVQw0n2608i5JUXaHxaSsnxkF0om9w1YM
  kw4IlsNhqkR97OGwTtAPtEsnFYZ4/BM/SHmPsvWfbxaDwpWM2A0rW2OyVm56MOUmNgdlZDYP
  iL1w9rc4OdKs1w9SwOcvEcDaEaTP1hbuZF5LY0IGoTNQnaB1zAF1J2Cos0JprVfefIiHdJS6
  o2l1I1l4OtE37rDXPLc9qg7UDu1sAfCp90yG7naCy6LzIq1mQpLvDiTdRcqFieOI65ioHjYN
  i0TdMoF+JLrziaB3xkaBvBb6NHECZtGpqfab4b1gKr1oNi33paYm1a8QErRme2BhI8VNsOq7
  hzw0aGfanqBNuj71pzRHJnaTd6jhcsk4gly7Dh3wi2AKBTUj5kPilPJGYFXyTQ6oycTHZWDW
  4MkrTxOZb1kFTnUNny9TswvB+eZD81zaR//CfH9nmvHuCU8FAjGV32wq0QxPBhRYtmFnBboj
  GHWj1SXUIODweUWhbGGOQn6XOgU/eyxnS8g2WObxMtTzZ6IN9Pq6YrZBp+NMYRmfId/CWBJ1
  RDraHrRmOcfcTa/MsXpVUjqwKhfi6KVwyHYezsm/5EzkAahtna66pFVM5zI3/AeKX6ntKNBn
  Bk5mpnKehnJjR8SsiWgranmiw2m5mOBBZ182ZoMGJb6WQ3xazUO1mSPHKnFvR0MhU49RccF/
  ptfkP9pFlIO2mW/mttnZxmGsZ8x/AWebQc0XFki81qqre1214cJoirGjegicyBEpGdAnhF1J
  8DWyB7CsOtInGsyFr5rSIe3gyNG0KeL/JOjkWZXqgd84s2IwoItQwrEhqKNpPlFfcjM+WqP4
  7r/4SGGjKE4RfsNSqG74NhcM5pV8rHRHMjjT2B+OH6TAdOqyBicyxY3H+4wYJnFRF89326tp
  5Lj8XmSnATLSTgN4QLw5+x5CZLBLFocQpbD8XzXwAS2viNDwnlx7piqB/v6DvLFets07Bt4q
  0N01ET8kNf4h9V91KkIL9etfm/Koy9cZxgPIvTwQ5QnTtpkLaZWn0JycBWpNuZRxkW8lT+Am
  VxfG2GC8xlC51gkJvxlz4TSYF6wKPOhcYZE+BfKCWjFKK8xmPCltXMTdMDDg3vhKwHdfjeAd
  blX6okx8rFyc6MgmHlhfq9zx1Az3ky2rIMzXlibvhNrEoUjsSgTtPLNNWpT0NbSJ8t0HLx+f
  evaIk6x0KXPAugwRlGYa3AMkTzF8xBwHShdpbQxLh66jEN6t6hzG/Ya2XJSQxD37lkrxlqYl
  nyYbRt04peRPcMbv1fLcn+6qydsXXqtXK84DDjVgykKDg3kyCysI+00Qlceh/O6yeDEZFkJ2
  PGzUsjdKw2YFLY9MlwRaTUCkk2V+YKL+yxobTGzPktrqW3yPs8NOyax8mNBfdH8O+yFdWK9v
  R75dfZv0UewQqH5yXwGVn2qrnEecZKfIe0GgC6C7Y7gEpBwLjmPXkJUvIU54CI7r5428aosL
  2c+oHl6oqLn6iDVhtNEIKX8quqN0NplONvi6y1O1crAXOsFUfRKtgW8FPgfrvDOCk86DaR5C
  M3RG+0B38FCrm7wChewNQhwO4OiQYHe1OEi6TyWdDNIIrLXRLy9MPZfZHWys5WLUyj5+HYas
  vTAaCO4k8Jgqjk3Wm+4V4THeM5tUeVgxAoPwD21iiVsywMQdNzLR3DKSJB9ZmnlapGq6goe3
  xkZZkXpmxk/e6ZLD9lnc8DR5RzkvKQWnxPcxf8H2PO09xRuPel7jPx9xbcf8ZV4cFWP8yKPX
  Zu47bqh4b9dAbtiJfVo6y+p6Abe0c+dKZCou6sWNqTusTza6y7b1ayZPe1tw6viO/LLhoP2P
  tWOeRqY+8oAu613xuA7nsv376u/8/Y/f0sA9kvhApvYKLxhDGAEWE9sloMULHPPEdvkb6hp4
  238M7a0G+tEkyrizO3DDgK2cb3d2Okl6kLpNueQktD3YgTHQl1bBMNflcL2GExn6KiX357nH
  VWLk8ILrPXq9Cz6VkztoG61IjvqF3KZMOdqXfQOkm2ZOnuQi9ppr4d1TodpT38Njr1vWL1I9
  501RIAeYn5/6BXYzwKs7XUvdaNxP54OM8KXGWvK9Fy+LqTbSVVqSTJrpuOCfL2YSLz2RvkbH
  GkjhMBTwOV31nHWAGnKmaMG+FVjhtKTzqbnh7zxmSsXVD6ObCqyT7OFkHopVTreewsyrAuHG
  9JgcWJem+UrSskMd/xU9NmjPBkrEkCD1MezEFPSzSJfkqq246wqR7O6+gt4YtqCaGI044+Ga
  jTv6kz4A45ogK2KWXoOhClMQOwcjiO9izdkpliqu1KPQ9xp4GJxQVm7clbAMp17STIDoa47p
  b0Dnmpku/Qwe4qqEKjUJ86M3KMrcaWcNfyrWh7YAfORkfGGfILwz6lzqET+ay4ZTedaKTz3K
  028CdapHeuEG8mDiBpXcIdeFcptTedrKRXmIHnSazJ2QGKvDlBoyhazU19CvnAO25Q+mZ5Fk
  Pi2fmKtueLm8QHdEzPiF5mj1xCveTSgaLGpFDadRfQZ1G2H+AmkrN6aFliFG1BhdZf4O+l+j
  jgHhYg7agZH5Nuh25YAAiOh5V9R3hcoNiOYzhr7DPPguftNUJ5oOGh9EkPpoWH3HkFRnp8p9
  hfZHCYWaMGY9RychbPDYprs8JwZB/EDBdJ7ZIZY7+Z0g2jYbUATLrUPqY3vCKB/v+aZXM+rX
  HHh63Zi5U/oWHAzZsnicHBu3cnYLsFV1sJb9RR4jYXu62k+T1sAFqP77u5m+/sH2ESv3h14B
  O6ZfjNqk3z9B8RCvCjey1NzI9/BTs4jMUuOJ6ZfXJqOOVjMNcw3TkcTYR5UqViGe93TiqhR1
  qkGZzo/LPj+IhA==
}

Code:

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.

[Alef]

Here are pics

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




z= abs(z^3*iter*0.05)+c
iter=iter+1




Rotated by 90 degrees.
z=z^2*iter*0.05 +c
iter=iter+1




z= conj(z^-4*iter*0.05)+c
iter=iter+1




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

[kram1032]

you get quite some nice results.
What you do seems sort of similar to most of my works.
Except for the first, oldest one in this set (which was made in Blender and Indigo, although it's such a simple scene, you could probably write it into an indigo xml format by hand), all of them are some sort of Buddhabrot fractal.
http://kram1032.deviantart.com/gallery/8114987
For a while I used random polynomials of fifth order. Those turned out to be pretty nice.

[Ryan D]

I enjoy fiddling with Fractint and using its rather simple orbit display method of rendering images to come up with Buddhabrot-style animations.  Although I must say that I'm completely baffled by what video file settings might be needed to come up with something that looks good on either Vimeo or YouTube - the shaded, wispy colours are usually butchered by the compression routines used by these two sites.  I can come up with something that looks fairly clean with Sony Vegas (images are rendered, processed and uploaded at 1280x720), but most of the Buddhabrot-style animations range from mediocre to dreadful when viewed online.  Oh well.  Nonetheless, here are a couple of my favourite orbit cloud animations.  The first is a Barnsley Julia, the second one of Fractint's invented generalized function fractals using the old buggy cosxx routine.

Ryan

<a href="http://vimeo.com/moogaloop.swf?clip_id=49018096&amp;amp;server=vimeo.com&amp;amp;fullscreen=1" target="_blank">http://vimeo.com/moogaloop.swf?clip_id=49018096&amp;amp;server=vimeo.com&amp;amp;fullscreen=1</a>

<a href="http://vimeo.com/moogaloop.swf?clip_id=49084660&amp;amp;server=vimeo.com&amp;amp;fullscreen=1" target="_blank">http://vimeo.com/moogaloop.swf?clip_id=49084660&amp;amp;server=vimeo.com&amp;amp;fullscreen=1</a>

[fractalrebel]

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?

Whose Class Switch are you using? Mine and Dave Makin's are substantially different.

[Alef]

Whose Class Switch are you using? Mine and Dave Makin's are substantially different.

Standart. Yourš seems simmilar. Maybe David Makin's could work becouse they uses different switches and bailouts so probably don't have #pixel inside.

Changed coeffs, so that colours are less bright + sine transform to turn whites back to colours + more sampling.



Lines should be of not enought area of pixel sampling.



 z*tan(z)+c render is nice one. I tested the same formula, but got something different, probably cos of small bailout or something.
http://kram1032.deviantart.com/art/A-nice-tan-157868619