Mod the Machine

2013 Inventor API Survey

2013-05-20T12:09:41-07:00

It’s time again for the annual API survey. Please help us help you by taking a few minutes and filling out the survey. Everyone is welcome to respond. Your answers help us to determine what to work on in upcoming releases of Inventor and help us to justify resources to work on API enhancements. The more responses we get the more we know people care about the API and the more accurate the results will be so we can work on the areas that will best benefit the majority of those using the API.

In question 5 you have a virtual $100 to spend on different API enhancements. Here’s the link to the survey and thank you for taking the time to respond.

Click here to take survey

Note: The survey is ending on the 16th of June.

See this post to see the results from the 2012 survey.

-Wayne

Inventor 2014 new API for sketch creation

2013-05-15T15:41:08-07:00

There are four new API enhancements for sketches. Three of them create sketch curves that could be created from the UI in previous releases. One of the enhancements is new in the UI too.

Slots

In the 2014 release you can now easily create slots.

Creating slots in the API is accomplished by calling one of these Add methods that are on several different sketch objects:

AddArcSlotByCenterPointArc
AddArcSlotByThreePointArc
AddStraightSlotByCenterToCenter
AddStraightSlotByOverall

Here is the signature for AddArcSlotByCenterPointArc:

Sketch.AddArcSlotByCenterPointArc( CenterPoint As Object, StartPoint As Object, SweepAngle As Double, Width As Double )

Equation curves

Inventor 2013 added the ability to create sketch curves using equations. Now you can create curves using equations with the API. The SketchEquationCurve object represents an equation curve within a sketch. Different sketch objects have a SketchEquationCurves collection and you use the Add method to create a SketchEquationCurve. If you have not used equation curves before I would suggest looking at the Inventor help file to see how to create these from the UI. Once you understand how these curves are created in the user interface the arguments in the SketchEquationCurves.Add method will be easier to understand. Here is the signature :

SketchEquationCurves.Add( EquationType As CurveEquationTypeEnum, CoordinateSystemType As CoordinateSystemTypeEnum, XValueOrRadius As String, YValueOrTheta As String, MinValue As Variant, MaxValue As Variant )

Intersection Curves

This is another API enhancement that is catching up to the UI. The IntersectionCurve object represents the results of creating an intersection between different types of geometry. The Sketch3d and Sketch3dProxy now have an IntersectionCurves collection. You use the Add method to create an IntersectionCurve. Here is the signature:

IntersectionCurves.Add( EntityOne As Object, EntityTwo As Object )

Control point splines

Inventor 2013 introduced the ability to create splines using control points. The 2014 API can now create this type of spline. Both 2D and 3D sketch objects have a SketchControlPointSplines collection. (SketchControlPointSplines3D) Use the Add method to create these splines. Here is the signature:

SketchControlPointSplines.Add( ControlPoints As ObjectCollection )

C# example:

Below is one of the functions from this C# project which was translated from the VBA example in the help file. The c# project also has a CreateSlots() function that creates sketch curves by calling the four different methods for creating slots.

Download Inventor_2014_Sketch_Examples

SketchCurves does the following:

1. Creates a sketch and adds a SketchControlPointSpline

2. Creates another sketch and adds a SketchEquationCurve

3. Creates a Sketch3D and adds a SketchControlPointSpline3D

4. Adds a SketchEquationCurve3D to the Sketch3D

5. Adds a surface feature using a profile created using the SketchControlPointSpline from sketch. (step 1)

6. Adds a surface feature using a profile created using the SketchEquationCurve from sketch2. (step 2)

7. Creates another Sketch3D named interSketch, This sketch uses IntersectionCurves.Add

After running the code a new part is created with the geometry

public void SketchCurves()
{
    // Create a new part.
    PartDocument partDoc = 
        (PartDocument)ThisApplication.Documents.Add
             (DocumentTypeEnum.kPartDocumentObject, 
       ThisApplication.FileManager.GetTemplateFile
             (DocumentTypeEnum.kPartDocumentObject));
 
    PartComponentDefinition partDef = 
(PartComponentDefinition)partDoc.ComponentDefinition;
 
    // Create a 2D sketch on the X-Y plane.
    PlanarSketch sketch1 = 
                (PlanarSketch)partDef.Sketches.Add
                             (partDef.WorkPlanes[3]);
 
    TransientGeometry tg = 
(TransientGeometry)ThisApplication.TransientGeometry;
 
    // Create a spline based on control points.
    ObjectCollection pnts = 
    (ObjectCollection)ThisApplication.
        TransientObjects.CreateObjectCollection();
 
    pnts.Add(tg.CreatePoint2d(2, 0));
    pnts.Add(tg.CreatePoint2d(4, 1));
    pnts.Add(tg.CreatePoint2d(4, 2));
    pnts.Add(tg.CreatePoint2d(6, 3));
    pnts.Add(tg.CreatePoint2d(8, 1));
    SketchControlPointSpline controlPointSpline = 
                 (SketchControlPointSpline)sketch1.
               SketchControlPointSplines.Add(pnts);
 
    // Create a 2D sketch on the Y-Z plane.
    PlanarSketch sketch2 = 
        (PlanarSketch)partDef.Sketches.Add
                         (partDef.WorkPlanes[1]);
 
    // Create a spline based on an equation.
    SketchEquationCurve equationCurve = 
(SketchEquationCurve)sketch2.SketchEquationCurves.
            Add(CurveEquationTypeEnum.kParametric, 
              CoordinateSystemTypeEnum.kCartesian, 
             ".001*t * cos(t)", ".001*t * sin(t)",
                                     0.1, 360 * 3);
 
    // Create a 3D sketch.
    Sketch3D sketch3 = 
            (Sketch3D)partDef.Sketches3D.Add();
 
    // Create a 3D spline based on control points.
    pnts = ThisApplication.TransientObjects.
                         CreateObjectCollection();
    pnts.Add(tg.CreatePoint(10, 0, 0));
    pnts.Add(tg.CreatePoint(12, 1, 3));
    pnts.Add(tg.CreatePoint(12, 2, -5));
    pnts.Add(tg.CreatePoint(14, 3, 2));
    pnts.Add(tg.CreatePoint(16, 1, -3));
 SketchControlPointSpline3D controlPointSpline2 = 
             (SketchControlPointSpline3D)sketch3.
           SketchControlPointSplines3D.Add(pnts);
 
    // Create a 3D spline based on an equation.
    SketchEquationCurve3D equationCurve2 = 
        (SketchEquationCurve3D)sketch3.
           SketchEquationCurves3D.Add
           (CoordinateSystemTypeEnum.kCartesian,
       ".001*t * cos(t) + 8", ".001*t * sin(t)", 
                         "0.002*t", 0, 360 * 3);
 
    ThisApplication.ActiveView.Fit();
 
    // Extrude the 2d curves.
    Profile prof = default(Profile);
    prof = sketch1.Profiles.AddForSurface
                        (controlPointSpline);
    ExtrudeDefinition extrudeDef = 
        (ExtrudeDefinition)partDef.Features.
        ExtrudeFeatures.CreateExtrudeDefinition
(prof, PartFeatureOperationEnum.kSurfaceOperation);
 
    extrudeDef.SetDistanceExtent(6, 
                  PartFeatureExtentDirectionEnum.
                        kSymmetricExtentDirection);
 
    ExtrudeFeature extrude1 = 
                     (ExtrudeFeature)partDef.
          Features.ExtrudeFeatures.Add(extrudeDef);
 
    // Change the work surface to 
    // not be transparent.
    WorkSurface surf = default(WorkSurface);
    surf = extrude1.SurfaceBodies[1].Parent;
    surf.Translucent = false;
 
    prof = sketch2.Profiles.
                   AddForSurface(equationCurve);
 
    extrudeDef = partDef.Features.ExtrudeFeatures.
        CreateExtrudeDefinition
(prof, PartFeatureOperationEnum.kSurfaceOperation);
    extrudeDef.SetDistanceExtent(9, 
        PartFeatureExtentDirectionEnum.
                          kPositiveExtentDirection);
    ExtrudeFeature extrude2 = 
        (ExtrudeFeature)partDef.Features.
                    ExtrudeFeatures.Add(extrudeDef);
 
    // Create a new sketch and an 
    //intersection curve.
    Sketch3D interSketch = 
        (Sketch3D)partDef.Sketches3D.Add();
 
    interSketch.IntersectionCurves.Add
              (extrude1.SurfaceBodies[1], 
                  extrude2.SurfaceBodies[1]);
}

-Wayne

Inventor 2014 API for the new Joint feature

2013-04-12T18:16:05-07:00

One focus of the 2014 release is “Ease of use”. An example of this is the new Joint command that will definitely make it easier to make relationships between parts in an assembly. This command is on the Assemble tab next to Constrain.

When you run this command new graphic feedback shows you where the joints could be added before you add the joint.

API Support for Joints

The API also supports Joints. Here are several of the new classes, new method and an enum related to Joints.

AssemblyJoint, AssemblyJointDefinition

AssemblyComponentDefinition.Joints (collection)

AssemblyJointTypeEnum, CreateAssemblyJointDefinition

You use an AssemblyJointDefinition as input to create a joint. To create this use the CreateAssemblyJointDefinition method of the Joints collection. (Property of the AssemblyComponentDefinition) This method takes a Joint Type and two GeometryIntent objects. If you have used the API to create drawing annotations you will be familiar with GeometryIntent objects. To create the joint use the Add method of the Joints collection.

Below are the functions from this C# example that create a joint. (zip includes the ipt) This example was converted to C# from the VBA example in the help file. After you run the example you will see a new assembly with two components that share a joint.

I dragged the part (rotated) to show the joint.

C# functions:

public void AssemblyJoint()
{
    // Create a new assembly document.
    AssemblyDocument asmDoc =
(AssemblyDocument)ThisApplication.Documents.Add 
      (DocumentTypeEnum.kAssemblyDocumentObject, 
     ThisApplication.FileManager.GetTemplateFile
    (DocumentTypeEnum.kAssemblyDocumentObject));
 
    AssemblyComponentDefinition asmDef = 
                     asmDoc.ComponentDefinition;
 
    Matrix trans = 
ThisApplication.TransientGeometry.CreateMatrix();
 
    // Place an occurrence into the assembly.
    ComponentOccurrence occ1 = 
        asmDef.Occurrences.Add
("C:\\Inventor2014APISamples\\SamplePart.ipt",
                                         trans);
 
    // Place a second occurrence with the matrix 
    //adjusted so it fits correctly with the 
    //first occurrence.
    trans.Cell[1, 4] = 6 * 2.54;
    ComponentOccurrence occ2 = 
        asmDef.Occurrences.Add
("C:\\Inventor2014APISamples\\SamplePart.ipt", 
                                         trans);
 
    // Get Face 1 from occ1 and 
    // create a FaceProxy.
    Face face1 = 
        (Face)GetNamedEntity(occ1, "Face1");
 
    // Get Face 2 from occ2 and 
    // create a FaceProxy.
    Face face2 = 
        (Face)GetNamedEntity(occ2, "Face2");
 
    // Get Edge 1 from occ2 and  
    // create an EdgeProxy.
    Edge Edge1 = 
        (Edge)GetNamedEntity(occ2, "Edge1");
 
    // Get Edge 3 from occ1 and 
    // create an EdgeProxy.
    Edge Edge3 = 
        (Edge)GetNamedEntity(occ1, "Edge3");
 
    // Create an intent to the 
    // center of Edge1.
    GeometryIntent edge1Intent = 
        asmDef.CreateGeometryIntent
    (Edge1, PointIntentEnum.kMidPointIntent);
 
    // Create an intent to the center of Edge3.
    GeometryIntent edge3Intent = 
        asmDef.CreateGeometryIntent
        (Edge3, PointIntentEnum.kMidPointIntent);
 
    // Create two intents to define 
    // the geometry for the joint.
    GeometryIntent intentOne = 
        asmDef.CreateGeometryIntent
                        (face2, edge1Intent);
    GeometryIntent intentTwo = 
        asmDef.CreateGeometryIntent
                        (face1, edge3Intent);
 
    // Create a rotation joint between the two parts.
    AssemblyJointDefinition jointDef = 
       asmDef.Joints.CreateAssemblyJointDefinition
       (AssemblyJointTypeEnum.kRotationalJointType, 
                             intentOne, intentTwo);
 
    jointDef.FlipAlignmentDirection = false;
    jointDef.FlipOriginDirection = true;
    AssemblyJoint joint = 
                   asmDef.Joints.Add(jointDef);
 
    // Make the joint visible.
    joint.Visible = true;
 
    // Drive the joint to animate it.
    joint.DriveSettings.StartValue = "0 deg";
    joint.DriveSettings.EndValue = "180 deg";
    joint.DriveSettings.GoToStart();
    joint.DriveSettings.PlayForward();
    joint.DriveSettings.PlayReverse();
 
}
 
 
// This finds the entity associated with 
// an iMate of a specified name.  This
// allows iMates to be used as a generic 
// naming mechansim.
private object GetNamedEntity
    (ComponentOccurrence Occurrence, string Name)
{
        // Look for the iMate that has the 
        // specified name in the referenced file.
        PartComponentDefinition partDef = 
   (PartComponentDefinition)Occurrence.Definition;
 
        object resultEntity = null;
        resultEntity = null;
 
        foreach (iMateDefinition iMate 
                    in partDef.iMateDefinitions) 
        {
            // Check to see if this iMate has 
            // the correct name
            if (iMate.Name.ToUpper() == 
                                Name.ToUpper()) 
            {
             // Get the geometry associated 
             // with the iMate. Using InvokeMember
             // because the iMateDefinition is the
             // base class and does not have an 
             // Entity property
              object entity = null;
              entity = iMate.GetType().InvokeMember
                           ("Entity",
                            BindingFlags.GetProperty,
                            null, iMate, null);
 
                // Create a proxy.
                Occurrence.CreateGeometryProxy
                    (entity, out resultEntity);
                break; 
            }
        }
 
        // Return the found entity, or Nothing  
        // if a match wasn't found.
        return resultEntity;
}

-Wayne

Control feature creation based on user defined boundary

2013-03-29T15:25:59-07:00

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

Inventor 2014 API Enhancements

2013-03-27T13:55:04-07:00

Inventor 2014 was officially released yesterday. Here’s a quick overview of the API enhancements for this release. I’ll go into more detail of some of them in later posts.

Support for dimension styles. The API previously had minimal support for all of the settings associated with a dimension style. This was also one of the highest requested enhancements from the yearly API survey. With Inventor 2014 all of the settings are now available from the API, with the exception of those on the “Notes and Leaders” tab. The notes and leaders settings are quite a bit more complicated and will need to wait until later.
API support for the new types of sketch curves. Inventor 2013 introduced two new curve types; control point and equation curves in both 2D and 3D sketches. There is now full API support for both types in both 2D and 3D sketches.
API support for 3D intersection curves. Inventor has supported the ability to create an intersection curve between two surfaces for a long time. This capability is now also supported through the API.
Inventor 2014 introduces some new sketch command for drawing slots. There are also API methods that provide the equivalent capability to the commands.
Inventor 2014 introduces a new feature that can significantly improve performance for very large assemblies called assembly Express Mode. There is full API support for this.
Another new feature in Inventor 2014 is assembly joints. Joints are a more user-friendly type of constraint. An assembly can use both the traditional constraints and joints to define the relationships between parts. There is full API support for joints.
Inventor and the API now support creating work points at the centers of spheres.
The API supports a new enhancement to the boundary patch feature where the weight, or smoothness, can be controlled for each selected edge.
The API now supports the ability to imprint solids. This takes two bodies as input and creates two new bodies where the faces on the new bodies have been split where any of the faces were overlapping between the bodies. This is important for analysis applications to control where nodes on their mesh are created.
The API now fully supports consistent materials. Consistent materials was introduced with Inventor 2013. There wasn’t time to do the equivalent API work at the time but there was some work done so the Material and RenderStyle objects would work with consistent materials. This works ok but has some issues because the old Material and RenderStyle objects are not a one-for-one match to the new consistent material functionality. With Inventor 2014 new API functionality has been introduced that fully supports consistent materials.
There is now API support for Pack & Go.
A few updates were made to the BIM exchange API in reaction to some enhancements made in the product.
Inventor now supports VBA 7. VBA 7 is able to run natively on both 32 and 64-bit Windows. The previous VBA only supported 32-bit Windows, so this is great news for those running 64-bit Windows. With earlier version of Inventor on a 64-bit system, in order to support VBA at all, Inventor would spawn a separate 32-bit process that would host VBA. This is no longer required and as a result there is no longer any delay when accessing VBA and your macros will also run much faster. As a side benefit, the scroll button now scrolls the code window.

-Brian

DevTech Team Meeting in San Rafael CA

2013-03-18T13:52:42-07:00

I work for an organization at Autodesk named Developer Technical services. (We support the Autodesk Developer Network). This last week the DevTech Americas team had a meeting at one of the Autodesk offices in San Rafael California. (Colleagues from Europe and the Media and Entertainment team where there too.) We had one and a half days of presentations. Some of the presentations centered around what we have been doing lately to learn cloud and mobile. My favorite presentation was by Philippe Leefsma on HTML 5. Philippe had many examples of what you can do using this technology. (I really liked the one on voice recognition) He has made several posts recently on the Cloud & Mobile DevBlog such as this one:

First try at Windows 8 programming with JavaScript & HTML5

I thought the presentation by Gopinath Taget on what he has been doing to learn cloud security was also very interesting. He talks about this on the Cloud & Mobile DevBlog as well:

Cloud Security: Securing with SSL – Using Fiddler

The other presentations were great too. My short presentation was on my experiences getting up to speed on Python.

Jim Quanci leading one of the presentations

Fun and Interesting

Monday night we had a DevTech grand prix. (electric Go-Carts) We all tried our best to get to the winners circle but in the end Fenton Webb’s experience with high speed maneuvers allowed him to take the top prize.

The race is on

Tuesday afternoon we were fortunate to get a tour of the California Academy of Sciences building in San Francisco. The building is a great example of how the design of the building effects energy usage.

This is the roof of the museum. The top is six inches of dirt and all of the plants are native to California. The windows open depending on the heat inside.

Team meetings like this are one reason I appreciate working for Autodesk.

-Wayne

Inventor API Training Lesson 12

2013-03-06T17:51:49-08:00

Here is section twelve of the Inventor API training where you see how Apprentice is used to access Inventor Data without having to use Inventor. You also learn about the Inventor viewer control. This is the fourth post with the Inventor API training material. (Section one is here).

Here is the agenda for this section. Be sure to see the Lab instructions at the end of this section. (completed samples in VB.NET and C# are available)

Apprentice Definition
Apprentice Functionalities
Apprentice Guidelines
Apprentice vs. Inventor: Differences
Saving Files with Apprentice

Inventor View Control

Apprentice Definition

This diagram shows where the API for Apprentice fits in . You use a stand alone client application, reference the Inventor API and use the apprentice classes to access Inventor data.

Apprentice provides a subset of the Inventor API and is
free as it is installed as part of Inventor View. A simple way to think of Apprentice is that it's a smaller version of Autodesk Inventor that does not have a user interface. Because there is not a user interface the only way to access its functionality is by using its API. Apprentice can be very efficient for certain applications because it's smaller than the complete Autodesk Inventor application and because it runs in the same process as your application.

Apprentice Functionalities

Apprentice provides read-only access to the following:

Assembly structure
B-Rep
Drawing sheets and views (limited access)
iParts
iAssemblies
BOM

Apprentice provides read / write access to the following:

iProperties
attributes
file references

Apprentice – Guidelines

Apprentice should NOT be used in-process with Inventor such as in an Add-In or through Inventor’s VBA. (If the Add-In is an exe type then it is ok).

In past releases a type library specifically for Apprentice was delivered with both Autodesk Inventor and Apprentice. This type library contained the limited set of objects supported only by Apprentice. Now the Autodesk Inventor type library contains all of the Apprentice functionality and is used to access Apprentice. (You add a reference to Inventor.Interop for an Apprentice project). A version of the old Apprentice type library is still supplied for legacy reasons, but this will likely be discontinued in future releases.

Apprentice vs. Inventor: differences

Apprentice is instantiated using a “new ApprenticeServerComponent”. (Instantiating Inventor would be done using something like CreateObject)

The ApprenticeServerComponent supports a few methods and properties that are unique to Apprentice.

Open and Close methods, which are used to open and close documents within Apprentice

DisplayAffinity, which is used to optimize the behavior of Apprentice for viewer applications

MinimizeFileSize, which compresses files by removing versions

FileSaveAs, used to save files

The document objects used within Apprentice are different from the document objects used in Autodesk Inventor. (Apprentice does not have a Documents collection) In Inventor there are the PartDocument, AssemblyDocument, DrawingDocument, and PresentationDocument objects. In Apprentice, the ApprenticeServerDocument object represents the part, assembly, and presentation documents and the ApprenticeServerDrawingDocument represents the drawing document.

Note: Apprentice cannot save a file from a previous version. You would need to migrate the file prior to saving it with Apprentice. (To migrate a file, open it with Inventor, save it and close it).

VB.NET Example that uses Apprentice to open an ipt file

Private Sub ApprenticeSample()

    ' Create Apprentice.

    Dim oApprentice As ApprenticeServerComponent

    oApprentice = New ApprenticeServerComponent

    ' Open a document.

    Dim oDoc As ApprenticeServerDocument

    oDoc = oApprentice.Open("C:\Temp\Part1.ipt")

    MsgBox("Opened: " & oDoc.DisplayName)

End Sub

Saving Files with Apprentice

Use FlushToFile if the code is only modifying iProperties. This is   more efficient because the document is not written back.

VB.NET Example that uses FlushToFile after changing iProps

Private Sub SetProperty(ByVal author As String)

    Dim oApprenticeDoc As ApprenticeServerDocument

    oApprenticeDoc = mApprenticeServer.Open _

                       ("c:\Temp\MyPart.ipt")

    'Get "Inventor Summary Information" PropertySet

    Dim oPropertySet As PropertySet

    oPropertySet = oApprenticeDoc.PropertySets _

     ("{F29F85E0-4FF9-1068-AB91-08002B27B3D9}")

    'Get Author property

    Dim oProperty As Inventor.Property =

                       oPropertySet.Item("Author")

    oProperty.Value = author

    oApprenticeDoc.PropertySets.FlushToFile()

    oApprenticeDoc.Close()

End Sub

VB.NET Example that uses the FileSaveAs to make a copy

Public Sub saveToNewFile()

    ' Create an instance of Apprentice.

    Dim apprentice As New _

    Inventor.ApprenticeServerComponent()

    ' Open a part

    Dim appDoc As _

    Inventor.ApprenticeServerDocument _

      = apprentice.Open _

                  ("C:\Temp\Part1.ipt")

    ' Save the file to a new name

    Dim myFileSaveAs As FileSaveAs =

                  apprentice.FileSaveAs

    myFileSaveAs.AddFileToSave _

    (appDoc, "C:\Temp\Part1_update.ipt")

    myFileSaveAs.ExecuteSaveCopyAs()

    appDoc.Close()

End Sub

Transient Camera

You can create image files by getting the camera from the TransientObjects of the ApprenticeServerComponent CreateCamera method.

VB.NET example that opens a part and creates a jpg file

Public Sub saveMyImage()

    ' Create an instance of Apprentice.

    Dim apprentice As New _

    Inventor.ApprenticeServerComponent()

    ' Open the specified file.

    Dim appDoc As _

    Inventor.ApprenticeServerDocument _

      = apprentice.Open("C:\Temp\Part1.ipt")

    ' Create a camera.

    Dim cam As Inventor.Camera =

apprentice.TransientObjects.CreateCamera

    ' Associate the camera with the part's

    ' component definition.

    cam.SceneObject =

                appDoc.ComponentDefinition

    ' Set the camera to the desired

    ' orientation and position.

    cam.ViewOrientationType =

        Inventor.ViewOrientationTypeEnum.

               kIsoTopRightViewOrientation

    cam.Fit()

    cam.ApplyWithoutTransition()

    'cam.Apply()

    Dim oTOs As TransientObjects

    oTOs = apprentice.TransientObjects

    Dim oTopColor As Color

    oTopColor =

        oTOs.CreateColor(255, 0, 0)

    Dim oBottomColor As Color

    oBottomColor =

        oTOs.CreateColor(255, 255, 255)

    ' Create an jpg file

    cam.SaveAsBitmap("C:\Temp\Part1.jpg",

        800, 600, oTopColor, oBottomColor)

End Sub

Inventor View Control

You can use a control that is installed with Inventor View to view Inventor files in your own application. The control is named InventorViewCtrl.ocx. To add it to your project in Visual Studio right click on the Toolbox and select “Choose Items…” On the COM Components tab select it. Once it is in the Toolbox select it and place it on your form.

Note: To work with Inventor View control of 2013 use .NET framework 3.5

Before Inventor 2012, InventorViewCtrl.ocx was registered automatically with product. Starting from 2012, the registry-free was introduced. So plug-in developers have to link the corresponding manifest files to their application if they want to use the OCX.

Two options:
1. Use mt.exe to generate manifest file by yourself and link the manifest file to your application.
2. Use old style. But you have to register InventorViewCtrl.ocx manually by running “Regsvr32 InventorViewCtrl.ocx”.

See the post here for more information about this:

http://adndevblog.typepad.com/manufacturing/2012/05/inventor-view-control-is-not-registered-on-inventor-2012.html

Lab work with Apprentice API

Create a Windows Forms application that has two buttons a label and a TextBox. When one of the buttons is clicked, provide the user with a way to select a part file (ipt). Once the file is selected create a jpg from the file. When the other button is selected open a file and update the Author iProperty with the value in the TextBox.

Lab – use the view control

Create a Windows Forms application that has the viewer control and a button. When the user clicks the button display the file in the viewer control.

Here are examples of the completed Labs. (VB.NET and C#) The zip also contains the ppt we use for the training.

Download Inventor_Training_Module_12_Samples

-Wayne

Inventor API Training Lesson 2

2013-02-25T14:56:53-08:00

Here is section two of the Inventor API training where you see how the API is used to create and access Inventor documents. This section also covers iProperties, working with units, and parameters. This is the third post with the Inventor API training material. (Section one is here).

Common Document Functionalities

Here is the agenda for this section. Be sure to see the Lab instructions at the end of this section. (completed samples in VB.NET and C# are available)

Document Types
Working with Documents
Document Settings
iProperties
Units of Measure
Parameters

Document Types

Inventor has unique document types for different types of data.
Part Documents (*.ipt)
Assembly Documents (*.iam)
Drawing Documents (*.idw)
Presentation Documents (*.ipn)
The API represents each document type using a different type of object for each type of document.

Accessing Documents
Documents.Add()

To create a new document use the Add method of the Documents collection. This method takes a DocumentTypeEnum which determines which type of document to create. (first argument) You can have a file that you can use as a template. To use that file, you provide a string that is a path to the file. (second argument). The third argument of the Add method is a boolean that determines if the file is opened visible or not. The GetTemplateFile method of the FileManager object allows you to use the default template and change settings for the file that is being created. (You can use this for the second argument of the Add method)
Documents.Open()

The Open method of the documents collection will open existing documents. The first argument is a string with the file path of the document and the second is a boolean that controls the visibility.
Documents.Item()

You use the Item property to access currently open documents. The ActiveDocument property of the Application will get you the current document.

Opening and Creating Documents VB.NET examples

'Opens an existing document.assume part1.ipt exists

Public Sub OpenDoc()

    Dim oDoc As Document

    oDoc = _InvApplication.Documents.Open _

                             ("C:\Temp\Part1.ipt")

End Sub

'Creates a new document using a specified template.

Public Sub CreateDoc()

    Dim oDoc As PartDocument

    oDoc = _InvApplication.Documents.Add _

          (DocumentTypeEnum.kPartDocumentObject, _

     _InvApplication.FileManager.GetTemplateFile _

   (DocumentTypeEnum.kPartDocumentObject), True)

End Sub

'Creates a new document using internally

'defined template. (Can be done in the UI by

'using Ctrl-Shift when creating new document.)

Public Sub CreateDoc2()

    Dim oDoc As PartDocument

    oDoc = _InvApplication.Documents.Add _

(DocumentTypeEnum.kPartDocumentObject, , True)

End Sub

Saving Documents

The first time a new document is saved you should use the SaveAs method with the SaveCopyAs flag set to False.

Dim oDoc As PartDocument

    oDoc = _InvApplication.Documents.Add _

          (DocumentTypeEnum.kPartDocumentObject)

    oDoc.SaveAs("C:\Temp\SaveTest.ipt", False)

For documents that have been saved to disk you can use the Save method or the SaveAs with the SaveCopyAs flag set to True to create a copy. An error will occur if the file name parameter is the same as the open document. (keep in mind that the method will overwrite existing files).

    oDoc.Save()

    oDoc.SaveAs("C:\Temp\SaveTest2.ipt", True)

You can use the FileSaveCounter property of the document to determine if the document has been saved.

Closing Documents

To close a document call the Close method. You can use the SkipSave parameter to close it without saving.

Document.Close([SkipSave As Boolean = False])

Using the SkipSave argument you can bypass the dialog asking to save the changes and force the document to close without saving. This is useful in cases where you use a file as a template by opening the file, modifying it in some way, and using SaveCopyAs to save it as a new file. Using this you can close the original without saving and without forcing the user to interact with a dialog.

The API has a way to close all documents. Using this method will not save any changes to documents.

Documents.CloseAll([UnreferencedOnly As Boolean = False])

Document Settings

Document settings are exposed from various objects obtained from the document.

In this excerpt from the object model diagram you can see the objects that will allow you to get and update document settings. Notice that these objects are accessed by using properties of the document.

iProperties

iProperties in the User Interface

iProperties are used to associate information with a document. There are a predefined set of properties are available through the iProperties dialog. End-users can create additional properties using the “Custom” tab of the iProperties dialog. These properties are supported by both Inventor and Apprentice.

iProperties – Property Sets

The PropertySets object acts as the container for all of the properties.

The PropertySets object provides access to the individual PropertySet objects using the Item property.

iProperties – Property Set

The PropertySet object contains a group of properties.

Most PropertySet objects roughly correspond to the tabs in the iProperties dialog. PropertySet objects are identified by the following:
InternalName (consistent)
Name (consistent)
DisplayName (may change)

iProperties - Property

Properties are named values and they are identified by:
ID (consistent)
Name (consistent)
DisplayName (may change)

Property values

Property values are stored internally as Variants. The following types are supported: Integer, Long, Double, String, Date, and Boolean. (With the exception of the thumbnail image which is IPictureDisp.)

PropId’s are defined in the various property related enums.

iProperty Names
Name and Internal Name of Inventor defined property sets:

Inventor Summary Information

{F29F85E0-4FF9-1068-AB91-08002B27B3D9}

Inventor Document Summary Information

{D5CDD502-2E9C-101B-9397-08002B2CF9AE}

Design Tracking Properties

{32853F0F-3444-11D1-9E93-0060B03C1CA6}

Inventor User Defined Properties

{D5CDD505-2E9C-101B-9397-08002B2CF9AE}

InternalNames can be found using the Object Browser and in SDK\Include\PropFMTIDs.h

VB.NET Example of changing an iProperty

' Access "Design Tracking Properties"

' "Designer" and change its value

Public Sub iPropAccess()

    Dim oDoc As Document

    oDoc = _InvApplication.ActiveDocument

    ' Access a particular property set.

    ' Design tracking property set.

    Dim oDTProps As PropertySet

    oDTProps = oDoc.PropertySets.Item _

("{32853F0F-3444-11d1-9E93-0060B03C1CA6}")

    ' Access the same property set using

    ' the display name or name.

    ' DisplayName is not dependable

    ' because it can be localized, so

    'the internal name or name is preferred.

    oDTProps = oDoc.PropertySets.Item _

             ("Design Tracking Properties")

    ' Get a specific property, in this case

    ' the designer property.

    Dim oDesignerProp As Inventor.Property

    oDesignerProp = oDTProps.ItemByPropId( _

PropertiesForDesignTrackingPropertiesEnum _

         .kDesignerDesignTrackingProperties)

    ' You can also use the name or display name

    ' the display name has the problem that

    ' it can be changed.

    oDesignerProp = oDTProps.Item("Designer")

    ' Show the display name and value.

    Debug.Print(oDesignerProp.DisplayName _

                & " = " & oDesignerProp.Value)

    ' Change the designer name.

    oDesignerProp.Value = "Bill & Ted"

End Sub

iProperties - Creation

To create new property set use the Add method of the PropertySets collection. (Name and InternalName must be unique with respect to other property sets in the document).

PropertySets.Add(Name As String, [InternalName]) As PropertySet

To create and add new properties to the PropertySet use the Add method. Keep in mind that properties cannot be added to the predefined sets, except for the custom property set. Also the
name and PropId must be unique with respect to other properties in the property set. The value type can be most Variant types except arrays and objects.

PropertySet.Add(PropValue, [Name], [PropId]) As Property

Note: PropertySets and Properties can be created as hidden by using a name that begins with an underscore. These will not be returned by indexing through a collection. They can only be retrieved by asking for them by name.

Units of Measure

When you use Inventor manually there is a setting that controls the units that are used. When using the API numbers are always in the same internal units and your code needs to convert between units to get the correct behavior. (unless the document settings are using the same internal units).

All Inventor documents use these internal units.
Length: Centimeters
Angle: Radians
Time: Second
Mass: Kilogram

The units specified by the end-user in the Document Settings dialog are used to convert internal units to/from the units the end-user wants to use.

UnitsOfMeasure object

The UnitsOfMeasure object allows you to work with different units. It provides utilities to help with unit handling, primarily the conversion between strings and values. If you are working with numbers you will most likely need to use UnitsOfMeasure to get the results you expect.

A unique UnitsOfMeasure object can be obtained from each document. The UnitsOfMeasure object obtained from a document can be used for unit conversion and also provides a way to control unit settings for the document. The UnitsOfMeasure obtained from the Application object can be used for unit conversion.

Units of Measure - Unit Types
Whenever a unit type is specified within the API, it can be defined in two different ways:

1. As a value from UnitsTypeEnum with a specific unit type such as:

kInchLengthUnits, kMillimeterLengthUnits, kDegreeAngleUnits.

The current default type specified by the end-user: kDefaultDisplayLengthUnits, kDefaultDisplayAngleUnits.
The internal base units: kDatabaseLengthUnits, kDatabaseAngleUnits.

2. As a string, i.e. “in”, “mm mm mm”, “m ^ 3”, “m /(s s)”

Units of Measure – Internal Units

Internally, Inventor uses a consistent set of units regardless of what the user has specified as the document default and the precision is always double-precision floating point,

Internal units used by Inventor for the various types of units

VB.NET - UnitsOfMeasure to get valid input from the user

Private m_oUOM As UnitsOfMeasure

Private Sub UserForm_Initialize()

    ' get the UnitsOfMeasure of the

    ' current document

    m_oUOM = _InvApplication.

        ActiveDocument.UnitsOfMeasure

End Sub

Private Sub TextBox1_Change()

    ' Check if the input string defines

    'a valid length.

    If Not m_oUOM.IsExpressionValid _

        (TextBox1.Text, _

   UnitsTypeEnum.kDefaultDisplayLengthUnits) Then

        ' The string is not valid so change

        ' the text color to red.

        TextBox1.ForeColor =

                   Drawing.Color.Red

    Else

        ' The string is valid so change

        'the text color to the default color.

        TextBox1.ForeColor =

                      Drawing.Color.Black

    End If

End Sub

VB.NET – UnitsOfMeasure - Using user Input

' Get the real value of the input string.

    Dim dValue As Double

    dValue = m_oUOM.GetValueFromExpression _

                           (txtInput.Text, _

   UnitsTypeEnum.kDefaultDisplayLengthUnits)

    ' Compare the value with the length of

    ' a sketch line.

    If System.Math.Abs)

(oSketchLine.Length - dValue)_ < 0.00001 Then

        MsgBox _

         ("Line is equal to the input value")

    Else

        MsgBox _

     ("Line is not equal to the input value")

    End If

VB.NET UnitsOfMeasure - Displaying Values

In this example a double (centimeters) is passed into a function that gets the value of the double in the units that are current and returns it as a string.

Private Sub TestLength()

    ShowLength(6.5)

End Sub

Private Sub ShowLength(ByVal dLength As Double)

    ' Get the string representation of the length.

    Dim strLength As String

    strLength = m_oUOM.GetStringFromValue _

                                (dLength, _

   UnitsTypeEnum.kDefaultDisplayLengthUnits)

    MsgBox("The Length is: " & strLength)

End Sub

Parameters

Component Definition

The Component definition will be discussed in following lessons. However we need to introduce it here because parameters are obtained form properties of the component definition. This excerpt from the Object Model diagram shows the property that will allow you to get the Component Definition of a document. (Drawings don’t have a ComponentDefinition).

Parameters - In the User Interface

Parameters – In the API

Notice how the Parameters collection is obtained from a PartComponentDefinition or AssemblyComponentDefinition

In this VB.NET code snippet the Parameters are accessed.

' Get the Parameters collection object.

    Dim oParameters As Parameters = _

    _InvApplication.ActiveDocument.

            ComponentDefinition.Parameters

Parameters – UI vs. API

On the left in this picture you can see settings from the parameters dialog. The text on the right shows how a similar setting would be made using the API.

VB.NET - Parameters - Setting Values

Public Sub SetParameter()

    ' Get the Parameters object. Assumes

    'a part or assembly document is active.

    Dim oParameters As Parameters

    oParameters = _InvApplication.

   ActiveDocument.ComponentDefinition.Parameters

    ' Get the parameter named "Length".

    Dim oLengthParam As Parameter

    oLengthParam = oParameters.Item _

                              ("Length")

    ' Change the equation of the parameter.

    oLengthParam.Expression = "3.5 in"

    ' Update the document.

    _InvApplication.ActiveDocument.Update()

End Sub

Parameters – Units

The Unit property can be set using either a String or a value from UnitsTypeEnum. This enum is an API equivalent to the pre-defined unit types displayed in the Unit Type dialog.

Setting the unit type using a String is the same as defining a unit in the Unit Type dialog and allows you to define custom unit types by combining known unit types.

Parameters – Values

Unlike in the user-interface, the API allows you to directly set the value of a parameter. The Value property sets the actual value of the parameter and will overwrite any existing equation.

Note: In API, Parameter values are always defined using internal units. (use UnitsOfMeasure to convert)
Length – Centimeters
Angle – Radians
π radians = 180 degrees
π = Atn(1) * 4

Parameters - Tolerances
Tolerances can be defined for Model parameters. The Tolerance object exposes functionalities of the Tolerance dialog.

The SetToDefault, SetToDeviation, SetToLimits, etc… methods of the Parameter object allow you to define the parameter’s tolerance.
    Call oParam.Tolerance.SetToDeviation("0.125 in", “-0.0625 in")
    Call oParam.Tolerance.SetToDeviation(2.54 / 8, -2.54 / 16)

The ModelValueType property sets which tolerance to use when computing the model value.The Precision property sets the number of decimal places to display.

The SetAllToMax, SetAllToMedian, SetAllToMin, SetAllToNominal methods of the Parameters object provides the equivalent of the Parameter dialog’s “Reset Tolerance”.

Parameters – Parameter Types

The Parameters collection returns all Parameter objects regardless of the type. The ModelParameters, ParameterTables, ReferenceParameters, and UserParameters objects provide access to specific types of parameters.

Parameters – Parameter Creation

Parameters are created by using methods on the collection for the specific type of parameter you want to create. In the user-interface you can only create user parameters. All other types are indirectly created as a result of other actions. In the API you can directly create user, model, and reference parameters. TableParameters are created by importing an Excel worksheet. Parameters are created using either the AddByExpression or AddByValue methods

VB.NET - Creating Parameters

' add user parameters

    Dim oUserParams As UserParameters

    oUserParams = oCompDef.Parameters.

                        UserParameters

    Dim oParam As Parameter

    oParam = oUserParams.AddByExpression _

        ("NewParam1", "3", _

           UnitsTypeEnum.kInchLengthUnits)

    oParam = oUserParams.AddByExpression _

                  ("NewParam1", "3", "in")

    oParam = oUserParams.AddByExpression _

                      ("NewParam2", "3", _

UnitsTypeEnum.kDefaultDisplayLengthUnits)

    oParam = oUserParams.AddByExpression _

                   ("NewParam2", "3 in", _

UnitsTypeEnum.kDefaultDisplayLengthUnits)

    oParam = oUserParams.AddByValue _

            ("NewParam3", 3 * 2.54, _

UnitsTypeEnum.kDefaultDisplayLengthUnits)

Parameters – API Only Functionality

Creation of Model and Reference parameters.
Delete unused Model and Referenced Parameters.
DisabledActionTypes – Prohibit deletion of user parameters.
Dependents, DrivenBy – Provides dependency information between parameters.
Creation of custom parameter groups.
Change the type of a parameter.

Model to Reference
Reference to Model
User to Model
User to Reference

Lab: iProperties

Write a .Net program that performs the following steps:
1. Create a new part document.
2. Edit the value of the author property to contain your name.
3. Create a new custom (user-defined) property

4. Save the document

5. Close the document.

Lab: Parameters and UOM
1. Interactively create a simple part that contains a parameter named “Length” to control the size of the part.

2. Create a .Net program that contains a dialog that looks similar to this:

3. The end-user should have created a parameter named “Length” which is a numeric. By this code, he is able to enter any valid expression. The text field should provide feedback when an invalid expression has been defined.

4. When the “Update” button is pressed the entered value should be assigned to the parameter

Here are examples of the completed Labs. (VB.NET and C#) It also contains the ppt we use for the training and another project with some sample code.

Download Inventor_Training_Module_02_Samples

-Wayne

Inventor API Training Lesson 11

2013-02-18T10:47:49-08:00

Here is section eleven of the Inventor API training. In this section we cover how to use the API to print and translate files. There are 21 sections to this training and we decided that they did not need to be posted in order. (Section one is here). I am going to alternate posts between sections 1-10 and 10-21.

Printing and Translating Files

Here is the agenda for this section. Be sure to see the Lab instructions at the end of this section. (completed sample is available)

PrintManager Object
DrawingPrintManager
Printing Example
File Translation
Accessing Translators Options
DataIO Object

PrintManager Object

The PrintManager object can be accessed from the different types of documents such as an part or assembly. Also Drawings and Apprentice support special print managers that provide additional printing capabilities.These PrintManager objects provide that same settings that are available in the Print command dialogs in the user interface.

PrintManager - Main Properties
Here are the main properties and methods of the PrintManager object.

NumberOfCopies: Default value to 1
PaperHeight / PaperWidth: Sets the paper dimensions. This property is only used when the PaperSize property is set to kPaperSizeCustom
Printer: gets and sets the name of the printing device

PrintToFile(String FileName): Prints to the specified file using the current property settings
SubmitPrint: Prints the file using the current property settings

DrawingPrintManager Object
The DrawingPrintManager object derives from PrintManager and has some additional properties and methods specific to drawing documents.

AllColorsAsBlack: No colors in the print
PrintRange: Can be set to kPrintCurrentSheet, kPrintAllSheets, kPrintSheetRange.
ScaleMode / Scale: Gets and sets how the scale of the print is defined.
RemoveLineWeights: All lines will have the same default width

GetSheetRange / SetSheetRange: Gets/sets the sheet range to print.

Print Sample VB.NET

Public Sub PrintSample()

    Dim oDrawDoc As DrawingDocument

    oDrawDoc = mApp.ActiveDocument

    Dim oPrintMgr As DrawingPrintManager

    oPrintMgr = oDrawDoc.PrintManager

    With oPrintMgr

        .Printer = "\\ADSOREPS1\oreprn001"

        .NumberOfCopies = 1

        .ScaleMode = _

      PrintScaleModeEnum.kPrintFullScale

        .PaperSize = _

          PaperSizeEnum.kPaperSize11x17

        .SubmitPrint()

    End With

End Sub

File Translation

Simple Translation using Open and SaveAs
You can use the Document.SaveAs and Documents.Open methods to translate documents in and out of Inventor. The extension of the filename supplied will be used to determine which translator to use. With this approach default settings are used. The default settings are the settings last used when interactively translating a file. In this code snippet an stp file is opened and a document is saved as and AutoCAD dwg file.

Documents.Open( “C:\Temp\Test.stp” )
Document.SaveAs( “C:\Temp\New.dwg”, True )

File Translation using the translator Add-Ins
If you want to control the settings when translating files you use the Translator Add-Ins. The main properties and methods of translator add-ins are these:

HasOpenOptions: Returns whether or not the translator has options available for opening files. The three arguments (DataMedium, TranslationContext, NameValueMap ) contain settings you can use.

Open: Opens (translates) a file. This method takes four objects as arguments that control how the open will work.

DataMedium: Use the FileName property to set the file name to open.

TranslationContext: For file, set Type to kFileBrowseIOMechanism you can place the translated file into an existing document with the OpenIntoExisting property

NameValueMap: Use this to set the options for the open

Object: The object that will be created - usually a document

HasSaveCopyAsOptions: Returns whether or not the translator has options available for saving files. The three arguments (Object, TranslationContext, NameValueMap ) will contain settings you can use.

SaveCopyAs: Save the document to the specified data-source. This method takes the following arguments:

Object: The document to be saved
TranslationContext: For file set Type to kFileBrowseIOMechanism

NameValueMap: Use this to set the options for the translation
DataMedium: Use the FileName property to set the file name to save

Each of the translator Add-Ins have a GUID. You can use this identifier (String) with the ItemById method of the ApplicationAddIns property of the Inventor Application object to instantiate the translator. The following example gets the STEP translator and uses the HasOpenOptions() method to print the options (that could be set before using the Open method) to the immediate window.

Accessing Translator’s Open Options – VB.NET

Public Sub GetTranslatorOpenOptions()

    'Using the GUID of the STEP Translator

    Dim clsId As String

    clsId = "{90AF7F40-0C01-11D5-8E83-0010B541CD80}"

    Dim oTranslator As TranslatorAddIn

    oTranslator = _

        mApp.ApplicationAddIns.ItemById(clsId)

    Dim medium As DataMedium

    medium = _

        mApp.TransientObjects.CreateDataMedium

    ' medium.FileName = "C:\MyInventorDoc.xxx"

    medium.MediumType = _

            MediumTypeEnum.kFileNameMedium

    Dim context As TranslationContext

    context = mApp.TransientObjects.

                     CreateTranslationContext

    Dim options As NameValueMap

    options = mApp.TransientObjects.

                          CreateNameValueMap

    Dim index As Integer

    If oTranslator.HasOpenOptions _

            (medium, context, options) Then

        For index = 1 To options.Count

            Debug.Print(options.Name(index) _

& " = " & options.Value(options.Name(index)))

        Next

    End If

End Sub

Accessing Translator’s Save Options - VB.NET

Public Sub GetTranslatorSaveAsOptions()

    ' Using GUID of the DWF Translator

    Dim clsId As String

    clsId = "{0AC6FD95-2F4D-42CE-8BE0-8AEA580399E4}"

    Dim oTranslator As TranslatorAddIn

    oTranslator =

        mApp.ApplicationAddIns.ItemById(clsId)

    Dim context As TranslationContext

    context =

   mApp.TransientObjects.CreateTranslationContext

    context.Type =

        IOMechanismEnum.kUnspecifiedIOMechanism

    Dim options As NameValueMap

    options =

        mApp.TransientObjects.CreateNameValueMap

    Dim SourceObject As Object

    SourceObject = mApp.ActiveDocument

    Dim index As Integer

    If oTranslator.HasSaveCopyAsOptions _

        (SourceObject, context, options) Then

        For index = 1 To options.Count

            Debug.Print(options.Name(index) &

      " = " & options.Value(options.Name(index)))

        Next

    End If

End Sub

Inventor 2013: Built-in Translator Add-Ins GUIDs

DWF:                {0AC6FD95-2F4D-42CE-8BE0-8AEA580399E4}
PDF:                 {0AC6FD96-2F4D-42CE-8BE0-8AEA580399E4}
DWFx:              {0AC6FD97-2F4D-42CE-8BE0-8AEA580399E4}
JT:                    {16625A0E-F58C-4488-A969-E7EC4F99CACD}
i-drop:               {21DB88B0-BFBF-11D4-8DE6-0010B541CAA8}
CATIA Part:       {2FEE4AE5-36D3-4392-89C7-58A9CD14D305}
SolidWorks:       {402BE503-725D-41CB-B746-D557AB83BAF1}
Pro/E:               {46D96B7A-CF8A-49C9-8703-2F40CFBDF547}
STL:                  {533E9A98-FC3B-11D4-8E7E-0010B541CD80}
DWF:                {55EBD0FA-EF60-4028-A350-502CA148B499}
Pro/E Granite:    {66CB2667-73AD-401C-A531-64EC701825A1}
IDF:                  {6C5BBC04-5D6F-4353-94B1-060CD6554444}
SAT:                 {89162634-02B6-11D5-8E80-0010B541CD80}
CATIA Product: {8A88FC01-0C32-4B3E-BE12-DDC8DF6FFF18}
Pro/E Neutral     {8CEC09E3-D638-4E8F-A6E1-0D1E1A5FC8E3}
CATIA Import:    {8D1717FA-EB24-473C-8B0F-0F810C4FC5A8}Parasolid Text:   {8F9D3571-3CB8-42F7-8AFF-2DB2779C8465}
STEP:               {90AF7F40-0C01-11D5-8E83-0010B541CD80}
IGES:                {90AF7F44-0C01-11D5-8E83-0010B541CD80}
UGS NX:            {93D506C4-8355-4E28-9C4E-C2B5F1EDC6AE}
Content Center   {A547F528-D239-475F-8FC6-8F97C4DB6746}
Parasolid Binary:{A8F8F8E5-BBAB-4F74-8B1B-AC011251F8AC}
Drag & Drop      {B95D705C-E915-4A5B-A498-E73AC98923A2}
DWG:               {C24E3AC2-122E-11D5-8E91-0010B541CD80}
DXF:                 {C24E3AC4-122E-11D5-8E91-0010B541CD80}
Alias:                {DC5CD10A-F6D1-4CA3-A6E3-42A6D646B03E}

DataIO Object
Some Inventor objects support a DataIO object. You can use this object to get input and output of formatted data. Use the GetInputFormats / GetOutputFormats methods to get the list of formats supported by a DataIO objects (ex DXF, DWG for sketches, FlatPattern, XML for iProperties, SAT for worksurfaces,…)

DataIO VB.NET examples

    Public Sub ExportWorkSurface()

        Dim oWorkSurfaces As WorkSurfaces

        oWorkSurfaces = mApp.ActiveDocument.

              ComponentDefinition.WorkSurfaces

        Dim oDataIO As DataIO

        oDataIO = oWorkSurfaces(1).

                     SurfaceBodies(1).DataIO

        oDataIO.WriteDataToFile _

           ("ACIS SAT", "C:\Temp\result.sat")

    End Sub

    Public Sub ExportSketchDXF()

        Dim oSketch As PlanarSketch

        oSketch = mApp.ActiveDocument.

            ComponentDefinition.Sketches(1)

        Dim oDataIO As DataIO

        oDataIO = oSketch.DataIO

        Call oDataIO.WriteDataToFile _

               ("DXF", "C:\Temp\dxfout.dxf")

    End Sub

Lab: Access the Translator Add-In options
Create a windows forms application. On the form have a ListView, a ComboBox and a Button. In the ComboBox allow the user to select the name of a Translator. When the button is clicked populate the ListView with the open options and save options for the selected Translator Add-In. Here are examples of the completed Lab. (VB.NET and C#)

Download Inventor_Training_Module_11_Samples

-Wayne

ETO 2013 R2 Add-In template, VS Add-Ins can impact ETO Studio InventorApplication global rule

2013-02-12T15:05:17-08:00

Here are a couple of things about ETO 2013 R2 that I have found recently.

1. If you have used the Inventor ETO Add-In template you may find that the ribbon tab for the Add-In does not display properly when Inventor is launched through ETO Studio. When Intent is started from Visual Studio, it does extensive processing in its OnReady handler. It reads command-line arguments and they tell it to load or create a model and establish communications with VS. Because of this the event handlers in the Add-In can be called later compared to when they are called when Inventor is started normally.

To avoid this behavior you can call the code that creates the ribbon in the IntentInitialized function. Here is a slightly modified version of the Add-In code. (In IntentModel.cs) This change fixed the problem in one case. (Keep in mind that the the Add-In template should be considered as a starting point).

// This will be called if and when Intent

//gets initialized by the host.

void IntentInitialized

    (IntentAPI intentAPI, object hostAPI)

{

// Set up model event handlers if desired.

    IHostAPI host = (IHostAPI)hostAPI;

    ModelEvents ModelEvent =

                    intentAPI.ModelEvents;

    host.Events.BeforeModelLoad +=

        new EventHandler(Events_BeforeModelLoad);

    ModelEvent.BeforeRender +=

        new EventHandler<BeforeModelRenderArgs>

                       (ModelEvent_BeforeRender);

    ModelEvent.AfterRender +=

        new EventHandler<AfterModelRenderedArgs>

                       (ModelEvent_AfterRender);

    // Added to resolve problem with AddIn

    // ribbon when debugging

    if (intentAPI.Models.Count > 0)

    {

        m_gui.Activate();

    }

}

2. We have found in one case that ETO Studio is adversely effected by the Visual Studio Add-In named ReSharper. Some of the symptoms are the following:

Error Message when opening the ETO Studio project: “The parameter is incorrect”.

Edit Rule Error - “Design for selected part not loaded in Visual Studio Environment. Please make sure the project containing the design is open”

ETO Model browser sees the designs under root, but cannot open them. Clicking “Edit Design” gives the same error as above.

Design Navigator shows no User Designs

The behavior has been reported to Autodesk ETO engineering. For now the suggestion is to disable the Visual Studio Add-In.

3. There is now an InventorApplication global Rule. Before that, you had to use hidden %%InventorApplication. Here you see the ETO Console in Visual Studio using the Inventor API:

-Wayne