Mod the Machine

3rd party libraries used by Inventor

Here is a list of the various 3rd parties libraries and their versions that Inventor 2022 is using - i.e. they are used by the core product, and some of them are also used by certain add-ins.

If you are using any of them from your add-in then the best is to make sure you are using the same version to avoid version conflict:

Component Name	Version
DevExpress	19.1.5
7z	18.06.0.0
CEFSharp	75.1.141
SQLite	3.30.1
Qt	5.150.10
QtMFCBridge	5150.280.1
TBB	6.1.20

 

"Member not found" error in C# add-in

As mentioned in other blog posts (e.g. here and here) as well, using Embed Interop Types = True with the Inventor interop assembly does not work well. 

Apart from some events not firing, you might not find all the properties either. E.g. in the case of a Parameter object, when doing this: 

var unitType = param.get_Units();

I get this error:

{"Member not found. (Exception from HRESULT: 0x80020003 (DISP_E_MEMBERNOTFOUND))"}

So just set Embed Interop Types to False:

Just for completeness' sake (though the above solution should solve the problem), there could be another way as well to avoid this error.
You could declare a dynamic variable for the parameter (in order to use late-binding) and access the property through that:  

dynamic p = param;
var unitType = p.Units;

- Adam

Level Of Details in next Inventor release

As Garin mentioned in this post, one of the new features the team has been working on is Model States.

This might have an effect on some of the Level Of Details related functions, events, and properties in the API.

If you are using any of those, the best thing to do is join the beta program where you can find more details about this functionality and can also use pre-release versions (alphas and betas) of Inventor to test your add-in.

Generate flat pattern for 3d folded sheet metal files

I vaguely remember now seeing this before, but could not recall it when someone asked about it the other day, that Inventor can generate flat pattern for any folded sheet metal model, without having to first create all the related sheet metal features (bend, flange, etc) by hand.

In this case I started with opening a STEP file of the 3D folded sheet metal. When I select "Convert To Sheet Metal" then I need to select the base face for the sheet metal, and then the thickness will be automatically populated with the correct value.

There is no dedicated function in the Inventor API for that very last part about finding out the thickness.
However, we can use things like FindUsingRay() to find the face opposite the one we want to use as the base, and then check the distance between them

There are two ways to open a non-Inventor file: simply use the Documents.Open() function, in which case the file will be converted, or through ComponentDefinition.ImportedComponents, in which case you can also decide to reference the file - see Import AnyCAD documents associatively

When doing this whole thing through the API, then you have to find a way to figure out which face should be used as base. One option could be looking for the largest planar face.
Once you have that you need to find the face opposite that and check the distance between them. That should provide the thickness of the sheet metal.

Here is a VBA sample showing this:

Function GetThickness(sb As SurfaceBody) As Double
  ' Find biggest face
  Dim f As Face
  Dim bf As Face
  Dim area As Double
  For Each f In sb.Faces
    ' Only care about planar faces
    If TypeOf f.Geometry Is Plane And f.Evaluator.area > area Then
      Set bf = f
      area = f.Evaluator.area
    End If
  Next
  
  ' Find the opposite face
  Dim p As Plane
  Set p = bf.Geometry
  
  Dim pt1 As Point
  Set pt1 = bf.PointOnFace
  
  Dim tr As TransientGeometry
  Set tr = ThisApplication.TransientGeometry
  
  Dim objs As ObjectsEnumerator
  Dim pts As ObjectsEnumerator
  Dim n As UnitVector
  ' We have to search in the opposite direction
  ' of the face's normal vector
  If bf.IsParamReversed Then 
    Set n = p.Normal 
  Else 
    Set n = tr.CreateUnitVector( _ 
      -p.Normal.x, -p.Normal.y, -p.Normal.z) 
  End If
  ' objs(2) should be the opposite face
  ' but we do not need it, the intersection point
  ' is enough, i.e. pts(2)
  Call sb.FindUsingRay(pt1, n, 0, objs, pts)
  
  ' The first point found will be on the same face
  ' The second one will be on the face opposite
  Dim pt2 As Point
  Set pt2 = pts(2)
  
  GetThickness = pt1.DistanceTo(pt2)
End Function

Sub ConvertToSheetMetal()
  Dim path As String: path = "C:\Temp\SheetMetal_0.05in.stp"
  
  Dim doc As PartDocument
  Set doc = ThisApplication.Documents.Open(path)
  
  ' Turn it into a sheet metal part
  doc.SubType = "{9C464203-9BAE-11D3-8BAD-0060B0CE6BB4}"
  
  Dim cd As SheetMetalComponentDefinition
  Set cd = doc.ComponentDefinition
 
  cd.UseSheetMetalStyleThickness = False
  cd.Thickness.Value = GetThickness(cd.SurfaceBodies(1))
  
  Call cd.Unfold
End Sub

And the result:

If the part is not really a folded sheet metal, then though the Unfold "succeeds", the body of the "Folded Model" and the "Flat Pattern" will be the same.  
You can test this by comparing the bodies:

Sub TestFlatPattern()
  Dim doc As PartDocument
  Set doc = ThisApplication.ActiveDocument
  
  Dim cd As SheetMetalComponentDefinition
  Set cd = doc.ComponentDefinition
  
  Dim tr As TransientBRep
  Set tr = ThisApplication.TransientBRep
  
  Dim objs As ObjectCollection
  Set objs = ThisApplication.TransientObjects.CreateObjectCollection
  Call objs.Add(cd.SurfaceBodies(1))
  Call objs.Add(cd.FlatPattern.SurfaceBodies(1))
  Set objs = tr.GetIdenticalBodies(objs)
  
  If objs.Count > 0 Then
    MsgBox ("The flat pattern body is the same as the original body")
  End If
End Sub

-Adam

Get Named Face of iPartFactory

One enhancement in Inventor 2019 was the ability to Assign Name to objects - see iLogic Enhancements

I wrote about how you could automate that in Automate creation of Named Geometry

This feature is something that you could also use to mark objects in an iPart factory and use that later on to find them when its member is used in an assembly.

Here is an article on the difficulties of finding derived objects in iPart members: Get edge in derived part that drives work point 

Let's say we have these files:

The Named Face in the iPart Factory will not show up in the iPart Member, so we'll have to figure out the connection ourselves using the ReferencedEntity property of the Face in the member document.   

Once we have that we need to also get the Face Proxy representing the specific Face of the iPart Member inside the Assembly, so that we can do things with it, like selecting it in the UI.

We can achieve all that using the following code - this is VBA 

Sub TestSelectNamedFace()
  Dim selSet As SelectSet
  Set selSet = ThisApplication.ActiveDocument.SelectSet

  Dim occ As ComponentOccurrence
  Set occ = selSet(1)
  
  Call selSet.Clear
  
  Call selSet.Select(GetNamedFace(occ, "MyFace"))
End Sub

Function GetNamedFace(occ As ComponentOccurrence, name As String) As Face
  Dim memberDoc As PartDocument
  Set memberDoc = occ.Definition.Document
  
  If Not memberDoc.ComponentDefinition.IsiPartMember Then
    Call MsgBox("Not an iPart member based occurrence")
  End If
  
  Dim factoryDoc As PartDocument
  Set factoryDoc = memberDoc.ComponentDefinition. _
    iPartMember.ReferencedDocumentDescriptor.ReferencedDocument
    
  Dim addin As ApplicationAddIn
  Set addin = ThisApplication.ApplicationAddIns. _
    ItemById("{3BDD8D79-2179-4B11-8A5A-257B1C0263AC}")
  
  Dim iLogicAuto As Object
  Set iLogicAuto = addin.Automation
  
  Dim namedEntities As Object
  Set namedEntities = iLogicAuto.GetNamedEntities(factoryDoc)
  
  Dim f As Face
  Set f = namedEntities.FindEntity(name)
  
  If f Is Nothing Then
    Call MsgBox("Did not find named Face")
  End If
  
  Dim f2 As Face
  For Each f2 In memberDoc.ComponentDefinition.SurfaceBodies(1).Faces
    If f2.ReferencedEntity Is f Then
      ' Get the face into the context of the assembly
      Call occ.CreateGeometryProxy(f2, GetNamedFace)

      Exit Function
    End If
  Next
End Function

First select the relevant occurrence in the assembly then run the code:

You can find info on NamedEntities object and its functions like FindEntity() here 

-Adam

Has higher version than referenced assembly

Some assemblies might be relying on a specific higher version of Autodesk.Inventor.Interop.dll than the one your project is referencing. That's the problem I ran into with Autodesk.iLogic.Core.dll in case of the project talked about here: Get iLogic Form information from Inventor documents

My project was working fine, but when I installed the latest Inventor 2020 update and tried to compile my project, I got this error:

Assembly 'Autodesk.iLogic.Core' with identity 'Autodesk.iLogic.Core, Version=24.30.37300.0, 
Culture=neutral, PublicKeyToken=null' uses 'Autodesk.Inventor.Interop, Version=24.2.0.0, 
Culture=neutral, PublicKeyToken=d84147f8b4276564' which has a higher version than referenced assembly 
'Autodesk.Inventor.Interop' with identity 'Autodesk.Inventor.Interop, Version=24.1.0.0, 
Culture=neutral, PublicKeyToken=d84147f8b4276564'

You can find the various versions of Autodesk.Inventor.Interop.dll in the "C:\Windows\Microsoft.NET\assembly\GAC_MSIL\Autodesk.Inventor.Interop" folder including version 24.2 (after installing the relevant Inventor update):

Once I added that reference, the project compiled fine. 😀 

-Adam

iMates based shelving unit

I wrote about using iMates a few times already, but I thought it could still be worth sharing this model as well that I'm using for a Design Automation API for Inventor sample talked about here.

I have 90cm and 180cm corner posts and mid-section posts, and 90cm and 120cm wide shelves to select from:

I have the following iMates in the models:  

The corner posts have an a and b iMate at each level named (a1, b1, a2, b2, etc), the mid-section posts have an additional c and d iMates as well at each level (c1, d1, etc)  
The selves have a to d iMates on the two ends (1a - 1d and 2a - 2d)
Most of the time the correct letters match up between the post and the shelf, apart from two corner posts where a is matched with c and b is matched with d.

All iMates use the same Constraint type: Insert & Opposed

The 3 parameters driving the model are: Column, Height and ShelfWidth
When the rule is run it has three main parts:
1) start
- add corner post and ground it
- add the shelves
- add the other corner post

2) middle (repeated depending on how many columns we have)
- add the two mid-section posts
- add the shelves

3) end
- add the two corner posts

Instead of the main parameter changes kicking off the iLogic rule, I added an iTrigger parameter to do it.

Sub Main()
  Trace.WriteLine("Main,  starting")
  trigger = iTrigger0	
	
  Dim height As String = Parameter("Height")  'Height
  Dim width As String = Parameter("ShelfWidth") ' ShelfWidth 
  Dim columns As Integer = Parameter("Columns") ' Columns 
  Dim rows = 4 
  If height = "90" Then rows = 2
	  
  Trace.TraceInformation("Main, Values: height = {0}, width = {1}, columns = {2}, rows = {3}", height, width, columns, rows) 	  

  Dim asm As AssemblyDocument
  asm = ThisDoc.Document 
  
  Dim acd As AssemblyComponentDefinition
  acd = asm.ComponentDefinition
  
  Dim tg As TransientGeometry
  tg = ThisServer.TransientGeometry
  
  Dim path As String
  path = ThisDoc.Path + "\"
  Trace.WriteLine("Main, path = " + path)

  ' START
  
  Dim post As ComponentOccurrence
  Dim bottomShelf As ComponentOccurrence
  
  ' add first corner (a,b)
  post = acd.Occurrences.Add(path + "corner" + height + ".ipt", tg.CreateMatrix)
  post.Grounded = True
  
  ' add shelves (1a,1b)
  bottomShelf = AddShelves(post, path + "shelf" + width + ".ipt", rows)
  
  ' add second corner (1c,1d) // enough to mate the first level
  Call AddPost(bottomShelf, path + "corner" + height + ".ipt", "1", "c", "a", "d", "b")
  
  ' MIDDLE
  Dim Column As Integer
  For Column = 2 To columns
    ' add first mid (2a,2b) // enough to mate the first level
    Call AddPost(bottomShelf, path + "mid" + height + ".ipt", "2", "a", "a", "b", "b")
  
    ' add second mid (2c,2d) // enough to mate the first level
    post = AddPost(bottomShelf, path + "mid" + height + ".ipt", "2", "c", "c", "d", "d")
  
    ' add shelves ()
    bottomShelf = AddShelves(post, path + "shelf" + width + ".ipt", rows)
    
    ' repeat
  Next
  
  ' END
  
  ' add third corner (2a,2b) // enough to mate the first level
  Call AddPost(bottomShelf, path + "corner" + height + ".ipt", "2", "a", "a", "b", "b")
  
  ' add fourth corner (2c,2d) // enough to mate the first level
  Call AddPost(bottomShelf, path + "corner" + height + ".ipt", "2", "c", "a", "d", "b")
End Sub

Function GetimateDefinition(defs As iMateDefinitionsEnumerator, name As String) As iMateDefinition
  Dim def As iMateDefinition
  For Each def In defs
    If def.Name = name Then
      GetimateDefinition = def
      Exit For
    End If
  Next
End Function

Function AddShelves(post As ComponentOccurrence, fullPath As String, rows As Integer) As ComponentOccurrence
  Trace.WriteLine("AddShelves, fullPath = " + fullPath)
  
  Dim tg As TransientGeometry
  tg = ThisServer.TransientGeometry
  
  Dim acd As AssemblyComponentDefinition
  acd = post.Parent
  
  Dim occs As ComponentOccurrences
  occs = acd.Occurrences
  
  Dim postMate As iMateDefinition
  Dim shelfMate As iMateDefinition
  Dim shelf As ComponentOccurrence
  Dim i As Integer
  For i = 1 To rows
    shelf = occs.Add(fullPath, tg.CreateMatrix)
    If AddShelves Is Nothing Then
      AddShelves = shelf
    End If
    
    postMate = GetimateDefinition(post.iMateDefinitions, "a" + CStr(i))
    shelfMate = GetimateDefinition(shelf.iMateDefinitions, "1a")
    Call acd.iMateResults.AddByTwoiMates(postMate, shelfMate)
    
    postMate = GetimateDefinition(post.iMateDefinitions, "b" + CStr(i))
    shelfMate = GetimateDefinition(shelf.iMateDefinitions, "1b")
    Call acd.iMateResults.AddByTwoiMates(postMate, shelfMate)
  Next
End Function

Function AddPost(shelf As ComponentOccurrence, fullPath As String, shelfSide As String, shelfMate1 As String, postMate1 As String, shelfMate2 As String, postMate2 As String) As ComponentOccurrence
  Trace.WriteLine("AddPost, fullPath = " + fullPath)
  Dim tg As TransientGeometry
  tg = ThisServer.TransientGeometry
  
  Dim acd As AssemblyComponentDefinition
  acd = shelf.Parent
  
  Dim occs As ComponentOccurrences
  occs = acd.Occurrences
  
  Dim postMate As iMateDefinition
  Dim shelfMate As iMateDefinition
  AddPost = occs.Add(fullPath, tg.CreateMatrix)
  
  postMate = GetimateDefinition(AddPost.iMateDefinitions, postMate1 + "1")
  shelfMate = GetimateDefinition(shelf.iMateDefinitions, shelfSide + shelfMate1)
  Call acd.iMateResults.AddByTwoiMates(postMate, shelfMate)
  
  postMate = GetimateDefinition(AddPost.iMateDefinitions, postMate2 + "1")
  shelfMate = GetimateDefinition(shelf.iMateDefinitions, shelfSide + shelfMate2)
  Call acd.iMateResults.AddByTwoiMates(postMate, shelfMate)
End Function

The model can be found here: https://github.com/adamenagy/QuickerAssemblerDA/tree/master/forgesample/wwwroot/files

-Adam

Reference Key Manager

Brian has a very detailed article on Reference Keys (exposed through the ReferenceKeyManager object) and as I was playing with them I thought it could be useful to have a tool for that.

So I created an add-in that lets you create Key Contexts and Reference Keys for the various objects, and binding them back to objects in the model.
When switching between documents, it also stores/loads data to/from json files named based on the Document's DisplayName plus ".json" as extension, .e.g. "Boxes.iam.json" 
They will be saved in the same folder as the add-in's dll and their content will look like this:

{
  "contexts": {
    "Default": {
      "index": 0,
      "keys": [
        "AgEBAAQAAAADAAAA"
      ]
    },
    "AgAAAAEAAAA=": {
      "index": 1,
      "keys": [
        "AgEBAAQAAAACAAAA",
        "AgEBAAQAAAADAAAA",
        "AgEBAAQAAAAGAAAA"
      ]
    }
  }
}

Here is the add-in's form:

As I was looking for icons I ran into the Visual Studio Image Library which can be downloaded from the Microsoft website:
https://www.microsoft.com/en-us/download/confirmation.aspx?id=35825

Here is the source code of the project: https://github.com/adamenagy/ReferenceKeyManager

I modified the Project settings so that the Output folder will always be the correct location for loading the add-in in Inventor:
%AppData%\Autodesk\ApplicationPlugins\ReferenceKeyManager

The way to do that is open the csproj file in a text editor and then you can use special variables like $(AppData) in the <OutputPath>:

<OutputPath>$(AppData)\Autodesk\ApplicationPlugins\ReferenceKeyManager\</OutputPath>

-Adam

ReleaseComObject vs FinalReleaseComObject

When freeing up COM objects in your Inventor add-in, don't use FinalReleaseComObject() as it will badly affect other add-ins. It fully releases the object, so that other add-ins previously referencing it will not be able to access it either.

Here is an example.

AddIn1 does this when being unloaded:

public void Deactivate()
{
  Marshal.FinalReleaseComObject(m_inventorApplication);
  m_inventorApplication = null;

  GC.Collect();
  GC.WaitForPendingFinalizers();
}

AddIn2 has the following code executing when its button is clicked:

private void M_buttonDefinition_OnExecute(NameValueMap Context)
{
  try
  {
    MessageBox.Show(m_inventorApplication.ActiveDocument.DisplayName, 
      "m_inventorApplication.ActiveDocument.DisplayName");
  }
  catch (Exception ex)
  {
    MessageBox.Show(ex.Message, "Accessing m_inventorApplication");
  }
}

If I unload AddIn1 and try to use AddIn2's command, I'll run into this:

(error message says: "COM object that has been separated from its underlying RCW cannot be used.")

Instead of using FinalReleaseComObject(), you could use ReleaseComObject() or even just setting the variable to null might be enough.
You can still call GC.Collect() & GC.WaitForPendingFinalizers() to trigger the release of the objects.

-Adam

iLogic variable not up-to-date

When an iLogic rule runs and it has a variable with the name of a given Inventor parameter, then it will take the current value of that parameter and keep using it - its value will not get updated if the value of the parameter is changed in the meantime outside the rule.
The following article alludes to it, though does not say it explicitly: About Rules and Forms in iLogic

Let's say we have a parameter named "MyParam" and two rules: "MyRule" and "ChangeMyParam". Neither rule is run automatically, i.e. they have the "Don't run automatically" option checked:

Inside "MyRule" we use "MyParam" variable and show its value before and after calling "ChangeMyParam" rule.

MyRule:

MessageBox.Show(MyParam, "MyRule before ChangeMyParam")

iLogicVb.RunRule("ChangeMyParam") 

MessageBox.Show(MyParam, "MyRule after ChangeMyParam")

MessageBox.Show(Parameter("MyParam"), "MyRule after ChangeMyParam")

ChangeMyParam:

MyParam = MyParam + 10

This is what we get when we run "MyRule":

As you can see, if you want to get the up-to-date value of an Inventor parameter, then you can use the Parameter() function.

-Adam