Fractal painter (Python recipe) by James Coliins

ActiveState Code (http://code.activestate.com/recipes/578051/)

# PREAMBLE



# My original intention was to create some

# disruptive visual camoflage, inspired by the pattern on

# the bark of plane trees. The result was never quite what I intended

# and several fixes had to be incorperated to aproximate what I wanted.

# The end result is effective though and reminds me of a Jackson Pollock

# or a Monet painting.

# I think that the program does quite a good job of producing an aesteticalty

# pleasing picture, through a purely mathematical process,

# though some considerable tweeking on the part of the programmer

# was needed to achieve this.

# In this version, I am able to show a wide variety of colour schemes.

# Artists code their colours according to three dimensions, (hue, chorma and saturation)

# This might be a more apropriate approach than (red, green, blue).



# CODE



from Tkinter import *

from math import *

from random import*



# critical parameters, adjust to suit

W = 800        # canvas dimensions

H = 500        # golden ratio  

nLow    = 25   # recursive limiter

nCover  = 0.05  # Adjusts probability of a particular area being painted over per sweep

nMSpan  = 10.0  # Same as above, These two parameters depend upon the number of recursions

nCSpan  = 8.0  # Same for colour range

nSplatterSize = 0.25

# scale factor per recursion. i.e. not scale invariant

aScale  = [0.05, .1, .6, 0.9,0.9,0.3,0.1,0.1,0.1,0,0,0,0,0,0,0,0,0,0,0,0]

# colours 

aColour = [0.5,0.0,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5]



# The two functions VibrantHousePaint and DrawDrip

# can be modified to suit 

def VibrantHousePaint(oM, nR):

    # colour scheme

    rg  = oM.rg

    rb  = oM.rb

    gb  = oM.gb

    cR = ColStr(int((ZeroToOne(oM.r + rg - rb - oM.rgb , nCSpan * nR)) * nMaxR) + nMinR) # red   

    cG = ColStr(int((ZeroToOne(oM.g - rg + gb - oM.rgb , nCSpan * nR)) * nMaxG) + nMinG) # green 

    cB = ColStr(int((ZeroToOne(oM.b + gb - rb - oM.rgb , nCSpan * nR)) * nMaxB) + nMinB) # blue              

    return '#' + cR + cG + cB                         



def DrawDrip(nX, nY, oM, nR, bScheme):

    colour = apply(bScheme, (oM, nR))

    nL = (nLow + 0.0) * nR / 3

    nX1 = dist(nX, nL * nSplatterSize)

    nY1 = dist(nY, nL * nSplatterSize)

    nL2 = dist(nL , nL)

    canvas.create_oval( nX1, nY1, nX1 + nL2, nY1 + nL2, fill = colour, width = 0)

    canvas.create_rectangle( nX1, nY1 , nX1 + nL2 / 2.0, nY1 + nL2 / 2.0, fill = colour, width = 0)

    canvas.update()





class splat:

    def __init__(self,z,r,g,b,rg,rb,gb,rgb):

        self.z   = z

        self.r   = r

        self.g   = g

        self.b   = b

        self.rg  = rg

        self.rb  = rb

        self.gb  = gb

        self.rgb = rgb



def ColStr( x):

    if x > 255:

        x = 0

    if x < 0:

        x = 255

    s = "%x" % x # converts x into a hexidecimal string

    if len( s) < 2:

        s = '0' + s

    return s



def Load(aGrid, nX, nY, n):

    # changes value if not set, or else it returns the value

    cKey = str( nX) + '_' + str( nY)

    if aGrid.has_key(cKey):

       return aGrid[cKey]

    aGrid[cKey] = n

    return n





def ZeroToOne(nM, nSpan):

    # maps the Real domain onto [0 , 1]

    return atan(nM * nSpan) / pi + 0.5 

    

def mid(n1, n2):

    return int((n1 + n2) / 2) 



def dist(nP, nScale):

    return nP + (random() - 0.5) * nScale



def odist(A, nS1, nS2):

    z = 0

    r = 0

    g = 0

    b = 0

    h = 0

    v = 0

    rg = 0

    rb = 0

    gb = 0

    rgb = 0

    for i in A:

        z += i.z

        r += i.r

        g += i.g

        b += i.b

        rg += i.rg

        rb += i.rb

        gb += i.gb

        rgb += i.rgb

    l = len(A)

    z = dist(z / l, nS1)

    r = dist(r / l, nS2)

    g = dist(g / l, nS2)

    b = dist(b / l, nS2)

    rg = dist(rg / l, nS2)

    rb = dist(rb / l, nS2)

    gb = dist(gb / l, nS2)

    rgb = dist(rgb / l, nS2)

    return splat(z, r, g, b, rg, rb, gb, rgb)



def FracDown(aGrid, nX1, nY1, nX2, nY2, oTL, oTR, oBL, oBR, nLim, nRecursive, bScheme):          

    # fractal lanscape grenerator

    dx  = nX2 - nX1

    dy  = nY2 - nY1

    nS  = aScale[nRecursive]

    nSC = aColour[nRecursive]

    oT  = odist([oTL, oTR], nS * nHorizFactor, nSC)

    oL  = odist([oTL, oBL], nS, nSC)

    oR  = odist([oTR, oBR], nS, nSC)

    oB  = odist([oBL, oBR], nS * nHorizFactor, nSC)

    oM  = odist([oTL, oTR, oBL, oBR], nS * nDiagFactor, nSC)

    nXm = mid(nX1, nX2)

    nYm = mid(nY1, nY2)

    oTL = Load(aGrid, nX1, nY2, oTL)

    oTR = Load(aGrid, nX2, nY2, oTR)

    oBL = Load(aGrid, nX1, nY1, oBL)

    oBR = Load(aGrid, nX1, nY1, oBR)



    if dx <= nLow and dy <= nLow: 

       if ZeroToOne(oM.z, nMSpan * sqrt(nRecursive)) > nLim:

           DrawDrip(nXm, nYm, oM, sqrt(nRecursive), bScheme)

       return

    t1  = (aGrid, nX1, nYm, nXm, nY2, oTL, oT,  oL,  oM,  nLim, nRecursive + 1, bScheme)          

    t2  = (aGrid, nXm, nYm, nX2, nY2, oT,  oTR, oM,  oR,  nLim, nRecursive + 1, bScheme)          

    t3  = (aGrid, nX1, nY1, nXm, nYm, oL,  oM,  oBL, oB,  nLim, nRecursive + 1, bScheme)          

    t4  = (aGrid, nXm, nY1, nX2, nYm, oM,  oR,  oB,  oBR, nLim, nRecursive + 1, bScheme)          

    aT  = [t1,t2,t3,t4]

    shuffle(aT)

    for i in aT:

        apply(FracDown, i)





def ColourRange():

    nMin = int(random() * 255)

    nMax = int(random() * 255)

    if nMin > nMax:

       nMin, nMax = nMax, nMin

    return nMin, nMax - nMin



def Frac(nLim, bScheme):

    aGrid = {}

    s1 = splat(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)

    s2 = splat(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)

    s3 = splat(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)

    s4 = splat(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)

    FracDown(aGrid, 0, 0, W - 1, H - 1, s1, s2, s3, s4,nLim, 1, bScheme)          



seed()

canvas = Canvas( width = W, height = H)

canvas.pack(side = TOP)

canvas.create_rectangle( 0, 0, W, H, fill = 'gray', width = 0)

nHorizFactor = (W + 0.0) / (H + 0.0)

nDiagFactor  = sqrt(H**2 + W**2) / (H + 0.0) 

nMinR, nMaxR = ColourRange()

nMinG, nMaxG = ColourRange()

nMinB, nMaxB = ColourRange()

Frac(nCover, VibrantHousePaint)

print 'done'