Mod the Machine

Automate creation of Named Geometry

Named Geometry is an iLogic feature that lets you tag geometry in the UI:
(See section "Use Assign Name to Identify Geometry for Constraints" here)

iLogic has an Automation interface that lets you automate iLogic specific features from your iLogic Rule or add-in/app. 

Using that we can also manipulate Named Geometry entries - e.g. add a new one.
This is what it would look like in a Rule:

' Select Face before running this code
Dim iLogicAuto = iLogicVb.Automation

Dim namedEntities = iLogicAuto.GetNamedEntities(ThisDoc.Document)

Dim f = ThisDoc.Document.SelectSet(1)

namedEntities.SetName(f, "MyNewFace")

Result:

We can also achieve the same from e.g. VBA:

Sub AddNamedGeometry()
 ' Select Face before running this code
  Const iLogicAddinGuid As String = "{3BDD8D79-2179-4B11-8A5A-257B1C0263AC}"

  Dim doc As Document
  Set doc = ThisApplication.ActiveDocument
  
  Dim addin As ApplicationAddIn
  Set addin = ThisApplication.ApplicationAddIns.ItemById(iLogicAddinGuid)

  Dim iLogicAuto As Object
  Set iLogicAuto = addin.Automation

  Dim namedEntities As Object
  Set namedEntities = iLogicAuto.GetNamedEntities(doc)

  Dim f As Face
  Set f = doc.SelectSet(1)

  Call namedEntities.SetName(f, "MyNewFace")
End Sub

-Adam

Troubleshooting, debugging

Sometimes we get code samples with hundreds of lines of code in iLogic where the last part fails. Even if it's not iLogic, it's still better to narrow down things to the specific function that is not working and create a test that focuses on it.

This will make it much easier for others to help you (e.g. on the forum) and might enable you to spot the issue with your code (if it's not a problem with the API itself)

For example, if your code is creating all the geometry that you want to add a feature to and that last bit fails for some reason, then
- remove the feature creation you have problems with
- run the rest of the code to create the geometry that the feature needs
- save that part/assembly and create a function that focuses on the feature that you're having problems with creating

The best is to do that in a programming environment that allows you to step through code and investigate the variables you are using. The simplest way for everyone to run your code in is VBA - if you create a .NET project (whether add-in or stand-alone app) not everyone has Visual Studio installed to run it, and if it's iLogic then you have limited debugging options.

Let's say we run into issues with KnitFeatures.Add() when running this sample code: Adding a new stitch (knit) feature API Sample 

I can just remove the last part about creating the KnitFeature object and run it:

Now I have the geometry that the creation of the last feature needs, and can move the last part of the code into a separate VBA method that would only run the code that creates the KnitFeature:

Sub StitchFeatureCreate_Test()
    Dim oPartDoc As PartDocument
    Set oPartDoc = ThisApplication.ActiveDocument

    Dim oCompDef As PartComponentDefinition
    Set oCompDef = oPartDoc.ComponentDefinition
    
    Dim oSurfaces As ObjectCollection
    Set oSurfaces = ThisApplication.TransientObjects.CreateObjectCollection
    
    oSurfaces.Add oCompDef.WorkSurfaces.Item(1)
    oSurfaces.Add oCompDef.WorkSurfaces.Item(2)
    
    Dim oKnitFeature As KnitFeature
    Set oKnitFeature = oCompDef.Features.KnitFeatures.Add(oSurfaces)
End Sub

As discussed in this blog post, this way you can also examine the various objects you are using - you might e.g. realize that you are trying to pass in the wrong objects to the function, or some parameters are not correct.

If you happened to find an issue with the API then it will make it much easier for us to verify the problem on our side :) 

When it comes to debugging iLogic code, this might come handy too: 
https://adndevblog.typepad.com/manufacturing/2014/08/debug-ilogic.html

-Adam

 

 

 

 

 

AU Early Bird registration ending soon...

If you want to learn about all the new things we are working on then DevCon & AU Las Vegas are probably the best places for that.

Here is one class not to miss if you are writing Inventor add-ins and thinking of venturing into the cloud:
SD225601 - Bringing your Inventor Add-in into Forge Design Automation

I will also have a presentation on getting started with Next Generation Forge technologies:
FDC231764 - My First Forge Data Platform and Forge Services Application

Here you can register for both AU and DevCon:
https://forge.autodesk.com/devcon-2018#tickets

Please note that AU Early Bird registration is ending on 15th October!

Hope to see you there! :)

Use ChromiumWebBrowser from Inventor

ChromiumWebBrowser enables you to have a browser component in your app with Chrome capabilities. It requires an external process as well called CefSharp.BrowserSubprocess.exe, which is generated as part of your output by the CefSharp.WinForms NuGet component that you need to add to your project.

In case of having a standalone application the default settings are good enough because all the components will be created in the same output path next to your project's exe. However, in case of an Inventor add-in (or any other add-in for that matter) the add-in files will be located somewhere other than the main exe (in this case Inventor.exe), so you need to adjust the CefSettings accordingly.

private void InitializeChromium()
{
    CefSettings settings = new CefSettings();
    // Get the folder path of the add-in dll
    string assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
    settings.BrowserSubprocessPath = Path.Combine(assemblyFolder, "CefSharp.BrowserSubprocess.exe");
    Cef.Initialize(settings);

    ChromeWebBrowser = new ChromiumWebBrowser("http://www.google.com");
    ChromeWebBrowser.LoadError += ChromeWebBrowser_LoadError;

    this.Controls.Add(ChromeWebBrowser);
    ChromeWebBrowser.Dock = DockStyle.Fill;
}

In this case you'll see that the sub-process gets started successfully:

And the Chromium browser component seems to work fine:

-Adam

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

Controlling Points in a Sketch using Parameters

I saw a similar question being asked twice recently and thought I would address it here.  The questions were from Fusion 360 users but it also applies to Inventor.  The specific question was “How to create a 3D spline where the control points are determined by parameters?”

The first thing to discuss is what exactly you’re controlling. The question was about controlling the shape of a spline but it could also be about changing the end point of a line or the center of a circle. The good news is that the same answer applies to any sketch geometry.  The important thing to understand is that all sketch geometry, in both Fusion 360 and Inventor, is controlled by sketch points. When you drag and change the position of the end of a line you’re really just dragging a sketch point and the line is attached to that so it moves.  The same is true with the center of a circle.  The point you see at the center isn’t just for convenience so you can easily see where the center is but it’s a real sketch point that controls the position of the circle.  Splines are the same.  When you create a spline and click to define a fit point, Fusion 360 or Inventor, creates a sketch point and the spline fits through and is dependent on that point. You modify the shape of the spline by moving the point.

By understanding that the position of sketch geometry is controlled by sketch points, that changes the original question to “How do I control the position of sketch points using parameters?” That’s what I want to explain here. If we look at a single point in a sketch and want to precisely control its position we can add dimension constraints to it, like shown below.

 

I created the sketch on the X-Y construction plane, (or work plane in Inventor), so all points on the plane will have a Z value of 0.  (I’ll use the term “construction plane” for the remainder of this post.) The dimensions are between the origin point and the sketch point I want to control so the values specify the X and Y offset from the model origin.  When the dimensions were placed, model parameters were automatically created and the dimension is dependent on them.  The picture below shows the two parameters with their default names of d1 and d2 in the Fusion 360 Parameters dialog.

 

It’s wise to rename these as you go along so you can easily identify which dimension controls which point.  I’ve renamed them to point1_x and point1_y, as shown below.

 

That’s really the answer to question and you just build on that idea to be able to control a spline using parameters.  You’ll just have more points and a lot more parameters.  Below is an example of a spline and it’s controlling parameters.  When creating a spline you can draw the spline first and then dimension to the points that were automatically created or you can draw the points first and then fit the spline through the existing sketch points.  Either approach will create the same result so it’s just a matter of which seems the easiest for you.  For me, I think creating the points first can be a little easier because it’s easier to understand which parameter goes with which point when you just have one or two.

 

Now by editing the parameter values I can easily modify the curve to an exact desired shape, as shown below.

 

I posted previously showing a model that I built and animated using exactly this same technique.  The picture below shows the result but it’s all accomplished by editing the values of parameters which in turn control the positions of points that splines fit through and then various features were created using those splines.

 

Controlling the Z Value

The above illustrates how to control the X and Y position of a sketch point, which it typically all that’s needed.  However in some cases you might also want to control the Z position.  First you need to decide if you really need to control the Z position or if using a plane that is positioned other than on the model X-Y plane will work.  You can create the sketch in any arbitrary plane and dimension the points from any arbitrary point so it doesn’t always have to be from the model origin but that is common to have coordinate data relative to the model base coordinate system.

In Fusion 360, all sketches are 3D so sketch points can exist anywhere in space and aren’t limited to being on the x-y plane of the sketch.  However, if you move a point out of the x-y plane you can’t control the z offset using a dimension which means it’s only the x-y position that can be controlled by a dimension and the associated parameter.  Inventor is the same except that 2D and 3D sketches are different types of sketches.  What I’ve discussed so far is for 2D sketches.

For both Fusion 360 and Inventor, the way to control the Z height is by using construction planes.  Assuming we want to control the x-y-z position of a point relative to model space, you’ll first create a construction plane that is an offset from the X-Y base construction plane.  When you create an offset construction plane, Fusion 360 and Inventor automatically create a parameter that controls the offset distance of the construction plane.  You’ll then create the sketch that contains the points on that construction plane.  The offset distance of the construction plane now controls the Z height of all points on that sketch and the dimension constraints to those points defines the X and Y positions.  If every point needs to have independent Z values that means a new offset construction plane and sketch for each point.

If you end up with points in different sketches then you have some additional work.  In Inventor you need to create a new 3D sketch and create a new spline by selecting the points as the points to fit the spline to.  In Fusion 360 it’s also easy but you have to change a preference setting to allow the creation of a spline off of the x-y plane of the sketch.  That preference setting is highlighted below.

Now you have full control of the x, y, and z positions of a sketch point.

 

Using the API

Another option for controlling the position of sketch points is to use the API in either Fusion 360 or Inventor.  There are two ways to use the API to control the position of a sketch point.  In the example of the melting butter I created points whose positions were controlled by parameters like I’ve already talked about and then used a Python script to change the values of the parameters.  That’s illustrated in the melting butter post.  Another approach is to not use parameters at all and use the API to move the points to the desired location.  That’s possible but also has it’s own issues, like finding the point you want to move.  Using the API to directly move a point is a bit beyond the scope of this post but I wanted to mention it in case it’s something that might better fit your needs.

-Brian

Units and Parameters in Inventor

I recently saw a question asking about how to determine if a parameter is of a certain unit type and thought it would be worth writing a bit more here for everyone’s benefit.

First, let’s look at the object model for Parameters, which is shown below on the left.  You’ll notice that there’s a base class “Parameter” object and several other types derived from it; DerivedParameter, ModelParameter, TableParameter, ReferenceParameter, and UserParameter.  These correspond to the groupings you see in the Parameter dialog.  In the picture on the right you can see two model parameters which were created when I placed two dimension constraints in a sketch to control the sketch size. These are referred to as “driving” dimensions because these drive the model and if I change their values the model will update.  Model dimensions are also created when you create modeling features that are driven by a parameter.  There are two reference parameters which were created when I added dimension constraints to a sketch that would have overconstrained the sketch.  These dimensions are being controlled by the sketch and are referred to as “driven” dimensions.  The parameters will update as the model changes.  I also created three parameters that I named “Length”, “Message”, and “IsItRaining”.  These are user parameters because they’re created by the user.  There can also be other types besides numeric like in the example below with Text and Boolean parameters.  And the final type represented below are table parameters.  These are created when you import an Excel spreadsheet to create parameters.

So, those are the types of parameters that Inventor supports.  Depending on the type, there are certain things you can and can’t do with a parameter.  For example, you can’t delete a model parameter, because its tied to a modeling entity and will exist as long as that entity exists.  A table parameter can’t be deleted either because it’s controlled by the referenced Excel spreadsheet.  You can’t edit the value of a reference or table parameter because the value is controlled by the model or the value in the spreadsheet.  The point is that all of these are different types of the Parameter object and they each have slightly different behaviors but they all support the functionality of the Parameter object.  The parameter object supports quite a few methods and properties and depending on the specific type of parameter, not all of them may function the same.  For example you can use the Value property to get and set the value of a model parameter but for a reference parameter the Value property behaves as read-only. 

The question that sparked this response was related to the units of a parameter.  The units of a parameter don’t define its object type but the unit is just a property of a parameter. In fact for user parameters, the user can easily change the units of a parameter. The value of a parameter can be of three different categories; numeric, text, or Boolean.  The Parameter object supports the Units property which returns a String indicating the unit category.  For a parameter that has a text value the Units property will return “Text” and for a Boolean value it will return “Boolean”. 

By far, the most common unit category is a numeric value.  The Units property for a numeric value can return an almost infinite number of results.  It returns the current unit string that represents the current unit assigned to that parameter.  For example, the most common kind of numeric unit is length and could be returned as “mm”, “cm”,, “m”, “in”, “yd”, “mi” (for miles), etc.  These are all valid units for lengths.  For model and reference parameters, the units used to define length uses the default length units of the document as defined in the Document Settings dialog, as shown below.

For user parameters you can define any unit type you want.  For lengths there are a known set of length types that Inventor will allow you to use. I think I listed most of them above. The same is true for the other base unit types like angles, mass, and time.  However, there are a lot of units types that are a combination of other types so their can be a huge number of combinations.  For example, area is defined using any of the length types like “in * in” or “cm * cm”.  In fact it will even allow “in * cm” as a valid area.  I’m not sure what that means but it just demonstrates the flexibility.  More complex types that aren’t even listed in the units list in Inventor can be defined by the user like acceleration using “m/s/s” or “m/s^2”.  The point being that there isn’t a small set of unit types that can be used for numeric parameter values. 

In the API there is an enum with the most common unit types that can be used in some cases but you can also always use the String equivalent and in many cases have to use the String representation of the unit type because it’s not in the enum.  For example you can use kInchLengthUnits from the UnitTypesEnum or “in” or “inch”.

The original question was about how to determine if a parameter is defining a length or an angle value. You can use the Units property of the parameter to get back the current units of the parameter. Remember that this will return “Text”, “Boolean”, or a string defining the unit type of a numeric parameter. The trick is to be able to correctly handle the numeric parameter because a length or angle can be defined in many different ways.  In most cases you don’t care if they’ve chosen to use cm, inch, or mile but just want to know if it’s a length or not.  There are some other utilities in Inventor that can help to determine this.

The UnitsOfMeasure object provides several utility methods related to units.  You can take advantage of these when working with parameters. You get the UnitsOfMeasure object from the Document using its UnitsOfMeasure property.  I’ll let you look at the documentation for the UnitsOfMeasure object to see all of what the UnitsOfMeasure supports but I want to focus on one its the more obscure methods right now, which is the CompatibleUnits method.  Using this method we can answer the question above.  What this method does is test two different values to see if their units are “compatible” or of the same category of unit.  If we want to know if a parameter defines a length we can use this to see if it’s compatible with a value we know is a length.  If this returns True, we know it defines a length.  Here’s a VBA example to check to see if a parameter is a length.

Dim param As Parameter
Set param = partDoc.ComponentDefinition.Parameters.Item(“SomeParameter”)

Dim uom As UnitsOfMeasure
Set uom = partDoc.UnitsOfMeasure

If uom.CompatibleUnits(param.Expression, param.Units, "1", "cm") Then
    MsgBox(“Is Length”)
Else
    MsgBox(“Is NOT a Length”)
End If

The CompatibleUnits method compares two values where each value is defined by two inputs.  The first is the expression of the value which is a string and could be something like “5” or “5 in” or “5in + 3cm” or “d1” or any number of valid expressions that can be used to define the value of a parameter.  The second input is the unit of the parameter which can be any of the of unit types discussed previously (“in”, “cm*cm”, “m/s^2”, etc.).  In the example above it’s using the Expression property of the parameter as the first input and its Units property as the second input. For the value to compare, all we need is a value that we know defines a valid length.  For the expression portion I use “1”, but it could be any value like “99.999” or “1/2”.  For the unit portion I use “cm” but any of the known length units will also work because it doesn’t matter what the specific unit type is as long as it defines a length.

Here are two functions that can be used to easily determine if a parameter is a length or angle. The TestParamFunctions method tests the two functions. Notice that in the functions I first check to make sure the parameter isn’t a Text or Boolean type because the CompatibleUnits method will fail in those cases.

VBA

Public Sub TestParamFunctions()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    
    Dim param As Parameter
    For Each param In partDoc.ComponentDefinition.Parameters
        If IsLengthParam(param, partDoc) Then
            MsgBox param.name & " is a length."
        ElseIf isAngleParam(param, partDoc) Then
            MsgBox param.name & " is an angle."
        Else
            MsgBox param.name & " is something else."
        End If
    Next
End Sub

Public Function IsLengthParam(param As Parameter, doc As Document) As Boolean
    If param.Units = "Boolean" Or param.Units = "Text" Then
        IsLengthParam = False
        Exit Function
    End If
    
    Dim uom As UnitsOfMeasure
    Set uom = doc.UnitsOfMeasure
    
    If uom.CompatibleUnits(param.expression, param.Units, "1", "cm") Then
        IsLengthParam = True
    Else
        IsLengthParam = False
    End If
End Function

Public Function isAngleParam(param As Parameter, doc As Document) As Boolean
    If param.Units = "Boolean" Or param.Units = "Text" Then
        isAngleParam = False
        Exit Function
    End If
    
    Dim uom As UnitsOfMeasure
    Set uom = doc.UnitsOfMeasure
    
    If uom.CompatibleUnits(param.expression, param.Units, "1", "deg") Then
        isAngleParam = True
    Else
        isAngleParam = False
    End If
End Function

Visual Basic .NET and iLogic

Public Sub TestParamFunctions()
    Dim invApp As Inventor.Application = GetObject(, "Inventor.Application")
    Dim partDoc As PartDocument = invApp.ActiveDocument

    Dim param As Parameter
    For Each param In partDoc.ComponentDefinition.Parameters
        If IsLengthParam(param, partDoc) Then
            MsgBox(param.Name & " is a length.")
        ElseIf isAngleParam(param, partDoc) Then
            MsgBox(param.Name & " is an angle.")
        Else
            MsgBox(param.Name & " is something else.")
        End If
    Next
End Sub

Public Function IsLengthParam(param As Parameter, doc As Document) As Boolean
    If param.Units = "Boolean" Or param.Units = "Text" Then
        Return False
    End If

    Dim uom As UnitsOfMeasure = doc.UnitsOfMeasure

    If uom.CompatibleUnits(param.Expression, param.Units, "1", "cm") Then
        Return True
    Else
        Return False
    End If
End Function

Public Function isAngleParam(param As Parameter, doc As Document) As Boolean
    If param.Units = "Boolean" Or param.Units = "Text" Then
        Return False
    End If

    Dim uom As UnitsOfMeasure = doc.UnitsOfMeasure

    If uom.CompatibleUnits(param.Expression, param.Units, "1", "deg") Then
        Return True
    Else
        Return False
    End If
End Function

-Brian

3D PDF Publish fails for invisible document

When creating a 3D PDF file for a document, it needs to be visibly open inside Inventor. This is currently the requirement.

However, you can have an invisible Inventor instance doing the 3D PDF generation, as discussed here.
So you could do things that way if you don't want the document to pop up for the user in the UI.  

-Adam

3D PDF Publish makes Inventor visible

A partner reported that when using Inventor invisibly in the background to create 3D PDF, then the Publish command of the 3D PDF Add-In causes Inventor to become visible :-/

He was kind enough to also check with Anark (the creator of the 3D PDF Add-In) about it :) and they said the issue was solved in Inventor 2017 SP1/R2 and is of course also available in 2017.3 Update.

I checked things with Inventor 2017 SP1/R2 and indeed the issue seems to have been solved :)

-Adam

Store and restore occurrence position

If you want to store the position of a ComponentOccurrence in order to be able to restore it later on, then you could simply store the Transformation values of the occurrence. They could be saved in a separate file, in Attributes, some other place - up to you where.

This VBA sample will store the values in an AttributeSet:

Sub StorePosition()
  Const kAttSetName = "Adam.OccurrencePosition"
  Const kCellNamePrefix = "cell"
  
  Dim asm As AssemblyDocument
  Set asm = ThisApplication.ActiveDocument
  
  Dim occ As ComponentOccurrence
  Set occ = asm.SelectSet(1)
  
  Dim cells() As Double
  Call occ.Transformation.GetMatrixData(cells)
  
  Dim attValues(15) As Variant
  Dim attNames(15) As String
  Dim attTypes(15) As ValueTypeEnum
  
  Dim i As Integer
  For i = LBound(cells) To UBound(cells)
    attValues(i) = cells(i)
    attNames(i) = kCellNamePrefix + Trim(str(i))
    attTypes(i) = kDoubleType
  Next
  
  Dim attSet As AttributeSet
  If occ.AttributeSets.NameIsUsed(kAttSetName) Then
    Set attSet = occ.AttributeSets("Adam.OccurrencePosition")
  Else
    Set attSet = occ.AttributeSets.Add("Adam.OccurrencePosition")
  End If
  
  Dim attEnum As AttributesEnumerator
  ' If the name was not Trim()-ed this would give an error
  Set attEnum = attSet.AddAttributes(attNames, attTypes, attValues, True)
End Sub

Sub RestorePosition()
  Const kAttSetName = "Adam.OccurrencePosition"
  Const kCellNamePrefix = "cell"
  
  Dim asm As AssemblyDocument
  Set asm = ThisApplication.ActiveDocument
  
  Dim occ As ComponentOccurrence
  Set occ = asm.SelectSet(1)
  
  Dim attSet As AttributeSet
  If occ.AttributeSets.NameIsUsed(kAttSetName) Then
    Set attSet = occ.AttributeSets("Adam.OccurrencePosition")
  Else
    Call MsgBox("Position data was not stored for this occurrence!")
    Exit Sub
  End If
  
  Dim cells(15) As Double
  Dim i As Integer
  For i = 0 To 15
    Dim cellName As String
    cellName = kCellNamePrefix + Trim(str(i))
    If Not attSet.NameIsUsed(cellName) Then
      Call MsgBox("Not all position data stored for this occurrence!")
      Exit Sub
    End If

    cells(i) = attSet(cellName).value
  Next
  
  Dim mx As Matrix
  Set mx = occ.Transformation
  
  Call mx.PutMatrixData(cells)
  
  occ.Transformation = mx
End Sub

The code in action:

-Adam