Mod the Machine

Learning About New Functionality in Inventor 2011

For those of you in the US and Canada there’s a free virtual event for you to learn more about the new features in the latest release of products.  Here’s the brief description I was given.

It’s here — your chance to preview all the new ways that Autodesk 2011 software can help you transform your business challenges into new opportunities.  Attend Autodesk’s free Seize the Opportunity Virtual Event.

Monday, April 19, 2010
7:00 a.m.–2:00 p.m. PT

Get access to exclusive sessions and live demonstrations, including:

• How to achieve greater speed, power and flexibility using AutoCAD 2011 software
• Going beyond 3D to Digital Prototyping with Autodesk® Inventor® software
• Delivering building projects more economically and with minimal environmental impact using Autodesk® Revit® software for building information modeling (BIM).
• Delivering transportation and environmental engineering projects faster with AutoCAD® Civil 3D® software.
• How Autodesk Digital Entertainment Creation software can open new opportunities for creativity and give you a competitive edge.

Explore all the new opportunities that Autodesk 2011 software can offer you. Register for the free Seize the Opportunity Virtual Event today at www.autodesk.com/seizetheopportunity

Sorry to those of you in other countries.  I assume there will be similar events for you.

Manufacturing DevCamp 2010 and DevLab

Registration is now open for the Manufacturing DevCamp on June 2-4, 2010 in Portland, Oregon.  You can register here and get more information here. DevCamp is a three-day conference for both beginners and experts interested in learning more about extending the capabilities of Autodesk Inventor through its API. The day before the conference begins and throughout the rest of the week, we’ll also be hosting a DevLab.  A DevLab This is a great opportunity to bring your project in and get advice on any issues you might be having.  (Here’s a more detailed description of what a DevLab is.)

DevCamp – June 2-4, 2010, Portland, Oregon
DevLab – June 1, 2010, Lake Oswego, Oregon

During the three days, we will have several keynote talks, (including Manufacturing Senior Vice President Buzz Kross), and will be holding more than 20 sessions on the various manufacturing related products, most of which are targeted at Inventor.  The classes will be taught by DevTech engineers (those that support ADN developers) and also some of us from the Inventor engineering team.  Here’s an overview of the classes (with a full agenda here):

Beginner

• Introduction to .NET programming for non-programmers
• Introduction to the Inventor API – parts 1, 2, 3 and 4
• Introduction to Vault programming
• AutoCAD Mechanical customization
• Working with large machines and factories?  An introduction to the Navisworks API

Expert

• Working with solids through the Inventor API
• Creating custom commands in Inventor
• The Vault client and job processor API’s
• Advanced Vault programming
• Inventor API customization case studies
• In-depth review of the Inventor 2011 API’s – Part 1 and 2

Sharing

• The Doctor is in: bring your challenges and problems and get expert advice/help
• Talk to the Inventor product managers
• Talk to the Inventor API designer and developers

Business

• Teaming with the Autodesk sales team and Autodesk Authorized Resellers
• Leveraging your relationship with Autodesk to grow your business
• Understanding Autodesk mergers and acquisitions

A large portion of the Inventor development team works from an office in Lake Oswego, Oregon, (about 10 miles southwest of Portland).  This makes it possible for senior management and the Inventor engineering team to participate in the event and provides a great opportunity for you to meet them and discuss your trials and triumphs with Autodesk software.

If you haven’t been to Portland before there’s a lot to see in the area so hopefully you can spare a little more time outside the conference and do some site-seeing.

If any of you are cyclists, the Pioneer Century ride is on June 5th (the Saturday following the conference) and will let you experience some of Oregon at a more relaxed pace than a car. I’ll be riding the 100 mile option if anyone wants to join in.

Here are some links for some more things to see and do in the Portland area:

General Portland Info

Multnomah Falls and the Columbia River Gorge

Portland's Saturday Market

Mt. Saint Helens National Volcanic Monument

Mt. Hood

Oregon Coast

Autodesk Inventor 2011 New Functionality

With respect to the API, the http://www.autodesk.com/developinventor website has been updated with the information for Inventor 2011.  There is a PowerPoint presentation that goes through the new API features and also a set of demo files, including sample code, that demonstrates many of the new features.

To learn about new non-API functionality in Inventor 2011 you can attend a virtual event that Autodesk is hosting. It’s Monday, April 19th, 2010 from 7am–2pm Pacific time.  Register for this event at http://www.autodesk.com/seizetheopportunity

VBA Code Writing Tip

This week has been busy and left me with little time to work on finishing up some posts I’ve been working on.  Here’s a quick tip that can make coding in VBA or VB6 a little easier.  Maybe you already know about it, but it’s something I didn’t learn about until I had been using VBA and VB6 for several years.

When you’re entering code in a VBA code window you get Intellisense help when accessing methods and properties on objects.  VB.Net uses intellisense to help you when typing variable names.  You can also get help with variable names in VBA, it’s just not automatic like it is in VB.Net.  When you’ve typed the first few characters of a variable, press ctrl-space and the intellisense window will display showing you the available variable names that match the characters you’ve typed in so far.  You can continue typing to narrow down the list or choose one from the list.  Once you’ve selected one from the list by clicking with the mouse or using the arrow keys, press the tab key to use it.  An example of its use is shown below.

The written description makes it sound like a bit difficult to use with a lot of steps  but it quickly became second nature for me and has saved me a lot of typing.

Autodesk University Class Proposals

The invitation to submit proposals for this years Autodesk University was sent out earlier this week.  Do you have a topic you think would be interesting to a lot of other Inventor users?  Now's the time to start thinking about it.  The deadline for proposals is May 14th.

If you don’t have an idea for a class or teaching a class isn’t your thing, what would you like to hear from others?  Remember that AU isn’t limited to those few that can attend in Las Vegas; there are the new virtual sessions that are available online and the papers from the classes benefit everyone.  So even if you can’t attend in Las Vegas you should still care about the topics covered.  If you have any ideas for API specific or general Inventor classes please let me know.  I’ll pass any ideas onto other experts that might be interested in teaching your suggested classes.  It’s always difficult to come up with new topics each year so any input is appreciated.

Material from the Free Online API Class

I mentioned before in the previous post about the free online API training class that the material would be posted online.  The material is currently available as a single zip file that contains the videos, slides, and labs for the sessions that have been completed so far.  This zip file will be added to each week with the material presented during the most recent session.  The final session is currently scheduled for May 6, 2010.  If the format or location for this delivery changes, I’ll add a new post describing the changes.

Flattening an Assembly

I had an internal request recently for a utility to take any assembly and create an equivalent single-level assembly.  In this particular case they had a large assembly whose structure didn’t make sense for their current use and the structure made it difficult to delete individual components.  By flattening the assembly they’re now able to quickly remove portions of the assembly and get something they can begin working with.  In this specific case, to begin building fixtures around it.

Here’s the VBA macro code that does the flattening.  (I had to add some line continuations that I wouldn’t normally use to get the code to fit within the narrow space I have here.)

' Macro that creates a new assembly that represents a flattened
' version of the current active assembly.  The result is a single
' level assembly of occurrences.  There are not constraints and
' each occurrence is grounded.
Public Sub FlattenAssembly() 
   ' Get the active assembly. 
   Dim sourceAsmDoc As AssemblyDocument 
   On Error Resume Next 
   Set sourceAsmDoc = ThisApplication.ActiveDocument 
   If Err Then 
  MsgBox "An assembly must active." 
  Exit Sub 
   End If 
   On Error GoTo 0

   ' Create the new, empty assembly. 
   Dim targetAsmDoc As AssemblyDocument 
   Set targetAsmDoc = ThisApplication.Documents.Add( _
  kAssemblyDocumentObject, _
  ThisApplication.FileManager.GetTemplateFile( _
  kAssemblyDocumentObject))

   ' Traverse through the existing assembly getting 
   ' each leaf component and creating an occurrence 
   ' in the new assembly that represents it. 
   Call CopyAssemblyAsFlat(targetAsmDoc.ComponentDefinition, _ 
   sourceAsmDoc.ComponentDefinition.Occurrences)
End Sub



' Utility sub used by FlattenAssembly macro.  This sub is call
' recursively to traverse an entire assembly.  It creates new
' top-level occurrences in the target assembly to represent each
' of the occurrences found in the source assembly.
'
' TargetAsm - The component definition of the target assembly.
' Occurrences - The occurrences collection of the assembly
' to traverse.
Private Sub CopyAssemblyAsFlat( _
   TargetAsm As AssemblyComponentDefinition, _ 
   Occurrences As ComponentOccurrences) 
   ' Iterate through the occurrences in the current level 
   ' of the assembly. 
   Dim occ As ComponentOccurrence 
   For Each occ In Occurrences 
  ' Skip any invisible, suppressed, or excluded components. 
  If occ.Visible And Not occ.Suppressed And _
  Not occ.Excluded Then 
' Check to see if this occurrence is a part or assembly. 
If occ.DefinitionDocumentType = kPartDocumentObject Then 
    ' Create an occurrence in the target assembly 
    ' for this part. 
    Dim newOcc As ComponentOccurrence 
    Set newOcc = _
   TargetAsm.Occurrences.AddByComponentDefinition( _ 
occ.Definition, occ.Transformation) 
    newOcc.Grounded = True 
Else 
    ' Recursively call this sub to continue 
    ' traversing the assembly. 
    Call CopyAssemblyAsFlat(TargetAsm, occ.SubOccurrences) 
    End If 
End If 
   Next
End Sub

The macro uses somewhat of a brute force method.  It creates a new, empty assembly, traverses the existing assembly to determine what parts are used and where they’re located and then reconstructs the original assembly by placing parts in the new assembly.  The parts are positioned correctly in the new assembly but there aren’t any constraints and they’re all grounded.

You can see that there’s really not much code needed to do this.  It’s actually just a variation of the assembly traversal code from a previous post.

Update (March 29, 2010)
A couple of limitations with the program have been pointed out to me and are worth noting.

1. All assembly features are lost.
2. All weldment data is lost (preparations, welds, finishing).

Luckily I don’t believe these are an issue in most cases where the program would be used, but in case you do have assembly features or weldments you should be aware of these limitations.

iProperty Performance

Here’s some performance data regarding using Inventor and Apprentice to work with iProperties.  I found this interesting and think it will be useful when architecting your programs so you fully understand the advantages and disadvantages of different approaches.

All of the test results shown below are for processing 1000 unique files.

Test 1 – Open, Edit, Save, Close
This test opened each of the 1000 files, edited the value of two iProperties, saved the document, and closed it.

1. Apprentice – 116 seconds.
2. Inventor (visible document) – 1068 seconds.  This test opened the documents visibly by setting the second argument of the Documents.Open method to True.
3. Inventor (invisible document) – 238 seconds.  This is the same as the test above but opens the documents invisibly by setting the second argument of the Documents.Open method to False.

The biggest difference is between opening the document visibly or invisibly.  When a document is opened invisibly, Inventor is able to optimize the open and not read all of the file.  Opening a file invisibly is similar to the time it takes in Apprentice, as shown by test 2 below.  However, for test 1 Apprentice is still twice as fast.  Two things account for the extra time spent by Inventor; changing the property value and saving the document.  Changing the value of an iProperty in Inventor is transacted, meaning that you can undo the operation.  Transacting has some overhead which accounts for some of the time.  Apprentice doesn’t have any transaction capabilities so it doesn’t have this overhead.  The other big difference is the save.  To save an iProperty change in Inventor you need to save the entire document using Document.Save.  In Apprentice you can save just the iProperty portion of the document using PropertySets.FlushToFile.

Test 2 – Open, Read, Close
This test also operated on all 1000 files by opening a file, reading property values, and closing the document.

1. Apprentice – 92.341 seconds
2. Inventor (invisible document) – 100.374 seconds

These numbers show that there isn’t a lot of difference between invisible Inventor and Apprentice when you don’t do anything that’s transacted and you don’t save the document.  This is particularly important for add-in writers to understand since you can’t use Apprentice within an add-in.

Test 3 – Open, Close
This test uses VB.Net to open and close the same 1000 files.  It opens a file, reads the file into memory, and closes the file.  It is a pure VB.Net program and has nothing to do with Inventor.  I wrote this program to help understand how much of the time is spent on general overhead of reading the file and how much time is spent by Inventor or Apprentice actually doing the work they need to do.  As you can see, most of the time used by Apprentice or Inventor is system overhead of opening and reading the file.  Anytime you have to read or write data to a hard drive, performance will be slow.

1. VB.Net – 77.69 seconds

Summary
If you need to write a utility to manipulate iProperties, using Apprentice will allow you to create the fastest program.  However, if you just need to read iProperty data, opening documents invisibly in Inventor is almost as fast and a good alternative.  Remember that Apprentice cannot be used within an add-in.  If you need to do a lot of iProperty processing (writing and saving) through an add-in it might be worth creating a separate exe that uses apprentice that your add-in uses.  You need to be careful that those documents are not currently open in Inventor.

Gotcha
Here’s something to watch out for when doing any timing tests like those above.  The first time I ran a test it was slow and subsequent runs were significantly faster.  For example, when I first ran test 2 with Inventor it took 100 seconds and then running the same test a second time only took 4 seconds.  Even test 3, which doesn’t have anything to do with Inventor went from 77 seconds for the first run down to 0.338 seconds for subsequent runs.  What’s happening is that Windows is caching data in memory in case the data is used again.  This is great if you are reusing data but I think in most workflows where you’re batch reading and updating iProperties this won’t be the case.  To get the times reported above I rebooted between each test to clear memory and force the data to be read from disk.

iProperties Without Inventor (Apprentice)

Continuing with the iProperty theme of some recent posts I want to talk about the ability to work with iProperties without using Inventor. You can do this using a component known as Apprentice. Apprentice doesn’t have a user-interface but is a component use can only use through programming. Apprentice is installed as part of Inventor and is also installed as part of Inventor View (www.autodesk.com/inventorview).  This means if Inventor or Inventor View is installed on a machine you’ll have access to the Apprentice component and any Apprentice dependent program will work.  The fact that it’s available with Inventor View is interesting since Inventor View is free.

What is Apprentice?
Apprentice is a programming component that provides access to Inventor files.  Using Apprentice you can open Inventor files, query information from them, and in a few cases, edit data.  Apprentice supports a small subset of the functionality that Inventor supports and is primarily read-only with just a few exceptions.  The primary things it provides access to are:

• Geometry of solids and surfaces (B-Rep)
• Assembly structure
• File references
• Bill Of Material
• Printing
• Attributes
• iProperties

You’ll notice that there are a lot of things missing.  Apprentice is designed to be smaller and faster than Inventor and achieves this by providing having less code and operating on smaller portions of a document.  Even things that are exposed in Apprentice will often have limitations that aren’t present in Inventor.  For example, let’s say you have an extrude feature that you’ve added an attribute to in Inventor.  Using Apprentice, you can open that part and you can query for all attributes and get the attribute set associated with the feature.  However when you try and get the feature from the attribute set it’s not available because Apprentice doesn’t support features.  Apprentice is good at what it does but does have limitations you need to be aware of before attempting to use it in a project.

Using Apprentice
Apprentice uses much of the same code and components as Inventor.  Because of this there are conflicts if you try running both of them within the same process.  Remember that Apprentice always runs within the process of another program.

This means:

• You can’t use Apprentice with Inventor’s VBA.
• You can’t use Apprentice in an Add-In.

Using VBA within another application, for example Excel, is ok since Apprentice will be running within the Excel process and not Inventor’s process.  Another common use of Apprentice is within standalone exe programs where Apprentice will be running within the exe process.  The example that part of this post is a standalone exe.

Another limitation of Apprentice is that it can’t migrate files.  Migration occurs when you open a file that is older than the current version of Inventor.  For example, if I have an Inventor 2009 file on disk and open it with Inventor 2010 the data is migrated to the current version of Inventor.  Inventor is smart and only migrates what’s necessary based on what you’re currently doing with the file.  However, if you save the file, the entire file must be migrated to the current version before it is saved.  Apprentice can open and query older files but nothing can be changed and saved because that would require migration.  You can use the NeedsMigrating property to determine if a file can be edited and saved.  This is demonstrated in the sample at the bottom of this post.

Connecting to Apprentice
Here’s an example of how to use Apprentice within a VB Express Windows forms application.  To enable the use of Apprentice in your program you need to add a reference to the Inventor Object Library.  The Inventor Object Library is used for both Inventor and Apprentice even though Apprentice only supports a small subset of the entire library.  You can add the reference using the Project | Add Reference… command.  In the example below I’ve select the version 14.0.0 (Inventor 2010) interop.

Below is the minimum code needed to load Apprentice.  This declares and creates a new ApprenticeServerComponent object.  The ApprenticeServerComponent object is similar to the Inventor Application object.  It is the top-level object for Apprentice.

Dim apprentice As New Inventor.ApprenticeServerComponent

It’s also common to declare the variable and then create apprentice separately, like shown below.  I do this in the sample program where the variable is declared as a member variable so I can reuse it.

Dim apprentice As Inventor.ApprenticeServerComponent
apprentice = New Inventor.ApprenticeServerComponent

When you create the ApprenticeServerComponent object the Apprentice dll’s are loaded into your process and you can access the apprentice functionality through the properties and methods of the object.

Once you have an instance of the ApprenticeServerComponent, the next step is to open an Inventor document.  You do this using the Open method of the ApprenticeServerComponent object, as shown below.

' Open a file using Apprentice.
Dim apprenticeDoc As Inventor.ApprenticeServerDocument
apprenticeDoc = apprentice.Open(Filename)

Apprentice supports the ApprenticeServerDocument and ApprenticeServerDrawingDocument types.  The ApprenticeServerDocument object can represent all document types.  the ApprenticeServerDrawingDocument can be used to access some drawing specific functionality.

Using iProperties With Apprentice
Once you have the document, accessing iProperties is the same in Apprentice as it is in Inventor.  The example below gets the summary information property set and changes the value of the “Company” property.  The previous posts on using the API with iProperties also apply to Apprentice.

' Get the "Summary Information" property set. 
Dim summaryPropSet As Inventor.PropertySet 
summaryPropSet = apprenticeDoc.PropertySets.Item( _ 
                           "Inventor Document Summary Information") 

' Get the "Company" property. 
Dim companyProp As Inventor.Property 
companyProp = summaryPropSet.Item("Company")

' Change the value of the iProperty. 
companyProp.Value = "Widgets R Us"

Saving Changes With Apprentice
When you use Inventor to change iProperties, you save the changes by saving the document.  In Apprentice there’s a much more efficient way of saving iProperty changes.  Instead of saving the entire document it’s possible to just save the iProperties.  You do this using the FlushToFile method of the PropertySet object, as illustrated below.

' Save the iProperty changes. 
apprenticeDoc.PropertySets.FlushToFile()

Example Program
Here’s an example program written using Visual Basic 2008 Express.  It demonstrates the functionality discussed above.  It’s a simple program that gets all of the part files in a specified directory, changes an iProperty value and saves it.  Even though it’s simple it does demonstrates the functionality needed to access iProperties using Apprentice.  You’ll need to modify it to fit your specific requirements.

Document Thumbnails and Button Icons

I had a hard time deciding what to title this post since what I’m actually discussing here isn’t something that someone would likely be searching for.  The real topic is “Issues When Using the Inventor API Out-of-Process”.  The typical problems people run into because of out-of-process issues are when working with thumbnail or button images.

First, let’s define what it means to be running in-process versus out-of-process.  For our purposes, a process is an executable that’s running.  Inventor is an example of a process.  A windows executable that you write is also an example of a process.

When Inventor is running there is an Inventor process.  Add-ins, which are dll’s and not exe’s, are loaded within the Inventor process and are referred to as running in-process.  VBA is only available from Microsoft as a 32-bit component, so with 32-bit Inventor VBA also runs in-process.  This is illustrated in the picture below with both VBA and the Add-In running within Inventor’s process.

With 64-bit Inventor, VBA can’t be loaded since a 32-bit component can’t load within a 64-bit process.  To still allow customers the use of VBA on 64-bit machines, Inventor runs a separate 32-bit process which hosts VBA.  VBA then talks to Inventor through the API but is running out-of-process with respect to Inventor, as illustrated below.

So what does it matter if VBA is running in or out of Inventor’s process?  There are a couple of things this affects.  First, running out-of-process will be slower than in-process.  There’s more overhead in passing data back and forth between processes.  Second, is that bitmap data can’t be passed between two processes.  Inventor uses the Microsoft IPictureDisp object to represent bitmap data and it doesn’t support being passed between processes.

The VBA programs below both get the thumbnail image from the active document.  One uses the Document.Thumbnail property and the other uses the Thumbnail iProperty.  Both of them will work in 32-bit Inventor since VBA runs in-process but they will fail for 64-bit Inventor.  In the SaveThumbnail macro the failure happens when calling the Thumbnail property of the document because that is when the bitmap would be passed.  For the iProperty example, the failure occurs when calling the Value property of the Property object.  Any call that passes an IPictureDisp object won’t work when running out-of-process, including getting or setting icons for buttons.

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

    ' Get the thumbnail from the document.
    Dim thumb As IPictureDisp
    Set thumb = doc.Thumbnail

    ' Create the filename for the bmp file so it is the same
    ' as the document name but with a "bmp" extension.
    Dim filename As String
    filename = Left$(doc.FullFileName, Len(doc.FullFileName)-3)&"bmp"

    ' Save the thumbnail.
    Call SavePicture(thumb, filename)
End Sub

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

    ' Get the thumbnail from the document's iProperty.
    Dim oPropSet As PropertySet
    Set oPropSet = doc.PropertySets.Item( _
"Inventor Summary Information")
    Dim thumb As IPictureDisp
    Set thumb = oPropSet.Item("Thumbnail").Value

    ' Create the filename for the bmp file so it is the same
    ' as the document name but with a "bmp" extension.
    Dim filename As String
    filename = Left$(doc.FullFileName, Len(doc.FullFileName)-3)&"bmp"

    ' Save the thumbnail.
    Call SavePicture(thumb, filename)
End Sub

Here are some other examples where you can encounter out-of-process issues.  If you’ve written a windows application it will be a separate exe and will run as a separate process.  It can still use the Inventor API, but it will be out-of-process and because of this will not be able to access any bitmaps through the API.

 

Another example is using another product’s VBA.  For example, Excel is illustrated in the picture below.  Excel is it’s own process and it’s version of VBA is running in-process to Excel.  If Excel’s VBA is using Inventor’s API it will be accessing it out-of-process and will not have any access to bitmaps through the API.

Another way to access Inventor data is using Apprentice.  Apprentice is a programming only component and doesn’t have a user-interface and can’t run on its own but will always run in-process to its host application, (which is what you write).  In the example below, the primary application, Your.exe, has loaded Apprentice and Apprentice has opened a part document.  When using the Apprentice API (which is a subset of the Inventor API) you can successfully get the thumbnail because Apprentice is running in-process to your application and the IPictureDisp can be passed.

If you’ve seen the program from a previous post that creates a parts list with thumbnail images you might think that it’s breaking some of these rules.  It doesn’t, but these limitations did affect the choices I made as I arrived at the final design.  In that program, the code is an Inventor Add-in that reads the part list data from Inventor.  For each row in the parts list it accesses the associated document and gets the thumbnail.  Since the add-in is running in-process to Inventor there’s no problem to read the thumbnail.  As it processes each row and gets the thumbnail, it writes the thumbnail to disk.  It then accesses Word through it’s API.  This communication is out-of-process.  Using Word’s API it has Word insert the thumbnail into the table.  The Word API function to insert a bitmap into a table takes a filename as input.  Word uses this to read the bitmap from disk and insert it into the table.  The bitmap was never directly passed between Inventor and Word but went through the intermediate step of going to the disk.  If the Word function to place the bitmap into a table had taken an iPictureDisp as input the program would not have worked and I would have had to come up with some other solution.