Mod the Machine

Entitlement API changes in Inventor 2020

We already have some articles on using the Entitlement API from Inventor:
- Entitlement API in Inventor
- Entitlement API in Inventor 2018

There is now a change you have to be aware of.
Starting with Inventor 2020, to guarantee the Entitlement API calls work properly to get the UserName, call the Inventor API's Application.Login() function before or after webServiceMgr.Initialize() so the WebServices are fully initialized.
Otherwise, you may see a valid UserId, but an empty UserName when the user is already logged in.
Note: the Application.Login() function is hidden, so IntelliSense in Visual Studio will not list it.

And, if the user attempts to login when you have not used the Login() API call, they may get an error dialog that the service is not available:

-Adam

Import AnyCAD documents associatively

There are two main ways to import a non-Inventor document: use "Reference Model" or "Convert Model"

In case of the "Convert Model", for each component of the original document an Inventor model (assembly or part) will be created. It's the same for "Reference Model", but instead of storing those files separately on the hard drive in a special folder (default folder is "C:\Users\<user name>\Documents\Inventor"), those documents will be embedded in the Inventor model. Not only that, but there will be a reference to the original model and if that gets updated, then Inventor will offer you to update the host assembly as well. 

If you simply add a non-Inventor model as a new occurrence then the "Convert Model" option will be used:
(Note: I simply opened the Stapler sample (Inventor sample models are available from here), exported it as a Step file and used that in the below code)

Sub ImportAnyCADToAssembly()
    Dim oDoc As AssemblyDocument
    Set oDoc = ThisApplication.ActiveDocument
 
    Dim oAssyCompDef As AssemblyComponentDefinition
    Set oAssyCompDef = oDoc.ComponentDefinition
    
    Dim oMatrix As Matrix
    Set oMatrix = ThisApplication.TransientGeometry.CreateMatrix()
 
    Dim oOcc As ComponentOccurrence
    Set oOcc = oAssyCompDef.Occurrences.Add( _
        "C:\Autodesk\autodesk_inventor_2019_samples_dlm\Models\Assemblies\Stapler\Stapler.stp", _
        oMatrix)
End Sub

If you want to import the model using the "Reference Model" option then you have to go through the ImportedComponents collection. There is a sample for that in the Inventor API Help, but here it is as well:

Sub AssociativelyImportAnyCADToAssembly()
    Dim oDoc As AssemblyDocument
    Set oDoc = ThisApplication.ActiveDocument
 
    Dim oAssyCompDef As AssemblyComponentDefinition
    Set oAssyCompDef = oDoc.ComponentDefinition
 
    'Create the ImportedGenericComponentDefinition based on a Step file
    Dim oImportedGenericCompDef As ImportedGenericComponentDefinition
    Set oImportedGenericCompDef = oAssyCompDef.ImportedComponents.CreateDefinition( _
        "C:\Autodesk\autodesk_inventor_2019_samples_dlm\Models\Assemblies\Stapler\Stapler.stp")
 
    'Set the ReferenceModel to associatively import the Step file
    'True is the default value
    oImportedGenericCompDef.ReferenceModel = True
 
    'Import the Step file to assembly
    Dim oImportedComp As ImportedComponent
    Set oImportedComp = oAssyCompDef.ImportedComponents.Add(oImportedGenericCompDef)
    Dim oOcc As ComponentOccurrence
    'The last occurrence should be the one we just added
    Set oOcc = oAssyCompDef.Occurrences(oAssyCompDef.Occurrences.Count)
    
    'If you want to add more instances, you can do that e.g. through using the
    'occurrence's definition
    'Dim oMatrix As Matrix
    'Set oMatrix = ThisApplication.TransientGeometry.CreateMatrix()
    'Set oOcc = oAssyCompDef.Occurrences.AddByComponentDefinition(oOcc.Definition, oMatrix)
End Sub

Now we got the model embedded in the assembly:

You can see that the icons for the occurrence are different in this case from the usual assembly and part document icons.

For completeness' sake, here is another way of importing non-Inventor documents in an associative way. This time going through the translator add-ins:

Sub AssocImport()
    Dim sFilename As String
    sFilename = "C:\Autodesk\autodesk_inventor_2019_samples_dlm\Models\Assemblies\Stapler\Stapler.stp"
       
    Dim sClientID As String
    sClientID = "{90AF7F40-0C01-11D5-8E83-0010B541CD80}" 'GetTranslatorCLSID for STEP
   
    Dim oTransAddIn As TranslatorAddIn
    Set oTransAddIn = ThisApplication.ApplicationAddIns.ItemById(sClientID)
   
    oTransAddIn.Activate
   
    'Get the transient object, take it as a factory to produce other objects
    Dim oTransientObj As TransientObjects
    Set oTransientObj = ThisApplication.TransientObjects
   
    'Prepare the 1st parameter for Open(), the file name
    Dim oFile As DataMedium
    Set oFile = oTransientObj.CreateDataMedium
    oFile.FileName = sFilename
 
    'Prepare the 2nd parameter for Open(), the open type, for convenience set it as drag&drop
    Dim oContext As TranslationContext
    Set oContext = oTransientObj.CreateTranslationContext
    oContext.Type = kFileBrowseIOMechanism
   
    'Prepare the 3rd parameter for Open(), the import options
    Dim oOptions As NameValueMap
    Set oOptions = oTransientObj.CreateNameValueMap
   
    Dim oDefaultOptions As NameValueMap
    Set oDefaultOptions = oTransientObj.CreateNameValueMap
     
    Dim bHasOpt As Boolean
    bHasOpt = oTransAddIn.HasOpenOptions(oFile, oContext, oDefaultOptions)
    oOptions.Value("AssociativeImport") = True
 
    Dim oSourceObj As Object
    oTransAddIn.Open oFile, oContext, oOptions, oSourceObj
   
    Dim oTransDoc As Document
    Set oTransDoc = oSourceObj
   
    If oTransDoc.DocumentType = kAssemblyDocumentObject Then
        Dim oAsm As AssemblyDocument: Set oAsm = oTransDoc
        Debug.Print oAsm.ComponentDefinition.ImportedComponents(1).Name
    ElseIf oTransDoc.DocumentType = kPartDocumentObject Then
        Dim oPart As PartDocument: Set oPart = oTransDoc
        Debug.Print oPart.ComponentDefinition.ReferenceComponents.ImportedComponents(1).Name
    End If
End Sub

There are two useful code samples in this blog post that can be useful concerning translator add-ins (getting a list of them with their ID's and listing all the available settings they provide): https://adndevblog.typepad.com/manufacturing/2014/02/get-option-names-and-values-supported-by-inventor-translator-addins-via-api.html

-Adam

Design Automation for Inventor webinar

If you are developing add-in's for Inventor, this webcast could be a nice way to learn about how to migrate all or parts of your add-in's functionality to the cloud by using Forge Design Automation for Inventor.

Further details on the webcast here.

-Adam

Cannot convert argument 1 from 'const wchar_t [16]' to 'LPTSTR'

You might run into this error when you ...

1) Create a C++ standalone project in VS2017 (15.5 and later versions)
2) Turn the C/C++ -> Language -> Conformance mode option to Yes:

3) Include InventorUtils.h

The exact error will be:

Severity	Code	Description	File
Error	C2664	'LPOLESTR T2OLE(LPTSTR)': cannot convert argument 1 from 'const wchar_t [16]' to 'LPTSTR'	c:\users\public\documents\autodesk\inventor 2020\sdk\developertools\include\dispatchutils.h

The solution is to turn off the Conformance mode

-Adam

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