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

[Koba]

IanC: If you need to post somewhere soon, I think it will be ok to post here. Your work can be a demo of what this contest is all about!

So if anyone is a mod here/or is on good terms with a mod, can I get some advice on where best to place a contest thread?

Koba

[IanC]

Argh, my plans are changing, so I've no idea what's happening!

Anyway, here's a quick post of a render to get it out there in case I have to leave in a min:


I've written code for another attractor, and have a few more planned. Mathematical, so it's easy

Edit - it's a shame you can't use vert colours for halos (or can you?) because you can make some really beautiful images then.

[Koba]

IanC: Beautiful Render! I am very impressed. I'm wondering how you did it...surely that isn't a mesh! Did you write directly to the render output somehow? Amazing!

Of course, you'll need to submit the script for testing once you have finished with it. Also make sure the render image posted above reflects what the final version of the script creates.

So! Any contenders? I think IanC has instantly raised the bar of what is to be expected! Anyone willing to rise to the challenge? :-D

Koba

[IanC]

Koba: Thanks! It took about an hour to make the script, mainly because I made a trivial error (note to self, + != - ), it's pretty simple really.

It's a mesh, built according to equations, you can also animate the building process which is quite cool.

You can edit the values to give different 3d shapes, I just happen to like this one.

I'll get the script cleaned up tomorrow, I've found out I won't be leaving until Monday morning.

[forTe]

50 line python script I wrote generates the image below from modelling to texturing to camera setup to opening a window/rendering. I still need to do some tweaks to get material settings right (get it smooth instead of bumpy), add comments, speed up code, etc. Uses the lorenz attractor model (like I assume IanC's does as well). I may try a couple of other models in the next couple of days as well to see if I like them better. Haven't had time to render out a fullsize version yet (it doesn't take long to render, I just haven't done it).

[IanC]

Yeah, it's a lorenz attractor

I've got rossler working, but it's quite boring. I've a few polynomial ones I want to get working, and could look good, but rossler was a bit of a waste. Still, they only take a couple of minutes to implement.

Aside, to get rid of the bumpiness, increase the size of the halos. I think it's basically an aliasing issue. Try 0.03 or 0.02. If it's too bright, just make the material darker, and use more iterations to get more points for the attractor. If you're having problems with speed, try using the values of 10,28 and 8/3 (a,b,c) because that isn't periodic for a long time. Yours looks like it's on a cycle that it will follow closely for a long time. Mine's on a time step of 0.001 with 500,000 iterations and it takes about 5 seconds on my AMD64 3000+.

Line count, I'm on 2 import lines, 16 to define the lorentz & run it and create the mesh, add it to the scene, 7 for the material.

Still need to stick the camera in, as well as call a render. I'll post a functional line count program, with no useless lines, as well as the one I'm working on for people to use if they want.

[kakapo]

wouldn't it be better to count kilobytes (without comments) instead of lines? since with python you can use semicolons to achieve longer lines if you want.

hm... but on the other hand using kilobytes probably will encourage using short cryptic variable names.

[forTe]

I think by lines, what was implied was statements, so that even if you do use the semicolon trick, each one will essentially count as a line. We are also now to the point where it is becoming more what you are coding and how well it works, rather than its length I think (although longer scripts generally work slower, but not necessarily).

@IanC: Yeah I thought about doing some polynomial ones too, but the 30+ coeffecients on some of the scared me off a little. Still I'm going to try to implement some modest second order ones and see if I can get results.

Thanks for the tips on increasing my smoothness, but sadly my computer is not as good as yours, and 100,000 iterations took 282 seconds.

[RobertT]

Nice work so far!

Here's my WIP script... trying a different route just to see where it goes

# Blender Artists Python Challenge # 1 ("Fractal" theme)
# Script by RobertT
# Status: Work in Progress
# 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
    
    # Create new scene for this project
    try:
        Scene.Unlink(Scene.Get('FractalScene'))
    except:
        print "Creating new scene..."
    sceneFractal = Scene.New('FractalScene')

    # Make the newly established scene the active scene
    sceneFractal.makeCurrent()

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

    # Create and Position a New Orthogonal Camera
    cameraNew = Blender.Camera.New('persp') 
    cameraObject = sceneFractal.objects.new(cameraNew)
    cameraObject.setLocation(0.0, 0.0, 7.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)

    cubeMesh = Mesh.Primitives.Cube(1.5)
    cubeNew = sceneFractal.objects.new(cubeMesh,'cubeNew') 
    cubeNew.setLocation(0.0, 0.0, 0.0)
    
    objectFractal.makeParent([cubeNew], 0, 0)
    objectFractal.enableDupVerts = 1

    # Assign the "Fractal Mesh" a New Material
    materialNew = Material.New('FracMat')
    materialNew.rgbCol = [1.0, .7, 0.0]
    materialNew.setRef(1.0)
    materialNew.setMode(Material.Modes.WIRE)
    cubeNew.setMaterials([Material.Get('FracMat')])
    cubeNew.colbits = (1<<0) 

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

    # 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():
    r1 = Rand(-3.0, 3.0)
    r2 = Rand(-3.0, 3.0)
    r3 = Rand(-3.0, 3.0)
    print r1, r2, r3
    return r1, r2, r3



# 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



# 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 = 11
    renderContext.imageSizeX(800)
    renderContext.imageSizeY(600)
    renderContext.enableShadow(1)
    renderContext.enableRayTracing(1)
    renderContext.enableGaussFilter(1)
    renderContext.gaussFilterSize(1.5)
    renderContext.render()
    



# The Main Program Begins Here!

#This variable controls how many dupliverts
#are added to the project.

iterations = 222

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

I didn't know if "delete the default Blender" stuff had to be done, along with the rendering routines, in Python as well, so I just assumed for now it did and have some code in there for those purposes

I didn't know if there was a line limit so far. There's approximately 70 lines to the code without comments/extra whitespace for legibility, and there's even less without the extra "delete the scene" code and render code.

I will update this project as time permits and provide a sample render.

RobertT

[RobertT]

[duplicate post, disregard]

RobertT

[RobertT]

I updated my script quite after a number of changes and simplifications. Randomization code is less fancy and a remnant of an earlier test that was to literally take some more interesting turns through an idea I thought would work based on a key-event-driven project I had worked on a while back.

Part of my original concept was to use a variety of Python and direct QAdd pushes to the Blender event system to see if there could be first a randomly defined set of points that could then be extruded and transformed (via virtual keystrokes sent to the event system).

The end designs would have been far more recursive and intricate in appearance than the product of the current script (still in WIP), but the QAdd only works for those operations that do not require feedback.

A QHandled EKEY, for example, doesn't return control to the program until some manual confirmation (enter/mouse click) in the 3D View, so the initial idea of the script had to be dropped. The event system rewrite would almost certainly would make this method a deprecation anyway

So the script became simpler, using dupliverts as a means of achieving repeated patterns through an ortho camera at the time. I've been switching the script-generated camera between ortho and pespective between tests with different results.

I've also been considering ways of using the array modifier, if possible, as part of this project. I'll see how much I can experiment with this as free time permits.

I did not find a way to change the render filter type (Mitch, CatRom, Gauss, etc.) in Python. Does anyone know of a way to do that? I have gone through all the 244 PyDocs at
http://www.blender3d.org/documentation/244PythonDoc/

A "make dupli objects real" Python equivalent of CTRL SHIFT A was something I could not find either in the docs. That could be handy do to have if it's not already in the API. Alternately, I could use the vert cloud I'm creating as locations for new objects.

Still much to think about

RobertT

[forTe]

Looks nice so far RobertT:

So far I don't have the deleting code in my script, but I guess looking at the rules it does appear that deleting the stuff should be part of the script (albeit it is quite a little bugger to do so).

My original approach to doing this was very similar to yours, but in the end I opted for the vertex method because it gave finer lines to me. Your code would be significantly easier to animate in a future challenge, though. Oh well, I'll keep working on the path I'm on for now, since I like the math aspect.

As for your questions about changing filters, etc. I don't see anything in the docs about that either. Very few scripts have to actually set the render data up, so I guess that's been a slightly neglected part of the API. Maybe these challenges can help get some more options in that region of the API.

[Meta-Androcto]

Really good work by all involved so far, I look forward to seeing the results!
Keep up the good work!
m.a.

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

it's still a bit messy. i am new to linking/unlinking objects to the scene. maybe someone can help me with deleting the unneeded text objects correctly? also how can i clear the complete current scene at the start of the script?

[Koba]

Nice...Three entries and two scripts!

Suggestions for improvement:

RobertT: Your image is great. Perhaps you could move the camera if the fractal is in 3D phase space to highlight the 3D nature of the thing - maybe tricky without shading. Also good to see you are finding the limits of the API - keep your suggestions for the Blender Python team!

ForTe: Nice too. A little more density would show the behaviour of the attractor a bit better I think.

kakapo: A white background would be more striking imho. Looking at your fractal it reminded me of a Serpinski Gasket. Maybe someone will feel like doing some Python vertex pushing to create one of those!

Keep it up! I think I may consider submitting this thread as a news item to BlenderNation to get more interest. Perhaps such a code contest may become a regular occurance! Thanks for your submissions everyone and keep them coming!

Koba

[IanC]

Maybe someone will feel like doing some Python vertex puching for that!

Beat me to it, I've just coded one. I might go for a general one, but I've got a gasket working.

[RobertT]

Thanks for the encouragement!

This challenge is really is a lot of fun. Thanks for thinking it up and for being open to suggestions!

Last night I combined some of my initial ideas (dupliverts, randomness) and came up with a different approach that has yielded some very interesting results so far.

I really wanted to stay with the concept of dupliverts so this was not a mere producer of utter randomness but rather of a product, complex or simple depending on how it's configured, that could exhibit, or at least contain, aspects of self-similarity and recursion, yet on the other hand not be entirely regulated in appearance.

This morning I think I finally found that balance, so I'm going to call this finished

With that, here is the final script, its title inspired by the graphical output it creates:

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

There was some effort at this stage to make the script more artistic in its output, using this time around a variable color scheme that uses alpha overlays to achieve gradations of colors.

The script has now become user customizable through the four following variables (explained in the code): iterations, reiterations, sizer, and cameraType.

You can have the script generate images through an ortho or perspective camera for different effects.

The final script produces this image using its default settings:



(direct link to image)

Here is another image using these respective values for iterations, reiterations, and sizer: 40, 12, 5:



(direct link to image)


Here is an example of an orthogonal rendering using these values for iterations, reiterations, and sizer: 32, 20, 11:



(direct link to image)


Simply by altering the color and/or wireframe usage in this script, this script can become a variable procedural textural-greeble for bump and/or texturing Even more advanced results could be attained by introducing custom shapes other than the cubes used in this script.

I enjoyed this challenge and look forward to future ones.

RobertT

[gaalgergely]

wow!
really awesome stuff, reminds me of demo scene hacks. i wish i could code and cook up something to participate, but my lack of knowledge does not enables this....
when will this competition end?

[eeshlo]

Just my luck, this is one of the very few blender contests I could actually make a contribution to, especially considering the theme, but unfortunately I'm busy with other things...
Good luck to everyone else though, all the current entries already look very promising

[Fligh]

So if anyone is a mod here/or is on good terms with a mod, can I get some advice on where best to place a contest thread?

(I thought we were on good terms?)

For the time being I think leaving it here, where you get the most traffic, is best.

In the future we could put a general Announcement, which appears in all forums, and then run the actual thread in one of the Competition Forums. I don't think the Python and Plugins forum is the right place, though others may differ.

%<