Mod the Machine

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

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

Creating Construction Geometry in Assemblies in Inventor

I was working on answering a question recently and put together a bit of code to make sure my answer was correct and thought it might be useful to some others so I want to share it here.

The initial question was a good one. The question was how to create an offset work plane in an assembly using the API. The obvious thing is to use the AddByPlaneAndOffset method of the WorkPlanes collection but if you try it, it will fail and if you look at the help it will tell you that it’s not supported in assemblies, but it also doesn’t say how to do it.

Assemblies and construction geometry are a bit strange. Working interactively with Inventor, work geometry seems to work just that same as when working in a part, but if you look close you’ll see a big difference. If you create an offset work plane using the UI in an assembly and then look at the result in the browser you’ll see the work plane in the browser just like you would in a part, except in an assembly the work plane browser node can be expanded and then you’ll see that there’s a flush constraint.  Work geometry in a part has intelligence within itself to know what it’s related to and how it’s related so if that geometry is modified it can correctly re-compute itself.  Work geometry in an assembly isn’t intelligent at all.  It just exists in space and the intelligence to position it is done by adding constraints. 

The assembly work geometry commands have a lot of intelligence in them and will create the work geometry and automatically add the needed constraints to get the desired behavior.  The API doesn’t do this. You can create a work plane in space but then you need to add the flush constraint as a separate step. In an assembly, the only way you can create work geometry is to use the AddFixed methods on each of the work geometry collections.

Below is the VBA code I wrote to test this. It demonstrates getting a selected face and then creating a work plane on that face. I’m using an offset of 0, but any offset could be used.  A fair amount of the code is just figuring out the orientation of the work plane.  Although the orientation doesn’t really matter except for looks.  To get a logical orientation it uses the longest linear edge on the selected face and if there aren’t any linear edges then it aligns it with one of the primary model axes. The UI command also does some additional work to size the created work plane to fit the geometry, which the API and this sample doesn’t do.  The API does support setting the size of a work plane but I haven’t attempted that here.

Public Sub CreateWorkPlane()
    Dim asmDoc As AssemblyDocument
    Set asmDoc = ThisApplication.ActiveDocument
   
    Dim asmDef As AssemblyComponentDefinition
    Set asmDef = asmDoc.ComponentDefinition
   
    ' Have a planar face selected.
    Dim selFace As Face
    Set selFace = ThisApplication.CommandManager.Pick(kPartFacePlanarFilter, "Select planar face")
   
    ' Get the underlying plane geometry from the face.
    Dim facePlane As Plane
    Set facePlane = selFace.Geometry
   
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
   
    ' Find the longest linear edge on the face and use it as the X axis.
    Dim testEdge As Edge
    Dim longDir As UnitVector
    Dim longLength As Double
    longLength = 0
    For Each testEdge In selFace.Edges
        If testEdge.GeometryType = kLineSegmentCurve Then
            Dim lengthVec As Vector
            Set lengthVec = testEdge.StartVertex.Point.VectorTo(testEdge.StopVertex.Point)
            If lengthVec.length > longLength Then
                longLength = lengthVec.length
                Set longDir = lengthVec.AsUnitVector
            End If
        End If
    Next
   
    Dim xVec As UnitVector
    Dim yVec As UnitVector
    Dim pi As Double
    pi = Atn(1) * 4
    If Not longDir Is Nothing Then
        ' Use the longest edge as the x direction for the work plane.
        Set xVec = longDir
        Set yVec = facePlane.Normal.CrossProduct(xVec)
    Else
        ' No linear edges was found so calculate another axis to use as the x axis.
        ' Use the model x, y, or z axis depending on which one is closest to 90 deg from the normal.
        Dim angleDiff As Double
        Dim testVec As UnitVector
        Set testVec = tg.CreateUnitVector(1, 0, 0)
        angleDiff = Abs((pi / 2) - facePlane.Normal.AngleTo(testVec))
        Set xVec = testVec
       
        Set testVec = tg.CreateUnitVector(0, 1, 0)
        If Abs((pi / 2) - facePlane.Normal.AngleTo(testVec)) < angleDiff Then
            angleDiff = Abs((pi / 2) - facePlane.Normal.AngleTo(testVec))
            Set xVec = testVec
        End If
       
        Set testVec = tg.CreateUnitVector(0, 0, 1)
        If Abs((pi / 2) - facePlane.Normal.AngleTo(testVec)) < angleDiff Then
            angleDiff = Abs((pi / 2) - facePlane.Normal.AngleTo(testVec))
            Set xVec = testVec
        End If
       
        Set yVec = facePlane.Normal.CrossProduct(xVec)
        Set xVec = yVec.CrossProduct(facePlane.Normal)
    End If
   
    ' Create the "fixed" work plane.
    Dim wp As WorkPlane
    Set wp = asmDef.WorkPlanes.AddFixed(facePlane.RootPoint, xVec, yVec)
   
    ' Create a flush constraint between the face and the workplane with an offset of 0.
    Dim flush As FlushConstraint
    Set flush = asmDef.Constraints.AddFlushConstraint(selFace, wp, 0, facePlane.RootPoint, facePlane.RootPoint)
End Sub

-Brian

Inventor 2015 API Enhancements

Inventor 2015 will soon be shipping. Most of the API enhancements are keeping up with the new Inventor 2015 functionality and some of the enhancements are catching up to things that have been  available from the Inventor user interface in previous releases. 

Enhancements in the API for Parts

Sweep Feature.

The SweepFeature has a new option for twist angle and now  instead of having a method call that takes all the arguments to create a sweep you create a definition object and set all the properties on that object and provide definition as input to create the sweep. In the UI when you click the sweep command the dialog comes up it gathers all of the inputs needed to create the sweep but the sweep is not actually created until you click ok. You can consider the definition object as similar to the dialog.

 

 

Work plane.

Previous to Inventor 2015 you could create a mid plane between two parallel planes. Inventor now supports the creation of a plane between any two planes and they do not have to be parallel. An example of this is bisecting two perpendicular planes. A new point argument that defines which quadrant to use needs to be provided because if the planes are not parallel there are two possible solutions.

 

 

 

 

Work plane created using WorkPlanes.AddByTwoPlanes()

 

DirectEditFeature

In the UI the direct edit feature lets you push and pull features. The API has read support and allows you to find information such as  which operations were defined.

FreeformFeature

Another enhancement in the user interface is T-Spline capabilities. In the product it is referred to as a Freeform. The 2015 API has minimal support for this but should change in the future. In this release you can find the FreeformFeature and do basic feature operations such as getting its name, suppressing it or reordering it in the tree.

Sketch

Inventor 2015 has changes to sketching that makes it more intuitive to use. The API has been updated because there are quite a few new settings.

These settings are exposed through the API.

 

Enhancements in the API for Sheet metal

Punch – cut across bend

Now when you do a punch you have an option to have the punch cut across a bend.

Punch on the right used cut across bend

You can think of it as unfolding the part and doing the punch and then folding it back. (the edges are normal to the flat)

Punch – cut normal to the flat pattern

In this case the edges will be perpendicular to the flat. Instead of being perpendicular to the sketch. This will make it easier to fabricate the part.

Cut on the left is normal to the flat

How it looks in the flat pattern.

Flat pattern orientation

You now have more control over the flat pattern orientation.  In the UI there is a new dialog where you can pre define multiple orientations and switch between those and the API provides full access.

 

Enhancements in API for Assemblies

BOM Structure

There are new methods to import and export the BOM customization file. The API has some support for the BOM but it does not support defining the BOM structure. A solution is to interactively create the BOM structure that you want and export it. Using the API you can import that to have a custom BOM structure.

AssemblySymmetryConstraint

The assembly symmetry constraint has a new option to control the orientation and the API was enhanced to provide that capability.

Enhancements in API for Drawings

Hole table title

In this release you have control over hole table title.

Foreshortened dimensions

Foreshortened drawing dimensions are linear, angular, and arc length dimensions.

 

Miscellaneous Enhancements

FileManager

The FileManager object now has a method ReferencedDocumentCount that will allow you to get the number of referenced documents. The WillOpenExpressDefault method will allow you to find out whether the input assembly will open in Express mode by default. To use these methods you just pass in a file name and it returns the information.

 

-Wayne

Updating Parts Through an Assembly

Have you written some code to do some type of operation on a part, (i.e. create/update a parameter, create/update an iProperty, etc.), and now would like to perform that update on every part that’s used within a particular assembly?  I have good news, if you’ve already figured out how to do the work for a single part, doing it for all of the parts in an assembly is a simple step away.  Let’s look at updating a single part first and the progression of that program to updating a complete assembly.

Below is a typical VBA macro that creates or updates a parameter in a part.

Public Sub UpdateParameter()
    ' Get the active part.
    Dim part As PartDocument
    Set part = ThisApplication.ActiveDocument
   
    ' Get the user parameters collection.
    Dim userParams As UserParameters
    Set userParams = _ 
               part.ComponentDefinition.Parameters.UserParameters

    ' Check to see if the parameter already exists.
    Dim param As Parameter
    On Error Resume Next
    Set param = userParams.Item("SomeValue")
    On Error GoTo 0
   
    If param Is Nothing Then
        ' The parameter doesn't exist so add it.
        Set param = userParams.AddByExpression("SomeValue", _ 
                             "2 inch", kDefaultDisplayLengthUnits)
    End If
End Sub

Here’s a variation of the macro above converted into a Sub that gets the part document through an argument. The additional code for the argument is highlighted below and the first portion of the code where it got the active document in the sample above has been removed since the document is now passed to it.

Public Sub UpdateParameter(part As PartDocument)
    ' Get the user parameters collection.
    Dim userParams As UserParameters
    Set userParams = _ 
                part.ComponentDefinition.Parameters.UserParameters

    ' Check to see if the parameter already exists.
    Dim param As Parameter
    On Error Resume Next
    Set param = userParams.Item("SomeValue")
    On Error GoTo 0
   
    If param Is Nothing Then
        ' The parameter doesn't exist so add it.
        Set param = userParams.AddByExpression("SomeValue", _ 
                             "2 inch", kDefaultDisplayLengthUnits)
    End If
End Sub

Here’s the macro that calls the sub above.  It gets the active part document and calls the Sub, passing it the part document.

Public Sub UpdatePart()
    ' Get the active part.
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
   
    ' Call the function to update the part.
    Call AddParameter(partDoc)
End Sub

Now we want to perform this same update to every part in the active assembly.  The code to do that is below.  It gets the active document, which in this case is an assembly and then uses the AllReferencedDocuments property of the assembly document to get the documents referenced by the assembly.  It then looks for the parts, to skip any referenced subassemblies, and calls the AddParameter sub just the same as before, passing in the part document.  This is the same PartDocument object you would get if you opened the part by itself and used the Application.ActiveDocument property.  The only difference is how you got the PartDocument object which in this case is through the assembly.

Public Sub UpdateAssembly()
    Dim asmDoc As AssemblyDocument
    Set asmDoc = ThisApplication.ActiveDocument
   
    ' Iterate through all of the referenced documents at
    ' all levels of the assembly.
    Dim doc As Document
    For Each doc In asmDoc.AllReferencedDocuments
        ' Check for part documents.
        If doc.DocumentType = kPartDocumentObject Then
            ' Call the function to update the part.
            Call AddParameter(doc)
        End If
    Next
End Sub

The function getting the part document can do anything to the part because it is a full PartDocument object.  It doesn’t even know how the reference was obtained.  There are no limitations.

-Brian

Inventor 2014 API for the new Joint feature

One focus of the 2014 release is “Ease of use”. An example of this is the new Joint command that will definitely make it easier to make relationships between parts in an assembly. This command is on the Assemble tab next to Constrain.

When you run this command new graphic feedback shows you where the joints could be added before you add the joint.

API Support for Joints

The API also supports Joints. Here are several of the new classes, new method and an enum related to Joints.

AssemblyJoint, AssemblyJointDefinition

AssemblyComponentDefinition.Joints (collection)

AssemblyJointTypeEnum, CreateAssemblyJointDefinition

You use an AssemblyJointDefinition as input to create a joint. To create this use the CreateAssemblyJointDefinition method of the Joints collection. (Property of the AssemblyComponentDefinition) This method takes a Joint Type and two GeometryIntent objects. If you have used the API to create drawing annotations you will be familiar with GeometryIntent objects. To create the joint use the Add method of the Joints collection.

Below are the functions from this C# example that create a joint. (zip includes the ipt) This example was converted to C# from the VBA example in the help file. After you run the example you will see a new assembly with two components that share a joint.

I dragged the part (rotated) to show the joint.

C# functions:

public void AssemblyJoint()

{

    // Create a new assembly document.

    AssemblyDocument asmDoc =

(AssemblyDocument)ThisApplication.Documents.Add

      (DocumentTypeEnum.kAssemblyDocumentObject,

     ThisApplication.FileManager.GetTemplateFile

    (DocumentTypeEnum.kAssemblyDocumentObject));

 

    AssemblyComponentDefinition asmDef =

                     asmDoc.ComponentDefinition;

 

    Matrix trans =

ThisApplication.TransientGeometry.CreateMatrix();

 

    // Place an occurrence into the assembly.

    ComponentOccurrence occ1 =

        asmDef.Occurrences.Add

("C:\\Inventor2014APISamples\\SamplePart.ipt",

                                         trans);

 

    // Place a second occurrence with the matrix

    //adjusted so it fits correctly with the

    //first occurrence.

    trans.Cell[1, 4] = 6 * 2.54;

    ComponentOccurrence occ2 =

        asmDef.Occurrences.Add

("C:\\Inventor2014APISamples\\SamplePart.ipt",

                                         trans);

 

    // Get Face 1 from occ1 and

    // create a FaceProxy.

    Face face1 =

        (Face)GetNamedEntity(occ1, "Face1");

 

    // Get Face 2 from occ2 and

    // create a FaceProxy.

    Face face2 =

        (Face)GetNamedEntity(occ2, "Face2");

 

    // Get Edge 1 from occ2 and 

    // create an EdgeProxy.

    Edge Edge1 =

        (Edge)GetNamedEntity(occ2, "Edge1");

 

    // Get Edge 3 from occ1 and

    // create an EdgeProxy.

    Edge Edge3 =

        (Edge)GetNamedEntity(occ1, "Edge3");

 

    // Create an intent to the

    // center of Edge1.

    GeometryIntent edge1Intent =

        asmDef.CreateGeometryIntent

    (Edge1, PointIntentEnum.kMidPointIntent);

 

    // Create an intent to the center of Edge3.

    GeometryIntent edge3Intent =

        asmDef.CreateGeometryIntent

        (Edge3, PointIntentEnum.kMidPointIntent);

 

    // Create two intents to define

    // the geometry for the joint.

    GeometryIntent intentOne =

        asmDef.CreateGeometryIntent

                        (face2, edge1Intent);

    GeometryIntent intentTwo =

        asmDef.CreateGeometryIntent

                        (face1, edge3Intent);

 

    // Create a rotation joint between the two parts.

    AssemblyJointDefinition jointDef =

       asmDef.Joints.CreateAssemblyJointDefinition

       (AssemblyJointTypeEnum.kRotationalJointType,

                             intentOne, intentTwo);

 

    jointDef.FlipAlignmentDirection = false;

    jointDef.FlipOriginDirection = true;

    AssemblyJoint joint =

                   asmDef.Joints.Add(jointDef);

 

    // Make the joint visible.

    joint.Visible = true;

 

    // Drive the joint to animate it.

    joint.DriveSettings.StartValue = "0 deg";

    joint.DriveSettings.EndValue = "180 deg";

    joint.DriveSettings.GoToStart();

    joint.DriveSettings.PlayForward();

    joint.DriveSettings.PlayReverse();

 

}

 

 

// This finds the entity associated with

// an iMate of a specified name.  This

// allows iMates to be used as a generic

// naming mechansim.

private object GetNamedEntity

    (ComponentOccurrence Occurrence, string Name)

{

        // Look for the iMate that has the

        // specified name in the referenced file.

        PartComponentDefinition partDef =

   (PartComponentDefinition)Occurrence.Definition;

 

        object resultEntity = null;

        resultEntity = null;

 

        foreach (iMateDefinition iMate

                    in partDef.iMateDefinitions)

        {

            // Check to see if this iMate has

            // the correct name

            if (iMate.Name.ToUpper() ==

                                Name.ToUpper())

            {

             // Get the geometry associated

             // with the iMate. Using InvokeMember

             // because the iMateDefinition is the

             // base class and does not have an

             // Entity property

              object entity = null;

              entity = iMate.GetType().InvokeMember

                           ("Entity",

                            BindingFlags.GetProperty,

                            null, iMate, null);

 

                // Create a proxy.

                Occurrence.CreateGeometryProxy

                    (entity, out resultEntity);

                break;

            }

        }

 

        // Return the found entity, or Nothing 

        // if a match wasn't found.

        return resultEntity;

}

-Wayne

C# Help Examples for Assemblies–General & Constraints

Here are two more sections of VBA examples converted to C#. These functions are related to constraints and other demos for assemblies that did not fit in one of the other sections. This is the seventh post with converted Help examples.

Note: One of the VBA examples caused a serious error and I logged a Change Request for it. The converted code for this macro is in the C# project but the function name is not added to the combo box. See this post for more information about these projects.

This project has the following functions:

 Download Inventor_Help_Examples_CSharp_Asmb_Gen_Constraints

FixAllOccurrences
CreateShrinkwrapSubstitute
AssociativeBodyCopy
InsertConstraint
MateConstraint
MateConstraintOfWorkPlanes
MateConstraintWithLimits
CreateiMateDefinitionSample
iMateResultCreationSample

 

Here is the InsertConstraint function

//    Assembly Insert Constraint Add API Sample

//Description

//This sample demonstrates the creation of an

//assembly insert constraint.

//Before running the sample, you need to open an

//assembly that contains at least two parts.

// Select circular edges on the two parts that

//will be used for the constraint and run the

//sample code. (Set the priority of the Select

//command and use the Shift-Select to select

//multiple edges.)

public void InsertConstraint()

{

    // Set a reference to the active assembly

    AssemblyDocument oDoc =

            (AssemblyDocument)

               ThisApplication.ActiveDocument;

 

    AssemblyComponentDefinition oAsmCompDef =

                (AssemblyComponentDefinition)

                      oDoc.ComponentDefinition;

 

    // Set a reference to the select set.

    SelectSet oSelectSet = default(SelectSet);

    oSelectSet =

      ThisApplication.ActiveDocument.SelectSet;

 

    // Validate the correct data is in the

    //select set.

    if (oSelectSet.Count != 2)

    {

        MessageBox.Show

("Select two circular edges for the insert.");

        return;

    }

 

    // Get the two edges from the select set.

    Edge oEdge1 = null;

    Edge oEdge2 = null;

    try

    {

        oEdge1 = (Edge)oSelectSet[1];

        oEdge2 = (Edge)oSelectSet[2];

    }

    catch

    {

            MessageBox.Show

("Select two circular edges for the insert.");

        return;

    }

 

    //Note: this code does not test to see if

    //the edges are circular edges (they need to be)

 

    // Create the insert constraint

    //between the parts.

    InsertConstraint oInsert =

                 default(InsertConstraint);

    oInsert = oAsmCompDef.Constraints.

                        AddInsertConstraint

                    (oEdge1, oEdge2, true, 0);

}

-Wayne

C# Help Examples for Assemblies Occurences

Here is another section of VBA examples converted to C#. These functions are related to using occurrences in assemblies. This group was fairly easy to migrate compared to some of the other sections I did for previous posts. Also there were several C# examples already in the help file. I added them to the project for completeness.

This project has the following functions.

 Download InventorHelpExamples_Assembly_Occ

AddOccurrencesToFolder
Demote
Promote
ReplaceContentCenterPart
AssemblyCount
MoveOccurrence
AddOccurrence
AddiAssemblyOccurrence
AddiPartOccurrence
iMateDuringOccurrencePlacementSample
AddOccurrenceWithRepresentations

 

Here is the AddOccurrencesToFolder function:"

// Add assembly occurrences to a new folder API Sample

//Description

//Demonstrates assembly occurrences to a new folder

//Have an assembly with at least one occurrence in it

//and run the sample.

public void AddOccurrencesToFolder()

{

    AssemblyDocument oDoc =

             default(AssemblyDocument);

 

    oDoc = (AssemblyDocument)

                ThisApplication.ActiveDocument;

 

    AssemblyComponentDefinition oDef =

            default(AssemblyComponentDefinition);

                 oDef = oDoc.ComponentDefinition;

 

    BrowserPane oPane = default(BrowserPane);

    oPane = oDoc.BrowserPanes.ActivePane;

 

    ObjectCollection oOccurrenceNodes =

                      default(ObjectCollection);

    oOccurrenceNodes = (ObjectCollection)

        ThisApplication.TransientObjects.

                      CreateObjectCollection();

 

 

 foreach (ComponentOccurrence oOcc

                            in oDef.Occurrences)

    {

        BrowserNode oNode = default(BrowserNode);

    oNode = oPane.GetBrowserNodeFromObject(oOcc);

        oOccurrenceNodes.Add(oNode);

    }

 

    BrowserFolder oFolder = default(BrowserFolder);

        oFolder = oPane.AddBrowserFolder

        ("My Occurrence Folder", oOccurrenceNodes);

 

}

-Wayne

Discussion on Client Graphics – Segment 4

Here is the last of four articles on Client Graphics. This was originally in a technical paper written by Autodesk Developer Network engineer Xiaodong Liang.

Note: Segment 3 is here.

This zip file has a VB.NET project with the examples discussed in this section.

Download ClientGraphics_Segment_4

Start of segment 4

Interaction Client Graphics
Interaction Client Graphics operate in a similar manner to regular ClientGraphics, except that it all happens in the context of InteractionEvents. ClientGraphics created via InteractionGraphics are optimized for this environment, and run much faster. They are well suited to real-time feedback during a command. As the client graphics are displayed in the context of an InteractionEvents object, they can take advantage of mouse movement information, selection information, in fact, any events supported by the InteractionEvents objects. These graphics are automatically removed once the associated InteractionEvents object stops.

The interaction graphics can be Preview or Overlay. Preview graphics are equivalent to regular Client Graphics. The only difference between Overlay and Preview graphics is that Overlay graphics can be drawn independently, in a single view (window), and then merged with the last full redraw of the scene by drawing the graphics in a special "overlay" plane. It doesn't mean that the graphics are always drawn on top. You can position them anywhere you want and you can toggle the "burn through" option. In short, anything you can do with preview graphics you can do with overlay graphics.

The creation of interaction graphics is not transacted. This is done for performance reasons, and to avoid some side effects, like clearing of the selection set. This also means that transacting operations cannot be mixed with preview graphics.

 

‘<code snippet: interaction events (Overlay)>
‘start interaction event and get the overlay graphics
Dim oIE As InteractionEvents
Set oIE = ThisApplication.CommandManager.CreateInteractionEvents
oIE.Start

Dim oClientGraphics As ClientGraphics
Set oClientGraphics = oIG.OverlayClientGraphics

‘create line strip graphics
Dim oLineStrip As LineStripGraphics
Set oLineStrip = oLineStripNode.AddLineStripGraphics
   
' Assign the same coordinate set to the line strip.
oLineStrip.CoordinateSet = oCoordSet

' Update the view to see the resulting spiral.
oIG.UpdateOverlayGraphics ThisApplication.ActiveView

 

Store Client Graphics
In general, ClientGraphics will be maintained and transformed by Inventor for the duration of the session only. Using the GraphicsDataSetsCollection.Add method will allow the data to be saved with the file. When the document is opened, the ClientGraphics are persisted, and are still available to be further manipulated.

In Part or Assembly documents, you can attach client graphics to ClientFeature objects, so the graphics will be stored with document. The presumption is the graphics data is created by GraphicsDataSetsCollection.Add. In Drawing documents only the data can be saved. A developer’s application has to redraw the graphics using the client graphics data after the Drawing document has been re-opened.

 

‘<code snippet: store client graphics with client feature>
Dim invCF As ClientFeature
‘get/create ClientFeature
Dim invCFD As ClientFeatureDefinition
invCFD = invCF.Definition

‘Create & store graphics data
Dim oGraphicsData As GraphicsDataSets
Set oGraphicsData = oDoc.GraphicsDataSetsCollection.Add2("TestCG_StoreData", True)

 ‘create graphics in the ClientFeature
Dim oClientGraphics As Inventor.ClientGraphics
Set oClientGraphics = invCFD.ClientGraphicsCollection("ClientFeatureTest")


‘create graphics node
Dim oGraphicsNode As GraphicsNode
Set oGraphicsNode = oClientGraphics.AddNode(oClientGraphics.count + 1)

Dim oPointCoords(11) As Double 'create 4 points
  oPointCoords(0) = 0: oPointCoords(1) = 0: oPointCoords(2) = 0
  oPointCoords(3) = 1: oPointCoords(4) = 1: oPointCoords(5) = 0
  oPointCoords(6) = 2: oPointCoords(7) = 0: oPointCoords(8) = 0
  oPointCoords(9) = 3: oPointCoords(10) = 1: oPointCoords(11) = 0
  Call oCoordSet.PutCoordinates(oPointCoords)

   'Lines: totally, 2 lines
  Dim oGraphic As LineGraphics
  Set oGraphic = oGraphicsNode.AddLineGraphics         
  oGraphic.CoordinateSet = oCoordSet

 

Advanced Functionality
Slice
This provides the functionality that slices the graphics based on the input planes and optionally caps the sliced end.
Texture mapping
Texture mapping provides the ability to more accurately define color mapping to the model.  For example, with the previous functionality you were limited to assigning colors to vertices and then relying on Inventor to interpolate the color across the triangle.  If you had a plane constructed of two triangles you would not be able to define any intermediate colors between the vertices.

This is the end of this series. These posts will also be of interest:

AU Session - Client Graphics API Exposed

MFG DevBlog post - Complete ClientFeature example in C#

The Manufacturing DevBlog has other posts on Client Graphics as well. Also don’t forget the help file. It has examples for ClientGraphics too.

- Wayne

Discussion on Client Graphics – Segment 3

Here is the third of four articles on Client Graphics. This was originally in a technical paper written by Autodesk Developer Network engineer Xiaodong Liang.

Note: Segment 2 is here.

This zip file has a VB.NET project with the examples discussed in this section.

Download ClientGraphics_Segment_3

Start of segment 3

Using Index Sets
The Index Set provides a flexible way to arrange the coordinate set, color set and normal set (for triangles). For example, with the same coordinate data, the figure below, on the left, creates the line graphics from 1-2-3-4 where all lines have the same color, while the figure on the right creates the line from 1-3-2-4 and each line has a different color defined using an index set.

‘<code snippet: Line, With Coordinate Index Set and Color Set>
     Dim oPointCoords(11) As Double 'create 4 points
    oPointCoords(0) = 0:     oPointCoords(1) = 0:     oPointCoords(2) = 0
    oPointCoords(3) = 1:     oPointCoords(4) = 1:     oPointCoords(5) = 0
    oPointCoords(6) = 0:     oPointCoords(7) = 1:     oPointCoords(8) = 0
    oPointCoords(9) = 1:     oPointCoords(10) = 0:     oPointCoords(11) = 0
    Call oCoordSet.PutCoordinates(oPointCoords)
 
    'Line strip: totally, 3 lines
    Dim oGraphic As LineGraphics
    Set oGraphic = oGraphicsNode.AddLineGraphics   
    oGraphic.LineWeight = 5

    ‘Create Coordinate Index Set
    Dim oCoordinateIndex As GraphicsIndexSet
    Set oCoordinateIndex = oDataSets.CreateIndexSet(oDataSets.count + 1)
    oCoordinateIndex.Add 1, 1  'from point 1
    oCoordinateIndex.Add 2, 3  'connect to point 3
    oCoordinateIndex.Add 3, 3  'from point 3
    oCoordinateIndex.Add 4, 2  'connect to point 2
    oCoordinateIndex.Add 5, 2  'from point 2
    oCoordinateIndex.Add 6, 4  'connect to point 4  
   
    'Create the color set: two colors.
    Dim oColorSet As GraphicsColorSet
    Set oColorSet = oDataSets.CreateColorSet(oDataSets.count + 1)
    Call oColorSet.Add(1, 255, 0, 0)
    Call oColorSet.Add(2, 0, 255, 0)
   
  ' Create the index set for color
    Dim oColorIndex As GraphicsIndexSet
    Set oColorIndex = oDataSets.CreateIndexSet(oDataSets.count + 1)
    oColorIndex.Add 1, 2  'line 1 uses color 2
    oColorIndex.Add 2, 1  'line 2 uses color 1
    oColorIndex.Add 3, 2  'line 3 uses color 2 
   
    oGraphic.CoordinateSet = oCoordSet
    oGraphic.CoordinateIndexSet = oCoordinateIndex

Using ‘Strip’ graphics
Strip Graphics are used to group the coordinates associated with a series of connected graphics objects and are only available with LineStrip, TriangleStrip or TriangleFan. You can specify the strip length. e.g. in the code below, points 1,2,3 are defined as one triangle strip, while points 4,5,6,7 are defined as another strip. Each strip is independent of the other strips. You can also specify the color for each.

‘<code snippet: Triangle Strip, Set Strip>
Dim oPointCoords(20) As Double    ‘create 7 points,
oPointCoords(0) = 0:     oPointCoords(1) = 0:     oPointCoords(2) = 0
oPointCoords(3) = 1:     oPointCoords(4) = 1:     oPointCoords(5) = 0
oPointCoords(6) = 2:     oPointCoords(7) = 0:     oPointCoords(8) = 0
oPointCoords(9) = 3:     oPointCoords(10) = 1:     oPointCoords(11) = 0
oPointCoords(12) = 4:     oPointCoords(13) = 0:     oPointCoords(14) = 0
oPointCoords(15) = 5:     oPointCoords(16) = 1:     oPointCoords(17) = 0
oPointCoords(15) = 5:     oPointCoords(16) = 1:     oPointCoords(17) = 0
oPointCoords(18) = 6:     oPointCoords(19) = 0:     oPointCoords(20) = 0
                                              
Call oCoordSet.PutCoordinates(oPointCoords)
 
‘or Triangle Strip: totally 5 triangles
Dim oGraphic As TriangleStripGraphics
Set oGraphic = oGraphicsNode.AddTriangleStripGraphics
 
Dim oStrip(1) As Long
oStrip(0) = 3  ‘ point 1,2,3   for strip 1
oStrip(1) = 4  ‘ point 4,5,6,7 for strip 2
oGraphic.PutStripLengths oStrip

'Create the color set: two colors.
Dim oColorIndex As GraphicsIndexSet
Set oColorIndex = oDataSets.CreateIndexSet(oDataSets.count + 1)
oColorIndex.Add 1, 1
oColorIndex.Add 2, 2
oColorIndex.Add 3, 1
oColorIndex.Add 4, 2
oColorIndex.Add 5, 1     
   
  ' Create the index set for color
Dim oColorSet As GraphicsColorSet
Set oColorSet = oDataSets.CreateColorSet(oDataSets.count + 1)
Call oColorSet.Add(1, 255, 0, 0)
Call oColorSet.Add(2, 0, 255, 0)

oGraphic.CoordinateSet = oCoordSet
oGraphic.ColorIndexSet = oColorIndex
oGraphic.ColorSet = oColorSet
oGraphic.ColorBinding = kPerStripColors

Using Model Native Data
Most scenarios where Client Graphics are required are based on the models native geometry. It is quite easy to get the data using Inventor API objects. e.g. SurfaceBody, Face, Edge, Vertex in Part or Assembly Documents, and DrawingCurve in drawing documents. The code below creates and transforms a surface using an existing SurfaceBody from the model.

It is also possible to obtain a coordinate data set from the existing SurfaceBody, Edge or Face objects using the CalculateStrokes method. You determine the tolerance (the number of points you need) by first calling GetExistingStrokeTolerances. You may need to do this multiple times in order to assess the average tolerance for the model. Similarly, obtain triangular facets from a SurfaceBody or Face using CalculateFacets.

‘<code snippet: Using model native data>
Dim oPartDef As PartComponentDefinition
Set oPartDef = ThisApplication.ActiveDocument.ComponentDefinition      
       
Dim oTransientBRep As TransientBRep
Set oTransientBRep = ThisApplication.TransientBRep
       
 ‘by Transient Brep class to copy the surface body
  Dim oBody As SurfaceBody
  Set oBody = oTransientBRep.Copy(oCompDef.SurfaceBodies.Item(1))
    
  ' Create client graphics based on the transient body
  Dim oSurfaceGraphics As SurfaceGraphics
  Set oSurfaceGraphics = oSurfacesNode.AddSurfaceGraphics(oBody)
       
‘move the graphics to a new location
  Dim oMatrix As Matrix
  Set oMatrix = ThisApplication.TransientGeometry.CreateMatrix
       
  oMatrix.SetTranslation ThisApplication.TransientGeometry.CreateVector(0, 0, 100)

Basic Properties
Graphics has some properties to control the basic behavior.
Render Style
By default, the linetype, lineweight and color will use the settings on RenderStyle until they are overridden by LineType, LineWeight, Color (for Curve and Surface objects), and ColorSet (for Line, Triangle and TriangleFan objects).
Point Style
Specific to Point objects only, and controls the point style.
Visibility
Controls whether or not the graphics are visible.
Selectable
Specifies whether client graphics can be selected when the Select command is running.
Burn Through
This specifies whether or not graphics are always visible even if they are blocked by other objects.
Transformation
This property is used to transform a graphics node.
Transform Behavior
Two special transform behaviors: front facing and pixel scaling.
•    Front Facing
Client graphics with this property do not rotate as the view is rotated but maintain the same orientation on the screen. They are positioned at a specified location within model space and their position on the screen will change as the view is zoomed in and out and scrolled, but their orientation will not change.
•    Pixel Scaling
Here client graphics maintain the same size and position relative to the screen. As the user zooms in and out in the graphic window, these objects remain static.
Any graphics object can also have no transform behavior (which means it's size, position, and orientation are maintained relative to model space), front facing, pixel scaling, or front facing & pixel scaling. By default an object has no transform behavior, with the exception of text. Text always has front facing behavior regardless of the behavior type set through this method.
Anchor Behavior
This will anchor the primitive in view space so that the graphics will display in one fixed position, no matter how the view changes.

End of Segment 3

- Wayne