Python "Short Code" Contest - Chosing the next theme!

[IanC]

Ok, here's my entry, because I've run out of time:

import Blender
from Blender import *
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
		for i in xrange(iterations):
				x0,y0,z0=x,y,z
				x+=((a*y)-(a*x))*timestep
				y+=((b*x0)-y-(x*z0))*timestep
				z+=((x0*y0)-(c*z0))*timestep
				#plot.append([x,y,z])
				moved=((x-x0)**2+(y-y0)**2+(z-z0)**2)
				#must have moved by a small amount
				if moved>0.0001:
						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=200000)

#create mesh

mesh = Mesh.New('rosslerMesh')
mesh.verts.extend(meshDetails[0])
mesh.faces.extend(meshDetails[1])

#create material

mat=Material.New('haloGlow')
mat.mode |=Material.Modes.HALO
mat.add=1
mat.haloSize=0.03
mat.rgbCol=[0.18,0.12,0.07]

#Put it in the scene

scn=Scene.GetCurrent()
ob=scn.objects.new(mesh,'rosslerOb')
ob.colbits|=1<<0
ob.setMaterials([mat])

#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([0,0,0])

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

It can do a mandelbrot or julia in 2d, and can do rossler and lorenz strange attractors in 3d.

Cutting out the unused code for the final image gives about 36-38 lines I think.

It doesn't do anything with the current scene, so delete everything and go from blank.

Output:


I've got an animation of it building which is quite cool. You can do one yourself, but I'll try and get this uploaded tonight.

I didn't have time to make this into a full scene, but here's a short gasket (24 lines of code to produce a single one, a few more for a nice run):

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))

Which produces a series of these in varying levels of complexity:


Maybe it'll be useful to someone.

Good luck all!

[forTe]

Update for my script:



1200x600 so I won't hotlink it directly. The script no longer uses the lorenz attractor but a different equation with a much longer name that I can't recall right now. I got some tweaks to do on materials and some optimizations and code cleanup/commenting and I'll be done.

Generates on my computer with fading technology in 233 seconds.

[IanC]

Very nice! I look forward to seeing your script, I couldn't get many of the attractors to work well.

[Koba]

See? This is great!

I must say, while both IanC, forTe and kakapo have produced results *well* beyond of what I was expecting so soon - RobertT has blown me away with his imagery (my personal opinion). And yet, as code is so important to this contest, the winner may be well be decided on technical merit by other coders!

Nice to also see some fractal volumes and surfaces too. Just to show that there are lots of approaches to the problem.

Really, I couldn't be happier with your entries and enthusiasm guys! My only problem is thinking up a theme for next week that will be as stimulating as this one's! :-)

Koba

EDIT: I would love to enter but the huge Blender project I'm currently working on takes priority. If I did enter, my approach would be to use the Mandlebrot fractal equation (simple) and create a fine grid of individual verts with a Halo material whose colour would be defined by the number of iterations to escape to infinity (if I remember correctly!). If I get a chance, I may have a go tomorrow.

[basse]

hmm, ok... pretty.. but why do i get this feeling it's not really competition of programming. but instead a competition of implementing somebody elses code...

robertt is the only one here showing some originality.

.b

[Ace Dragon]

RobertT's script looks incredible, I wonder, I understand posting short code that does interesting things, but many could use python scripts that could be highly useful and save time, I personally would like to see a comprehensive and powerful procedural building generator for instance to really save time for large city scenes, look online for papers on modeling of procedural buildings. And low poly versions of them for use in the Blender GE.

I also like the swirly pattern generator and the script that makes that triangle thing (forgot the name of that thing)

[IanC]

Shame you feel that way, basse.

I've taken three equations and built it from there myself, would you say ODE was implementing another persons code because it used the laws of motion?

[basse]

ianc:
i dont know. maybe i'm wrong here... could very well be, i'm not real programmer.

but i was just hoping to see other stuff than fractals and attractors, that's all.. those i've seen so many times...

.b

[forTe]

@basse: This was just a first go around to get interest started in the competition. I believe in the future we'll have significantly harder more useful challenges to implement new and more useful code.

@Cyborg Dragon: At one point about a year ago I was implementing a procedural building modelling/ city generation tool. I never published anything related to it because it just was too restrictive. I have since picked it up again and started working on it, but progress is a little slower this time because I am not quite as motivated, I'm trying to think through the design a little more, I'm designing a UI that uses custom elements, and I have so many ideas relating to it, that its getting hard to organize them and make the code efficient. For a slight bit of information on the old script you can go here (only ever got that first page up, everything else is a 404) and here for a screenshot. It wound up just being another greebling script, but it was based on vertex groups, meaning that each vertex group in an object could have its own heights assigned to it and buildings took on the footprints of whatever face they were created from(this was the city aspect of it). There really was not much in the way of building generation outside of a couple of roof types (no windows/doors/facades/decorations).

[Koba]

forTe: Have you heard of "The Beast"? It was a fantastic script that started as a cityblock generator I think. It also ended up going fur/feathers with alpha maps pretty well. Sadly development stopped. This was quite a while ago but I would look into it if you haven't already.

basse: Future challenges will have more interesting themes much more open to orginality. Many fractals are standard mathematical objects - perhaps I should have made the rules such that it must be fractal like without being a mathematical fractal object. As you said RobertT succeeds in this regard.

However, the rules stand as they are so everyone is still on equal footing.

Koba

[Ace Dragon]

forTe: I think if the building generation was powerful, offered good customization options, and operated on any shape that could become something good, something that could potentially be useful for generating game content quickly and bringing together large city scenes. I don't have the python knowledge to do this, but it could really save time for anything from commercial productions to games.

[IanC]

Originally Posted by basse ianc: i dont know. maybe i'm wrong here... could very well be, i'm not real programmer. but i was just hoping to see other stuff than fractals and attractors, that's all.. those i've seen so many times...

Fair point, I'd like to have gone much further with this, but I really haven't had the time. My original idea was to create a forest style image, with a few other bits and bobs.

I look forward to future challenges, now that I have more of an idea about what is expected.

Edit - I played a little and came up with a pun & slightly more interesting image (imo)

I thought this maybe looked like a little pencil sketch of two bees, so this is called "2B or not 2B"

[edit]grrr, imageshack![/edit]


final code before I go to bed:

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()

[forTe]

Alright actually have some code to post this time. I'm gonna keep playing with it some, maybe add back the Lorenz attractor as well if I feel like it.

Result:


Code:

#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()

136 lines with everything. Probably closer to 50-60 lines of actually code

@Koba: Yes, I looked at Beast a while ago, but haven't done so recently. I may dig it up and take a once over the code. Maybe something can give me the kick in the pants I need to start getting some dirty work done on that project.

[Sanne]

Wow, I love those images, great work everybody!

And basse, I don't think the implementation of mathematical equations is trivial, it would be quite a challenge (at least for me and my state of Blender Python knowledge). It's very helpful to have those scripts to look at and learn from.

[scabootssca]

well i think this python challenge thing would be a good idea
like a weekend challenge or weekly or whatever

[Koba]

IanC:

I really love your new image! Much more artsy but still very much on theme. Your new idea is wonderful but as a suggestion, more attractors may look even better. If you could fold the wings by varying amounts and place many more in the scene randomly you could have a swarm of "attractors".

If not, you still have a great final entry!

Koba

[leojS]

Great work from everyone, but I must say Robert's has got to be the best one! I thought it would be interesting to see what it would look like to decrease the size of the camera lense and render out the mesh generated by Robert's script:



(Click to view bigger version)

Hopefully I'll brush up my Blender-Python skills and enter in the next challenge.

[UglyMike]

Nice.... I've always loved Fractals. Got a ton of books on them at home, including Mandelbrot's seminal work
Of course, as stated by some, fractals are 'easy' as they consist of known mathematical formulas....but even here RobertT surprised a lot of us with here more 'artistic' take.
For those wanting python with more meat, we should remember that it is a 'short code' contest...
To get around this, we could try to do a more evolutionary approach, using the previously selected pice of Python code and building upon it.
Challenge1: Code a random rock (smooth, wheathered, jagged,...) generator
Chalenge 2: Using the winner of challenge one, extend it to genereate either a plane or a cloud of random rocks (no overlap, single size with random variation ,..)
Challenge 3: using the winner of challenge 2, build a moving asteroid cloud (3d) or using the 2D element drop the rocks on a fractal terrain, each rock sinking a random amount in the terrain
Challenge 4:....
Just an example of a possible evolutionary approach. This could also be used for city-building (generic building, generic streetplan, placement of buildigs on streetplan, moving agents (cars, pedestrians,..)...)
The difficulty here would probably be getting acquainted with the ever inceasing complexity of the evolving Python code wich would probably unfairly advantage each iteration's 'winner' ..
Ah well, just an idea.

[pildanovak]

hmm, a nice thread, and nice pictures. this could also result in some nice scripts for environment generation.

[Dani]

Hey, this is nice!
A lot of learning material generated in a short time! This is a great idea! I'm no good at maths, but maybe one day I'll take the challenge!
Dani