Mod the Machine

Getting the Overall Size of Parts

The question of getting the size of a part frequently comes up and I wanted to spend some time discussing the existing functionality and other options. The discussion here applies to both Fusion 360 and Inventor (and probably most other CAD systems).

What is a Bounding Box?
The easiest way to get a size of a part is to get the bounding box (also called the range box) of the object.  Let’s look at what a bounding box is by looking at some simple 2D examples first.  A 2D bounding box is a rectangle that encompasses the object. Below is an example of a part (the shaded area) and it’s bounding rectangle (dashed lines).  If we measured the size of this box I think we would all agree that it looks like an accurate measure of the overall size of the part.

 

A typical bounding box is defined using just two points; the minimum and maximum points.  The picture below shows the two 2D points used to define the bounding box. A limitation with defining a bounding box in this way is that the rectangle is oriented such that it’s edges are always parallel to the x and y model axes.

 

Below is the same part that has been rotated and its bounding box is displayed. In this case the size of the bounding box probably isn’t what you wanted and in most cases is not particularly useful.

What you probably really wanted was this bounding box but that box can’t be defined by a simple two points and needs additional information to define the orientation.

Bounding boxes aren’t something specific to the Inventor and Fusion 360 API’s but are a basic concept in computer graphics. The usual intent of a bounding box is not to provide a tight fitting, orientated box around a part but instead to provide a very fast box that fits around a certain piece of geometry. The only thing guaranteed is that the object is completely contained within the box and there is no guarantee about how tight the box fits around the object. In many cases, like in the first example, the size of the range box is the same as the physical size of the part but there are cases when this is not the case. Below, on the left, is an example from Inventor where the bounding box is quite a bit larger than the visible part. At first glance this would seem to be a bug in the calculation but the bounding box is including the control polygon of the spline surface, as shown on the right. So it may not be what you want but it is arguably correct and is the simplest for Inventor to calculate.

Bounding boxes are intended to be used in more complex operations where you need to first determine if a particular object should be considered in a calculation. To determine if an object should be included you can often use it’s bounding box to see if it’s within the area to be calculated. This is a very simple and fast calculation that can be performed to determine if the object can be eliminated from the more complicated and costly computations.  Operations with bounding boxes like this are also very simple.  For example you can combine bounding boxes to create a new box that contains the originals.

The Inventor API has the Box and Box2d objects that are used to pass back the bounding box information and these objects also provide properties and methods to let you work with the box information.  The Fusion 360 API has the BoundingBox3D and BoundingBox2D objects that provide the equivalent functionality.  The most important feature of these objects is that they return the coordinates of the min and max points.

Getting Accurate Bounding Boxes
As discussed above, the bounding box returned by the Inventor RangeBox property and returned by the Fusion360 boundingBox property may not be what you need.  Unfortunately, a bounding box that is always tight fitting to the visible graphics is not currently provided by either Inventor or Fusion 360. However, it is possible to calculate a very close approximation on your own using other API functionality. What I’m going to show you here will create a tight range box but it will still be oriented so it’s parallel to the world XYZ planes. The ability to automatically calculate a bounding box that is oriented to get the tightest fitting box possible is a very difficult problem that I haven’t seen a solution to. It’s something you could probably write a PhD paper on. The easiest approach to the orientation problem is to ask the user for help by lettin them define the coordinate system the bounding box should be calculated in, essentially defining the directions for the length, width and height. That’s possible but a little more than I wanted to go into in this post so I’ll limit this discussion to calculating a tight fitting bounding box that’s oriented parallel to the world XYZ planes.

To do this you can use a triangular mesh representation of the model and calculate your own bounding box by including all of the vertices of the mesh. The result will be as accurate as the mesh. In both Inventor and Fusion 360 you can calculate a mesh representation to any tolerance you want or you can get the existing mesh that Inventor or Fusion 360 is using for the display of the model.  The actual model is made up of accurate smooth surfaces, but a mesh representation is created and used internally to display the model. Using the existing mesh is faster that calculating a new one but if accuracy is critical you might want to calculate a new mesh. The shape of the model will also affect the accuracy. A model made up entirely of planes will result in an exact mesh representation regardless of the tolerance of the mesh because the triangles exactly represent those faces.  If a model has any curved surfaces, even as simple as a cylinder, then the mesh is an approximation.  I’ve tried to illustrate this in the picture below.  On the left are the original models where one model is made entirely of planes and the other has planes, cylinders, and a sphere.  On the right is the triangular mesh representations of the two parts.  The first model is an exact representation because the shape can be exactly represented by the triangles.  However, the second model has curved surfaces and has to be approximated by the triangles.  The accuracy of the bounding box you build will depend on their being a triangle vertex at the minimum and maximum X, Y, and Z sizes of the model.  The more triangles, the more likely you’ll have vertices at those locations but it also means more processing for Inventor or Fusion to calculate the mesh and more processing for you to analyze the mesh to build the range box. 

 

I’ve used the code similar to that below in a few programs I’ve posted previously. The calculateTightBoundingBox function takes in a body and optional tolerance and returns the tight fitting bounding box.  If no tolerance is provided, the existing display mesh is used. There can be more than one display mesh because Inventor and Fusion will generate different meshes depending on how close you zoom into the model so the display always appears smooth. When using the display mesh, this function will use the highest quality display mesh that exists. If a tolerance is provided, then a new mesh is calculated using that tolerance. There is a test function for each that is used to test the calculateTightBoundingBox function.  Samples below are provided in Python for Fusion 360 and VBA and Visual Basic for Inventor.  Below is the result on the previous model where the bounding box returned by Inventor was much larger.

Fusion 360 Python

# Function to test the calculateTightBoundingBox function.
def run(context):
    ui = None 
    try:
        app = adsk.core.Application.get()
        ui = app.userInterface
        des = adsk.fusion.Design.cast(app.activeProduct)
        
        bodySelect = ui.selectEntity('Select the body.', 'Bodies')
        body = adsk.fusion.BRepBody.cast(bodySelect.entity)
        
        # Call the function to get the tight bounding box.
        bndBox= calculateTightBoundingBox(body)
        
        # Draw the bounding box using a sketch.
        sk = des.rootComponent.sketches.add(des.rootComponent.xYConstructionPlane)        
        lines = sk.sketchCurves.sketchLines
        
        minXYZ = bndBox.minPoint
        minXYmaxZ = adsk.core.Point3D.create(bndBox.minPoint.x, bndBox.minPoint.y, bndBox.maxPoint.z)
        minXmaxYZ = adsk.core.Point3D.create(bndBox.minPoint.x, bndBox.maxPoint.y, bndBox.maxPoint.z)
        minXZmaxY = adsk.core.Point3D.create(bndBox.minPoint.x, bndBox.maxPoint.y, bndBox.minPoint.z)
        
        maxXYZ = bndBox.maxPoint
        maxXYminZ = adsk.core.Point3D.create(bndBox.maxPoint.x, bndBox.maxPoint.y, bndBox.minPoint.z)
        maxXZminY = adsk.core.Point3D.create(bndBox.maxPoint.x, bndBox.minPoint.y, bndBox.maxPoint.z)
        maxXminYZ = adsk.core.Point3D.create(bndBox.maxPoint.x, bndBox.minPoint.y, bndBox.minPoint.z)
        
        lines.addByTwoPoints(minXYZ, minXYmaxZ)
        lines.addByTwoPoints(minXYZ, minXZmaxY)
        lines.addByTwoPoints(minXZmaxY, minXmaxYZ)
        lines.addByTwoPoints(minXYmaxZ, minXmaxYZ)
        
        lines.addByTwoPoints(maxXYZ, maxXYminZ)
        lines.addByTwoPoints(maxXYZ, maxXZminY)
        lines.addByTwoPoints(maxXYminZ, maxXminYZ)
        lines.addByTwoPoints(maxXZminY, maxXminYZ)
        
        lines.addByTwoPoints(minXYZ, maxXminYZ)
        lines.addByTwoPoints(minXYmaxZ, maxXZminY)
        lines.addByTwoPoints(minXmaxYZ, maxXYZ)
        lines.addByTwoPoints(minXZmaxY, maxXYminZ) 
    except:
        if ui:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))

# Calculates a tight bounding box around the input body.  An optional
# tolerance argument is available.  This specificies the tolerance in
# centimeters.  If not provided the best existing display mesh is used.
def calculateTightBoundingBox(body, tolerance = 0):
    try:
        # If the tolerance is zero, use the best display mesh available.
        if tolerance <= 0:
            # Get the best display mesh available.
            triMesh = body.meshManager.displayMeshes.bestMesh
        else:
            # Calculate a new mesh based on the input tolerance.
            meshMgr = adsk.fusion.MeshManager.cast(body.meshManager)
            meshCalc = meshMgr.createMeshCalculator()
            meshCalc.surfaceTolerance = tolerance
            triMesh = meshCalc.calculate()
   
        # Calculate the range of the mesh.
        smallPnt = adsk.core.Point3D.cast(triMesh.nodeCoordinates[0])
        largePnt = adsk.core.Point3D.cast(triMesh.nodeCoordinates[0])
        vertex = adsk.core.Point3D.cast(None)
        for vertex in triMesh.nodeCoordinates:
            if vertex.x < smallPnt.x:
                smallPnt.x = vertex.x
               
            if vertex.y < smallPnt.y:
                smallPnt.y = vertex.y
               
            if vertex.z < smallPnt.z:
                smallPnt.z = vertex.z
           
            if vertex.x > largePnt.x:
                largePnt.x = vertex.x
               
            if vertex.y > largePnt.y:
                largePnt.y = vertex.y
               
            if vertex.z > largePnt.z:
                largePnt.z = vertex.z
               
        # Create and return a BoundingBox3D as the result.
        return(adsk.core.BoundingBox3D.create(smallPnt, largePnt))
    except:
        # An error occurred so return None.
        return(None)

 

Inventor VBA

Public Sub TestTightBoundingBox()
    ' Have a body selected.
    Dim body As SurfaceBody
    Set body = ThisApplication.CommandManager.Pick(kPartBodyFilter, "Select the body.")
    
    ' Call the function to get the tight bounding box.
    Dim bndBox As Box
    Set bndBox = calculateTightBoundingBox(body)
        
    ' Draw the bounding box using a 3D sketch.
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    Dim sk As Sketch3D
    Set sk = partDoc.ComponentDefinition.Sketches3D.Add()
    Dim lines As SketchLines3D
    Set lines = sk.SketchLines3D

    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
    
    Dim minXYZ As Point
    Dim minXYmaxZ As Point
    Dim minXmaxYZ As Point
    Dim minXZmaxY As Point
    Set minXYZ = bndBox.MinPoint
    Set minXYmaxZ = tg.CreatePoint(bndBox.MinPoint.x, bndBox.MinPoint.y, bndBox.MaxPoint.Z)
    Set minXmaxYZ = tg.CreatePoint(bndBox.MinPoint.x, bndBox.MaxPoint.y, bndBox.MaxPoint.Z)
    Set minXZmaxY = tg.CreatePoint(bndBox.MinPoint.x, bndBox.MaxPoint.y, bndBox.MinPoint.Z)
    
    Dim maxXYZ As Point
    Dim maxXYminZ As Point
    Dim maxXZminY As Point
    Dim maxXminYZ As Point
    Set maxXYZ = bndBox.MaxPoint
    Set maxXYminZ = tg.CreatePoint(bndBox.MaxPoint.x, bndBox.MaxPoint.y, bndBox.MinPoint.Z)
    Set maxXZminY = tg.CreatePoint(bndBox.MaxPoint.x, bndBox.MinPoint.y, bndBox.MaxPoint.Z)
    Set maxXminYZ = tg.CreatePoint(bndBox.MaxPoint.x, bndBox.MinPoint.y, bndBox.MinPoint.Z)
    
    Call lines.AddByTwoPoints(minXYZ, minXYmaxZ)
    Call lines.AddByTwoPoints(minXYZ, minXZmaxY)
    Call lines.AddByTwoPoints(minXZmaxY, minXmaxYZ)
    Call lines.AddByTwoPoints(minXYmaxZ, minXmaxYZ)
    
    Call lines.AddByTwoPoints(maxXYZ, maxXYminZ)
    Call lines.AddByTwoPoints(maxXYZ, maxXZminY)
    Call lines.AddByTwoPoints(maxXYminZ, maxXminYZ)
    Call lines.AddByTwoPoints(maxXZminY, maxXminYZ)
    
    Call lines.AddByTwoPoints(minXYZ, maxXminYZ)
    Call lines.AddByTwoPoints(minXYmaxZ, maxXZminY)
    Call lines.AddByTwoPoints(minXmaxYZ, maxXYZ)
    Call lines.AddByTwoPoints(minXZmaxY, maxXYminZ)
End Sub

' Calculates a tight bounding box around the input body.  An optional
' tolerance argument is available.  This specificies the tolerance in
' centimeters.  If not provided the best existing display mesh is used.
Public Function calculateTightBoundingBox(body As SurfaceBody, Optional Tolerance As Double = 0) As Box
    On Error GoTo ErrorFound
       
    Dim vertCount As Long
    Dim facetCount As Long
    Dim vertCoords() As Double
    Dim normVectors() As Double
    Dim vertInds() As Long
       
    ' If the tolerance is zero, use the best display mesh available.
    If Tolerance <= 0 Then
        ' Get the best display mesh available.
        Dim tolCount As Long
        Dim tols() As Double
        Call body.GetExistingFacetTolerances(tolCount, tols)
        Dim i As Integer
        Dim bestTol As Double
        bestTol = tols(0)
        For i = 1 To tolCount - 1
            If tols(i) < bestTol Then
                bestTol = tols(i)
            End If
        Next
       
        Call body.GetExistingFacets(bestTol, vertCount, facetCount, vertCoords, normVectors, vertInds)
    Else
        ' Calculate a new mesh based on the input tolerance.
        Call body.CalculateFacets(Tolerance, vertCount, facetCount, vertCoords, normVectors, vertInds)
    End If

    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
   
    ' Calculate the range of the mesh.
    Dim smallPnt As Point
    Dim largePnt As Point
    Set smallPnt = tg.CreatePoint(vertCoords(0), vertCoords(1), vertCoords(2))
    Set largePnt = tg.CreatePoint(vertCoords(0), vertCoords(1), vertCoords(2))
   
    For i = 1 To vertCount - 1
        Dim vertX As Double
        Dim vertY As Double
        Dim vertZ As Double
        vertX = vertCoords(i * 3)
        vertY = vertCoords(i * 3 + 1)
        vertZ = vertCoords(i * 3 + 2)
       
        If vertX < smallPnt.x Then
            smallPnt.x = vertX
        End If
           
        If vertY < smallPnt.y Then
            smallPnt.y = vertY
        End If
           
        If vertZ < smallPnt.Z Then
            smallPnt.Z = vertZ
        End If
       
        If vertX > largePnt.x Then
            largePnt.x = vertX
        End If
           
        If vertY > largePnt.y Then
            largePnt.y = vertY
        End If
           
        If vertZ > largePnt.Z Then
            largePnt.Z = vertZ
        End If
    Next
   
    ' Create and return a Box as the result.
    Set calculateTightBoundingBox = tg.CreateBox()
    calculateTightBoundingBox.MinPoint = smallPnt
    calculateTightBoundingBox.MaxPoint = largePnt
    Exit Function
ErrorFound:
    Set calculateTightBoundingBox = Nothing
    Exit Function
End Function

 

Inventor Visual Basic (iLogic)

Public Sub TestTightBoundingBox()
    Dim invApp As Inventor.Application = GetObject(, "Inventor.Application")
    ' Have a body selected.
    Dim body As SurfaceBody
    body = invApp.CommandManager.Pick(SelectionFilterEnum.kPartBodyFilter, "Select the body.")

    ' Call the function to get the tight bounding box.
    Dim bndBox As Box = calculateTightBoundingBox(body)

    ' Draw the bounding box using a 3D sketch.
    Dim partDoc As PartDocument = invApp.ActiveDocument
    Dim sk As Sketch3D = partDoc.ComponentDefinition.Sketches3D.Add()
    Dim lines As SketchLines3D = sk.SketchLines3D

    Dim tg As TransientGeometry = invApp.TransientGeometry

    Dim minXYZ As Point = bndBox.MinPoint
    Dim minXYmaxZ As Point = tg.CreatePoint(bndBox.MinPoint.X, bndBox.MinPoint.Y, bndBox.MaxPoint.Z)
    Dim minXmaxYZ As Point = tg.CreatePoint(bndBox.MinPoint.X, bndBox.MaxPoint.Y, bndBox.MaxPoint.Z)
    Dim minXZmaxY As Point = tg.CreatePoint(bndBox.MinPoint.X, bndBox.MaxPoint.Y, bndBox.MinPoint.Z)

    Dim maxXYZ As Point = bndBox.MaxPoint
    Dim maxXYminZ As Point = tg.CreatePoint(bndBox.MaxPoint.X, bndBox.MaxPoint.Y, bndBox.MinPoint.Z)
    Dim maxXZminY As Point = tg.CreatePoint(bndBox.MaxPoint.X, bndBox.MinPoint.Y, bndBox.MaxPoint.Z)
    Dim maxXminYZ As Point = tg.CreatePoint(bndBox.MaxPoint.X, bndBox.MinPoint.Y, bndBox.MinPoint.Z)

    lines.AddByTwoPoints(minXYZ, minXYmaxZ)
    lines.AddByTwoPoints(minXYZ, minXZmaxY)
    lines.AddByTwoPoints(minXZmaxY, minXmaxYZ)
    lines.AddByTwoPoints(minXYmaxZ, minXmaxYZ)

    lines.AddByTwoPoints(maxXYZ, maxXYminZ)
    lines.AddByTwoPoints(maxXYZ, maxXZminY)
    lines.AddByTwoPoints(maxXYminZ, maxXminYZ)
    lines.AddByTwoPoints(maxXZminY, maxXminYZ)

    lines.AddByTwoPoints(minXYZ, maxXminYZ)
    lines.AddByTwoPoints(minXYmaxZ, maxXZminY)
    lines.AddByTwoPoints(minXmaxYZ, maxXYZ)
    lines.AddByTwoPoints(minXZmaxY, maxXYminZ)
End Sub


' Calculates a tight bounding box around the input body.  An optional
' tolerance argument is available.  This specificies the tolerance in
' centimeters.  If not provided the best existing display mesh is used.
Public Function calculateTightBoundingBox(body As SurfaceBody, Optional Tolerance As Double = 0) As Box
    Try
        Dim vertCount As Integer
        Dim facetCount As Integer
        Dim vertCoords() As Double = {}
        Dim normVectors() As Double = {}
        Dim vertInds() As Integer = {}

        ' If the tolerance is zero, use the best display mesh available.
        If Tolerance <= 0 Then
            ' Get the best display mesh available.
            Dim tolCount As Long
            Dim tols() As Double = {}
            Call body.GetExistingFacetTolerances(tolCount, tols)
            Dim bestTol As Double
            bestTol = tols(0)
            For i As Integer = 1 To tolCount - 1
                If tols(i) < bestTol Then
                    bestTol = tols(i)
                End If
            Next

            body.GetExistingFacets(bestTol, vertCount, facetCount, vertCoords, normVectors, vertInds)
        Else
            ' Calculate a new mesh based on the input tolerance.
            body.CalculateFacets(Tolerance, vertCount, facetCount, vertCoords, normVectors, vertInds)
        End If

        Dim tg As TransientGeometry = body.Application.TransientGeometry

        ' Calculate the range of the mesh.
        Dim smallPnt As Point = tg.CreatePoint(vertCoords(0), vertCoords(1), vertCoords(2))
        Dim largePnt As Point = tg.CreatePoint(vertCoords(0), vertCoords(1), vertCoords(2))
        For i As Integer = 1 To vertCount - 1
            Dim vertX As Double = vertCoords(i * 3)
            Dim vertY As Double = vertCoords(i * 3 + 1)
            Dim vertZ As Double = vertCoords(i * 3 + 2)

            If vertX < smallPnt.X Then
                smallPnt.X = vertX
            End If

            If vertY < smallPnt.Y Then
                smallPnt.Y = vertY
            End If

            If vertZ < smallPnt.Z Then
                smallPnt.Z = vertZ
            End If

            If vertX > largePnt.X Then
                largePnt.X = vertX
            End If

            If vertY > largePnt.Y Then
                largePnt.Y = vertY
            End If

            If vertZ > largePnt.Z Then
                largePnt.Z = vertZ
            End If
        Next

        ' Create and return a Box as the result.
        Dim newBox As Box = tg.CreateBox()
        newBox.MinPoint = smallPnt
        newBox.MaxPoint = largePnt
        Return newBox
    Catch ex As Exception
        Return Nothing
    End Try
End Function

 

-Brian

A Problem with Attribute Helper and a Fix

A partner notified me about a problem he had found with my Attribute Helper add-in that I wasn’t aware of. He told me that if you have the new “Interactive Tutorial” and “Attribute Helper” add-ins both loaded, then Inventor will crash when you shut it down with the dialog below.

 

As I said, I wasn’t aware of the problem but had a good idea of the cause. I wasn’t following my own advice from this post almost a year ago.  I made the changes recommended there so that my Deactivate method of the add-in went from this:

Public Sub Deactivate() Implements Inventor.ApplicationAddInServer.Deactivate
    ' Release objects.
    Marshal.FinalReleaseComObject(g_inventorApplication)
    g_inventorApplication = Nothing

    If Not m_attributeButtonDef Is Nothing Then
        Marshal.FinalReleaseComObject(m_attributeButtonDef)
    End If

    If Not m_UIEvents Is Nothing Then
        Marshal.FinalReleaseComObject(m_UIEvents)
        m_UIEvents = Nothing
    End If

    System.GC.WaitForPendingFinalizers()
    System.GC.Collect()
End Sub

To this:

Public Sub Deactivate() Implements Inventor.ApplicationAddInServer.Deactivate
    ' Release objects.
    m_attributeButtonDef = Nothing
    m_UIEvents = Nothing
End Sub

 

With that change, the crash went away. I hadn’t published a new version of the “Attribute Helper” add-in for a couple of years so I’ve made this change and created a new installer.  You can get the latest version of “Attribute Helper” here.  After installing make sure that you’re running the latest version by checking that the version is 2.6, as shown below.

And if attributes are new to you, you can learn more about what they are here.  The source code for the add-in is also available on GitHub.

-Brian

CNC Fun

This past June for the Forge Developer Conference I worked with some of the great folks at opendesk and ShopBot to put together a working demonstration using their furniture designs, machine tools, and Fusion 360.

opendesk has a large catalog of furniture designs that are made locally on-demand from sheet stock. You should check out their website because it’s an interesting concept.  ShopBot has a selection of CNC routers in all sizes from large 12 by 5 foot monsters down to the portable Handibot.  We decided to use the Johann Stool design from opendesk and allow attendees at the conference to design custom engravings for the top of the stool that would be cut at the conference using a ShopBot tool. 

I got involved to try and create a simple interface to allow non Fusion 360 users to easily create a design and send it to the router.  This consisted of two parts.  First I created a series of Fusion 360 custom commands that draw various designs as a sketch.  The picture below shows the new panel that the add-in creates in Fusion and its commands.  There are several different patterns that the commands allow you to create.  The one shown below creates a rectangular mesh with the grid positions randomized.  There’s also a command that creates several polygons to create a flower pattern, one that creates circles in a random pattern, one that rectangles arranges randomly, and finally one that draws sin curves. 

 

The main thing to remember with all of these specialized commands is that they’re just automating the creation of sketch geometry.  Below is the result of using the custom sketch commands and a bit of manual editing on the resulting sketches to create a new design.

The last custom command provided by the add-in sends the design to the CNC router.  To make the entire process easier, it doesn’t use the NC capabilities of Fusion 360 but with a single button click it directly creates the g-code data from the sketch geometry and sends it to the CNC router.  The command gets the geometry information from the sketch and essentially treats the sketch geometry as the tool path to create a g-code file that will drive the cutter along the sketch geometry.  Splines and circles are stroked into small lines and text is also converted into lines so the g-code consists entirely of point-to-point directions. Below is an example of one of the stool seats that contains some text.  To reduce the time at the conference to create a stool the stools were already mostly cut out in panels of birch plywood and then only the custom pattern on top needed to be machined.

 

Here’s Bill from ShopBot at the booth cutting a stool top. Bill also reported on the experience in his blog.

 

Besides doing the stools, ShopBot also brought a couple of the portable Handibot CNC routers and we used the same process to machine small badges that people could design in the same way. If you haven’t seen the Handibot before you should check out the website and look at some videos on YouTube to see what people are doing with it.

 

The whole process of getting ready for the Forge conference was a lot of fun and very educational for me.  CNC isn’t new to me but I hadn’t every directly written g-code before.  The entire Fusion stool add-in is currently available on github.  This could easily be done with Inventor too but so far I’ve only needed it for some Fusion 360 events.

After the Forge conference, a couple of guys from Autodesk (Philippe and Lucas) wanted to do something interesting with a Handibot at another event.  They liked what we had done at the Forge conference and had the great idea of cutting chocolate. Philippe is a much more colorful writer than me and has written a report about their adventure with chocolate.

-Brian

Updated Sheet Metal Extents Add-In

Kirk Arthur reminded me at Autodesk University about an issue with add-ins that I had blogged about and asked if I had made the recommended change to the Sheet Metal Extents add-in.  I truthfully couldn’t remember so I’ve gone ahead and bumped the version number, recompiled it, built the installer, and made the new version available.  As usual, please let me know if you run into any problems with it.  This is version 3.8 and should be compatible with Inventor 2013 and later.  Use this link to download a zip file that contains an installer that will install the add-in.

If you’re unfamiliar with this add-in, here’s the text from the ReadMe with a brief description.

This is an Add-In that when installed will automatically create and update three custom iProperties.  It should work for Inventor 2013 and later.  The iProperties created are:

SheetMetalLength - The length of the sheet metal flat pattern.
SheetMetalWidth - The width of the sheet metal flat pattern.
SheetMetalStyle - The active sheet metal style (or rule).

It also creates the following two reference parameters:

SheetMetalLength - The length of the sheet metal flat pattern.
SheetMetalWidth - The width of the sheet metal flat pattern.

The SheetMetalLength and SheetMetalWidth iProperties are the result of the two parameters being set to be exposed as iProperties.  The output format for these parameters can be edited to change the formatting of the associated iProperties.  The parameters should not be used as input to other parameters that control the shape of the part because this can result in cycles being created.

-Brian

Projecting Points Onto a Solid

There was a recent Inventor question posted on stackoverflow that I thought was interesting and decided to look at.  The question involved being able to project points from a sketch onto a solid.  Below is a picture of a sketch that contains many sketch center points.  In this case they were created by patterning a point to get a grid of points but they could be created in any way.  The goal is to project all of these points onto the solid.  For my program I chose to project them in the direction that is perpendicular (normal) to the sketch plane.

 

 

Here’s the result where the intersection points are created as work points.

 

The sketch can be in any orientation in space, as shown in the picture below.  In this case the results were created as points within a 3D sketch.

 

And here’s the VBA code that I came up with to do this.  It asks for the selection of a sketch (which you need to pick in the browser) and for a body.  The next section of code is the most confusing but it’s basically trying to determine where the selected sketch is relative to the selected body and then computing a value so that when it begins projecting the points, the point it projects is outside of the solid.  That’s actually the largest chunk of the code.  Towards the bottom of the macro you’ll see where the actual intersection work takes place.  It then prompts the user to select how to display the results where they can choose one of three ways; as work points, points in a 3D sketch, or written to a csv file.

Public Sub ProjectPoints()
    ' Have the sketch that contains the points selected.
    Dim sk As PlanarSketch
    Set sk = ThisApplication.CommandManager.Pick(kSketchObjectFilter, _
                                                 "Select the sketch")
   
    ' Have the body to project onto selected.
    Dim body As SurfaceBody
    Set body = ThisApplication.CommandManager.Pick(kPartBodyFilter, _
                                                   "Select the body")
   
    ' Get the part component definition.
    Dim compDef As PartComponentDefinition
    Set compDef = body.Parent
   
    ' *** Determine the side of the solid the sketch is on and if the
    ' *** sketch is outside the solid.
   
    ' Get the normal vector of the selected sketch.
    Dim skNormal As UnitVector
    Set skNormal = sk.PlanarEntityGeometry.Normal
    Dim skRootPoint As Point
    Set skRootPoint = sk.PlanarEntityGeometry.RootPoint
   
    ' Get the corners of the range box.
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
    Dim cornerPoints(7) As Point
    Dim range As Box
    Set range = body.RangeBox
    Set cornerPoints(0) = range.MinPoint
    Set cornerPoints(1) = tg.CreatePoint(range.MinPoint.x, range.MinPoint.y, _
                                         range.MaxPoint.Z)
    Set cornerPoints(2) = tg.CreatePoint(range.MinPoint.x, range.MaxPoint.y, _
                                         range.MinPoint.Z)
    Set cornerPoints(3) = tg.CreatePoint(range.MinPoint.x, range.MaxPoint.y, _
                                         range.MaxPoint.Z)
    Set cornerPoints(4) = range.MaxPoint
    Set cornerPoints(5) = tg.CreatePoint(range.MaxPoint.x, range.MinPoint.y, _
                                         range.MaxPoint.Z)
    Set cornerPoints(6) = tg.CreatePoint(range.MaxPoint.x, range.MinPoint.y, _
                                         range.MinPoint.Z)
    Set cornerPoints(7) = tg.CreatePoint(range.MaxPoint.x, range.MaxPoint.y, _
                                         range.MinPoint.Z)
   
    ' Construct a matrix where the X axis is along the sketch plane normal.
    Dim xAxis As Vector
    Set xAxis = skNormal.AsVector
   
    Dim yAxis As Vector
    Set yAxis = tg.CreateVector(xAxis.x + 1, xAxis.y + 1, xAxis.Z + 1)
   
    Dim zAxis As Vector
    Set zAxis = xAxis.CrossProduct(yAxis)
   
    Set yAxis = zAxis.CrossProduct(xAxis)
    xAxis.Normalize
    yAxis.Normalize
    zAxis.Normalize
   
    Dim transform As Matrix
    Set transform = tg.CreateMatrix
    Call transform.SetCoordinateSystem(skRootPoint, xAxis, yAxis, zAxis)
    transform.Invert
   
    ' Transform the range box points and compare them to sketch plane.
    Dim i As Integer
    Dim smallX As Double
    For i = 0 To 7
        Call cornerPoints(i).TransformBy(transform)
       
        If i = 0 Then
            smallX = cornerPoints(i).x
        Else
            If cornerPoints(i).x < smallX Then
                smallX = cornerPoints(i).x
            End If
        End If
    Next
   
    ' Determine the offset needed to position the points outside the solid.
    Dim offset As Double
    If smallX < 0 Then
        offset = -(smallX + 10)
        Dim tempNormal As Vector
        Set tempNormal = skNormal.AsVector
        Call tempNormal.ScaleBy(-1)
        Set skNormal = tempNormal.AsUnitVector
    Else
        offset = 0
    End If
   
    Dim offsetVector As Vector
    Set offsetVector = skNormal.AsVector
    Call offsetVector.ScaleBy(offset)
   
    ' *** Perform the intersection calculation of every center point in the sketch.
   
    Dim resultPoints As ObjectCollection
    Set resultPoints = ThisApplication.TransientObjects.CreateObjectCollection
    Dim skPoint As SketchPoint
    For Each skPoint In sk.SketchPoints
        ' Check to see if the point is a center point.
        If skPoint.HoleCenter Then
            ' Get the sketch point as a transient 3D point.
            Dim pnt As Point
            Set pnt = skPoint.Geometry3d
           
            ' Move the point outside the solid.
            Call pnt.TranslateBy(offsetVector)
           
            ' Intersect the point with the solid.
            Dim foundEnts As ObjectsEnumerator
            Dim locPoints As ObjectsEnumerator
            Call body.FindUsingRay(pnt, skNormal, 0.00001, foundEnts, locPoints, True)
           
            ' If an intersection was found, add it to the list.
            If locPoints.count > 0 Then
                Call resultPoints.Add(locPoints.Item(1))
            End If
        End If
    Next
   
    ' Prompt the user for which type of output they want.
    Dim result As String
    result = InputBox("Enter choice for output:" & vbCrLf & "1 - Work points" & _
                      vbCrLf & "2 - 3D sketch" & vbCrLf & "3 - csv File", _
                      "Enter output type", 3)
   
    If result = "1" Or result = "2" Then
        ' Start a transaction so that the creation is grouped in a single undo.
        Dim trans As Transaction
        Set trans = ThisApplication.TransactionManager.StartTransaction( _
                        ThisApplication.ActiveDocument, "Projected Points")
   
        If result = "1" Then
            ' Create work points.
            For i = 1 To resultPoints.count
                Call compDef.WorkPoints.AddFixed(resultPoints.Item(i))
            Next
        End If
   
        If result = "2" Then
            ' Create a 3D sketch and points in the sketch.
            Dim sk3D As Sketch3D
            Set sk3D = compDef.Sketches3D.Add()
            For i = 1 To resultPoints.count
                Call sk3D.SketchPoints3D.Add(resultPoints.Item(i))
            Next
        End If
   
        trans.End
    ElseIf result = "3" Then
        ' Write the points out to a file.
        Open "C:\Temp\Points.csv" For Output As #1
        For i = 1 To resultPoints.count
            Print #1, Format(resultPoints.Item(i).x, "0.00000000") & "," & _
                      Format(resultPoints.Item(i).y, "0.00000000") & "," & _
                      Format(resultPoints.Item(i).Z, "0.00000000")
        Next
        Close #1
        MsgBox "File written to ""C:\Temp\Points.csv"""
    Else
        MsgBox "Invalid Input"
    End If
End Sub

Hopefully this is useful as a starting point for something you might want to do.  It at least demonstrates a couple of interesting things.

This is all Inventor but for those of you using Fusion, Fusion doesn’t currently have the API functionality to fire a ray through the model so this can’t be done in the same way.  I do expect that to be available at some point in the future though.

-Brian

Creating Points at an Arbitrary XYZ Location in Fusion

There was a discussion on the Fusion forum about being able to create a construction point that’s positioned at a specific X, Y, Z location.  There is also a post on the IdeaStation.  Fusion doesn’t currently support that capability but only supports the creation of construction points relative to existing geometry. When creating construction geometry, there are two situations to consider; capturing design history (parametric modeling) and not capturing design history (direct edit modeling).  You switch between the two modeling types using the command in the context menu on the root component node in the browser, as shown below.

Direct Edit
In a direct edit design, construction points don’t remember their relationship to the original geometry used when creating them and they can be moved to any location after they’ve been created using the Move command.  Using the Move command it is possible to end up with a construction point at the desired X, Y, Z location but it’s an inconvenient workflow to first create the point and then move it.

Parametric Model
When working in a parametric model, all construction points are dependent on other geometry and can’t exist anywhere in space so it’s not possible to position a point at an arbitrary X, Y, Z location. However, parametric designs support something called a “Base Feature”. A base feature lets you create an “island” of direct edit data within your parametric design, so it ends up being the same workflow as in a direct modeling design, except that you also need to first create a base feature, as shown below.

So, it is possible to create a construction point at a specific X, Y, Z location in both parametric and direct modeling designs, but it’s inconvenient in both. With the recent May 7 Fusion update, the API now supports the creation and edit of base features.  With this capability it’s now possible to write an add-in that will support the creation of a construction point at a specified X, Y, Z location.

Once the add-in is installed, you’ll now see a new “Point at Coordinate” command in the CONSTRUCT menu, as shown below.

When you run the command when you’re in a direct modeling design the dialog on the left is displayed and when you’re in a parametric design, the dialog on the right is displayed.

Using the “Name” field you can specify what the name of the new construction point will be.  The default is “XYZ Point” but sometimes, depending on how you’re going to use the point, it can be useful to name it so you can easily identify which one is which when looking at the browser.

The “X Position”, “Y Position”, and “Z Position” fields are the X, Y, and Z values where the construction point will be created.  You can use any valid expression when specifying these values, including the use of parameter names.  For example, if you have a parameter named Length you can use “Length/2”.  The default units are whatever the current design units are.  But you can also override that by specifying the units.  For example “3 in” will be interpreted as 3 inches.  Whatever you use as input, it’s important to understand the point doesn’t remember this relationship so that if you use a parameter name and then later change the parameter value, the point will not move.

When the command is run in a parametric design, the “Base feature” dropdown at the top of the dialog is displayed. Because points at an arbitrary location must be created within a base feature when working in a parametric design, this lets you specify which base feature they’ll be created in.  If there isn’t an existing base feature, a new one will be created and that will be the default base feature when you run the command again, although you have the option of choosing any existing base feature.

To use the add-in just unpack the zip file anywhere on your computer.  Run the “Scripts and Add-Ins” command and click the green “+”, as shown below.  Browse to the location where you unpacked the zip file and choose the PointAtCoord.py file.  You’ll only need to do this once because Fusion will remember it for subsequent sessions.

 

You can either shut down and restart Fusion to make the command available, or while in the same session you can start the add-in.  This is only needed when first enabling the add-in because it will load automatically in subsequent sessions of Fusion.  To start the add-in, choose the “Add-Ins” tab on the “Scripts and Add-Ins” dialog, select the “PointAtCoord” add-in from the list, and click the “Run” button.

 

Now, and in all sessions of Fusion the “Point at Coordinate” command will be available.

You can find the source code for this add-in and a few others here on GitHub.  Please let me know if you find any problems or have suggestions on improvements.

Fusion Meetups and Melting Butter

I had posted a few weeks about some upcoming meetups discussing the Fusion API. To generate some interest for the meetups I created a small animation of some butter melting and forming a puddle in a butter dish. Here’s the original animation.  At the meetups I presented an introduction to Fusion’s API and shared how the animation was created. The meetup in Seattle was hosted by Microsoft and Jeremy Foster, from Microsoft, was kind enough to record it and post it on Microsoft’s Channel 9.

 

If you’re wondering how I created the animation and are imagining something elaborate you’re going to be a bit disappointed. The good news is that it’s probably simpler to do than you’re expecting. First, there are not any elaborate volume calculations to make sure the volume of the puddle matches the volume that has melted from the cube. I just tried to do what looked good. The melting of the cube and the formation of the puddle is done using parameters so the majority of the work is building the model, not writing the program. Although I’m using Fusion here, this is all possible with Inventor using the same concepts. What the program is doing is actually very simple; there’s a loop where in each iteration it changes the value of one or more parameters, updates the model, and captures the screen as an image. That’s it. The challenge is building the model so you get the behavior you want by editing parameters.

Let’s look in more detail how the butter model works. There are three components that make up the model; the butter dish, the block of butter, and the puddle. Below, three sketches are shown that are the key to making it all work. The sketch at the bottom defines the shape of the puddle. The other two sketches are used to create a loft feature which is subtracted from the block of butter.

Below is a detailed look at one of the sketches used to define the loft that cuts away the block of butter. The sketch consists of three lines and a spline. The vertical position of the points on the spline is being controlled through the use of dimension constraints. When you place a dimension in a sketch, a parameter is automatically created that controls the value of the dimension. By editing the parameters the points on the spline will move up and down. The program modifies the parameter values so that the points slowly move down, causing the block of butter to disappear.

The puddle uses the same principal but is slightly more complicated because the points don’t just move down but move in two directions. Below is the puddle sketch. To move the points in two directions there are two dimensions to each spline point, one controlling the horizontal (x) direction and another controlling the vertical (y) direction. To make the puddle grow, the parameters are edited to slowly move the points “out” away from the cube. I didn’t worry about how the puddle intersects the butter dish. As it grows it will end up extending into the dish, but it looks ok because you can’t see the overlap.

Below is a snapshot of most of the parameters that are used to drive the model. Sketch7 is the puddle sketch and Sketch8 is one of the loft sketches. I named each of the parameters a name that made sense to me so I knew which parameter to edit to get the corresponding point to move in the way I wanted.

Below is a sample program that demonstrates the full basic workflow where it changes a parameter through a range of values and captures and image at each change. It has a loop where it continually changes the parameter named “ToChange”. In the example below, the loop goes until the parameter reaches a specified value but it could also go a pre-defined number of steps. It depends on what you need in your specific case.

import adsk.core, adsk.fusion, adsk.cam, traceback

def run(context):

    ui = None

    try:

        app = adsk.core.Application.get()

        ui  = app.userInterface

        des = adsk.fusion.Design.cast(app.activeProduct)

        # Define the values that control the stepping.

        startValue = 5

        endValue = 10

        increment = 0.1

        # Get the parameter to change.

        param = des.allParameters.itemByName('ToChange')

        

        # Iterate through the parameter changes.

        currentValue = startValue

        frameCount = 0

        while currentValue < endValue:

            param.value = currentValue

            currentValue += increment

            

            # Allow Fusion a chance to update.

            adsk.doEvents()

            # Save the current viewport as an image.

            frameCount = frameCount + 1

            filename = 'C:/Temp/Animate/Test' + str(frameCount).zfill(4)

            app.activeViewport.saveAsImageFile(filename, 0, 0)

        

        ui.messageBox('Finished.')

    except:

        ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))

The code is really fairly simple. It's all a matter of how creative you get with your parametric model. You can use anything to determine the parameter value and you don't need to be limited to changing a single value. In the melting butter example, I change several values and use a random number so the butter melted and the puddle formed in a slightly random way.

The result is a directory containing a bunch of image files. There are many products that will let you combine the images into a video. For the gif file at the top of this post, I used GIMP (Gnu Image Manipulation Program).  For a higher resolution, full color animation I used another free tool called FFmpeg where I used the command line below to create the video:

ffmpeg.exe -i C:\Temp\Butter\Images\Butter%04d.png -b 5000k -r 30 output.avi

Here is the Fusion model and the Python program for the melting butter example. When running the code it begins by displaying a message box to allow you to reset the parameter values back to the original starting values and then an option to run through the parameter changes and generate the images. If you look at the code you’ll see that it does some work to reposition the history marker in the timeline to reduce the re-compute time because Fusion re-computes with every parameter change without an option to delay the re-compute. It moves the marker to just before the features that will re-compute, changes the parameters and then moves it to the end of the timeline so there is a single re-compute of the model with each set of parameter changes.

-Brian

Attribute Helper 2.5

A problem was reported and I’ve made a fix and have created a new version of the Attribute Helper utility.  If you’re unfamiliar with it, it’s a little utility that lets you create, view, and edit attributes within a document. If you’re relatively new to the Inventor API and are wondering what attributes are, here’s a post giving a quick introduction.

If you already have a version of “Attribute Helper” installed, you should first uninstall the version you have, which you can do using the standard Windows uninstall utility where you should see “Attribute Helper” listed as one of the installed programs, as shown below.

Once it’s uninstalled, you can install the 2.5 version of Attribute Helper.  There is some help documentation delivered with the utility with instructions on how to use it and you can quickly determine if it was installed correctly by checking to see if the Attribute Helper command is now available in the Tools panel when you have a document open.

And when you run the Attribute Helper command, you should see the dialog below with the version displayed being “2.5”, as shown below.

-Brian

Attribute Helper Update

Quite a few years ago I wrote a little utility that lets you create, view, and edit attributes within a document.  If you’re relatively new to the Inventor API and are wondering what attributes are, here’s a post giving a quick introduction. 

I’ve used the utility quite a bit over the years and haven’t had any problems but someone recently reported a problem they were having and I had a hard time believing that the problem could exist.  I was finally able to reproduce the problem and found out it could be a fairly common problem, it’s just that I happened to always use a certain workflow that avoided it.  That’s why it’s always good to get someone else to help test your programs.  

I’ve fixed the problem and have a new version available.  If you already have a version of “Attribute Helper” installed, you should first uninstall the version you have, which you can do using the standard Windows uninstall utility where you should see “Attribute Helper” listed as one of the installed programs, as shown below.

Once it’s uninstalled, you can install the new version of Attribute Helper.  There is some help documentation delivered with the utility with instructions on how to use it and you can quickly determine if it was installed correctly by checking to see if the Attribute Helper command is now available in the Tools panel when you have a document open.

And when you run the Attribute Helper command, you should see the dialog below with the version displayed being “2.4”, as shown below.

 

I’ve also made the source code available on GitHub

As always, please let me know if you find any problems or have suggestions for improvement.

-Brian