Mod the Machine

Plug-In of the Month – Feature Migrator for Inventor

A new plug-in of the month has just been posted at Autodesk Labs.  This one is called Feature Migrator for Inventor.  What it does is transfer assembly features down into the parts they affect.

Philippe Leefsma, one of the engineers that supports members of the Autodesk Developer Network (ADN) wrote this one.  Philippe has put a lot of thought and effort into this application.  Here’s a shot of the browser that’s displayed when you run the application.  It displays the assembly features that are valid for transfer.  This picture shows several of the features selected and the “Send to Parts” option selected.

The documentation that comes with the download describes the add-in and its features.  You can download it from here: http://labs.autodesk.com/utilities/ADN_plugins/

How to Time an Operation and Optimizing Code

I’ve found it beneficial to time how long it takes portions of my programs to run and in particular when a program takes longer to run than I initially expected.  Timing the different portions of a program tells you where the program is taking the most time and sometimes will help you find issues with your logic or how you’re using the API so you can make improvements to the execution time of your program.  Determining where your program spends time processing is referred to as profiling.  Some development environments provide profiling utilities and there are also 3rd party profilers available.  There’s no profiling functionality built-in to VBA so you’ll have to do something on your own.  Here’s the process I’ve used for several years to profile my VBA code.

First, I’ve created a small timer class.  I’ve found this easier to use and much more accurate than trying to use built-in VBA functions to get the current time.  Here’s the code for my timer class.

Private Declare Function QueryPerformanceFrequency _
            Lib "kernel32" (lpFrequency As Currency) As Long
Private Declare Function QueryPerformanceCounter _
            Lib "kernel32" (lpPerformanceCount As Currency) As Long

Private ConversionFactor As Currency
Private CurrentStartTime As Currency


Public Sub Start()
    Dim iReturn As Long
    iReturn = QueryPerformanceCounter(CurrentStartTime)
End Sub


Private Sub Class_Initialize()
    Dim iReturn As Long
    iReturn = QueryPerformanceFrequency(ConversionFactor)
End Sub


Public Property Get CurrentTime() As Double
    Dim NewTime As Currency
    Dim iReturn As Long
    iReturn = QueryPerformanceCounter(NewTime)
    Dim TotalTime As Currency
    TotalTime = NewTime - CurrentStartTime
    CurrentTime = TotalTime / ConversionFactor
End Property

To add the code above to your VBA project, run the Class Module command from the Insert menu.  This will create a new, empty class module.  Copy and paste the code above into the new module.

Rename the class module to “clsTimer”  Do this by selecting the class module in the Project Explorer tree and then editing the name in the Properties window, as shown below.

Now you can use this class to time portions of your code.  Here’s a simple example.  This creates two instances of the timer class.  One that will be used to time small portions of the program and another that will be used to time the overall execution.  After creating a timer you call the Start method to begin timing.  At any time you can use the timer’s CurrentTime property to get the elapsed time.  You can also call the Start method again to restart the timer.  The value returned is the number of seconds that have elapsed since the timer started.  I use the VBA Format function to control the number of decimal places displayed.

Public Sub TimerExample() 
    ' Create and start a timer for the total time.
    Dim timerAll As New clsTimer
    timerAll.Start

    ' Create and start a timer for individual times.
    Dim timer As New clsTimer
    timer.Start

    ' Time creating an assembly document. 
    Dim doc As Document
    Set doc = ThisApplication.Documents.Add(kAssemblyDocumentObject)
    Debug.Print "Assembly: " & Format(timer.CurrentTime, "0.000000")

    ' Restart the timer.
    timer.Start

    ' Time creating a drawing document.
    Set doc = ThisApplication.Documents.Add(kDrawingDocumentObject)
    Debug.Print "Drawing: " & Format(timer.CurrentTime, "0.000000")

    ' Restart the timer.
    timer.Start

    ' Time creating a part document.
    Set doc = ThisApplication.Documents.Add(kPartDocumentObject)
    Debug.Print "Part: " & Format(timer.CurrentTime, "0.000000")

    ' Display the total time. 
    Debug.Print "Total: " & Format(timerAll.CurrentTime, "0.000000")
End Sub

Here’s another example that puts this into practice to try and optimize a program.  It gets all of the faces from the active part.

Public Sub GetFaces1()
    ' Get the first body from the active part. 
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    Dim body As SurfaceBody
    Set body = partDoc.ComponentDefinition.SurfaceBodies.Item(1)

    ' Create a timer
    Dim timer As New clsTimer

    ' Start the timer.
    timer.Start

    ' Iterate through the faces using the Item property.
    Dim oFace As Face
    Dim i As Integer 
    For i = 1 To body.Faces.Count
        Set oFace = body.Faces.Item(i) 
    Next

    Debug.Print "Time for " & body.Faces.Count & " faces: " & _
                 Format(timer.CurrentTime, "0.000000")
End Sub

This results in the following being printed to my Immediate window:

Time for 1264 faces: 41.421942

It takes forty-one seconds to iterate over the faces in the body.  Let’s look at some things that can be done to improve the performance. 

A common coding method, particularly in VB/VBA, is to string multiple calls together in a single line.  This is done in the code above in a few places.  The first is where it gets the SurfaceBody object.  It does this by calling the ComponentDefinition property of the PartDocument object, and then calls the SurfaceBodies property on the PartComponentDefinition object that’s returned, and finally calls the Item property on the returned SurfaceBodies object.  There are three API calls within that single line.  It’s ok in this case since it’s only executed once, but sometimes you can do excessive processing when these are within loops.

Another line where there are multiple calls being made is the one within the For loop where it’s getting the Face.  In this case, this line is being call 1264 times.  Here’s a modified version where the SurfaceBodies object is obtained once, outside the loop and then used within the loop to get each face.  The new and modifies lines are highlighted in red.

Public Sub GetFaces2() 
    ' Get the first body from the active part. 
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    Dim body As SurfaceBody
    Set body = partDoc.ComponentDefinition.SurfaceBodies.Item(1)

    ' Create a timer
    Dim timer As New clsTimer

    ' Start the timer.
    timer.Start

    ' Iterate through the faces using the Item property.
    Dim oFace As Face
    Dim i As Integer  
    Dim oFaces As Faces
    Set oFaces = body.Faces
    For i = 1 To body.Faces.Count 
        Set oFace = oFaces.Item(i) 
    Next

    Debug.Print "Time for " & body.Faces.Count & " faces: " & _
                 Format(timer.CurrentTime, "0.000000")
End Sub

This results in the following being printed to my Immediate window:

Time for 1264 faces: 0.217899

We went from over 40 seconds down to less than one second.  This is over 190 times faster than the previous code, and a huge improvement.  Don’t always expect improvements like this, but taking the time to do a little profiling can often result in some time improvements.

There’s one more thing that can be done that might help with performance.  Instead of using the For statement to go from 1 to Count we can use the For Each statement.  This can result in better performance and also creates cleaner, easier to read code.

Public Sub GetFaces3() 
    ' Get the first body from the active part. 
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    Dim body As SurfaceBody
    Set body = partDoc.ComponentDefinition.SurfaceBodies.Item(1)

    ' Create a timer
    Dim timer As New clsTimer

    ' Start the timer.
    timer.Start

    ' Iterate through the faces using the Item property.
    Dim oFace As Face 
    For Each oFace in body.Faces
    Next

    Debug.Print "Time for " & body.Faces.Count & " faces: " & _
                 Format(timer.CurrentTime, "0.000000")
End Sub

This results in the following being printed to my Immediate window:

Time for 1264 faces: 0.060036

This is an improvement of about 3.5 times over the earlier time.

Update to Thumbnail Component

In my previous post I described how to access thumbnail images in Inventor documents.  At the bottom of that post is a link to an updated version of a component that provides access to thumbnails.  A problem has been reported since I posted that code and has now been fixed. 

It’s likely that most of you would have never noticed the problem, since it is a bit obscure.  The issue was with how the component was registering itself.  It was registering itself in the Current User portion of the registry which meant only the user that it was registered for would have access to the component.  In the problem that was reported, they were running Win7 and the application that was using the component needed to run as an administrator.  Running as an administrator looks at a different portion of the registry so the application couldn’t find the thumbnail component and would fail.  The fix changes the component so it is now registered for everyone.  Please see the readme for details on how to register it.

I updated the previous post so the link at the bottom is to the new version of the component and you can also access here.

Accessing Thumbnail Images

I’ve had a few recent posts that have talked briefly about using thumbnail images (Document Thumbnails and Button Icons, Parts List with Thumbnail Image, and Accessing iProperties).  If you need to get a thumbnail image from an Inventor document there are several possibilities.  I want to briefly cover those here.

Thumbnail as an iProperty
The thumbnail is stored as an iProperty within an Inventor document.  One way to access the thumbnail is as an iProperty.  The following VBA code accesses the thumbnail as an iProperty and writes it as a bmp file to disk.  (This code won’t work on a 64-bit Inventor because of the issues discussed in this post.)

Public Sub WriteThumbnail()
    ' Get the currently active document.
    Dim doc As Document
    Set doc = ThisApplication.ActiveDocument

    ' Get the Summary Information property set.
    Dim summaryInfo As PropertySet
    Set summaryInfo = doc.PropertySets.Item( _
                                     "Inventor Summary Information")

    ' Get the thumbnail property.  When using VBA, this will
    ' only work with 32-bit Inventor.
    Dim thumbProp As Property
    Set thumbProp = summaryInfo.Item("Thumbnail")

    ' Get the thumbnail image.
    Dim thumbnail As IPictureDisp
    Set thumbnail = thumbProp.Value

    ' Check that an image was returned.  It's possible for a
    ' file to not have a thumbnail.
    If Not thumbnail Is Nothing Then
        ' Write the thumbnail to disk.
        Call SavePicture(thumbnail, "C:\Temp\Thumb.bmp")
    Else
        MsgBox "The active document doesn't have a thumbnail."
    End If
End Sub

Because Apprentice provides access to iProperties, you can use it instead of Inventor to access the thumbnail.  Below is some VB.Net code that uses Apprentice to read a thumbnail from an Inventor document and display it within a picture box.

To use the code below, create a new “Windows Form Application”.  On the form add a button (Button1) and a picture box (PictureBox1).  Set the SizeMode property of the picture box to StretchImage.  My dialog is shown below.

You’ll also need to add references to the following components using the .Net tab of the Add Reference dialog:

Autodesk.Inventor.Interop
Microsoft.VisualBasic.Compatibility
stdole

Here’s my implementation for the form and the button click sub.

Imports Inventor
Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of Apprentice. 
      Dim apprentice As New ApprenticeServerComponent

      ' Open a document. 
      Dim doc As ApprenticeServerDocument 
      doc = apprentice.Open("C:\Temp\Part1.ipt") 

      ' Get the Summary Information property set. 
      Dim summaryInfo As PropertySet 
      summaryInfo = doc.PropertySets.Item( _
                                    "Inventor Summary Information") 

      ' Get the thumbnail property. 
      Dim thumbProp As Inventor.Property 
      thumbProp = summaryInfo.Item("Thumbnail") 

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = thumbProp.Value 

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

And here’s the result.

Document.Thumbnail Property
There’s another way you can get the thumbnail that’s simpler than going through the iProperty objects.  Both the Document and ApprenticeServerDocument objects  support the Thumbnail property.  Here’s a modified version of the program above that uses the Thumbnail property.

Imports Inventor
Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of Apprentice. 
      Dim apprentice As New ApprenticeServerComponent

      ' Open a document. 
      Dim doc As ApprenticeServerDocument 
      doc = apprentice.Open("C:\Temp\Part1.ipt")  

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = doc.Thumbnail

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

A big difference between using the Document.Thumbnail property and accessing the thumbnail as an iProperty is that the Document.Thumbnail property is read-only while the iProperty is writable.  This means you can push any image you would like into the iProperty to be used as the thumbnail for that document.  However, this is only supported in Inventor and setting the value of the thumbnail iProperty will fail when using Apprentice.

ThumbnailView Component
There’s one other way of accessing a thumbnail.  Because iProperties are stored using some Microsoft standards, it’s possible to use Windows functionality to directly access the thumbnail without using Inventor or Apprentice.  It requires some more advanced programming to do it this way, so to make it easier there’s a  component delivered as part of the Inventor SDK that you can use rather than write the code yourself.  The source code is also provided to serve as a sample for those that want to include this functionality within their applications.

To use this component you need to first install the DeveloperTools.msi package.  This is in the Inventor SDK directory (C:\Program Files\Autodesk\Inventor 2011\SDK on WinNT and C:\Users\Public\Documents\Autodesk\Inventor 2011\SDK on Vista or Win7).  Installing this will create an SDK\DeveloperTools\Tools\ThumbnailView directory that contains the component, its source code, and some samples demonstrating its use.

To use the component, go into the Bin directory and run the Register.bat file to register the component.  In your project where you’ll be using the component you’ll need to add a reference to it.  I typically use the Browse option and browse to the InventorThumbnailView.dll file.  Here’s a version of the previous program that uses this component to get the thumbnail.

Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of the ThumbnailProvider component.
      Dim thumbView As New InventorThumbnailViewLib.ThumbnailProvider

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = thumbView.GetThumbnail("C:\Temp\Part1.ipt")

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

One thing important to notice is that there’s no longer a reference to the Inventor component required since this isn’t using the Inventor API.

Inventor 2011 and ThumbnailView
The ThumbnailView component has been provided as a sample for several releases of Inventor.  However, an issue was discovered soon after Inventor 2011 was shipped where it was found the component doesn’t work with Inventor 2011 files.  In Inventor 2011 a change was made to how the thumbnail image is stored within the iProperty value.  Previously to Inventor 2011 it was stored as a bmp image.  In Inventor 2011 it’s now saved as a png image.  All of the other functionality that deals with the thumbnail, iProperties and the Document.Thumbnail property, were updated to account for this change.  However, the ThumbnailView utility slipped through the cracks and was not updated.  You can access an updated version of the component here that works with Inventor 2011 and previous files.