Rhino 3dm File Load / Draw / Bake

As part of getting an interactive preview into the Super Matter Tools UI I've been developing some proof-of-concept code to read Rhino 3dm files, load the objects into memory (without creating Rhino geometry), and draw them using a fast "display conduit". Further, I've worked on posing those objects (transforming them), and then "baking" them into actual Rhino geometry so they can be used to render animations.

This is similar to how Grasshopper lets users preview geometry and manipulate it without creating Rhino objects. Then, when things are set, baking them.

Here are a few screen captures of the code running (the full source code is listed at the end of this post):

A Kuka KR100HAL90 robot mesh, drawn shaded using the display conduit. The bounding box for the objects is expanded by 5% and drawn as well. For an overview of the Display Conduit in Rhino see this post: Display Conduit Introduction for RhinoCommon.

 The material diffuse color is changed to green and drawn again:

 The robot is rotated 90 degrees in Z, material is changed, and drawn:

The mesh is "baked", converting them to Rhino objects: 

This allows for drawing using the nicer rendering modes available - in this case Artistic:

The full python test code:

import rhinoscriptsyntax as rs
import scriptcontext
import Rhino
import System
import System.Drawing

def Main():
    # The 3dm file to open and read
    pathname = "C:\\KR100HAL90.3dm"
    # Open it and get the objects
    drawObjs = Load3DMFile(pathname)
 
    # Make the display conduit object for drawing
    dc = DisplayConduit(drawObjs)
 
    # Draw
    dc.xform = rs.XformIdentity()
    dc.Enabled = True
    rs.Redraw()
    rs.GetPoint("Click to continue...") # Wait...
 
    # Change the material color and draw again
    dc.material.Diffuse = System.Drawing.Color.Green
    rs.Redraw()
    rs.GetPoint("Click to rotate...") # Wait...
 
    # Rotate (and change color again)
    cplane = rs.ViewCPlane()
    dc.xform = rs.XformRotation2(90.0, cplane[3], cplane[0])
    dc.drawObjsBBox.Transform(dc.xform) # Update the bounding box to the rotated state
    dc.material.Diffuse = System.Drawing.Color.Yellow
    rs.Redraw()
    rs.GetPoint("Click to Bake Meshes...") # Wait
 
    # Convert the mesh to Rhino objects
    meshList = BakeMeshes(dc.drawObjs, dc.xform)
    if meshList:
        print "Meshes created: %d" % len(meshList)
    rs.Redraw()
 
    # Stop drawing
    dc.Enabled = False
    rs.Redraw()

# Read the 3dm file and return a list of the objects within it
def Load3DMFile(pathname):
    f3dm = Rhino.FileIO.File3dm.Read(pathname)
    if (f3dm):
        objs = f3dm.Objects
        return objs

# Convert the list of objects passed to Rhino geometry. Then transform
# them with the transformation matrix passed
def BakeMeshes(drawObjs, xform):
    meshList = []
    for item in drawObjs:
        if item.Geometry.ObjectType == Rhino.DocObjects.ObjectType.Mesh:
            mesh = item.Geometry
            verts = mesh.Vertices
            faces = mesh.Faces
            rhinoMesh = scriptcontext.doc.Objects.AddMesh(mesh)
            meshList.append(rhinoMesh)
    if (meshList):
        rs.TransformObjects(meshList, xform)
    return meshList

# Display Conduit class to draw in the viewports
class DisplayConduit(Rhino.Display.DisplayConduit):
    def __init__(self, objs):
        # Store the objects we are to draw
        self.drawObjs = objs
        # Store the transformation to apply - initially none
        self.xform = Rhino.Geometry.Transform.Identity
     
        # Get the bounding box for all the objects passed
        self.drawObjsBBox = Rhino.Geometry.BoundingBox(Rhino.Geometry.Point3d(-1,-1,-1), Rhino.Geometry.Point3d(1,1,1))
        for item in self.drawObjs:
            bbox = item.Geometry.GetBoundingBox(False)
            if (bbox):
                self.drawObjsBBox.Union(bbox)
     
        # Expand the bbox by 5% of the diagonal length for use in zoom extents
        amount = self.drawObjsBBox.Diagonal.Length*0.05
        self.drawObjsBBox.Inflate(amount)
     
        # Init the material to draw with
        self.material = Rhino.Display.DisplayMaterial()
        self.material.Diffuse = System.Drawing.Color.OrangeRed # Kuka robot color!
        self.material.Shine = 0.8
 
    # Called to quickly return the bounding box for the scene including our objects
    def CalculateBoundingBox(self, calculateBoundingBoxEventArgs):
        calculateBoundingBoxEventArgs.IncludeBoundingBox(self.drawObjsBBox)
 
    # Called to quickly return the zoom extents bounding box including our objects
    def CalculateBoundingBoxZoomExtents(self, calculateBoundingBoxEventArgs):
        calculateBoundingBoxEventArgs.IncludeBoundingBox(self.drawObjsBBox)
 
    # Called to draw the objects to the viewport. This is done before any Rhino
    # objects which will be drawn over ours.
    def PreDrawObjects(self, drawEventArgs):
        drawEventArgs.Display.DrawBox(self.drawObjsBBox, System.Drawing.Color.White)
        drawEventArgs.Display.PushModelTransform(self.xform) # Apply the transform
        for item in self.drawObjs:
            if item.Geometry.ObjectType == Rhino.DocObjects.ObjectType.Curve:
                drawEventArgs.Display.DrawCurve(item.Geometry, System.Drawing.Color.Green)
            elif item.Geometry.ObjectType == Rhino.DocObjects.ObjectType.Brep:
                drawEventArgs.Display.DrawBrepWires(item.Geometry, System.Drawing.Color.Red)
            elif item.Geometry.ObjectType == Rhino.DocObjects.ObjectType.Mesh:
                #drawEventArgs.Display.DrawMeshWires(item.Geometry, System.Drawing.Color.Blue)
                drawEventArgs.Display.DrawMeshShaded(item.Geometry, self.material)
            elif item.Geometry.ObjectType == Rhino.DocObjects.ObjectType.Point:
                drawEventArgs.Display.DrawPoint(item.Geometry.Location, System.Drawing.Color.White)
        drawEventArgs.Display.PopModelTransform() # Remove the transformation

# Run it...
if (__name__ == "__main__"):
    Main()

Read More

Super Matter Tools - Adding a Graphical User Interface

I've been working on a program called Super Matter Tools at Taubman College at the University of Michigan. I've been collaborating  with Taubman Fab Lab Director, Wes McGee, and with Dave Pigram, Director, Master of Advanced Architecture Program at University of Technology Sydney. They were the original developers of Super Matter Tools (SMT).

SMT is one of the programs used for tool path programming of the lab's robots. It's important that the lab develops its own software tools because of the number of unique research tracks taken in the lab. These custom tools and operations are not supported by commercial CAM applications such as MasterCAM, RhinoCAM, etc.

Developing a Graphical User Interface for Rhino Python

SMT began as a command line script. The first step was to eliminate the command line and replace it with a graphical user interface.

The earliest prototypes were created using SharpDevelop. Here's an example of a very early mock up done using SharpDevelop:

We didn't want to rely on that tool. Instead we wanted to have it all coded in python without the need for an external IDE. I developed those fundamental UI tools back in late 2012. They are available for any Rhino Python programmer to use - see my post Easily Create Graphical User Interfaces in Rhino Python to download the code and learn to use it.

The code continued to develop (!) until functionally it did as much as the command line version. That is, generated code for a single robot and a single operation. Here's the UI at that point - it only worked for one robot and operation - but the aim was to support more eventually and the UI reflects this:

Multiple Robots

In 2013 the lab upgraded its robotics capabilities by adding four more robots. We then needed to update the SMT workflow to support multiple robots, with multiple operations for each robot. The python class structure was revised and the tree view was updated to support this. Here are a few screen grabs of various UI panels.

This panel is for the Workcell. The workcell determines which robot or robots are available. From here you can import the workcell geometry (a 3D model of the robot environment) as well as add programs.

This is the panel for editing programs. A program is associated with a single machine. Controls here allow you to import the machine geometry, generate code for the robot to execute, and add operations. 

This is the panel for editing operations. The process determines which tool is used. 

Under each operation are pages for selecting geometry, specifying tool orientation, and curve division. 

There are other panels, for instance this one, which allow you to set the start and end point for the robots movements.

Interactive Posing and Code Generation

Initially, you set everything up in SMT and only after pressing OK to exit the UI did it generate code or pose the robots. It became clear quickly that we could keep the UI up and do both those things.
So the UI was updated to support interactive posing and generation of single operations as well as full programs.

We also added the capability to generate videos of the simulation. Here's an example of this type of rendering. This shows the robot moving along a helix toolpath.

A Simulate button and Trackbar control were added to control the simulation of the robot over the toolpaths. You can simulate a single operation, a single program, or multiple synchronized robots.  

Dynamic Draw

We are in the process of adding temporary drawing (similar to Grasshopper) rather than posing the Rhino geometry.

For an update on that progress please see: Rhino 3dm File Load / Draw / Bake.

Read More