Mod the Machine

API support for the creation and edit of a Move Body feature

The Inventor 2013 API now fully supports Move Body Features.  A move body feature allows you to manipulate the location and orientation of a body and is listed in the feature tree. There are different ways you can manipulate the body using methods of the new MoveDefinition object. You can rotate it, move it along a vector or do a free drag by specifying the xyz offset.

New 2013 Object & Methods: 

MoveFeatures.CreateMoveDefinition Method

MoveDefinition Object

• AddRotateAboutAxis
• AddMoveAlongRay
• AddFreeDrag

VBA Example:

Keep in mind that we only recommend using VBA for prototyping and learning the API but do not recommend using VBA in production.

To use this example have a part that has a multiple solid bodies. When you run the code select one of the bodies. This screenshot shows a solid body before running the code:

After the procedure is run a Move Body feature has been created. This feature changes the location of the body.

VBA Code:

' Demonstrates using the API to create a
' Move Body feature. You must have a part
' open that contains at least one body.
Public Sub MoveBody()
   ' Get the active part document.
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
   
    Dim partDef As PartComponentDefinition
    Set partDef = partDoc.ComponentDefinition

    ' Have the user select a body.
    Dim body As SurfaceBody
    Set body = ThisApplication.CommandManager.Pick _
        (kPartBodyFilter, "Select the body to move.")
   
    If Not body Is Nothing Then
        ' Create a collection containing the body to move.
        Dim bodyCollection As ObjectCollection
        Set bodyCollection = ThisApplication. _
              TransientObjects.CreateObjectCollection
       
        Call bodyCollection.Add(body)
       
       ' Create a move definition.
        Dim moveDef As MoveDefinition
        Set moveDef = partDef.Features.MoveFeatures _
                    .CreateMoveDefinition(bodyCollection)
       
       ' Define a rotate, move, and free drag.
        Call moveDef.AddRotateAboutAxis _
                    (partDef.WorkAxes.Item(3), True, _
                               3.14159265358979 / 4)
        Call moveDef.AddMoveAlongRay _
                    (partDef.WorkAxes.Item(1), True, 3)
       
        Call moveDef.AddFreeDrag(0.5, 6, 3)
       
       ' Create the move feature.
        Dim move As MoveFeature
        Set move = partDef.Features.MoveFeatures _
                                        .Add(moveDef)
    End If
End Sub

3D equivalent of a 2d curve on a surface

The Inventor 2013 API has several new methods for SurfaceEvaluator. One of these new methods allows you to get the equivalent 3D curve for a 2D curve defined in the parametric space of the surface.

New 2013 method: 

• SurfaceEvaluator.Get3dCurveFrom2dCurve()

VBA Example:

Keep in mind that we only recommend using VBA for prototyping and learning the API but do not recommend using VBA in production.

To use this example have a part file open and run the code. First it will prompt you to select a face. (The second time the code is run it will prompt to find out if you want to keep the existing client graphics).

It will then create several curves in the 2d parametric space. Then it gets the equivalent 3D curves, and creates those as client graphics to allow you to view the results. You can see the curves lie on the surface now, but they were originally defined as circle and five lines, but they came back as curves, because the surface is curved.

 

VBA Code:

' Demonstrates the conversion of a 2d parameteric
' space curve into the ' equivalent 3d model space
' curve.  To use this sample you must have a part
' open.  You can select any face and 3D curves
' will be drawn on the face using client graphics
Public Sub ParamCurveto3D()
   ' Have the user select a face whose parametric
    ' space will be used
    Dim testFace As Face
    Set testFace = ThisApplication. _
             CommandManager.Pick _
           (kPartFaceFilter, "Select a face")
   
    ' Get the surface evaluator from the face
    Dim surfEval As SurfaceEvaluator
    Set surfEval = testFace.Evaluator
   
    ' Get the parametric range of the face
    Dim paramRange As Box2d
    Set paramRange = surfEval.ParamRangeRect
   
   ' Get the transient geometry object
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
   
   ' Get the active document.  This assumes
    ' a part is active
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
   
   ' Create a client graphics object.  If one
    ' already exists, give the user
    ' the option of re-using it, or creating
    ' a new one.
    Dim graphics As ClientGraphics
    On Error Resume Next
    Set graphics = partDoc.ComponentDefinition. _
             ClientGraphicsCollection.Item("Test")
    If Err Then
     Set graphics = partDoc.ComponentDefinition. _
          ClientGraphicsCollection.Add("Test")
    Else
        If MsgBox("Yes add to existing graphics No = new", _
        vbYesNo + vbQuestion) = vbNo Then
            graphics.Delete
           
            Set graphics = partDoc.ComponentDefinition. _
            ClientGraphicsCollection.Add("Test")
        End If
    End If
   
    ' Create a new graphics node.
    Dim node As GraphicsNode
    Set node = graphics.AddNode(1)

    ' Do a loop that creates 5 lines that go
    ' from the minimum range point to
    ' five points along the maximum u parameter.
    Dim startPnt As Point2d
    Set startPnt = paramRange.MinPoint
    Dim endPnt As Point2d
    Dim i As Integer
    For i = 1 To 5
       ' Create the 2d line in parametric space
        Set endPnt = tg.CreatePoint2d _
          (paramRange.MaxPoint.X, (((paramRange. _
                MaxPoint.y - paramRange.MinPoint.y) _
             / 4) * (i - 1)) + paramRange.MinPoint.y)
       
        Dim surfCurve As LineSegment2d
        Set surfCurve = tg.CreateLineSegment2d _
                                    (startPnt, endPnt)
       
        ' Get the equivalent 3d curve in model space
        Dim resultCurve As Object
        Set resultCurve = surfEval. _
                       Get3dCurveFrom2dCurve(surfCurve)
       
        ' Create client graphics for this curve
        Dim crvGraphics As CurveGraphics
        Set crvGraphics = node.AddCurveGraphics _
                                          (resultCurve)
        crvGraphics.DepthPriority = 2
    Next
   
   ' Create a 2d circle in parametric space
    Dim center As Point2d
    Set center = tg.CreatePoint2d _
      ((paramRange.MaxPoint.X + paramRange.MinPoint.X) _
                         / 2, (paramRange.MaxPoint.y + _
                              paramRange.MinPoint.y) / 2)
   
    Dim radius As Double
    radius = (paramRange.MaxPoint.X - _
                           paramRange.MinPoint.X) * 0.25
    Dim paramCircle As Circle2d
    Set paramCircle = tg.CreateCircle2d(center, radius)
   
    ' Get the equivalent 3d curve in model space
    Set resultCurve = surfEval. _
                       Get3dCurveFrom2dCurve(paramCircle)
   
   ' Create client graphics for this curve
    Set crvGraphics = node.AddCurveGraphics(resultCurve)
    crvGraphics.DepthPriority = 2
       
    ThisApplication.ActiveView.Update
    ThisApplication.ActiveView.Fit
End Sub

-Wayne

Extract partial curves from 2d and 3d transient geometry

Another enhancement in the Inventor 2013 API related to transient geometry allows you to get partial curves from splines. You will find two new methods called ExtractPartial and Split on the BSplineCurve and BSplineCurve2d objects. These new methods make it easier to create new curves based on existing curves. Using ExtractPartial you can extract any portion of the curve as a new transient geometry spline. Using Split will get two transient curves from the original.

New 2013 methods used to extract a partial curve from a Spline

• BSplineCurve.ExtractPartial
• BSplineCurve.Split
• BSplineCurve2d.ExtractPartial
• BSplineCurve2d.Split

VBA Example:

Keep in mind that we only recommend using VBA for prototyping and learning the API but do not recommend using VBA in production.

Note: This example is only using ExtractPartial. (Not Split)

Before running this procedure create a Sketch with a spline. When you run this example it will prompt you to select a “2d  spline”. If you select a spline the selected entity will be a SketchSpline and the BSplineCurve2d is returned from the Geometry property of that object.

 

Remember that these methods are creating transient geometry so it is not affecting the real Inventor geometry. This example uses that transient geometry to create real Inventor geometry (3 splines) using Sketch.SketchFixedSplines.Add(). The code deletes the original spline. After running the procedure notice the three new splines:

VBA Code:

' Demonstrates the ability to extract partial
' curves from a transient geometry curve.  This
' sample has you select an existing sketch
' spline and extracts three curves from the curve.
' It then creates real curves using the extracted
' curves and deletes the original sketch curve.
Public Sub ExtractPartialCurves2D()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
   
    Dim spline As Object
    Set spline = ThisApplication.CommandManager _
    .Pick(kSketchCurveSplineFilter, "Select 2d spline")
   
   ' Get the spline geometry from the entity.
    Dim splineCurve As BSplineCurve2d
    Set splineCurve = spline.Geometry
   
    ' Get the parameter bounds of the curve.
    Dim startParam As Double
    Dim endParam As Double
    Call splineCurve.Evaluator.GetParamExtents _
                           (startParam, endParam)
   
    ' Extract three curves where they are in
    ' thirds of the original
    ' relative to the curves parameter space.
    Dim curves(2) As BSplineCurve2d
    Set curves(0) = splineCurve.ExtractPartial _
         (startParam, (startParam + endParam) / 3)
    Set curves(1) = splineCurve.ExtractPartial _
                 ((startParam + endParam) / 3, _
               ((startParam + endParam) / 3) * 2)
   
    Set curves(2) = splineCurve.ExtractPartial _
           (((startParam + endParam) / 3) * 2, _
                                       endParam)
   
    ' Create new sketch curves using
    ' the extracted splines.
    Dim splineSketch As sketch
    Set splineSketch = spline.Parent
    Call splineSketch.SketchFixedSplines. _
                             Add(curves(0))
    Call splineSketch.SketchFixedSplines. _
                             Add(curves(1))
    Call splineSketch.SketchFixedSplines. _
                             Add(curves(2))

    ' Delete the original curve.
    spline.Delete
End Sub

-Wayne

Get strokes for 2d and 3d transient wireframe geometry

An enhancement in the Inventor 2013 API allows you to get strokes for 2d and 3d transient geometry. One reason why you may want to do this is to approximate sketch geometry. The new method is GetStrokes of the CurveEvaluator and Curve2dEvaluator objects. To get the transient geometry (CurveEvaluator) from the sketch entity, use the Geometry.Evaluator property.

New 2013 method used to get strokes

• CurveEvaluator.GetStrokes
• Curve2dEvaluator.GetStrokes

VBA Example:

Please keep in mind that we only recommend using VBA for prototyping and learning the API but do not recommend using VBA in production.

To try out this example create a 3D Sketch. I used a helical curve as you can see in the screenshot. When you run the Approximate3DSketchGeometry procedure it prompts you to select a 3d entity and then displays an InputBox asking for the chord height tolerance. This value will be used as the maximum of deviation. (How far off can these line segments be to the curve). I used .25. This will be centimeters in database units.

A MsgBox is used to ask if you want to use existing client graphics, create new client graphics or just cancel. The lines that you see that approximate the curve, are drawn using client graphics. Here is the result after running the procedure:

VBA Code:

' Draws client graphics that is an approximation
' of the selected curve.
' To use this have a part open that contains
' a 3D skech that contains curves.
Public Sub Approximate3DSketchGeometry()
    Dim partDoc As PartDocument
    Set partDoc = _
              ThisApplication.ActiveDocument
   
   ' Have the user select a sketch entity.
    Dim selectObj As SketchEntity3D
    Set selectObj = ThisApplication. _
                    CommandManager.Pick _
                    (kSketch3DCurveFilter, _
                    "Select 3D sketch entity")
    If selectObj Is Nothing Then
        On Error Resume Next
        Call partDoc.ComponentDefinition _
        .ClientGraphicsCollection.Item _
                                ("Test").Delete
        Call partDoc.GraphicsDataSetsCollection _
                             .Item("Test").Delete
        ThisApplication.ActiveView.Update
        Exit Sub
    End If
   
   ' Get the tolerance to approximate with.
    Dim tolerance As Double
    tolerance = Val(InputBox _
     ("Enter the chord height tolerance:", _
                       "Tolerance", "0.25"))
   
   ' Get the evaluator from the curve.
    Dim eval As CurveEvaluator
    Set eval = selectObj.Geometry.Evaluator
   
   ' Get the parameter extents.
    Dim startParam As Double
    Dim endParam As Double
    Call eval.GetParamExtents _
                        (startParam, endParam)
   
    Dim vertexCount As Long
    Dim vertexCoords() As Double
    Call eval.GetStrokes(startParam, endParam, _
            tolerance, vertexCount, vertexCoords)
   
    ' Create a client graphics object.
    ' If one already exists, give the user
    ' the option of re-using it, or creating
    ' a new one.
    Dim graphics As ClientGraphics
    Dim graphicsData As GraphicsDataSets
    On Error Resume Next
    Set graphics = partDoc.ComponentDefinition. _
            ClientGraphicsCollection.Item("Test")
    On Error GoTo 0
    If graphics Is Nothing Then
        Set graphics = partDoc. _
      ComponentDefinition.ClientGraphicsCollection _
                                      .Add("Test")
        Set graphicsData = partDoc. _
           GraphicsDataSetsCollection.Add("Test")
    Else
        Dim answer As VbMsgBoxResult
        answer = MsgBox _
        ("Yes = existing. No = new Cancel. = quit.", _
                         vbYesNoCancel + vbQuestion)
        If answer = vbNo Then
            On Error Resume Next
            graphics.Delete
            partDoc.GraphicsDataSetsCollection _
                              .Item("Test").Delete
            On Error GoTo 0
           
            Set graphics = partDoc.ComponentDefinition _
                  .ClientGraphicsCollection.Add("Test")
            Set graphicsData = partDoc. _
                  GraphicsDataSetsCollection.Add("Test")
        ElseIf answer = vbYes Then
            Set graphicsData = partDoc. _
                GraphicsDataSetsCollection.Item("Test")
        ElseIf answer = vbCancel Then
            If Not graphics Is Nothing Then
                graphics.Delete
                partDoc.GraphicsDataSetsCollection _
                                .Item("Test").Delete
                ThisApplication.ActiveView.Update
                Exit Sub
            End If
        End If
    End If
   
    Dim coordSet As GraphicsCoordinateSet
    Set coordSet = graphicsData.CreateCoordinateSet(1)
    Call coordSet.PutCoordinates(vertexCoords)

   ' Create a graphics node.
    Dim node As GraphicsNode
    Set node = graphics.AddNode(1)
   
    ' Create a line strip using the calculated coordinates.
    Dim lineStrip As LineStripGraphics
    Set lineStrip = node.AddLineStripGraphics
    lineStrip.CoordinateSet = coordSet
   
    ThisApplication.ActiveView.Update
End Sub

-Wayne

Setting the Weight for iPart Members

There was a question posted on the customization newsgroup that I spent a little time investigating and think the answer might be of general interest.  The objective is to have a column in the iPart table that has the weight for that member.  I wasn’t able to figure out a way to do this with built-in functionality in Inventor but it turned out it isn’t too difficult to write a program to accomplish the task.  Although the program and description below is specific to the weight of a part, it could be modified to handle other part information that you want to associate with an iPart member.

First, let’s look at the iPart factory to see what needs to exist for the program to function correctly.  The only thing special is that I created a custom iProperty called “Weight” and added that as one of the iProperties that I want to set from the table.  It didn’t have to be an iProperty and could have been an “Other” value but using an iProperty provides the most flexibility for using the value elsewhere in Inventor.  For example, in the the drawing.  The picture below shows the iPart table after setting it up with this iProperty.  The values for this new column are empty.

Now we need to assign the correct weight for each row to the weight column.  If you had to this manually you would:

1. Activate a member.
2. Run the iProperties command
3. Go to the “Physical” tab of the iProperties dialog.
4. Click the “Update” button on the “Physical” tab.
5. Select and Copy the “Mass” field.
6. Open the iPart table and paste the mass value into the table for the correct row.
7. Close the iPart table.
8. Repeat steps 1 to 7 for every row in the table.

As you can see this is very tedious and prone to errors.  Instead of manually going through these steps they can be automated using Inventor’s programming interface.  Below is a VBA macro that will do the work.

Public Sub UpdateWeightOfiParts()
    ‘ Get the active document.  This assumes it is a part.
    Dim oPartDoc As PartDocument
    Set oPartDoc = ThisApplication.ActiveDocument

    ' Check that this part is an iPart factory.
    If Not oPartDoc.ComponentDefinition.IsiPartFactory Then
        MsgBox "This part must be an iPart factory."
        Exit Sub
    End If

    Dim oFactory As iPartFactory
    Set oFactory = oPartDoc.ComponentDefinition.iPartFactory

    ' Check that there's a "Weight" column in the iPart table,

    ' and get its index in the table.
    Dim iWeightColumnIndex As Long
    iWeightColumnIndex = GetColumnIndex(oFactory, "Weight")
    If iWeightColumnIndex = -1 Then
        MsgBox "The column ""weight"" does not exist in the table."
        Exit Sub
    End If

    ' Iterate through the rows
    Dim oRow As iPartTableRow
    For Each oRow In oFactory.TableRows
        ' Make this the active row so the model will recompute.
        oFactory.DefaultRow = oRow

        ' Get the weight.
        Dim dWeight As Double
        dWeight = oPartDoc.ComponentDefinition.MassProperties.Mass

        ' Convert it to current mass units defined by the document.
        Dim strWeight As String
        strWeight = oPartDoc.UnitsOfMeasure.GetStringFromValue( _ 
                                dWeight, kDefaultDisplayMassUnits)

        ' Set the row value for the weight column.
        oRow.Item(iWeightColumnIndex).Value = strWeight
    Next
End Sub


’ Function that given a factory and the name or a column will return
’ the index number of the column, if it’s found in the factory’s
’ table.  If the column is not found it returns –1.  The comparison
’ of the name is done in a case insensitive way.
Private Function GetColumnIndex(ByVal Factory As iPartFactory, _ 
                                ByVal ColumnName As String) As Long
    ‘ Iterate through all of the columns looking for a
    ‘ match to the input name.
    Dim i As Long
    For i = 1 To Factory.TableColumns.Count
        Dim oColumn As iPartTableColumn
        Set oColumn = Factory.TableColumns.Item(i)

        ‘ Compare this column with the input name.
        If LCase(oColumn.DisplayHeading) = LCase(ColumnName) Then
            ' A matching column was found so exit.
            GetColumnIndex = i
            Exit Function
        End If
    Next

    ' The column wasn't found so return -1.
    GetColumnIndex = -1
End Function

The program is essentially performing the same steps that would be required to do this manually.  It’s just able to do it much faster and without any mistakes.  After running the macro on my factory the table now looks like this.

It’s also important to recognize that the weight is a snapshot of the weight at the time the macro was run.  If the part is modified (for example, a new feature is added) or table values are edited that affect the part geometry, the weight will no longer be correct and the macro will need to be run again to update the weight column.