Mod the Machine

Migrate Inventor templates

There is a difference between using a document as a template or just simply opening it. Especially in the case of drawing templates.

Inventor can open older documents created in previous versions of the software and then save them. That's what document migration is: opening an old document and saving it in the latest version of the software. You can find more information about it here.

Inventor documents have a property called NeedsMigrating, but it only tells you if the document needs to be saved before modifying its content. It does not say if it can be used as a template or not.

Just to be on the safe side, the best thing is to migrate an older document before trying to use it as a template - especially a drawing template. 

You can do all this in advance e.g. using Task Scheduler, or just-in-time as well - here's how.

You can check programmatically the Inventor version the drawing was last saved in. If it has not been migrated yet then you can just open, save and close it before using it as a template.

Here is a VBA sample:

Sub UseTemplate()
  Const templatePath = "C:\Temp\Template2021\Standard.idw"

  Dim templateVersion As SoftwareVersion
  Set templateVersion = ThisApplication.FileManager.SoftwareVersionSaved(templatePath)

  Dim inventorVersion As SoftwareVersion
  Set inventorVersion = ThisApplication.SoftwareVersion

  If inventorVersion.Major > templateVersion.Major Then
    ' Migrate drawing template before using it
    Dim t As DrawingDocument
    Set t = ThisApplication.Documents.Open(templatePath, False)

    t.Save

    t.Close
  End If

  Dim doc As Document
  Set doc = ThisApplication.Documents.Add(kDrawingDocumentObject, templatePath, True)
End Sub

Open Drawing from a Part or Assembly

Inventor supports the “Open Drawing” command that you can access from the context menu when clicking on a part or assembly node in the browser.

 

The equivalent functionality is not available through the Inventor API. However, the logic behind the command is very simple and not difficult to do on your own using Inventor’s API and features built into your programming language. A part or assembly doesn’t know if there are any drawings referencing it so the command just takes the filename of the part or assembly and looks for a file within the project of the same name as the part or assembly but with a .idw or .dwg extension.

Below is a VBA Sub that passes in the active part or assembly document to a function that either returns the full filename to the found drawing or an empty string if it can’t find a drawing.

Public Sub FindDrawingTest()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument 
    
    ' Call the function to get the drawing. 
    Dim drawingFilename As String
    drawingFilename = FindDrawingFile(partDoc)
   
    ' Display the result.
    If drawingFilename <> "" Then
        MsgBox "The drawing for """ & partDoc.fullFilename & """ was found: " & vbCr & drawingFilename
    Else
        MsgBox "No drawing was found for """ & partDoc.fullFilename & """"
    End If
End Sub


' Find the drawing for the specified part of assembly.
Private Function FindDrawingFile(PartOrAssemblyDoc As Document)
    Dim fullFilename As String
    fullFilename = PartOrAssemblyDoc.fullFilename
   
    ' Extract the path from the full filename.
    Dim path As String
    path = Left$(fullFilename, InStrRev(fullFilename, "\"))
   
    ' Extract the filename from the full filename.
    Dim filename As String
    filename = Right$(fullFilename, Len(fullFilename) - InStrRev(fullFilename, "\"))
   
    ' Replace the extension with "dwg"
    filename = Left$(filename, InStrRev(filename, ".")) & "dwg"
   
    ' Find if the drawing exists.
    Dim drawingFilename As String
    drawingFilename = ThisApplication.DesignProjectManager.ResolveFile(path, filename)
   
    ' Check the result.
    If drawingFilename = "" Then
        ' Try again with idw extension.
        filename = Left$(filename, InStrRev(filename, ".")) & "idw"
       
        ' Find if the drawing exists.
        drawingFilename = ThisApplication.DesignProjectManager.ResolveFile(path, filename)
   
        ' Return the result.
        If drawingFilename <> "" Then
            FindDrawingFile = drawingFilename
        Else
            FindDrawingFile = ""
        End If
    Else
        ' Return the result.
        FindDrawingFile = drawingFilename
    End If
End Function

And here’s the same thing implemented in Visual Basic .NET

Private Sub btnFindDrawing_Click(sender As Object, e As EventArgs) Handles btnFindDrawing.Click
    Dim invApp As Inventor.Application = GetObject(, "Inventor.Application")
    Dim partDoc As Inventor.PartDocument = invApp.ActiveDocument

     '  Call the function to get the drawing. 

    Dim drawingFilename As String = FindDrawingFile(partDoc)

    ' Display the result.
    If drawingFilename <> "" Then
        MsgBox("The drawing for """ & partDoc.FullFileName & """ was found: " & vbCr & drawingFilename)
    Else
        MsgBox("No drawing was found for """ & partDoc.FullFileName & """")
    End If
End Sub


' Find the drawing for the specified part of assembly.
Private Function FindDrawingFile(PartOrAssemblyDoc As Inventor.Document)
    Dim fullFilename As String = PartOrAssemblyDoc.FullFileName

    ' Extract the path from the full filename.
    Dim path As String = System.IO.Path.GetFullPath(fullFilename)

    ' Extract the filename from the full filename.
    Dim filename As String = System.IO.Path.GetFileNameWithoutExtension(fullFilename)
    Dim invApp As Inventor.Application = PartOrAssemblyDoc.Parent

    ' Find if the dwg exists.
    Dim drawingFilename As String
    drawingFilename = invApp.DesignProjectManager.ResolveFile(path, filename & ".dwg")

    ' Check the result.
    If drawingFilename = "" Then
        ' Try again with idw extension.
        drawingFilename = invApp.DesignProjectManager.ResolveFile(path, filename & ".idw")

        ' Return the result.
        If drawingFilename <> "" Then
            Return drawingFilename
        Else
            Return ""
        End If
    Else
        ' Return the result.
        Return drawingFilename
    End If
End Function

-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

C# Help Examples for Drawing Views

Here is another section of VBA procedures from the help file converted to C#. These examples are related to drawing views. There was one example that already had a C# version.   

You can find details about how the C# projects can be used in this post. This project has the following functions:

 Download InventorHelpExamples_Drawing_Views

CreateBreakoperationInDrawingView
ModifyDrawingSketchEntityProperties
DrawingSketchFill
CreateDrawingSketchInView
AddBaseViewWithRepresentations
AddFlatPatternDrawingView
CreateDetailView
CreateDraftView
Layer
BreakAlignment
AddUsingSheetFormat

Here is CreateBreakoperationInDrawingView

//Creation of a break operation in a drawing view

//Demonstrates the creation of a break operation.

//Before running this sample, select a drawing

//view in the active drawing.

public void CreateBreakoperationInDrawingView()

{

    // Set a reference to the drawing document.

    // This assumes a drawing document is active.

    DrawingDocument oDrawDoc =

(DrawingDocument)ThisApplication.ActiveDocument;

 

    //Set a reference to the active sheet.

    Sheet oSheet = (Sheet)oDrawDoc.ActiveSheet;

 

 

    DrawingView oDrawingView = default(DrawingView);

    // Check to make sure a drawing view is selected.

    try

    {

        // Set a reference to the selected drawing.

        // This assumes that the selected view is

        // not a draft view.

        oDrawingView =

                 (DrawingView)oDrawDoc.SelectSet[1];

    }

    catch

    {

        MessageBox.Show

            ("A drawing view must be selected.");

        return;

    }

 

 

    // Set a reference to the

    //center of the base view.

    Point2d oCenter =

              (Point2d)oDrawingView.Center;

 

    // Define the start point of the break

    Point2d oStartPoint = ThisApplication.

        TransientGeometry.

        CreatePoint2d(oCenter.X - 1, oCenter.Y);

 

    // Define the end point of the break

    Point2d oEndPoint = default(Point2d);

    oEndPoint = ThisApplication.TransientGeometry.

         CreatePoint2d(oCenter.X + 1, oCenter.Y);

 

    BreakOperation oBreakOperation =

                        default(BreakOperation);

 

    oBreakOperation = oDrawingView.

                           BreakOperations.Add

(BreakOrientationEnum.kHorizontalBreakOrientation,

             oStartPoint, oEndPoint,

         BreakStyleEnum.kRectangularBreakStyle, 5);

}

C# Help Examples for Drawing Annotations, part two

Here is the second section of VBA procedures related to drawing annotations in the help file converted to C#. In this project you will find the rest of the 29 examples in this section. These examples create annotations such as feature control frames and stacked text. There is also an example that creates a title block with prompted text an an example that shows how to insert the title block on a sheet.

You can find details about how the C# projects can be used in this post. This project has the following functions:

 Download InventorHelpExamples_Drawing_Annotations_2

AddFeatureControlFrame
SheetTextAdd
StackedText
CreateHoleTables
AddThreadNote
AddLeaderNote
CreateOrdinateDimensions
CreatePartsList
PartListEdit
PartListQuery
AddPunchNote
RevisionTableQuery
AddSurfaceTextureSymbol
CreateTitleBlockDefinition
InsertTitleBlockOnSheet
TitleBlockCopy

Here is AddFeatureControlFrame

//  Create a feature control frame symbol API Sample

//Description

//This sample demonstrates the creation of a feature

//control frame symbol.

//Select a linear drawing curve and run the sample.

public void AddFeatureControlFrame()

{

        // Set a reference to the drawing document.

        // This assumes a drawing document is active.

        DrawingDocument oDrawDoc =

     (DrawingDocument)ThisApplication.ActiveDocument;

 

        // Set a reference to the active sheet.

        Sheet oActiveSheet = default(Sheet);

        oActiveSheet = oDrawDoc.ActiveSheet;

 

        // Set a reference to the drawing

        //curve segment. This assumes that a drwaing

        //curve is selected.

        DrawingCurveSegment oDrawingCurveSegment =

                      default(DrawingCurveSegment);

        oDrawingCurveSegment =

                             oDrawDoc.SelectSet[1];

 

        // Set a reference to the drawing curve.

        DrawingCurve oDrawingCurve =

                            default(DrawingCurve);

        oDrawingCurve =

                      oDrawingCurveSegment.Parent;

 

        // Get the mid point of the selected curve

        // assuming that the selection curve

        //is linear

        Point2d oMidPoint = default(Point2d);

        oMidPoint = oDrawingCurve.MidPoint;

 

        // Set a reference to the

        // TransientGeometry object.

        TransientGeometry oTG =

                    default(TransientGeometry);

        oTG = ThisApplication.TransientGeometry;

 

        ObjectCollection oLeaderPoints =

            default(ObjectCollection);

        oLeaderPoints =

            ThisApplication.TransientObjects.

                      CreateObjectCollection();

 

        // Create a few leader points.

        oLeaderPoints.Add

  (oTG.CreatePoint2d(oMidPoint.X + 10,

                          oMidPoint.Y + 10));

        oLeaderPoints.Add

  (oTG.CreatePoint2d(oMidPoint.X + 10,

                           oMidPoint.Y + 5));

 

        // Create an intent and add to the

        // leader points collection.

        // This is the geometry that the

        // symbol will attach to.

        GeometryIntent oGeometryIntent =

                     default(GeometryIntent);

        oGeometryIntent = oActiveSheet.

         CreateGeometryIntent(oDrawingCurve);

        oLeaderPoints.Add(oGeometryIntent);

 

        // Create a FeatureControlFrameRows object to

        //define the symbol's rows

        FeatureControlFrameRows oRows =

            (FeatureControlFrameRows)oActiveSheet.

                             FeatureControlFrames.

                    CreateFeatureControlFrameRows();

 

        // Add a row

        FeatureControlFrameRow oRow = 

        (FeatureControlFrameRow)oRows.Add

        (GeometricCharacteristicEnum.

                       kProfileOfAnySurface,

                           "0.20", "", "A", "B");

 

        // Create the feature control frame

        //symbol with a leader

        FeatureControlFrame oSymbol =

            default(FeatureControlFrame);

        oSymbol = oActiveSheet.FeatureControlFrames.

                         Add(oLeaderPoints, oRows);

}

-Wayne

C# Help Examples for Drawing Annotations, part one

There are a many VBA procedures related to drawings in the help file. In this project you will find 14 of the examples related to  drawing annotations converted to C#.

This section in the help has has 29 VBA demos.

You can find details about how the C# projects can be used in this  post. This project has the following functions:

 Download InventorHelpExamples_Drawing_Annotations_1

CenterAllDimensions
EditBalloons
CreateBalloon
GetComponentReferencedByBalloon
CreateBaselineDimensionSet
AddBendNote
CreateChainDimensionSet
CreateCustomTable
CreateBendTable
CreateConfigurationTable
CreateDrawingExcelTable
EditDrawingDimensions
DeleteUnattachedDimensions
DimensionAlign

Here is DimensionAlign:

//    Aligning drawing dimensions API Sample

//Description

//This sample demonstrates aligning the selected

//drawing dimensions along a horizontal or vertical

//axis. The first dimension selected defines the

//origin of the axis. A drawing document must be

//open and at least two dimensions selected.

public void DimensionAlign()

{

    DrawingDocument oDrawDoc =

   (DrawingDocument)ThisApplication.ActiveDocument;

 

    // Determine if there are any dimensions

    //in the select set.

    SelectSet oSelectSet = default(SelectSet);

    oSelectSet = oDrawDoc.SelectSet;

 

  var colDimensions = new List<DrawingDimension>();

 

    // long i = 0;

    for (int i = 1; i <= oSelectSet.Count; i++)

    {

        if (oSelectSet[i] is DrawingDimension)

        {

            // Add any dimensions to the collection.

            //We need to save them

            // in something besides the selection

            //set because once we start

            // manipulating them, the select set

            //will be cleared.

            colDimensions.Add(oSelectSet[i]);

        }

    }

 

    if (colDimensions.Count != 2)

    {

        MessageBox.Show

("Select at least 2 dimensions for this operation.");

        return;

    }

 

    // Ask the user if he/she wants vertical

    //or horizontal alignment.

    bool bHorizontal = false;

    DialogResult diagRes = MessageBox.Show

("Horizontal alignment? No = vertical alignment)",

     "Align Dimensions", MessageBoxButtons.YesNo);

 

    if (diagRes == DialogResult.Yes)

    {

        bHorizontal = true;

    }

    else

    {

        bHorizontal = false;

    }

 

    double dPosition = 0;

    for (int i = 0;

        i <= colDimensions.Count - 1;

                                       i++)

    {

        DrawingDimension oDimension =

                   default(DrawingDimension);

        oDimension = colDimensions[i];

 

 

        if (i == 0)

        {

            // Get the position of the

            //first dimension text. This is

            // the position the other

            //dimensions will be aligned to.

            if (bHorizontal)

            {

                dPosition = oDimension.Text.Origin.Y;

            }

            else

            {

                dPosition = oDimension.Text.Origin.X;

            }

        }

        else

        {

            // Change the position of the dimension.

            Point2d oPosition = default(Point2d);

            oPosition = oDimension.Text.Origin;

            if (bHorizontal)

            {

                // oPosition.Y = dPosition;

                oPosition.Y = dPosition;

            }

            else

            {

                // oPosition.X = dPosition;

                oPosition.X = dPosition;

            }

            oDimension.Text.Origin = oPosition;

        }

    }

}

-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 2

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

Note: Segment 1 is here

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

Download ClientGraphics_Segment_2

Start of segment 2

Graphic Primitives

Point

Point is the simplest graphics object available. You could change the point style such as circular dot, a cross etc, and from Inventor 2011, a Point can be displayed with an image. (This section uses VBA code snippets. In 64 bit using iPictureDisp from out of process is a known limitation. In 64 bit VBA is out of process)

' <code snippet : Point>
Dim oPointCoords(8) As Double
oPointCoords(0) = 0:   oPointCoords(1) = 0: oPointCoords(2) = 0
oPointCoords(3) = 0:   oPointCoords(4) = 1: oPointCoords(5) = 0
oPointCoords(6) = 1:   oPointCoords(7) = 1: oPointCoords(8) = 1

' Create an image set
Dim oImageSet As GraphicsImageSet
Set oImageSet = oDataSets.CreateImageSet(oDataSets.count + 1)
Dim oImage As IPictureDisp
Set oImage = LoadPicture("C:\Temp\MyImage.bmp")
Call oImageSet.Add(1,oImage)

‘add point graphics and assign the data
Call oCoordSet.PutCoordinates(oPointCoords) 
Dim oPointGraphics As PointGraphics
Set oPointGraphics = oPointNode.AddPointGraphics oPointGraphics.PointRenderStyle = kFilledCrossPointStyle
oPointGraphics.CoordinateSet = oCoordSet
oPointGraphics.BurnThrough = True

 

Line
These are individual line segments. Line graphics use two coordinates to define a line, and then the next two coordinates to define the next line, and so on through the defined coordinates.

Line Strip
These are a connected set of lines. Line strips use the first two coordinates to define the first line and then the last point of the first line becomes the first point of the second line and the next coordinate is used as the end point of the second line. This results in the set of points being connected by a continuous set of lines, drawing a continuous curve. So to define 2 connected lines, just 3 coordinates would be required.

‘<code snippet: Line or LineStrip> 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)

‘Line: every 2 points for 1 Line
Dim oGraphic As LineGraphics
Set oGraphic = oGraphicsNode.AddLineGraphics

‘Line strip: totally, 3 lines
‘Dim oGraphic As LineStripGraphics
‘Set oGraphic = oGraphicsNode.AddLineStripGraphics 

 

Triangle
These are used to define individual triangles. Each set of three coordinates defines a triangle. The next three coordinates then define the next triangle, and so on through all of the coordinates that are provided.

Triangle Strip
These provide a connected set of triangles. The first three coordinates define a triangle and the next coordinate defines another triangle using the previous two coordinates. You could also specify the strip length. This is provided for performance reasons.   

‘<code snippet: Triangle or Triangle 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)

‘Triangle: every 3 points for 1 triangle
Dim oGraphic As TriangleGraphics
Set oGraphic = oGraphicsNode.AddTriangleGraphics

‘or Triangle Strip: totally 5 triangles
‘Dim oGraphic As TriangleStripGraphics
‘Set oGraphic = oGraphicsNode.AddTriangleStripGraphics

oGraphic.CoordinateSet = oCoordSet

Graphics

Triangle Fan
This defines a set of connected triangles. The first coordinate is shared in all triangles. The first three coordinates define a triangle. And the next coordinate defines another triangle using the previous coordinates: one of which is the first coordinate. If all the coordinates surround the first point, then the resulting graphics looks like a fan. Again this facility is provided primarily for performance reasons.

 

TextGraphics

‘<code snippet: Text>
Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oTextGraphics As TextGraphics
Set oTextGraphics = oNode.AddTextGraphics

oTextGraphics.Text = Text
oTextGraphics.Anchor = oPosition
oTextGraphics.Bold = True
oTextGraphics.Font = "Arial"
oTextGraphics.FontSize = 40
oTextGraphics.HorizontalAlignment = kAlignTextLeft
oTextGraphics.Italic = True
Call oTextGraphics.PutTextColor(0, 255, 0)

 

Curve
Curves include the following objects: LineSegment, Circle, Arc3d, EllipseFull, EllipticalArc and BSplineCurve. The object TransientGeometry is used to create the geometry and client graphics then uses this geometry as input. You can also use the geometry from a model’s native data too.

‘<code snippet: Curve>
Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oCircle As Inventor.Circle
Set oCircle = oTG.CreateCircle(oTG.CreatePoint(0, 0, 0),
                                      oTG.CreateUnitVector(0, 0, 1), 5#)
   
Dim oGraphic As CurveGraphics
Set oGraphic = oGraphicsNode.AddCurveGraphics(oCircle)

 

Surface
TransientBrep is used to create the underlying geometry data, and client graphics objects then use this geometry. Again you can use the model’s native data: face, faces or face collection too.

‘<code snippet: Surface>
Dim oTransientBRep As TransientBRep
Set oTransientBRep = ThisApplication.TransientBRep
   
Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry


Dim oBody As SurfaceBody
Set oBody = oTransientBRep.CreateSolidCylinderCone _
                   (oTG.CreatePoint(0, 0, 0), _
                   oTG.CreatePoint(0, 10, 0), _
                   5, 5, 0) Dim oSurfaceGraphics As SurfaceGraphics
Set oSurfaceGraphics = oSurfacesNode. _
                             AddSurfaceGraphics(oBody)

 

End of Segment 2

-Wayne

Balloon Renumbering Across Sheets

I recently received a challenge from an Autodesk dealer that I couldn’t let sit since it seemed like it shouldn’t be too hard to solve. The problem he’s trying to solve is the case where the first sheet of a drawing contains a full assembly which is ballooned.  Other sheets in the drawing contains subassemblies and parts that are used in the full assembly.  What he wants is that the balloon numbers on the later sheets all match the numbers on the first sheet.  By default, each document gets its own set of part numbers so each subassembly will begin numbering it parts at 1.

The following VBA code is my attempt at a solution.  I didn’t put it through a lot of testing but it worked on what I did throw at it.  To use it, just have a drawing open and run the macro.  It can be re-run at any point to update the balloons is balloons on the first sheet are added or renumbered.

The program assumes the full assembly is on the first sheet and it examines all of the balloons on the first sheet getting the number and the document associated with the part the balloon is pointing at.  The program also determines the highest number used by any of the balloons on the first sheet.  The program then looks through the other sheets, examining each balloon to see if it points to any of same parts that were ballooned in the full assembly.  If it is a part already ballooned, the program overrides the balloon number using the number from the full assembly.  If the part or subassembly isn’t represented in the large assembly, it assigns it the next highest number.

' User-defined type used in the code code below.
Private Type udtPartInfo
   Number As Integer
   ReferencedFile As String
End Type


Public Sub RenumberBalloonsToFirstSheet()
   ' Get the active drawing document.
   If ThisApplication.ActiveDocumentType <> _
                                         kDrawingDocumentObject Then
      MsgBox "A drawing must be active."
      Exit Sub
   End If
 
   Dim drawDoc As DrawingDocument
   Set drawDoc = ThisApplication.ActiveDocument
   
   ' Get the first sheet
   Dim baseSheet As Sheet
   Set baseSheet = drawDoc.Sheets.Item(1)
   
   ' Get the drawing BOM from a balloon.  An assumption is that
   ' there is only one assembly represented on the sheet since
   ' this is arbitrarily using the BOM data of assembly associated
   ' with the first balloon found.
   Dim valSet As BalloonValueSet
   Set valSet = baseSheet.Balloons.Item(1).BalloonValueSets.Item(1)
   Dim drawBOM As DrawingBOM
   Set drawBOM = valSet.ReferencedRow.Parent
   Dim partInfo() As udtPartInfo
   ReDim partInfo(drawBOM.DrawingBOMRows.Count - 1)
  
   ' Determine which column contains the item number information.
   Dim itemColumn As Integer
   Dim i As Integer
   For i = 1 To drawBOM.DrawingBOMColumns.Count
      If drawBOM.DrawingBOMColumns.Item(i).PropertyType = _
                                        kItemPartsListProperty Then
         itemColumn = i
         Exit For
      End If
   Next
  
   For i = 1 To drawBOM.DrawingBOMRows.Count
      Dim drawBOMRow As DrawingBOMRow
      Set drawBOMRow = drawBOM.DrawingBOMRows.Item(i)

      ' Get the filename of the file associated with this
      ' row of the BOM.
      Dim partDef As PartComponentDefinition
      Set partDef = drawBOMRow.BOMRow.ComponentDefinitions.Item(1)
      partInfo(i - 1).ReferencedFile = partDef.Document.FullFileName
     
      ' Get the part number from the drawing BOM.  This could
      ' be different than the assembly BOM since it can be
      ' overridden in the drawing.
      partInfo(i - 1).Number = drawBOMRow.Item(itemColumn).Value
   Next
   
   ' Iterate through the other sheets setting the balloon values
   ' to match these. If a balloon to a new part is found it will
   ' be set to the next highest value so all parts have unique
   ' balloon values.
   For i = 2 To drawDoc.Sheets.Count
      Dim currentSheet As Sheet
      Set currentSheet = drawDoc.Sheets.Item(i)

      ' Look through the balloons on this sheet.
      Dim checkBalloon As Balloon
      For Each checkBalloon In currentSheet.Balloons
         ' Initialize the flag indicating a match was found.
         Dim matchFound As Boolean
         matchFound = False
         Dim valueSet As BalloonValueSet
         Set valueSet = checkBalloon.BalloonValueSets.Item(1)
         Dim checkFilename As String
         checkFilename = _
                      valueSet.ReferencedFiles.Item(1).FullFileName 

         ' Find the data that matches this balloon.
         Dim j As Integer
         For j = 0 To UBound(partInfo)
            If checkFilename = partInfo(j).ReferencedFile Then
               ' Override the balloon value to match, if
               ' it's different.
               matchFound = True
               If valueSet.ItemNumber <> partInfo(j).Number Then
                  valueSet.OverrideValue = partInfo(j).Number
               End If
               Exit For
            End If
         Next
      Next
   Next
End Sub

 

Updates:
Feb. 22, 2011: Revised the code because of some problems pointed out in the previous version.  The previous version was dependent on a balloon being present on the first sheet for every part in the assembly, which is not realistic.  The new code relies on the BOM, which will include every part.

Parts List with Thumbnail Image

There was a recent question in the customization newsgroup about creating a parts list in Word or Excel that contained the thumbnail image for each part.  This seemed like an interesting problem to tackle.  Since a parts list is a table, Excel was the obvious first choice.  However, after playing with it a bit I found that Excel doesn’t support inserting pictures into cells and from what I found online is an enhancement coming in Office 2010.  I also found out that Word does allow you to insert pictures into table cells so that’s what I decided to use.

Below is an example of the result using one of the sample files that comes with Inventor.

My initial code for this was a VBA macro but it was found to have a problem on 64-bit machines.  I’m leaving the original VBA version described below because it’s simpler and easier to understand the what’s going on.  It isn’t fancy but mostly does the job.  The new version is an add-in and will work on 32 and 64-bit machines.

Add-In Version 
To use this version download this zip file.  Inside the zip is a .exe and another zip file.  The .exe is an installer and running it will install the add-in.  It creates a new button on the Tools tab of the drawing ribbon.  If you’re using the classic UI then it adds a new button to the annotation panel bar.  The add-in is compatible with Inventor 2010.  The zip file contains the source code for the add-in, in case you’re interested in that.  It was written using Visual Basic Express 2008.

VBA Version
You can To use the program you need to copy and paste the source code into VBA.  I would recommend pasting it into your VBA application project, as shown below.

Since this program uses Word and drives it through the Word API, you need to add a reference to the Word Object Library.  You do this by using the References… command in the Tools menu within VBA.  You need to check the box next to “Microsoft Word 12.0 Object Library” as shown below.  (I received some feedback on the newsgroup that this will also work with Word 2002 with some small changes to the code, which I’ve made the linked source code.  There’s also a change so that it’s tolerant of files that don’t have a thumbnail.  Thanks to Cadfish1 from the autodesk.inventor.customization newsgroup for his input.)

Now you’re all set.  You need to have a drawing open and the parts list selected that you want to write out and then you can run the program.  You run the program using the Macros command on the Tools tab of Inventor (which you can also access using Alt-F8).  Once it’s finished you should have a new Word document that contains the parts list table.