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

CNC Corner Fix Utility

I created a Rhino Python script to quickly draw the geometry to allow the CNC router to clear out material in corners.

Download Here
(Note: This a Windows only plug-in. It will not work with Rhino for the Mac.)

To run the script load it into the Rhino Python editor. From Rhino type EditPythonScript. This launches the Python editor.

Choose the Open icon and load the CornerFix12.py script. Select Run Script from the fly-out menu shown.

The user interface is shown below.

Choose if you want to clean the corner material with a Router bit or a Drill bit. You can use a drill bit with a small diameter to make the least visible mark. Choose Router if you don't want to change tools and just cut the contour into the corner.

Choose the diameter of the bit you wish to use. Then set the Shift Cut %. For the least visible cut use the default of 99%. This will just barely cover the corner. If you change it to 0% the arc will be centered over the previous intersection point. Here are a few example of a router path to visualize the difference (the polylines intersect on the grid intersection points):

Click the Select Lines button. Select the two line segments leading into an inside corner. The arc will be drawn. Note: The program always draws to the inside corner - there is no reason to add arcs to outside corners because they can be cut without them. If you are using a drill bit a center point is drawn as well as the circle. Not trimming of the corner is done.

There is an extra 0.001" added to the width of the arc and lines drawn when routing. This allows CAM software toolpaths to enter the arc. Without this, particularly in Mastercam, the corner arc will be skipped.

Note you can fully operate Rhino as the script runs. This lets you explode, undo, join, whatever... as you fix up the corners. To quit the program just close the interface.

Important Safety Note

If you make the corner curve very small (as is shown above) you run the risk of burning the material. That's because the router bit is not moving much as it clears the corner material. This leaves the bit spinning in place (or almost so) and heats it way up. Therefore be careful when using the circle setting. It's better to drill the holes (for the smallest amount of material removed from the corner) or use a larger circle so the bit will continue to move as it clears out the corner. That is, use a diameter larger than the bit.

Here's an example of the burn that can occur - this is doing some pocketing (before the finish pass was cut):

In this case, there were so many corners cut this way, the bit go so hot that the spoil board beneath the material caught fire. That's never good.

Current Limitations:

• The program works on degree 1 curves only (polylines). 
• The polylines need to be open. So if you have a closed polyline explode it first, then use the tool. 
• The polylines need to intersect at a point or cross over one anther. If they don't fillet them with a radius of 0 first. Then select the lines. 

Read More

Torus Knot Maker

Overview

This post provides documentation for the Rhino 5 Python plug-in I wrote called the Torus Knot Maker.

A Torus Knot is a curve which lies on the surface of a torus (think donut shape). This plug-in generates them by sweeping a section curve along a path (a one rail sweep in Rhino). These are a few examples of the knots you can create:

The User Interface

The plug-in has a small dialog of controls and an interactive preview. The controls are documented below. 

Online Help: Clicking this control launches your default browser to this help page!

Path Curve Options
The two main parameters which define the path curve are conventionally called P and Q. See Torus Knot Wiki for more technical information.

• P: The number of times the knot winds around the axis of rotational symmetry. 
• Q: The number of times the knot winds around the interior of the torus. 
• Number of Points: The number of control points in the path curve. 
• Z Scale Factor: Use this number to increase the vertical height of the knot relative to its width. As fewer points are used in the path the knot can become "squashed down". This allows you to restore its height vertically. 

Note: P and Q need to be "relatively prime" otherwise the knot is simply a loop. Two numbers are relatively prime if they have no common factors other than 1 (in other words you cannot evenly divide both by some common value). Example: 2 and 3 are relatively prime (no common factor), but 2 and 4 are not relatively prime because you can divide both by 2 (2 is a common factor). As you change the values in the UI you'll quickly see when the values are not relatively prime because the shape is no longer twisting as if wrapping a torus.

Section Curve Options
These options affect the curve that is swept along the path.

• Smooth: If checked the section curve is smoothed (a degree 3 curve). Otherwise it is a polyline (degree 1). With this unchecked the knot will have crisp edges. 
• Radius: Controls the size of the section. Higher values make "thicker" knots. 
• Rotation: This allows you to rotate the section about its center point. This is most noticeable when Smooth is off. 
• Number of Points: The number of points in the section. 3 produces a triangular section, 4 a square, etc. The effect of this setting is less noticeable when Smooth is on. 

Output Options
These options control what is created after you press OK.

• Path Curve: If checked the path curve is created (degree 3 NURBS); otherwise it is not. 
• Section Curve: If checked the section curve is output (degree 1 or 3 NURBS); otherwise it is not. 
• Surface: If checked a surface (polysurface) is created; otherwise it is knot (hardy, har, har...)

Notes:

• The interactive preview does not appear in a Rendered viewport. Therefore you must use one of the other display modes when using the plug-in. 
• See the post Torus Knot Table - Design and Fabrication for details on actually making one of these knots from wood. 

Read More

Torus Knot Table - Design and Fabrication

I designed a table based on the geometry of a torus knot. I wanted to make the table from hardwood. This design was meant as a study of CNC cut wood joinery as well as achieving a high degree of curvature in a table made by 5-axis CNC milling.

I did it as the final project for my Master of Science in Digital Technologies degree from Taubman College at the University of Michigan. Tabuman College has a fantastic digital fabrication lab where I had access to the 5-axis router, abrasive water jet cutter and, CNC bed mill.

Concept

A torus knot is a curve which lies on the surface of a torus (think donut shape). Here is an example:

I wrote a Python script inside Rhino to generate the geometry. It starts with a single curve like the one above. This post provides a Rhino Python script to generate torus knot curves.

Depending on the input curve a great many tables are possible. Here are some 3D printed models showing different forms. The table I choose to fabricate is the one in the middle.

You enter a variety of properties such as the number of pieces, the length of an edge cross section, and properties of the dovetail bit that'll be used to cut the joints.

Once you've answered the questions it generates all the required geometry for toolpath setup. Everything is layered separately for an easier time assigning toolpaths in the toolpath setup software - Mastercam. Each part is exported to a separate file if you like.

Here are all three versions of the table run through the script: 

Data about the table is stored in the Rhino file as notes. Here you can see the max sizes, board feet required, and the size of the required block of wood for each piece. 

Fabrication

The prototype table was made from a single piece of 16/4 Yellow Poplar. The board was 4" thick, 10" wide and 16' long.

Each piece is CNC machined in two phases. The first phase cuts the sides, top, back, front and make portion of the dovetail joint. Each surface is left with 1/8" of extra material. This allows the wood to move a bit after the internal stresses of cutting have occurred. The final 1/8" is removed in the second phase.

The first phase is cut on a pair of 6" high pods and held to the table using vacuum pressure. The wood is glued to an 3/4" thick MDF spoil board which can be cut into to accommodate the curvature of the part. Here are all the parts glued to the MDF. The MDF board is larger because the extra surface area was needed to get enough vacuum pressure to hold very securely.

Here's a part sitting on the pods. It's necessary to put them up on pods so the router head can reach the end to cut the dovetail and so it can swarf mill the top surface.

After the first phase is done the dovetail is fully milled. Each side except the bottom is milled to within 1/8" of the final surface.

Before the part can be milled in the next phase it has to be band sawn free from the MDF plate it was glued to. It's okay to leave up to 1/2" on the bottom of the piece - that'll be removed during the final milling.

The second phase of cutting involves holding the workpiece steady using an aluminum fixture. It holds the part using the dovetail joint. I designed and modeled the fixture in Rhino and made it from off-cut aluminum plates. I waterjet cut out the parts, then milled them on the CNC bed mill.

  

The assembled fixture allows the dovetail to be tightly clamped against the vertical plane of the fixture. A metal dowel pin is run through the fixture to ensure proper vertical alignment and prevent the part from sliding in the dovetail bracket during cutting. 

Here a part is clamped in the fixture and is ready to be cut. As you can see, every face is accessible except the dovetail which is fully milled during phase one.

The dovetail bracket which holds the dovetail end of the workpiece was cut with the same carbide tipped bit used to cut the dovetails. That, and correct setup, ensures a perfect fit.
The alignment of the fixture is critical. The milled front face of the base is carefully aligned with the grid in the table. Then the exact position of the fixture is measured using a dial gauge.

  

Those measured coordinates are entered as the "table origin" - so the CNC thinks that's the 0,0,0 point. This matches how they were exported in Rhino and imported into Mastercam.

Once held in the fixture the part can be milled on all five remaining faces. Here is a part prior to any cutting:

First the endgrain is cut back 1/8" and the dovetail socket is cut. Then the bottom is milled to the final profile. Then the sides and top are cut.

You can see that the final edges of the part are only 1/8" away from the aluminum fixture.

Careful simulation inside Mastercam is required to ensure that the bit will never strike the fixture. The 3/4" solid carbide bit used to do the swarf milling is over $500 and hitting the fixture would destroy it. Yikes. The image below, taken looking down the tool axis from above, shows how close the cutter comes to the fixture. The screw near the cutter is smaller than the others - that's because the simulation showed it would hit!

Any surface that turns yellow during the simulation is cut -including that screw.

Of all 30 parts only one could not be milled correctly. That's because the sweep from one part to the next is too great and would have resulted in a collision with the fixture as the top of the dovetail was cut. So the top of the dovetail (just a 3/4" wide strip) does not match the neighboring part in this single case.

That extra material had to be removed with a gouge and then sanded smooth.

Here are all 30 parts cut prior to assembly.

Video: 

Assembly

The parts are glued up in pair. Then those pairs are glued up and so on...

Result

The table is sanded to remove any tool marks.

Walnut Version

Later I built another version of this table out of Walnut. It's discussed here. 

Read More