Manufacturing DevBlog

Array of Fusion objects in C++

By Adam Nagy

In languages like JavaScript it's very easy to use an array:

var objects = [];
objects[1] = object1;
objects[2] = object2;
// etc.

In C++ it's not too difficult either but takes a bit more code to create and delete such an array:

app = Application::get();
if (!app)
  return false;

ui = app->userInterface();
if (!ui)
  return false;

// Get selected entities
Ptr<Selections> sel = ui->activeSelections();
int selCount = sel->count();

// Create array for storing objects
Ptr<Base> * objects = new Ptr<Base>[selCount];

// Store the objects in the array
for( int i = 0; i < selCount; i++)
{
  objects[i] = sel->item(i)->entity();
}

// Retrieve items from the array
for(int i = 0; i < selCount; i++)
{
  Ptr<ConstructionPoint> pt = objects[i];
  const char * ot = objects[i]->objectType();
  if (pt)
  {
    // Do something...
  }
}

// Delete array
for(int i = 0; i < selCount; i++)
  objects[i].detach();
delete objects;

An even nicer solution could be using a vector:

std::vector<Ptr<Base>> objects(selCount);

for(int i = 0; i < selCount; i++)
{
  Ptr<Base> obj = sel->item(i)->entity();
  if (obj)
    objects[i] = obj;
}

Cable & Harness or Tube & Pipe assembly?

By Adam Nagy

Add-Ins that provide extra functionality without which the document might not function properly, add a DocumentInterest object to the document. 
These also supposed to have the same ClientId that the Add-In that created the DocumentInterest has.

Here is a VBA sample showing how you could get all the interests from a given document and all its children:

Sub ListInterests(doc As Document)
  Debug.Print doc.FullDocumentName

  Dim aas As ApplicationAddIns
  Set aas = ThisApplication.ApplicationAddIns
  
  Dim di As DocumentInterest
  For Each di In doc.DocumentInterests
    If di.InterestType = kInterested Then
      Dim aa As ApplicationAddIn
      Set aa = aas.ItemById(di.ClientId)
      Debug.Print "  >> Interest: " _
        + di.name + " by add-in " + aa.DisplayName
    End If
  Next
  
  Dim rd As Document
  For Each rd In doc.ReferencedDocuments
    Call ListInterests(rd)
  Next
End Sub

Sub ListAllInterests()
  Dim doc As Document
  Set doc = ThisApplication.ActiveDocument
  
  Call ListInterests(doc)
End Sub

 

IPictureDisp.Handle might be negative

By Adam Nagy

As mentioned in this blog post as well, for some reason the Handle of the IPictureDisp returned by the Thumbnail property of ApprenticeServerDocument can sometimes be negative.

I tested this with my own app as well - the one referenced in this blog post.

Strangely, when my .NET app is compiled to 32 bit, it seems to cause no issue for the AxHostConverter.PictureDispToImage() converter method (see below) to turn the IPictureDisp into a System.Drawing.Image:

internal class AxHostConverter : AxHost
{
  private AxHostConverter() : base("") { }

  static public stdole.IPictureDisp ImageToPictureDisp(Image image)
  {
    return (stdole.IPictureDisp)GetIPictureDispFromPicture(image);
  }

  static public Image PictureDispToImage(stdole.IPictureDisp pictureDisp)
  {
    return GetPictureFromIPicture(pictureDisp);
  }
}

However, when my .NET app is 64 bit then it is a problem and causes an exception. In that case the solution pointed out in the other blog post, i.e. accessing the Thumbnail multiple times, until the Handle of  IPictureDisp is positive solves the problem:

stdole.IPictureDisp pic = null;
bool retry;
int retryCounter = 0;
do
{
  retry = false;
  pic = doc.Thumbnail;
  System.Diagnostics.Debug.WriteLine("Handle = {0}", pic.Handle);
  if (pic.Handle <= 0)
  {
    retry = true;
    retryCounter++;
  }
} while (retry);

System.Diagnostics.Debug.WriteLine("retryCounter = {0}", retryCounter);

System.Diagnostics.Debug.WriteLine("Got Thumbnail");

There is another way which seems even more reliable since it does not require accessing the Thumbnail multiple times. It's used in this blog post and inside my app it could be used like this:

stdole.IPictureDisp pic = doc.Thumbnail;
Metafile mf = new Metafile(
  new IntPtr(pic.Handle),
  new WmfPlaceableFileHeader());

Image.GetThumbnailImageAbort callback =
  new Image.GetThumbnailImageAbort(
    delegate (){ return false; });

Image img = mf.GetThumbnailImage(
  form1.pictureBox.Width,
  form1.pictureBox.Height,
  callback,
  IntPtr.Zero);

Apprentice leaves lockfile.lck files behind

By Adam Nagy

When using Apprentice, it creates lockfile.lck files in the folders where the files you open with it reside. These only disappear once the process using Apprentice exited.
However, as soon as you close the document the related lock file becomes deletable, so nothing prevents you from deleting them or the folders they are in.

If you want to get rid of them as soon as possible then you could create a class that removes them automatically once you closed the Apprentice document. In .NET you could do something like this:

using System;
using Inv = Inventor;
using SysIO = System.IO;
using Inventor;
using System.Collections.Generic;

namespace ApprenticeConsoleCS
{
  class Program
  {
    class LckMonitor
    {
      ApprenticeServerComponent asc;
      Dictionary<string, int> map;

      public LckMonitor(ApprenticeServerComponent asc)
      {
        this.asc = asc;
        map = new Dictionary<string, int>();
      }

      public ApprenticeServerDocument Open(string fileName)
      {
        var folder = System.IO.Path.GetDirectoryName(fileName);

        // Keep track of it
        if (map.ContainsKey(folder))
          map[folder]++;
        else
          map[folder] = 1;

        // Open it
        return asc.Open(fileName);
      }

      public void Close(ApprenticeServerDocument doc)
      {
        var folder = System.IO.Path.GetDirectoryName(doc.FullFileName);

        // Close it
        doc.Close();

        // The folder should be in here already
        System.Diagnostics.Debug.Assert(map.ContainsKey(folder));

        map[folder]--;

        // If no one is referencing it now
        // then let's try to clean it up
        // It could be that another application will hold
        // on to it though
        if (map[folder] < 1)
        {
          map.Remove(folder);

          try
          {
            System.IO.File.Delete(folder + "\\lockfile.lck");
          }
          catch { }
        }
      }
    }

    [STAThread]
    static void Main(string[] args)
    {
      string filename = @"C:\temp\test.ipt";

      ApprenticeServerComponent asc = new ApprenticeServerComponent();
      LckMonitor lckMonitor = new LckMonitor(asc);

      ApprenticeServerDocument asd = lckMonitor.Open(filename);

      // Interact with the apprentice document

      lckMonitor.Close(asd);
    }
  }
}

Another thing you could do is migrate the Apprentice related functionality into a separate app. That way when the side process finishes the Apprentice component in it will finish too and will clean up those lock files. This blog post's solution includes that option as well.  

Use Apprentice from multi-threaded application

By Adam Nagy

I wrote about it already that you can use Apprentice in a side-thread, but that sample only showed a single instance doing it:
http://adndevblog.typepad.com/manufacturing/2014/09/apprentice-in-side-thread.html

Now here is a sample running multiple Apprentice instances in the same application on different threads. Each thread creates its own ApprenticeServerComponent - note that this object can only be used from the thread that created it, since it's not thread-safe.

Depending on how much calculation you're doing and how your app is structured, it could also be a good idea to migrate the Apprentice usage into a separate app which could be used from the main application.

This sample project shows both ways of doing things and allows you to switch between them through the "Use Apprentice in-process" check box.

Source: 
https://github.com/adamenagy/Apprentice-MultiThread

By the way, if you want to set the Output directory of a .NET project relative to the Solution directory, you can do that by editing the project file in a text editor:

C# project : setting output directory to solution dir

Need to use a Proxy for commands when editing a part in an assembly

By Wayne Brill

In the VBA example below a work plane in a part document is accessed and then the AppLookAtCmd is run. (changes the view to look directly at that WorkPlane)

To get AppLookAtCmd to use that WorkPlane it needs to be selected using the SelectSet of the assembly. (not the part) To get the WorkPlane in the assembly space use a WorkPlaneProxy. To create the WorkPlaneProxy use the ActiveOccurrence property of the assembly to get the occurrence of the part that is being edited and then use the CreateGeometryProxy method of the occurrence.   

Before running this example place a part in an assembly and then right click on the part in the Model browser and select Edit.

Public Sub selectionTest()
     'Get the object currently being edited.
    Dim ActiveObject As Object
    Set ActiveObject = ThisApplication.ActiveEditObject
   
    'Determine if a the object being edited is a document
    If Not TypeOf ActiveObject Is PartDocument Then
        Exit Sub
    Else
       Dim oDoc As Inventor.PartDocument
       Set oDoc = ActiveObject
    End If
   
    'Get the XY Plane of the part being edited
    Dim oWorkPlane As WorkPlane
    Set oWorkPlane = oDoc.ComponentDefinition.WorkPlanes("XY Plane")
     
   'Get the active document (an assembly)
    Dim oAsm As AssemblyDocument
    Set oAsm = ThisApplication.ActiveDocument
   
    ' The part that is being edited will be an occurrence
    Dim oOccurrence As ComponentOccurrence
    Set oOccurrence = oAsm.ComponentDefinition.ActiveOccurrence
   
    ' create a WorkPlaneProxy from the work plane in the part
    Dim oWorkPlaneProxy As WorkPlaneProxy
    oOccurrence.CreateGeometryProxy oWorkPlane, oWorkPlaneProxy
   
   ' Select the WorkPlaneProxy in the assembly
    oAsm.SelectSet.Select oWorkPlaneProxy
    
    ' Run the command it will use the work plane (a WorkPlaneProxy)
    ThisApplication.CommandManager.ControlDefinitions.Item("AppLookAtCmd").Execute
End Sub

Include Sketch from a Part multi-level deep

By Adam Nagy

We already have a blog post on Include sketches from sub-assemblies in a DrawingView using a sketch proxy, but it does not cover the scenario where the Document the Sketch resides in is multi-level deep in the assembly hierarchy - i.e. it's a SubOccurrence of an Occurrence.

As I mentioned in this blog post you have to make sure that you are getting objects in the right context. You can either do that by reaching objects only through Occurrences and SubOccurrences collections (never using Definition) or if you have to use Definition then get the object back into the right context using CreateGeometryProxy().
If you do not follow that correctly, like the below code, then your program won't work:

Whenever you use the property "Definition" you leave the current context and move into a lower one. As you can see the code only brings the oPrtSketch entity into the context of the MidAssembly.iam document. However, the DrawingView is referencing TopAssembly.iam, so that is the context the objects you pass to it should be in.  

The quickest fix to the above code is taking note of the occurrence of MidAssembly.iam inside TopAssembly.iam (oMidAsmOcc) and doing an extra call to CreateGeometryProxy to bring the object into the context of TopAssembly.iam. New code highlighted in red: 

Sub IncludeSketchFromPart()
Dim oDwg As DrawingDocument
Set oDwg = ThisApplication.ActiveDocument

Dim oView As DrawingView
Set oView = oDwg.ActiveSheet.DrawingViews(1)

Dim oTopAsm As AssemblyDocument
Set oTopAsm = oView.ReferencedDocumentDescriptor.ReferencedDocument

'Dim oMidAsmDef As AssemblyComponentDefinition
'Set oMidAsmDef = oAssy.ComponentDefinition.Occurrences.ItemByName("MidAssembly:1").Definition

Dim oMidAsmOcc As ComponentOccurrence
Set oMidAsmOcc = oTopAsm.ComponentDefinition.Occurrences.ItemByName("MidAssembly:1")

Dim oMidAsmDef As AssemblyComponentDefinition
Set oMidAsmDef = oMidAsmOcc.Definition

Dim oPrtOcc As ComponentOccurrence
Set oPrtOcc = oMidAsmDef.Occurrences.ItemByName("PartWithSketch:1")

Dim oSketch As PlanarSketch
Set oSketch = oPrtOcc.Definition.Sketches("PartSketch")

Dim oSketchProxy As PlanarSketchProxy
' This will get it into context of "MidAssembly.iam"
Call oPrtOcc.CreateGeometryProxy(oSketch, oSketchProxy)

' This will get it into context of "TopAssembly.iam"
Call oMidAsmOcc.CreateGeometryProxy(oSketchProxy, oSketchProxy)

Call oView.SetVisibility(oSketchProxy, True)
End Sub

Read Parameter values using Apprentice

By Adam Nagy

Unfortunately, Apprentice cannot access the Parameters of an Inventor document. You would need to use Inventor for that.
If firing up an Inventor instance would be too slow or not feasible for e.g. licensing reasons, a workaround could be setting those Parameters to export to iProperties:

In that case a corresponding iProperty will be automatically created and kept up-to-date in the "Inventor User Defined Properties" (Custom) section:

The good news is that iProperties can be read not only through Apprentice, but also using Structured Storage API, which is completely independent of Inventor. Here is a view of our Inventor part file in a program called Structured Storage Viewer:

Here is a sample using Structured Storage API to get information from an Inventor file: 
http://adndevblog.typepad.com/manufacturing/2013/03/save-extra-data-in-inventor-file-3.html

If setting the "Export Parameter" option for the Parameters you are interested in is not an option, then maybe you could run a batch process that stores those parameters somewhere else (e.g. in a CSV file named the same but with a ".csv" extension) next to the Inventor file, or create an Add-In which does the same but as part of the OnSaveDocument event of the ApplicationEvents object.

Get Reference Distance of Hole Feature

By Xiaodong Liang

When you create hole feature, Inventor allows you to set the distances with the reference  edges. This can be got by HoleFeature.PlacementDefinition.DistanceOne and HoleFeature.PlacementDefinition.DistanceTwo

If the reference  are not defined, you could iterate the edges of outer edge loop and  calculate the distance by Edge.Geometry.DistanceTo(point).  The following is an VBA code as a demo:

 

Sub getHolePlacement()

    'select a hole feature in advance
    Dim oHoleF As HoleFeature
    Set oHoleF = ThisApplication.ActiveDocument.SelectSet(1)
    
    'get HolePlacementDefinition
    Dim oPlaceDef As HolePlacementDefinition
    Set oPlaceDef = oHoleF.PlacementDefinition
    
    'reference are defined ?
    Dim oDisOne As Parameter
    Dim oDisTwo As Parameter
    
    On Error Resume Next
    Set oDisOne = oPlaceDef.DistanceOne
    
    If Err.Number > 0 Then
    
        
        'no distance defined
        
        'get plane the hole locates at
        
        Dim oPlane As Face
        Set oPlane = oPlaceDef.Plane
        
        'get out edge loop
        Dim oOutLoop As EdgeLoop
         Dim oEachLoop As EdgeLoop
         
         For Each oEachLoop In oPlane.EdgeLoops
            If oEachLoop.IsOuterEdgeLoop Then
                Set oOutLoop = oEachLoop
                Exit For
                
            End If
         Next
        
        
        'iterate each edge and filter out the linear lines
        Dim oEachEdge As Edge
        For Each oEachEdge In oOutLoop.Edges
            If TypeOf oEachEdge.Geometry Is LineSegment Then
                Dim oLine As LineSegment
                Set oLine = oEachEdge.Geometry
                
                'caculate the distance of hole center and the edge
                Dim oDis As Double
                oDis = oLine.DistanceTo(oHoleF.HoleCenterPoints(1))
                
                Dim oLineDir As UnitVector
                Set oLineDir = oLine.Direction
                
                Debug.Print "distance to the vector (" & oLineDir.X & "," & oLineDir.Y & "," & oLineDir.Z & ") is: " & oDis
            End If
        Next
        
    Else
        'distance are defined
         Set oDisTwo = oPlaceDef.DistanceTwo
         
         Debug.Print "distance one: " & oDisOne.Value & "  distance two: " & oDisTwo.Value
    End If
    
    Err.Clear
      

End Sub

Change MembersToInclude of a PartsList

By Adam Nagy

In the UI you can change which member of an iPart or iAssembly is included by double clicking the parts list and then clicking the "Member Selection" button:

If you try to change the included member like this then you'll get an "Invalid procedure call or argument" error:

If something does not work then it's always good to try to do it through the UI and then check the results in the VBA Watches window:
http://adndevblog.typepad.com/manufacturing/2013/10/discover-object-model.html

If you did that then you'd find (as shown in the above image) that MembersToInclude stores an array of strings - so that's what you'd need to pass to it:

Sub ChangeMembersToInclude()
  ' The PartsList needs to be selected in the UI
  Dim oPL As PartsList
  Set oPL = ThisApplication.ActiveDocument.SelectSet(1)
  
  ' This works
  Dim members(0) As String
  members(0) = "iPart-02"
  oPL.MembersToInclude = members
End Sub