Mod the Machine

Fast Booleans Using the API

The Inventor API supports some functionality that’s relatively new (since Inventor 2009) and is not very well known.  It’s called Transient B-Rep and is accessed through the TransientBRep property on the Application object.  It supports some relatively simple functionality and also some of the more complicated capabilities provided by the API.  Luckily you don’t have to understand the complicated in order to use the simple. 

There was a question on the Inventor Customization Forum recently that asked about being able to quickly perform many Boolean operations on a body by repeatedly moving another body and doing a difference operation.  They didn’t need the resulting model to have any intelligence (i.e. be parametric) but just needed accurate geometry.  The TransientBRep object supports functionality that makes this possible.

The Inventor API uses the term Transient to mean data that is not seen or saved in the document.  It’s data that exists outside of the model.  The TransientBRep object provides functions that are a very light wrapper over the Autodesk Shape Manager (ASM) modeling core.  When you create a feature in Inventor, it’s also using ASM to do the actual model computations but it is also doing a lot more work to remember all of the feature input, adding additional information to the resulting model to allow for associativity, creating data in the browser to represent the feature, and updating the graphics to display the modified model.  Although a key part of the process, the actual modeling is just a piece of all of the work that’s done.  Using the TransientBRep functionality allows you to do just the modeling work without all of the overhead of creating a standard feature.

I’ve created a small sample to demonstrate the concept and illustrate how to use the API.  I have a part model that contains two bodies.  The yellow body will be used as the base or main part material.  The red part is used as the tool.  In this case it can be thought of as a punch that will be used to remove material from the base part.  The punch has been built relative to the model origin, as can be seen by the base work planes.

In addition to the two bodies you can also see several work points that have been created. They’re normal work points except they’ve been named “Punch#”. as shown below. The points are used to specify locations where the tool is to be subtracted from the base.

When the macro is run it prompts you to select the base and tool bodies and then uses the TransientBrep functionality to create transient copies of those and then performs multiple Boolean operations by moving the tool and subtracting it from the base.  Finally it creates a base feature using the modified base body and turns off the display of the tool and the base body so the result can be seen, which is shown below.

Below is the sample macro and here is the sample part that I used to test it.  The part is an Inventor 2015 model, but this macro will work in previous versions of Inventor too.

Public Sub SampleBoolean()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument
    Dim partDef As PartComponentDefinition
    Set partDef = partDoc.ComponentDefinition
   
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
    Dim tb As TransientBRep
    Set tb = ThisApplication.TransientBRep
    Dim tObjs As TransientObjects
    Set tObjs = ThisApplication.TransientObjects
    
    ' Have the bodies selected.
    Dim baseBody As SurfaceBody
    Set baseBody = ThisApplication.CommandManager.Pick( _
                        kPartBodyFilter, _
                        "Select the base body")
   
    Dim toolBody As SurfaceBody
    Set toolBody = ThisApplication.CommandManager.Pick( _
                        kPartBodyFilter, _
                        "Select the tool body")
                       
    ' Copy the two bodies to create transient copies.
    Dim transBase As SurfaceBody
    Set transBase = tb.Copy(baseBody)
    Dim transTool As SurfaceBody
    Set transTool = tb.Copy(toolBody)
   
    ' Create a matrix and a point to use in positioning
    ' the punch.  The matrix is initialized to an identity
    ' matrix the point is (0,0,0).
    Dim trans As Matrix
    Set trans = tg.CreateMatrix
    Dim lastPosition As Point
    Set lastPosition = tg.CreatePoint
   
    ' Process each work point whose name starts with "Punch"
    ' by performing a boolean with the tool at that location.
    Dim wp As WorkPoint
    For Each wp In partDef.WorkPoints
        If Left$(UCase(wp.Name), 5) = "PUNCH" Then
            ' Transform the tool body to the position of the x and
            ' y coordinates work point, leaving the z as-is.  The 
            ' punch is at the last punch so the transform defines
            ' the difference between the last and the current.
            trans.Cell(1, 4) = wp.Point.X - lastPosition.X
            trans.Cell(2, 4) = wp.Point.Y - lastPosition.Y
            Call tb.Transform(transTool, trans)
           
            ' Do the boolean operation.
            Call tb.DoBoolean(transBase, transTool, _
                              kBooleanTypeDifference)
       
            ' Save the last position.
            Set lastPosition = wp.Point
        End If
    Next
   
    ' Create a base body feature of the result.
    Dim nonParamFeatures As NonParametricBaseFeatures
    Set nonParamFeatures = partDef.Features.NonParametricBaseFeatures
    Dim nonParamDef As NonParametricBaseFeatureDefinition
    Set nonParamDef = nonParamFeatures.CreateDefinition
   
    Dim objs As ObjectCollection
    Set objs = tObjs.CreateObjectCollection
    Call objs.Add(transBase)
    nonParamDef.BRepEntities = objs
    nonParamDef.OutputType = kSolidOutputType
   
    Call nonParamFeatures.AddByDefinition(nonParamDef)
   
    ' Turn off the display of the original two
    ' features to see the result.
    baseBody.Visible = False
    toolBody.Visible = False
   
    ' Force a refresh of the view.
    ThisApplication.ActiveView.Update
End Sub

-Brian

Inventor 2015 API Enhancements

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

Enhancements in the API for Parts

Sweep Feature.

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

 

 

Work plane.

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

 

 

 

 

Work plane created using WorkPlanes.AddByTwoPlanes()

 

DirectEditFeature

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

FreeformFeature

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

Sketch

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

These settings are exposed through the API.

 

Enhancements in the API for Sheet metal

Punch – cut across bend

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

Punch on the right used cut across bend

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

Punch – cut normal to the flat pattern

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

Cut on the left is normal to the flat

How it looks in the flat pattern.

Flat pattern orientation

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

 

Enhancements in API for Assemblies

BOM Structure

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

AssemblySymmetryConstraint

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

Enhancements in API for Drawings

Hole table title

In this release you have control over hole table title.

Foreshortened dimensions

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

 

Miscellaneous Enhancements

FileManager

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

 

-Wayne

Updating Parts Through an Assembly

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

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

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

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

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

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

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

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

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

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

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

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

-Brian

Control feature creation based on user defined boundary

Thanks to DevTech engineer Vladimir Ananyev for providing this post and great example.

Recently we were asked if the Inventor API could help by suppressing elements of holes in a rectangular pattern which are not completely inside a user-defined boundary.

The algorithm needs to suppress holes that have centers located outside the boundary at a distance greater than the hole radius from the boundary. The boundary could be complex geometry and the most difficult problem was to determine if the hole was completely inside or outside the boundary. This problem was solved by using Inventor API objects involved in the creation of profiles for solid geometry.

In the screenshots below you see a sketch and the extrusion that is created using the profile created with the AddForSolid() method.

 Dim oProfile As Profile _

    = oSketch.Profiles.AddForSolid(True)

The result is shown in Fig. 2.

If a circular profile path crosses the ellipse (boundary) or is located completely outside then it adds material to the solid body. Otherwise it subtracts material.

Figures 3 and 4 show that this rule works for profile paths of any other geometry as well.

This powerful built-in topology analyzer of the AddForSolid method you can be used to easily identify pattern elements that are completely inside the specified boundary. (Fortunately there are not any restrictions on the geometry of the profile paths).

To demonstrate this approach I used an iLogic rule. (Any language that can access the Inventor API could have been used too). In figure 5 you see the full rectangular pattern. After the rule is run, the holes outside of the boundary are suppressed. (figure 6)

The steps are as follows.
1. The Main function projects the boundary geometry from the planar sketch “Boundary” and all the elements of the holes pattern into the created on-the-fly transient planar sketch. (For simplicity the rule works with the first rectangular pattern in its parent part document). 

2. It then calls the AddForSolid method to create a profile object based on the combined projected geometry in the transient sketch. 

3.  The rule analyses every profile path in the profile object. If the path represents a projected hole’s pattern element and its property AddsMaterial returns True, then the corresponding pattern element is suppressed. The search for FeaturePatternElement is based on the reference to the projected sketch circle is performed by the function GetEltByGreenCircle.

Note:  The parent hole feature cannot be suppressed otherwise all the pattern will be suppressed as well, that is why our code ignores the parent feature.

An Inventor part file with the iLogic rule can be downloaded here.

Here are the two iLogic rules:

Sub Main()

 

    Dim oDoc As PartDocument =

      TryCast(ThisDoc.Document, PartDocument)

    If oDoc Is Nothing Then

        MessageBox.Show _

     ("This rule works with part documents only.",

         "iLogic Rule", _

          MessageBoxButtons.OK,

       MessageBoxIcon.Warning)

        Exit Sub

    End If

    Dim oDef As PartComponentDefinition =

                             oDoc.ComponentDefinition

 

    'this rule works with only one rect. pattern only

    'provided directly by item number

    Dim oPattern As RectangularPatternFeature =

     oDef.Features.RectangularPatternFeatures.Item(1)

 

    'restore all pattern elements in order to

    'get access to their faces

    For Each oElt As FeaturePatternElement _

                         In oPattern.PatternElements

        If oElt.Suppressed Then

            oElt.Suppressed = False

        End If

    Next

    oDoc.Update()

    ThisApplication.ActiveView.Update()

    Beep()

 

    Dim oBoundarySketch As PlanarSketch =

                    oDef.Sketches.Item("Boundary")

 

    'temporary sketch for profile

    Dim oSketch As PlanarSketch =

     oDef.Sketches.Add _

               (oBoundarySketch.PlanarEntity, False)

    oSketch.Visible = False

 

    'project boundary

    For Each oE As SketchEntity _

                  In oBoundarySketch.SketchEntities

        Call oSketch.AddByProjectingEntity(oE)

    Next

 

    'project parent hole

    Dim oHole As HoleFeature =

         TryCast(oPattern.ParentFeatures.Item(1),

                                     HoleFeature)

    If oHole Is Nothing Then

        MessageBox.Show _

("This rule works with hole feature pattern only.",

          "iLogic Rule", _

       MessageBoxButtons.OK, MessageBoxIcon.Warning)

        Exit Sub

    End If

    Dim oEdge As Edge =

             oHole.SideFaces.Item(1).Edges.Item(1)

    Call oSketch.AddByProjectingEntity(oEdge)

 

    'project holes pattern

    For Each oElt As FeaturePatternElement _

                        In oPattern.PatternElements

        If oElt.Faces.Count > 0 Then

            oEdge = oElt.Faces.Item(1).Edges.Item(1)

            Call oSketch.AddByProjectingEntity(oEdge)

        End If

    Next

 

    ' Create a profile.

    Dim oProfile As Profile =

                oSketch.Profiles.AddForSolid(True)

 

    For Each oPath As ProfilePath In oProfile

        If oPath.Count = 1 Then

            Dim oPE As ProfileEntity = oPath.Item(1)

            If oPE.CurveType =

                Curve2dTypeEnum.kCircleCurve2d Then

                Dim oSkE As SketchEntity =

                                   oPE.SketchEntity

                Dim oGreenCircle As SketchCircle =

                         CType(oSkE, SketchCircle)

                Dim oFPE As FeaturePatternElement =

                   GetEltByGreenCircle(oGreenCircle)

                If oFPE IsNot Nothing Then

                    If oPath.AddsMaterial = True Then

                        'should be suppressed

                        oFPE.Suppressed = True

                    End If

                End If

            End If

        End If

    Next

    'delete temporary sketch

    oSketch.Delete()

    oDoc.Update()

    Beep()

End Sub

 

 

Function GetEltByGreenCircle( _

  ByRef oGreenCircle As SketchCircle) _

                      As FeaturePatternElement

    'returns FPE corresponding to the

    'given SketchCircle object

 

    If oGreenCircle Is Nothing Then Return Nothing

    Dim oEdge As Edge

    Try

        oEdge = CType(oGreenCircle. _

         ReferencedEntity, Edges).Item(1)

    Catch ex As Exception

        Return Nothing

    End Try

 

    Dim oFace As Face

    If oEdge.Faces.Item(1).SurfaceType =

             SurfaceTypeEnum.kCylinderSurface Then

        oFace = oEdge.Faces.Item(1)

    Else

        oFace = oEdge.Faces.Item(2)

    End If

 

    If oFace.CreatedByFeature.Type =

              ObjectTypeEnum.kHoleFeatureObject Then

        Return Nothing

    End If

 

    Dim lKey As Long = oFace.TransientKey

 

    Dim oPattern As RectangularPatternFeature _

            = CType(oFace.CreatedByFeature,  _

                RectangularPatternFeature)

 

    For Each oElt As FeaturePatternElement

                        In oPattern.PatternElements

        If oElt.Faces.Count > 0 Then

            If lKey = oElt.Faces.Item(1). _

                                  TransientKey Then

                Return oElt

            End If

        End If

    Next

    Return Nothing

End Function 'GetEltByGreenCircle

 

(Thanks! to Vladimir)

-Wayne

C# Help Examples for Parts General

Here are the VBA examples in this section of samples for parts converted to C#. This group of examples includes an example for an event (TestSelection) that allows you to get an entity from the user using events. It also has some parameter and brep examples. The WorkPointAtMassCenter c# example was already in the help file. (Saved me some time converting it).

This project has the following functions.

 Download InventorHelpExamples_Part_General

CreateParametersAndGroup
MoldBaseSample
SelectivelyLinkParams
QueryAndShowFeatureDimensions
TestSelection
IsCylindricalFaceInterior
GetPartMassProps
GetPartMassPropsWithoutDirtying
WorkPointAtMassCenter
CreateMaterial
ShowMaterials
ModelParameters
TableParameters
CreateRectangleFace

 

Here is the CreateParametersAndGroup function:

// Creating a new parameter group API Sample

//Description

//This sample demonstrates the creation of model,

//reference and user parameters and

//copying these parameters to a newly created group.

public void CreateParametersAndGroup()

{

    // Create a new Part document.

    PartDocument oPartDoc = default(PartDocument);

    oPartDoc =

      (PartDocument)ThisApplication.Documents.Add

    (DocumentTypeEnum.kPartDocumentObject,

    ThisApplication.FileManager.GetTemplateFile

    (DocumentTypeEnum.kPartDocumentObject));

 

    // Set a reference to the compdef.

    PartComponentDefinition oCompDef =

        default(PartComponentDefinition);

    oCompDef = oPartDoc.ComponentDefinition;

 

    // Create a model parameter

    ModelParameter oModelParam =

                  default(ModelParameter);

    oModelParam = oCompDef.Parameters.

    ModelParameters.AddByValue

    (2, UnitsTypeEnum.kCentimeterLengthUnits);

 

    // Create a reference parameter

    ReferenceParameter oReferenceParam =

    default(ReferenceParameter);

    oReferenceParam = oCompDef.Parameters.

    ReferenceParameters.AddByValue

    (4, UnitsTypeEnum.kCentimeterLengthUnits);

 

    // Create a user parameter

    UserParameter oUserParam =

                       default(UserParameter);

    oUserParam = oCompDef.Parameters.UserParameters.

             AddByValue("length", 6,

              UnitsTypeEnum.kCentimeterLengthUnits);

 

    // Create a new custom parameter group

    CustomParameterGroup oCustomParamGroup =

    default(CustomParameterGroup);

    oCustomParamGroup = oCompDef.Parameters.

             CustomParameterGroups.Add

                ("Custom Group", "CustomGroup1");

 

    // Add the created parameters to this group

    // Note that adding the parameters to the

    //custom group does not remove it from the

    // original group.

    oCustomParamGroup.Add((Parameter)oModelParam);

    oCustomParamGroup.Add

                     ((Parameter)oReferenceParam);

    oCustomParamGroup.Add((Parameter)oUserParam);

}

C# Help Examples for Features – Part 1

Here is the first group of VBA examples in this section of samples for Features converted to C#.

This project has the following functions.

 Download InventorHelpExamples_Features_1

BoundaryPatchFeature
DecalFeature
DrawBlockWithPocket
EditFeatureProfile
ExtrudeSketchText
CreateAllRoundsFillet
CreateFilletComplex
CreateSimpleFillet
HighlightFeatureFaces
ClearHighlight

Here is CreateSimpleFillet

//    Fillet Feature (Simple) API Sample

//Description

//This sample demonstrates using the AddSimple method

//of the FilletFeatures collection

// to create a constant radius fillet.

public void CreateSimpleFillet()

{

    // Create a new Part document.

    PartDocument oPartDoc = default(PartDocument);

    oPartDoc =

     (PartDocument)ThisApplication.Documents.Add

           (DocumentTypeEnum.kPartDocumentObject,

     ThisApplication.FileManager.GetTemplateFile

         (DocumentTypeEnum.kPartDocumentObject));

 

    // Set a reference to the compdef.

    PartComponentDefinition oCompDef =

             default(PartComponentDefinition);

    oCompDef = oPartDoc.ComponentDefinition;

 

    // Create a sketch on the xy work plane.

    PlanarSketch oSketch = default(PlanarSketch);

    oSketch = oCompDef.Sketches.Add

                        (oCompDef.WorkPlanes[3]);

 

    // Draw a rectangle.

    oSketch.SketchLines.AddAsTwoPointRectangle

    (ThisApplication.TransientGeometry.

                           CreatePoint2d(-6, -4),

   ThisApplication.TransientGeometry.

                            CreatePoint2d(6, 4));

 

    Profile oProfile = default(Profile);

    oProfile = oSketch.Profiles.AddForSolid();

 

    // Create an extrusion.

    ExtrudeDefinition oExtrudeDef =

                   default(ExtrudeDefinition);

    oExtrudeDef = oCompDef.Features.

         ExtrudeFeatures.CreateExtrudeDefinition

(oProfile, PartFeatureOperationEnum.kJoinOperation);

 

    oExtrudeDef.SetDistanceExtent

             (5, PartFeatureExtentDirectionEnum.

                      kSymmetricExtentDirection);

 

    ExtrudeFeature oExtrude =

                          default(ExtrudeFeature);

    oExtrude = oCompDef.Features.

                  ExtrudeFeatures.Add(oExtrudeDef);

 

    // Define the set of edges that are for the start

    //and end faces of the solid.

    EdgeCollection oEdges =

                    default(EdgeCollection);

    oEdges = ThisApplication.TransientObjects.

                             CreateEdgeCollection();

 

    foreach (Edge oEdge in oExtrude.

                               StartFaces[1].Edges)

    {

        oEdges.Add(oEdge);

    }

 

    foreach (Edge oEdge in oExtrude.

                                EndFaces[1].Edges)

    {

        oEdges.Add(oEdge);

    }

 

    // Create the fillet feature.

    FilletFeature oFillet = default(FilletFeature);

    oFillet = oCompDef.Features.FilletFeatures.

                              AddSimple(oEdges, 1);

}

- Wayne

Discussion on Client Graphics – Segment 4

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

Note: Segment 3 is here.

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

Download ClientGraphics_Segment_4

Start of segment 4

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

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

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

 

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

Dim oClientGraphics As ClientGraphics
Set oClientGraphics = oIG.OverlayClientGraphics

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

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

 

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

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

 

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

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

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


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

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

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

 

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

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

AU Session - Client Graphics API Exposed

MFG DevBlog post - Complete ClientFeature example in C#

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

- Wayne

Discussion on Client Graphics – Segment 3

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

Note: Segment 2 is here.

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

Download ClientGraphics_Segment_3

Start of segment 3

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

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

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

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

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

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

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

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

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

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

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

End of Segment 3

- Wayne

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

Discussion on Client Graphics

My colleague Xiaodong Liang created a technical paper focusing on client graphics. I thought it would be interesting to present this material. Here is the first installment.

Client Graphics – Introduction

Client graphics provide the ability to draw custom graphics in the Inventor® modeling window. Some common uses of client graphics are to represent custom objects and to create interactive previews during commands, displaying the results of various analyses and for creating custom manipulators within the command. An example is a milling application in CAM, where the toolpath is shown using client graphics. Another example is to show the results of a finite element analysis.

The Inventor API allows you to create these graphics (referred to as Client Graphics) using primitives (points, lines, triangles, text, etc). Client Graphics allow the developer to provide visual cues. Inventor uses this feature itself in many scenarios, for instance, when the user creates an extrusion, a preview of the extruded part is displayed. While defining the extrude feature, a visual cue indicates how the final result will display.  A developer can provide similar visual cues within their own application.

 

API Object Model:

 

Types of Client Graphics:

Regular Client Graphics
This type of client graphics is associated with a document. They are transient unless associated with a client feature. One document/sheet/drawing view can have more than one client graphics object associated with it. Each client graphics object can have many graphics nodes. Each node can contain any number and any type of graphic primitives.

Interaction Client Graphics
This type of client graphics is available when using Interaction Events. It is always transient. The InteractionEvents object can have any number of nodes and graphics primitives, like Regular Client Graphics.

Graphics Data:

In Inventor, most client graphics are defined using two different types of objects; graphics data, and graphic primitives. The graphics data defines the low-level information that can be used to define primitives.  By separating the data from the primitives, the data can be re-used by multiple primitives.

Data Objects
For Point, Line, LineStrip, Triangle, TriangleStrip, and TriangleFans, the data object provides the list of coordinates that your graphics will be based upon, and other necessary data sets such as the color and normals.

Definitions

Coordinate Sets: The coordinates used to specify the vertices for the graphic sets.
Color Sets: A set of colors used by a graphic set. It overrides any other color information assigned to the set. Colors in the color set can be bound to the entire graphic set, each individual primitive in the set (e.g. each triangle in a triangle strip), or each vertex in the set (i.e. interpolated color).
Normal Sets: Contains a set of normal vectors to define how the lighting is calculated for the triangles.
Index Sets: Each graphics primitive can access this set to more efficiently use an associated coordinate or color set.

Subsidiary Objects

TransientGeometry: The TransientGeoemtry object is a utility object you use to create various points, curves, surfaces, and mathematical objects like vectors, and matrices. In association with client graphics, the ability to create different types of curves is useful because you can use these as input to define Curve graphics.
TransientBrep: The TransientBRep object is used to create transient surface and solid models. These can be used to create Surface graphics

General Procedure
Creation of Client Graphics follows the general procedure:
1. Get the GraphicsDataSetsCollection object from the Document
2. Add GraphicsDataSets object and create graphics data
(for Curve or Surface, create graphics data by TransientGeometry and Transient)
3. Get the ClientGraphicsCollection from the graphics owner: 
         Component in part/assembly 
         View/Sheet in drawing
         InteractionEvents for Interaction Client Graphics
         ClientFeatureDefintion for Client Feature
4.    Add a ClientGraphics object to ClientGraphicsCollection
5.    Add as many GraphicsNodes as you need
6.    Add GraphicsPrimitive objects to the node(s)
7.    Assign graphics data to the primitives
8.    Update the view(s)

VB.NET Example:
This example will create a simple client graphic using LineGraphics. See the comments in the code for more details: 

Imports Inventor

 

Public Class Form1

 

    Dim m_inventorApp As Inventor.Application _

                                      = Nothing

 

    Private Sub Button1_Click(ByVal sender As  _

                                System.Object, _

                  ByVal e As System.EventArgs) _

                        Handles Button1.Click

 

        ' Get an active instance of Inventor

        Try

            m_inventorApp = System.Runtime. _

                   InteropServices.Marshal. _

       GetActiveObject("Inventor.Application")

 

        Catch 'Inventor not started

            System.Windows.Forms.MessageBox. _

             Show("Start an Inventor session")

            Exit Sub

        End Try

 

        'Call the Sub

        DrawLineGraphics()

    End Sub

 

    'Draw LineGraphics (two points)

    Public Sub DrawLineGraphics()

        If m_inventorApp.Documents.Count _

                                  < 1 Then

            System.Windows.Forms.MessageBox. _

         Show("Make Assembly or Part current")

            Exit Sub

        End If

 

        Dim oDoc As Document

        oDoc = m_inventorApp.ActiveDocument

 

        If oDoc.DocumentType = DocumentTypeEnum _

                        .kPartDocumentObject Or _

                            oDoc.DocumentType = _

    DocumentTypeEnum.kAssemblyDocumentObject Then

            Try

 

                'Get GraphicsDataSetsCollection

                ' object from the Document.

                'Add a GraphicsDataSets object

                Dim oDataSets As GraphicsDataSets

 

                oDataSets = oDoc. _

         GraphicsDataSetsCollection.Add("TestCG")

 

                Dim oCompDef As ComponentDefinition

                oCompDef = oDoc.ComponentDefinition

 

                'Get the ClientGraphicsCollection

                'from the graphics owner.

                'Add a ClientGraphics

                Dim oClientGraphics As ClientGraphics

                oClientGraphics = oCompDef. _

               ClientGraphicsCollection.Add("TestCG")

 

                Dim coordSet As GraphicsCoordinateSet

                coordSet = oDataSets. _

                               CreateCoordinateSet(1)

 

                'Create graphics data. 

                'In this case, prepare two points

                'for line graphics

                Dim oPointCoords(5) As Double

                oPointCoords(0) = 0 _

              : oPointCoords(1) = 0 _

              : oPointCoords(2) = 0   'point 1

                oPointCoords(3) = 1 _

              : oPointCoords(4) = 0 _

              : oPointCoords(5) = 0   'point 2

 

                Call coordSet.PutCoordinates _

                                      (oPointCoords)

 

                'Add GraphicsNodes

                Dim oGraphicsNode As GraphicsNode

                oGraphicsNode = oClientGraphics. _

                                         AddNode(1)

 

                'Add GraphicsPrimitive to node

                Dim oGraphic As LineGraphics

                oGraphic = oGraphicsNode. _

                                   AddLineGraphics

 

                'Assign graphics data

                'to the primitives

                oGraphic.CoordinateSet = coordSet

 

                'update the view

                m_inventorApp.ActiveView.Update()

 

            Catch ex As Exception

                System.Windows.Forms. _

                   MessageBox.Show(ex.ToString())

                System.Windows.Forms. _

 MessageBox.Show("Prob creating Client Graphics")

            End Try

 

        Else

            System.Windows.Forms. _

   MessageBox.Show("Make Assembly or Part Active")

        End If

    End Sub

End Class