Python "Short Code" Contest - VOTE CLOSED! (Code)

[Koba]

Hi all!

By now you may have seen the original thread for the Python "Short Code" contest here or the image voting thread here. Anyway this is where you vote on who made the best code!

Only the final entries from the original thread will be posted - unless it is not part of the evolution of the final submission (ie side submission).

Before you look at the code, have a quick look at the beautiful output!


This week's theme was "Fractal" where the objective was to post an image generated purely in Python with fractal elements.

Criteria for selection:

- How well does the code satisfy the theme described above (visually/otherwise)?
- Is the code well commented?

- Is the code as concise as it could be (comments NOT included!) ?

- Is the code as clear as it could be?

- Does the code do any exceptionally clever things?

- Is the code general enough to be expanded on?

The Contestants:

Here I will post the contestants entries in the order they appeared in the original thread. I will post the final code entries posted there in the order they appeared.

The contestants in order they appeared are: kakapo, RobertT IanC and forTe.

It is worth checking that the code here does indeed generate the final images on the image thread!

So here we go!

kakapo:

import Blender
from Blender import Scene, Window, Mesh, Object, Text3d
from math import pi


#try:
#    scene = Scene.Get("textscene")
#except:
#    scene = Scene.New('textscene')
#scene.makeCurrent()
#
#for o in scene.objects:
#    scene.objects.unlink(o)

scene = Scene.GetCurrent()

#------------------------------------------------------------
def getmesh():
    text = Text3d.New("pyramid")
    text.setText("PYRAMID")
    text.setDefaultResolution(1)
    text.setExtrudeDepth(0.2)
    textobject = scene.objects.new(text)
    textobject.makeDisplayList()
    mesh = Mesh.New("textmesh")
    mesh.getFromObject(textobject)
    scene.objects.unlink(textobject)
    
    # calculate bounding box manually (since object.boundingBox doesn't seem work!?)
    minx = maxx = mesh.verts[0].co.x
    miny = maxy = mesh.verts[0].co.y
    minz = maxz = mesh.verts[0].co.z
    for v in mesh.verts:
        minx = min(minx, v.co.x)
        miny = min(miny, v.co.y)
        minz = min(minz, v.co.z)
        maxx = max(maxx, v.co.x)
        maxy = max(maxy, v.co.y)
        maxz = max(maxz, v.co.z)
    
    # center and scale to unit cube
    for v in mesh.verts:
        v.co.x = v.co.x / (maxx - minx) - 0.5
        v.co.y = v.co.y / (maxy - miny)
        v.co.z = v.co.z / (maxz - minz)
        
    return mesh

#------------------------------------------------------------
def pyramid(x, y, z, scale, level, side, mesh):
    
    meshobject = scene.objects.new(mesh)
    meshobject.setSize(scale, scale, scale)
    meshobject.RotX = pi * 0.5
    meshobject.LocX = x
    meshobject.LocY = y
    meshobject.LocZ = z
    
    # call recursively
    if level < 5:
        offset = 0.75 * scale
        zoffset = 1.0 * scale
        scale *= 0.5;
        level += 1
        if side != 2: pyramid(x + offset, y, z, scale, level, 1, mesh)
        if side != 1: pyramid(x - offset, y, z, scale, level, 2, mesh)
        if side != 4: pyramid(x, y + offset, z, scale, level, 3, mesh)
        if side != 3: pyramid(x, y - offset, z, scale, level, 4, mesh)
        pyramid(x, y, z + zoffset, scale, level, 0, mesh)
        

mesh = getmesh()
pyramid(0, 0, 0, 1, 1, 0, mesh)
pyramid(1.6, 1.6, 0, 1, 1, 0, mesh)
pyramid(-1.6, -1.6, 0, 1, 1, 0, mesh)
pyramid(1.6, -1.6, 0, 1, 1, 0, mesh)
pyramid(-1.6, 1.6, 0, 1, 1, 0, mesh)
pyramid(3.2, 0, 0, 1, 1, 0, mesh)
pyramid(-3.2, 0, 0, 1, 1, 0, mesh)
pyramid(0, 3.2, 0, 1, 1, 0, mesh)
pyramid(0, -3.2, 0, 1, 1, 0, mesh)


Window.RedrawAll()

[Koba]

RobertT:

# Blender Artists Python Challenge # 1 ("Fractal" theme)
# "Fractal Dream Imagery" Script by RobertT
# Status: Final Submission
# Designed and tested in Blender 2.44


import Blender
from Blender import Scene, Window, Mesh, Object, Camera, Lamp, Material, Mathutils
from Blender.Window import *
from Blender.Mathutils import Rand


# Here we will prepare the scene, first clearing the default
# Blender scene, and then adding our own new scene and elements.



def PrepareScene():
    global sceneFractal, meshFractal, objectFractal
    
    #Create new scene for this project
    sceneFractal = Scene.New('FractalScene')
    sceneFractal.makeCurrent()

    # Delete the default Blender scene
    try:
        Scene.Unlink(Scene.Get('Scene'))
    except:
        print "No default Blender scene to delete."

    # Create and Position a New Camera
    if cameraType == 0:
        cameraNew = Blender.Camera.New('persp') 
    else:
        cameraNew = Blender.Camera.New('ortho')         
    cameraObject = sceneFractal.objects.new(cameraNew)
    cameraObject.setLocation(0.0, 0.0, 10.0)

    # Create and Position a New Mesh that will
    # become the area where we "draw" this project
    meshFractal = Mesh.New('FractalMesh')
    objectFractal = sceneFractal.objects.new(meshFractal, 'FractalObject')
    objectFractal.setLocation(0.0, 0.0, 0.0)

    # Assign the "Fractal Mesh" a New Material
    materialNew1 = Material.New('FracMat1')
    materialNew1.rgbCol = [1.0, .6, 0.0]
    materialNew1.setRef(1.0)
    materialNew1.setEmit(.1)
    materialNew1.setSpec(.5)
    materialNew1.setHardness(64)
    materialNew1.setRayMirr(.4)
    materialNew1.rayMirrDepth = 3
    materialNew1.setMode("Traceable", "Shadow", "RayMirr","ZTransp")
    materialNew1.mode |= Material.Modes.FULLOSA | Material.Modes.SHADOWBUF
    materialNew1.setAlpha(.025)

    materialNew2 = Material.New('FracMat2')
    materialNew2.rgbCol = [1.0, 0.0, 0.0]
    materialNew2.setRef(0.5)
    materialNew2.setEmit(.1)
    materialNew2.setSpec(.3)
    materialNew2.setHardness(100)
    materialNew2.setMode("Traceable", "Shadow", "ZTransp")
    materialNew2.mode |= Material.Modes.FULLOSA | Material.Modes.SHADOWBUF
    materialNew2.setAlpha(.01)

    materialNew3 = Material.New('FracMat3')
    materialNew3.rgbCol = [0.2, 0.2, 0.7]
    materialNew3.setRef(0.5)
    materialNew3.setEmit(.1)
    materialNew3.setSpec(.3)
    materialNew3.setHardness(100)
    materialNew3.setMode("Traceable", "Shadow", "ZTransp", "Wire")
    materialNew3.mode |= Material.Modes.FULLOSA | Material.Modes.SHADOWBUF
    materialNew3.setAlpha(0.40)
    
    # Create and Position a New Sun Lamp
    lampNew = Lamp.New('Sun')
    lampNew.mode |= Lamp.Modes["RayShadow"]
    lampObject = sceneFractal.objects.new(lampNew)
    lampObject.setLocation(0.0, 0.0, 5.0)
    lampNew.setEnergy(1.2)
    lampNew.col = [1.0, .8, 0.50]
    lampObject.RotY += .10
    lampObject.RotZ += .40

    # Update the Blender 3D View
    Blender.Redraw()          

    viewArea = Window.GetScreenInfo(Window.Types.VIEW3D)
    id = viewArea[0]['id']



# Generate Random Coordinates for Vertices
# to be Used in the Creation of the Fractal Image

def GenerateCoordinates():
    rX = Rand(-5.0, 5.0)
    rY = Rand(-5.0, 5.0)
    rZ = Rand(-5.0, 5.0)
    return rX, rY, rZ



# Create a Cloud of Points (Vertices) for
# Our Dupliverted Cubes

def CreatePointCloud():
    global iterations
    while iterations > 0:
        coordinates = [GenerateCoordinates()]
        meshFractal.verts.extend(coordinates)
        iterations -= 1



# Place objects throughout the point cloud

def PopulatePointCloud():
    cubeMesh = Mesh.Primitives.Cube(.5)
    for v in meshFractal.verts:
        for a in range(reiterations):
            cubeNew = sceneFractal.objects.new(cubeMesh,'cubeNew') 
            objectFractal.makeParent([cubeNew], 0, 0)
            materialDecider = Rand(1.0, 3.0)
            if materialDecider < 1.5:
                cubeNew.setMaterials([Material.Get('FracMat1')])
            else:
                if materialDecider < 2.0:
                    cubeNew.setMaterials([Material.Get('FracMat2')])
                else:
                    cubeNew.setMaterials([Material.Get('FracMat3')])
            cubeNew.colbits = (1<<0) 
            cubeNew.setLocation(v.co[0]+Rand(-0.3,0.3), v.co[1]+Rand(-0.3,0.3), v.co[2]+Rand(-0.3,0.3))
            c = Rand(.01, .3)
            b = (a * c) * (sizer/4)
            cubeNew.setSize(Rand(b*.05, b*.2+Rand(0.0,0.5)),Rand(b*.05, b*.2+Rand(0.0,0.5)),Rand(b*.05, b*.2+Rand(0.0,0.5)))
    objectFractal.enableDupVerts = 1


# Update the 3D View to See Through Camera's View

def ChangeView():
    CameraView(0)



# Render the Project

def RenderTheProject():
    renderContext = sceneFractal.getRenderingContext()
    renderContext.enableOversampling(1)
    renderContext.OSALevel = 5
    renderContext.partsX(20)
    renderContext.partsY(20)
    renderContext.imageSizeX(800)
    renderContext.imageSizeY(800)
    renderContext.enableShadow(1)
    renderContext.enableRayTracing(1)
    renderContext.enableGaussFilter(1)
    renderContext.gaussFilterSize(1.0)
    renderContext.render()
    



# The Main Program Begins Here!

#This variable controls how many dupliverts
#are added to the project.
#Recommended range is from 1 to 64
iterations = 30

#This variable controls how many reiterations
#are performed during the draw routine.
#Recommnended range is from 1 to 32
reiterations = 20

#This variable controls the size of shapes drawn.
#Recommended range is from 1 to 20
sizer = 10


# Camera can be 0 (perspective) or 1 (ortho)
cameraType = 0


PrepareScene()
CreatePointCloud()
PopulatePointCloud()
ChangeView()
RenderTheProject()

[Koba]

IanC:

import Blender
from Blender import *
from Blender.Mathutils import Rand
from math import sin, cos

#### For a 2D Julia/Mandelbrot
def iterate(c, previous, limit):
        distSq=0
        while limit>0 and distSq<4:
                previous=(previous**2)+c
                distSq=previous.real**2 + previous.imag**2
                limit-=1
        return limit


def run(xsize,ysize):
        plot=[]
        for i in range(xsize):
                for j in range(ysize):
                        x=(2*float(i)/xsize)-1
                        y=(2*float(j)/ysize)-1
                        ans=iterate(complex(x,y),complex(x,y),10)
                        if ans==0:
                                plot.append([x,y,0])
        return [plot,[]]


### Rossler Attractor - boring
def rossler(loc=[0.,0.,0.],timestep=0.01,iterations=10000,a=0.2,b=0.2,c=5.7):
        plot=[loc]
        x,y,z=loc
        for i in xrange(iterations):
                x+=(-y-z)*timestep
                y+=(x+(a*y))*timestep
                z+=(b+(x*z)-(c*z))*timestep
                plot.append([x,y,z])
    
        faces=[]
        for i in xrange(iterations):
                faces.append([i,i+1])
        return [plot,faces]


### Lorenz Attractor        
def lorentz(loc=[0,0.2,0.],timestep=0.01,iterations=10000,a=10.,b=28.,c=(8.0/3),scale=0.1):
        plot=[loc]
        faces=[]
        velocity=[]
        x,y,z=loc
        j=0
        rfac=0.1
        for i in xrange(iterations):
                x0,y0,z0=x,y,z
                x+=((a*y)-(a*x))*timestep+(Rand()*rfac-rfac/2)
                y+=((b*x0)-y-(x*z0))*timestep+(Rand()*rfac-rfac/2)
                z+=((x0*y0)-(c*z0))*timestep+(Rand()*rfac-rfac/2)
                #plot.append([x,y,z])
                moved=((x-x0)**2+(y-y0)**2+(z-z0)**2)
                if moved>-10:
                        velocity.append(moved)
                        plot.append([x*scale,y*scale,z*scale])
                        faces.append([j,j+1])
                        j+=1
        print j
        print max(velocity),min(velocity)
        return [plot,faces,velocity]


        
#meshDetails=rossler(timestep=0.01,iterations=100000)
#meshDetails=run(100,100)
meshDetails=lorentz(timestep=0.001,iterations=500000)
print "Finished the first bee, second coming right up!"
meshDetails2=lorentz(timestep=0.001,iterations=500000)

#create mesh

mesh1 = Mesh.New('firstBee')
mesh1.verts.extend(meshDetails[0])
mesh1.faces.extend(meshDetails[1])

mesh2 = Mesh.New('secondBee')
mesh2.verts.extend(meshDetails2[0])
mesh2.faces.extend(meshDetails2[1])

#create material

mat=Material.New('haloGlow')
mat.mode |=Material.Modes.HALO
mat.add=1
mat.haloSize=0.015
mat.rgbCol=[0,0,0]
mat.alpha=0.05
#Put it in the scene

scn=Scene.GetCurrent()
ob=scn.objects.new(mesh1,'rosslerOb')
ob.colbits|=1<<0
ob.setMaterials([mat])
ob.setLocation([-0.418,-0.454,1.882])
ob.setSize([0.538]*3)
ob.rot=[0.3172,-0.3252,-0.0654]

ob2=scn.objects.new(mesh2,'rosslerOb2')
ob2.colbits|=1<<0
ob2.setMaterials([mat])
ob2.setLocation([0.816,0.741,0.092])
ob2.setSize([0.562]*3)
ob2.rot=[-0.087,0.096,0]

#Camera-tastic

cam=Blender.Camera.New('ortho')
camOb=scn.objects.new(cam)
scn.setCurrentCamera(camOb)
camOb.setLocation([4.72,-5.14,2.19])
camOb.rot=[1.599,0.00,0.74]

#Update the 3d window
Blender.Redraw()

#Set the background
world=Blender.World.GetCurrent()
world.setHor([1,1,1])

renderCon = scn.getRenderingContext()
renderCon.imageSizeX(800)
renderCon.imageSizeY(600)
renderCon.render()

Side Submission (gasket code):

import Blender
from Blender import Mesh,Scene
scn=Scene.GetCurrent()
def generate(location, scale, level, currentVerts,currentFaces):
    height=2.
    x,y,z=location
    newVerts,newFaces=[],[]
    if level:
        scale/=2.0
        generate(location,scale,level-1,currentVerts,currentFaces)
        generate([x-scale,y-scale,z-scale*height],scale,level-1,currentVerts,currentFaces)
        generate([x+scale,y-scale,z-scale*height],scale,level-1,currentVerts,currentFaces)
        generate([x-scale,y+scale,z-scale*height],scale,level-1,currentVerts,currentFaces)
        generate([x+scale,y+scale,z-scale*height],scale,level-1,currentVerts,currentFaces)    
    else:
        start=len(currentVerts)
        currentVerts.extend([[x,y,z],\
        [x-scale,y-scale,z-scale*height],\
        [x+scale,y-scale,z-scale*height],\
        [x+scale,y+scale,z-scale*height],\
        [x-scale,y+scale,z-scale*height]])
        currentFaces.extend([[start,start+1,start+2],\
        [start,start+2,start+3],\
        [start,start+3,start+4],\
        [start,start+1,start+4],\
        [start+1,start+2,start+3,start+4]])
    return [currentVerts,currentFaces]
for i in range(6):
    v,f=generate([0,0,2],1,i,[],[])
    level=Mesh.New(str(i)+'level')
    level.verts.extend(v)
    level.faces.extend(f)
    ob=scn.objects.new(level,'gasket'+str(i))

[Koba]

forTe:

#Script: Fractalite (For Blender Short Code Challenge #1)
#Date: July 15, 2007
#Press alt-p to see a demonstration

import Blender
from Blender import Camera, Mesh, Material, Object, Scene, Texture, Window

#Make a new scene for the data
def ClearScene():
    global SCN
    try:
        Scene.Unlink('Rabin-FabFractal')
        
    except:
        SCN = Scene.New('Rabin-FabFractal')
        
    SCN.makeCurrent()
    
    for obj in SCN.objects:
        SCN.objects.unlink(obj)

###########################################################
#Rabinovich-Fabrikant Equations
#To change the equation modify g and a in the following function
#g = gamma
#a = alpha
#For how to use g and a, so a reference on R-F functions
##########################################################
def UpdateRF():
    global X, Y, Z
    
    g = .9
    a = .01

    stepsize = .005
        
    X += (Y * (Z - 1 + (X*X)) + g*X) * stepsize
    Y += (X * (3*Z + 1 - (X*X) + g*Y)) * stepsize
    Z += (-2 * Z * (a + (X*Y))) * stepsize


#Make a Material for the finished mesh
def MakeMaterial(Tex):
    #Create New Material
    mat = Material.New('Fractal')
    
    #Make it a Halo
    mat.setMode('Halo', 'HaloTex')
    
    #Set Material Properties
    mat.rgbCol = [0.9, 0.9, 0.54]
    mat.setAdd(0.5)
    mat.setHaloSize(.100)
    
    #If Tex is set, this will add a Colorband to it (will override existing rgb color)
    if Tex:
        tex = Texture.New('FractalBlend')
        tex.setType('Blend')
        tex.stype = Texture.STypes.BLN_HALO
    
        colorband = [[1.0, .8, .1, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0, .5], [0.0, 0.0, 1.0, 1.0, 1.0]]
        tex.colorband = colorband
        tex.flags |= Texture.Flags.COLORBAND
    
        mat.setTexture(0, tex)

    return mat

def MakeScene(Iter, Tex = 1):
    global SCN, X, Y, Z
    
    #Create a New Mesh and Object
    baseMesh = Mesh.New('Rabin-Fab')
    baseObj = SCN.objects.new(baseMesh, 'Rabin-Fab')
    
    #Give the object a subsurface modifier
    mod = baseObj.modifiers.append(Blender.Modifier.Types.SUBSURF)
    mod[Blender.Modifier.Settings.RENDLEVELS] = 4
    
    #Give the mesh a material
    baseMesh.materials += [MakeMaterial(Tex)]
    
    #Generate the mesh and update after every calculation
    for i in xrange(Iter):
        #Prints out current vertice
        print i + 1
        
        UpdateRF()
        
        baseMesh.verts.extend(X, Y, Z)
        
        #Build edges on every possible one
        try:
            baseMesh.edges.extend(baseMesh.verts[-2], baseMesh.verts[-1])
        except:
            pass

        Window.RedrawAll()
        
def RenderScene():
    global SCN
    
    #Set Up Camera
    cam = SCN.objects.new(Camera.New())
    
    cam.setLocation(-10, -8, 50)
    
    #Blender Euler accepts Radians, but is converted to degrees internally?
    pi_12 = 3.14159/12
    cam.setEuler(pi_12, pi_12, -4 * pi_12)
    
    #Do the Rendering
    context = SCN.getRenderingContext()    
    context.imageSizeX(1200)
    context.imageSizeY(600)    
    context.render()
    
######################################################
#User Definable Variables
######################################################

#Set this quantity to define the number of vertices placed in the object
numberOfVertices = 4000

#Initial coordinates for the function
X = 1.0
Y = 1.0
Z = 1.0

######################################################
#Script Demonstration Code
######################################################
    
ClearScene()
MakeScene(numberOfVertices)
RenderScene()

----------------------------------------------------------------------------->

Ok! So that is it. Check out the images, check out the code and get voting!

Koba

[allanbs]

Koba,

You got my vote, nice image.

[dolittle]

I vote for 'Te' followed by 'RobertT'

[Ace Dragon]

ForTe has one of the best halo only renders I've ever seen which would look sweet if animated.

I vote for ForTe

[Meta-Androcto]

They are all good.
kakapo's is quite original/different from the others, maybe too many verts, thus slowish to build, well commented but not as informative as others.
RobertT's is so RobertTesque (look I made a new word! ) visually complex, well commented, quite fast to build & looks like RobertT's work...Amazing.
IanC's are quite good, I did have more fun experimenting with the first script, first posted,
as he mentioned time/other commitments, well done over all.
forTe's script is loads of fun watching it build, very well commented, very visually appealing, overall best. Of a great lot of scripts.

I would like to say that the overall winner is Koba for this great initiative & the Blender Community for sharing in it.
Thanks Koba. Well done indeed! You get my vote too.
Look forward to the next one. Torus Knots anyone?
m.a.

[Cessen]

forTe, RobertT, and kakapo had code that I considered to be reasonably well documented/commented code, and to me that is paramount to quality code.

Of those three, both kakapo's and RobertT's scripts failed to produce the same renders as their submitted images. Perhaps that was just a fluke system difference or something, but I don't really know that.

So for this part of the vote (the code part) I voted for forTe.

[IanC]

My code was pretty bad, hehe. There were a few bits I cleaned up & commented in another version of the code, then copied that one!

Thanks Meta, nice that someone has played with it

[RobertT]

Originally Posted by Cessen Of those three, both kakapo's and RobertT's scripts failed to produce the same renders as their submitted images.

My script should always produce images just like the ones you see in my original posts.

By design, they will never be exact because they all incorporate randomization parameters in addition to user-definable variables at the beginning of the program (after the subroutines). So the script should never produce the same image twice

The generated image Koba included in this thread with my script was created using the orthogonal camera setting. By default, the script uses a perspective camera setting and different variables.

In another thread I did notice someone else successfully generated a comparable image as I had using my script:

http://blenderartists.org/forum/show...8&postcount=57


One unrelated thing that might be worth mentioning, since this is the code consideration thread, is that my script does not make use of any existing fractal formula but rather relies on fractal factors such as self-similarity/supersymmetry and recursion to achieve its final effects.


I'd also like to say how happy I am with the way this challenge worked out. I really hope this becomes a permanent thing at Blender Artists

RobertT

[Koba]

I must say I am really inspired by you guys - you did so well on the very first challenge and you are eager for more!

Hopefully, my idea for next week's contest will be just as fruitful as last weeks! Here is a hint: it is an animation challenge this time. ;-)

Koba

[Koba]

AND THE WINNER OF THE CODE CONTEST IS:

By a huge margin! - forTe with 22 votes!

Followed by:

IanC with 7 votes
RobertT with 5 votes
kakapo with 2 votes

Well done kakapo! Your image may have come last in that contest but your coding skills pulled through spectacularly!

I know the poll is still open (my mistake) but voting is now closed with these numbers above!

Koba

[Koba]

This weeks "Short Code" contest rules can be found here:

http://blenderartists.org/forum/show...=100544&page=4

Koba