Python & Blender – Designing for 3D Printing
Python & Blender
Designing for 3D Printing
An Edmonton.py presentation byChris Want / cjwant@gmail.com / @cwant
Road map
- Talk about Blender in general
- Modeling meshes
- Python scripting
- Exporting for 3D printing
- Common issues
- ShapeWays 3D printing service bureau
But first, a short bio ...
- MSc in Math (U of A, long time ago)
- Previously a scientific visualization analyst at the U of A, lead the U of A's central 3D printer for almost 10 years (ZCorp, plaster based).
- Former Blender developer (semi-retired)
- Currently work for WestGrid, an HPC consortium
Blender
From the Blender website:
“Blender is a free and open source 3D animation suite. It supports the entirety of the 3D pipeline—modeling, rigging, animation, simulation, rendering, compositing and motion tracking, even video editing and game creation”- Blender is released under a GPL license
- Python scripting through a rich API
- Recommended:
- Keyboard with a numpad
- Three button mouse with a scrollwheeel
- Best graphics card you can afford
Python
Three ways to access python
- Built in text editor
- The python console
- Installed scripts that show up in the menus
We'll run our scripts through the text editor
Execute with Alt-P while your mouse is in the editor
Operators
Most of the modeling is done through the menus or through hot keys. These execute bits of code called "operators". The Python API maps well to these operators.
Check out the tooltips
bpy module and some of it's parts
- bpy.types: The main data classes for the objects in Blender
- bpy.data: Access to data within the program
- bpy.ops: Operators, e.g., things you might find in menus
- bpy.context: State of the program, for example the current view or scene
Objects and their data
An object is defined by the type of data it points to, e.g., mesh, camera, lamp, curve, text ...
>>> ob = bpy.data.objects["Profile"] >>> ob.data bpy.data.meshes["Plane"]
>>> ob2 = bpy.data.objects["Camera"] >>> ob2.data bpy.data.cameras["Camera"]
Modeling Meshes
Typically meshes are modeled in "Edit Mode".
Meshes are made of vertices, edges, and faces
Mesh data structures
Think of vertices as a zero-based list of coordinates
Think of faces/edges as pointers into the list of vertices
Vertices
# A list of 3D coordinates verts = [ [1, 1, 0], [1, -1, 0], [-1, -1, 0], [-1, 1, 0] ]
Edges
# List the verts to connect edges = [ [0, 1], [1, 2] ]
Faces
# List the verts to span faces = [ [0, 2, 3] ]
bpy.types.Mesh.from_pydata
# The magic is done by:
# bpy.types.Mesh.from_pydata
me = bpy.data.meshes.new("me")
me.from_pydata(verts,
edges,
faces)
ob = bpy.data.objects.new("ob",
me)
scn = bpy.context.scene
scn.objects.link(ob)
# Not needed
scn.objects.active = ob
ob.select = True
Profile to solid
Specification
To create the shape, we must specify:
- Profile shape (with numverts vertices, connected by edges)
- Radius
- Resolution
- Amplitude
- Cycles (peaks/valleys)
Implementation, part 1
Copy numverts vertices mulitple times, based on resolution
Implementation, part 2
Old edges become new faces.
Exploit the fact that we are connecting vertices who's indices are numverts apart.
Part 1: modules and globals
import bpy from math import sin, cos, pi num_cycles = 4 resolution = 64 radius = 5 amplitude = 1
Part 2: setup
def main():
oldob = bpy.data.objects["Profile"]
if oldob == None:
return
oldme = oldob.data
numvert = len(oldme.vertices)
numedge = len(oldme.edges)
numface = len(oldme.polygons)
verts = []
faces = []
Part 3: main loop
###### ... main() cont'd
for i in range(resolution):
for j in range(numvert):
# Duplicate and transform vertices
vold = oldme.vertices[j].co
vnew = transform_vert(vold, i)
verts.append(vnew)
# Extrude old edges into new faces
for j in range(numedge):
if oldme.edges[j].is_loose:
e = oldme.edges[j].vertices
f = edge_to_face(e, i, numvert)
faces.append(f)
Part 4: creating the new mesh
###### ... main() cont'd
me = bpy.data.meshes.new("thingy")
me.from_pydata(verts, [], faces)
ob = bpy.data.objects["thingy"]
ob.data = me
Part 5: transforming the vertices
def transform_vert(v, i): prop = float(i) / float(resolution) a = 2*pi*prop b = a * num_cycles cosa = cos(a) sina = sin(a) sinb = sin(b) x = (v[0] + radius) * cosa + v[1] * sina y = -(v[0] + radius) * sina + v[1] * cosa z = v[2] + sinb * amplitude return [x, y, z]
Part 6: old edges become new faces
def edge_to_face(e, i, numvert):
i1 = i
i2 = (i + 1) % (resolution)
f = [e[0] + i1*numvert,
e[1] + i1*numvert,
e[1] + i2*numvert,
e[0] + i2*numvert]
return f
Part 7: call main
(duh)
main()
Printability
Manifold Surfaces
The interior must be clearly defined
Printability
Fragility
Printability
Faceting
The subdivision surface modifier is your friend!
Export
From the File/Export menu ...
Recommendations:
- STL (Stereolithography) for monochrome
- X3D for color
- Think about the size of your object before exporting
Service Bureau
I use ShapeWays, because:
