Mod the Machine

"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

Hook up a chain using iMate's with MatchList

I already had a blog post on Hook up a chain using iMate's, but I was recently asked about more iMate related API samples, so I thought I could also demonstrate the usage of iMate MatchList. 
In theory, when using a MatchList, the iMates in the various components should be matched automatically when using the "Automatically generate iMates on place" option in the "Place Component" dialog, based on the names provided in the list. I did not realize that they over-match 😬
(i.e. if there are unresolved/unpaired iMates left then they will be matched even if there is no appropriate name in the MatchList) 
Inventor Idea Station: Match list for imates

This is what I thought of doing as a test:

We have 4 parts based on 2 types of models: a and b. There will be four connection points as shown in the above image. So we'll have an a type part with connections for points 1 and 2 named chain_a_1-2.ipt, one b type part with connections for point 2 and 3 named chain_b_2-3.ipt, etc
iMates will be named following this pattern: "<iMate type [Insert or Mate]><connection point number [1..4]><part type [a or b]>", e.g. Insert2b
Each iMate will have a MatchList containing the same iMate type for the same connection point but for the opposite part type:

Insert1a will be matching Insert1b, and Insert1b will be matching nothing, etc 

Unfortunately, as I mentioned above, simply relying on the "Automatically generate iMates on place" option in the "Place Component" dialog will not work as it will also match Insert1a to Insert3b and Mate1a to Mate3b when adding the second part to the assembly.

Instead, we can just place all the components in the assembly at the same time without automatic iMate resolution and then use the API to match the iMates.  

Here is the VBA code I used - if you want to use .NET / iLogic instead have a look at Convert VBA to .NET / iLogic

Function GetAlliMates(cd As AssemblyComponentDefinition) As NameValueMap
  Dim res As NameValueMap
  Set res = ThisApplication.TransientObjects.CreateNameValueMap
  
  Dim occ As ComponentOccurrence
  For Each occ In cd.Occurrences
    Dim imate As iMateDefinition
    For Each imate In occ.iMateDefinitions
      Call res.Add(imate.name, imate)
    Next
  Next
  
  Set GetAlliMates = res
End Function

Function MatchiMate( _
cd As AssemblyComponentDefinition, _
imate As iMateDefinition, _
imates As NameValueMap, _
ByVal name As String) As Boolean
  On Error Resume Next

  Dim imateMatch As iMateDefinition
  Set imateMatch = imates.item(name)
  If Not imateMatch Is Nothing Then
    Call cd.iMateResults.AddByTwoiMates(imate, imateMatch)
    Debug.Print "Matching " + imate.name + " with " + imateMatch.name + " // " + Err.Description
  End If
  MatchiMate = (Err.Number = 0)
  
  On Error GoTo 0
End Function

Sub HookTheChain()
  Dim doc As AssemblyDocument
  Set doc = ThisApplication.ActiveDocument
    
  Dim cd As AssemblyComponentDefinition
  Set cd = doc.ComponentDefinition
    
  Dim imates As NameValueMap
  Set imates = GetAlliMates(cd)
    
  Dim imate As iMateDefinition
  For Each imate In imates
    Dim item As Variant
    For Each item In imate.MatchList
      If MatchiMate(cd, imate, imates, item) Then
        Exit For
      End If
    Next
  Next
End Sub

When the code finishes, the parts will be on top of each other - I described the same thing in the other article. 
Best thing is to ground one of the components and then you can move around the others so they come apart and end up like shown in the picture on the top.

The above code only works well if inside the assembly each iMate has a unique name and should only be matched with a specific other iMate.

Here is the Inventor 2020 model I used: Download Chain_with_MatchList