Mod the Machine

DevLabs

Here’s an unbelievable opportunity, if you’re in a position that you can take advantage of it.  It’s essentially up to a weeks worth of free programming consultation.  Kean Walmsley, who is the manager of the DevTech team explains it fully in his blog Through the Interface.  DevTech is the support group for the Autodesk Developer Network (ADN).  Take a look at the locations and dates and see if one of them works for you.

Inventor 2010 API Information

The official Inventor API page has been updated with information about Inventor 2010, http://www.autodesk.com/developinventor.  Here are a couple of highlights of what’s available. 

• A PowerPoint presentation, along with sample code, that discusses the API enhancements that are in Inventor 2010.  It was pointed out that the PowerPoint file is in the new pptx format.  You can download an Office compatibility pack so you can view the new file formats in older versions of office.  The compatibility pack is available from Microsoft here.
  
• The new Object Model chart for Inventor 2010.  (This is also installed in the Docs directory as part of the Developer Tools in the SDK.)
  
• There is an update for the SDK.  There were some issues discovered in the wizards and sample programs that have been resolved in this update.  It’s a complete SDK install so you’ll need to uninstall your existing User Tools or Developer Tools if you have installed them and then install these updates.

Extracting a Specific Size Icon From a .ico File

Here’s something that I recently discovered after a lot of searching and some experimenting.  In my add-ins I prefer to use .ico files for my button icons.  Icons have some advantages over .bmp files in that you can define a transparent background and you can save multiple images within a single .ico file.  This is convenient because to fully support Inventor’s interface you should have three icon sizes, as listed below.

16x16 pixels – Used for small icons in both Classic and Ribbon interfaces.
24x24 pixels – Used for large icons in Class interface.
32x32 pixels – Used for large icons in Ribbon interface.

Using an icon editor it’s fairly easy to create the icons of the various sizes and then use that .ico file in my program.  What I couldn’t figure out was how to extract an icon of a specific size from the .ico file.  My searches just lead to postings from other who had the same question but no answers.  I finally began experimenting and found something that works.

In my add-in project I add each of the .ico files as a resource to my project.  In VB.Net you can access any item in your resources by name.  The name of my icon in the example below is “MyCommand1”.  The code below reads the icon of the specified size from the resource and ends up holding a reference to an Icon object. 

Dim smallIcon As System.Drawing.Icon
smallIcon = New System.Drawing.Icon(My.Resources.MyCommand1, 16, 16)

The code below reads in the large icon file from the same icon resource. 

Dim largeIcon as Sytem.Drawing.Icon
largeIcon = New System.Drawing.Icon(My.Resources.MyCommand1, 32, 32)

You can’t directly use an Icon object with Inventor’s API since it is expecting an IPictureDisp object.  The code below demonstrates how to convert an Icon to an IPictureDisp.  You’ll need to reference the Microsoft.VisualBasic.Compatibility and stdole libraries into the project first.

Dim smallPic As stdole.IPictureDisp
smallPic = Microsoft.VisualBasic.Compatibility.VB6.IconToIPicture( _
                                                          smallIcon)

Controlling Layers in Your Flat Pattern Export

When writing out a flat pattern as DXF or DWG you have control over which layers various bits of the flat pattern are written to.  You can see these options in the Save Copy As dialog when you right-click on the flat pattern in the browser, as shown below.

The dialog allows you to specify the layer name for various categories of items that can exist in a flat pattern.  You can change the layer names and control which groups are written to the DXF or DWG file.  This is all good functionality but you’re limited to the predefined sets of groups.  There is a solution to this that allows you to have very detailed control over which layer specific entities are written to.

Using the API you can assign an attribute to an edge in the flat pattern and this will control which layer that edge will be written to in the DXF or DWG file.  The name of the layer is specified by the attribute.  Below is a very simple example that will add an attribute to a selected edge.

' This program assumes that a sheet metal document is open, the
' flat pattern is active, and that an edge of the flat pattern is
' selected.  For simplicity, no error checking is done to
' validate this.
Sub AddLayerName()
    ' Get the active document.
    Dim oDoc As PartDocument
    Set oDoc = ThisApplication.ActiveDocument

    ' Get the selected edge.
    Dim oEdge As Edge
    Set oEdge = oDoc.SelectSet(1)

    ' Add an attribute set named “FlatPatternAttributes”
    ' to the selected edge.
    Dim attSet As AttributeSet
    Set attSet = oEdge.AttributeSets.Add("FlatPatternAttributes") 

    ' Add an attribute specifying the name of the layer.
    Dim myLayerName As String
    myLayerName = "CustomLayer"
    Call attSet.Add("LayerName", kStringType, myLayerName)
End Sub

Any edge on the flat pattern model is valid to name.  The bend and tangent lines are also Edge objects and can be assigned a layer name too.  Defining layers for sketches and sketch entities is not currently supported so attributes added to these will be ignored.  When you specify the layer of an entity using this technique it overrides the dialog settings.  For example, if an edge will normally be written to the IV_OUTER_PROFILE it will instead be written to the layer you specify using the attribute.

One other thing to be aware of is that only the edges that are visible are written to the DXF or DWG file.  The picture below shows a flat pattern as viewed with the Z axis pointed towards you.  This is the geometry you would expect in the output DXF or DWG file.

Here’s a close-up of an area of the model where it’s slightly rotated.  The red selected edge is on the “back” of the part and will not be written out to the DXF or DWG file.  Adding an attribute to this edge won’t have any effect since the edge is not written out.  The same is true for the bend and tangent lines too.  Only those on the “front” of the part will be written out.

When edges have been attributed in this way the Save Copy As command honors this by displaying this as a layer in the dialog to allow you to choose whether to write it out or not.  Notice in the picture below that the last layer in the list is “CustomLayer” which is the name that was assigned using the macro above.

 

These layer overrides are also honored when using the API to write out a DXF or DWG file of the flat pattern.  The program below is directly from Inventor’s online help and illustrates using the API to write out a DXF file of the flat pattern.  See the topic on the DataIO object in the online help for additional information about this.

Public Sub WriteSheetMetalDXF()
    ' Get the active document.  This assumes it is a part document.
    Dim oDoc As PartDocument
    Set oDoc = ThisApplication.ActiveDocument

    ' Get the DataIO object.
    Dim oDataIO As DataIO
    Set oDataIO = oDoc.ComponentDefinition.DataIO

    ' Build the string that defines the format of the DXF file.
    Dim sOut As String
    sOut = "FLAT PATTERN DXF?AcadVersion=R12"

    ' Create the DXF file.
    oDataIO.WriteDataToFile sOut, "C:\temp\flat.dxf"
End Sub

If attributes are something new to you watch this blog over the next couple of weeks for additional postings explaining attributes in more detail.

Positioning Assembly Occurrences

Rob Cohee recently posted a video demonstrating some skeletal modeling techniques in Inventor related to .  To simplify the process he used a VBA macro that I wrote for him.  It’s a simple macro and is useful by itself but also helps to demonstrate some API capabilities.  Here’s the macro that I provided Rob.

Public Sub AlignOccurrencesWithConstraints()
    Dim assemblydoc As AssemblyDocument
    Set assemblydoc = ThisApplication.ActiveDocument

    ' Get the occurrences in the select set.
    Dim occurrenceList As New Collection
    Dim entity As Object
    For Each entity In assemblydoc.SelectSet
        If TypeOf entity Is ComponentOccurrence Then
            occurrenceList.Add entity
        End If
    Next

    If occurrenceList.Count < 2 Then
        MsgBox "At least two occurrences must be selected."
        Exit Sub
    End If

    ' This assumes the first selected occurrence is the "base"
    ' and will constrain the base workplanes of all the other parts
    ' to the base workplanes of the first part. If there are
    ' constraints on the other they end up being over constrained.

    ' Get the planes from the base part and create proxies for them.
    Dim baseOccurrence As ComponentOccurrence
    Set baseOccurrence = occurrenceList.Item(1)

    Dim BaseXY As WorkPlane
    Dim BaseYZ As WorkPlane
    Dim BaseXZ As WorkPlane
    Call GetPlanes(baseOccurrence, BaseXY, BaseYZ, BaseXZ)

    Dim constraints As AssemblyConstraints
    Set constraints = assemblydoc.ComponentDefinition.constraints

    ' Iterate through the other occurrences
    Dim i As Integer
    For i = 2 To occurrenceList.Count
        Dim thisOcc As ComponentOccurrence
        Set thisOcc = occurrenceList.Item(i)

        ' Move it to the base occurrence so that if the base is
        ' not fully constrained it shouldn't move when the flush
        ' constraints are added.
        thisOcc.Transformation = baseOccurrence.Transformation

        ' Get the planes from the occurrence
        Dim occPlaneXY As WorkPlane
        Dim occPlaneYZ As WorkPlane
        Dim occPlaneXZ As WorkPlane
        Call GetPlanes(thisOcc, occPlaneXY, occPlaneYZ, occPlaneXZ)

        ' Add the flush constraints.
        Call constraints.AddFlushConstraint(BaseXY, occPlaneXY, 0)
        Call constraints.AddFlushConstraint(BaseYZ, occPlaneYZ, 0)
        Call constraints.AddFlushConstraint(BaseXZ, occPlaneXZ, 0)
    Next
End Sub

' Utility function used by the AlignOccurrencesWithConstraints macro.
' Given an occurrence it returns the base work planes that are in
' the part or assembly the occurrence references.  It gets the
' proxies for the planes since it needs the work planes in the
' context of the assembly and not in the part or assembly document
' where they actually exist.
Private Sub GetPlanes(ByVal Occurrence As ComponentOccurrence, _ 
                      ByRef BaseXY As WorkPlane, _ 
                      ByRef BaseYZ As WorkPlane, _ 
                      ByRef BaseXZ As WorkPlane)
    ' Get the work planes from the definition of the occurrence.
    ' These will be in the context of the part or subassembly, not 
    ' the top-level assembly, which is what we need to return.
    Set BaseXY = Occurrence.Definition.WorkPlanes.Item(3)
    Set BaseYZ = Occurrence.Definition.WorkPlanes.Item(1)
    Set BaseXZ = Occurrence.Definition.WorkPlanes.Item(2)

    ' Create proxies for these planes.  This will act as the work
    ' plane in the context of the top-level assembly.
    Call Occurrence.CreateGeometryProxy(BaseXY, BaseXY)
    Call Occurrence.CreateGeometryProxy(BaseYZ, BaseYZ)
    Call Occurrence.CreateGeometryProxy(BaseXZ, BaseXZ)
End Sub

The program above constrains the base work planes of the set of selected occurrences to the base work planes of one other selected occurrence (the base part).  It places three flush constraints between each part and the base part.  The advantage to this is that the occurrences are all constrained to the base part so that if the base part is repositioned all of the other parts will automatically move to maintain the relationship defined by the constraints.  The disadvantage is that it’s doing quite a bit of work and each constraint placement causes the assembly to recompute, which is what gave Rob time to go get coffee.

There’s another approach that is much faster if you just need to position parts but don’t need to associate their position to another part.  The macro below does this.  It’s simpler and runs much faster.  This macro positions the parts exactly as the previous macro but instead of creating constraints it just repositions them and then grounds them so they can’t be accidentally moved.

Public Sub AlignOccurrencesWithGround()
    Dim assemblydoc As AssemblyDocument
    Set assemblydoc = ThisApplication.ActiveDocument

    ' Get the occurrences in the select set.  The first occurrence
    ' selected will be the "base" where all of the other occurrences
    ' will be positioned relative to it.
    Dim baseOccurrence As ComponentOccurrence
    Dim baseTransform As Matrix
    Dim transObjects As TransientObjects
    Set transObjects = ThisApplication.TransientObjects
    Dim occList As ObjectCollection
    Set occList = transObjects.CreateObjectCollection
    Dim transformList As ObjectCollection
    Set transformList = transObjects.CreateObjectCollection
    Dim entity As Object
    For Each entity In assemblydoc.SelectSet
        ' Check that the selected entity is an occurrence.
        If TypeOf entity Is ComponentOccurrence Then
            ' Check if the base occurrence has been assigned.
            ' If not then this is the first occurrence found and
            ' use it as the base occurrence.
            If baseOccurrence Is Nothing Then
                Set baseOccurrence = entity
                Set baseTransform = baseOccurrence.Transformation
            Else
                ' This is another selected occurrence so just
                ' add it to the list.
                occList.Add entity
                transformList.Add baseTransform
            End If
        End If
    Next 

    ' Check that at least a base occurrence and one other occurrence
    ' was selected.
    If occList.Count < 1 Then
        MsgBox "At least two occurrences must be selected."
        Exit Sub
    End If

    ' Reposition all of the occurrences.  The TransformOccurrences
    ' method was new in Inventor 2009.
    Dim assemblyDef As AssemblyComponentDefinition
    Set assemblyDef = assemblydoc.ComponentDefinition
    Call assemblyDef.TransformOccurrences( occList, _
                                           transformList)

    ' Iterate through the occurrences and ground them.
    Dim i As Integer
    For i = 1 To occList.Count
        Dim thisOccurrence As ComponentOccurrence
        Set thisOccurrence = occList.Item(i)
        thisOccurrence.Grounded = True
    Next
End Sub

Here’s one final version of this macro that is still even simpler.  In the two previous macros the selected occurrences were moved relative to the location of the first selected occurrence.  The macro below moves every occurrence to be positioned relative to the base assembly coordinate system.  It doesn’t rely on selection but repositions every occurrence and grounds it.

Public Sub AlignOccurrencesWithOrigin()
    Dim assemblyDoc As AssemblyDocument
    Set assemblyDoc = ThisApplication.ActiveDocument
    Dim assemblyDef As AssemblyComponentDefinition
    Set assemblyDef = assemblyDoc.ComponentDefinition

    ' Create a matrix.  It is initialized as an identity matrix
    ' which means it defines a position as the origin and aligned
    ' with the global x, y, and z axes.
    Dim transGeom As TransientGeometry
    Set transGeom = ThisApplication.TransientGeometry
    Dim baseTransform As Matrix
    Set baseTransform = transGeom.CreateMatrix

    ' Create collections to load the occurrences into.
    Dim transObjects As TransientObjects
    Set transObjects = ThisApplication.TransientObjects
    Dim occList As ObjectCollection
    Set occList = transObjects.CreateObjectCollection
    Dim transformList As ObjectCollection
    Set transformList = transObjects.CreateObjectCollection

    ' Iterate through all of the occurrences.
    Dim occurrence As ComponentOccurrence
    For Each occurrence In assemblyDef.Occurrences
        ' Add each occurrence to the list.
        occList.Add occurrence

        ' Add the transform to the list.
        transformList.Add baseTransform

        ' Ground each occurrence.  This is ok to do here
        ' because the move will ignore the ground condition.
        occurrence.Grounded = True
    Next

    ' Reposition all of the occurrences.  The TransformOccurrences
    ' method was new in Inventor 2009. 
    Set assemblyDef = assemblydoc.ComponentDefinition
    Call assemblyDef.TransformOccurrences(occList, _
                                           transformList)
End Sub

Of course these macros just the demonstrate one solution using the API to a specific problem.  The same functionality demonstrated above and combined with other API functions can be used in many other ways to solve other problems.  All I’m trying to say is that if the macros above don’t quite do what you need them to do it’s time to start investigating Inventor’s API so that you can modify them to solve your specific problems.