Mod the Machine

Migrate Inventor templates

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

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

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

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

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

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

Here is a VBA sample:

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

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

  Dim inventorVersion As SoftwareVersion
  Set inventorVersion = ThisApplication.SoftwareVersion

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

    t.Save

    t.Close
  End If

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

3rd party libraries used by Inventor 2022

Here is a list of the various 3rd parties libraries and their versions that Inventor 2022 is using - i.e. they are used by the core product, and some of them are also used by certain add-ins.

If you are using any of them from your add-in then the best is to make sure you are using the same version to avoid version conflict:

Component Name	Version
DevExpress	19.1.5
7z	18.06.0.0
CEFSharp	75.1.141
SQLite	3.30.1
Qt	5.150.10
QtMFCBridge	5150.280.1
TBB	6.1.20

 

Tooltip text gets cropped

If you are using very long strings without tabs or spaces in them (e.g. a long file path), those will get cropped.
E.g. the file path "C:\\top_folder\\sub_folder\\sub_sub_folder\\sub_sub_sub_folder\\sub_sub_sub_sub_folder\\somefile.txt" will show up like this:

Currently, that will also add an empty area on the right side of the tooltip, but that will be fixed.

There are two things you can do:
- add zero-width space characters (\u200b) wherever you are ok with the string being broken into a new line (e.g. after each \ character in the file path)
- add an ellipsis character (\u2026) at the point where the rest of the information is not important
(the tooltip width is 300 pixels which would allow about 40-50 characters in a line) 

-Adam

Export driven joint values

In certain workflows, it can come handy to get the values of joints at multiple states of the model.
This way you can use those values downstream to drive (or at least help set up) a real-life model.

In the user interface, you can drag components to drive the movement of the model, or use e.g. Motion Study

We can do the same using the API as well. As we keep driving the model, we can check how the change affects the various joints and record their values.
Then we can save the values in a CSV file which then could be opened in Excel or a similar spreadsheet editor.

The code is made for this specific model but could easily be modified for others. It expects a list of components and a list of joints inside them that you want to monitor. In the case of both lists, you can specify the name that should be used in the CSV file.

After specifying where you want the CSV file to be saved, you can also provide the distance the main joint should be moved. 

The source code is here:
https://github.com/adamenagy/JointValueExporter/blob/main/JointValueExporter.py 

-Adam

Log debug messages in Fusion 360

The usual way to debug your Python add-in is to start it from Visual Studio Code, and use print() to write messages to the Debug Console:

However, sometimes you might just want some insight into what's going on inside your add-in without starting a debugging session.

One obvious way is to write information into a log file. Depending on your needs that might be the thing to do.

That will not provide real-time information though: you have to open the file in order to see what was written into it.

Another option is to write to the "Text Commands" palette of Fusion 360. If you don't mind a bit of delay for the messages to appear then just call writeText() function of the palette, otherwise also call adsk.doEvents()

You could create a couple of simple classes to implement what's needed:

class UiLogger:
    def __init__(self, forceUpdate):  
        app = adsk.core.Application.get()
        ui  = app.userInterface
        palettes = ui.palettes
        self.textPalette = palettes.itemById("TextCommands")
        self.forceUpdate = forceUpdate
        self.textPalette.isVisible = True 
    
    def print(self, text):       
        self.textPalette.writeText(text)
        if (self.forceUpdate):
            adsk.doEvents() 

class FileLogger:
    def __init__(self, filePath): 
        try:
            open(filePath, 'a').close()
        
            self.filePath = filePath
        except:
            raise Exception("Could not open/create file = " + filePath)

    def print(self, text):
        with open(self.filePath, 'a') as txtFile:
            txtFile.writelines(text + '\r\n')

Then you can create an instance of either of them and start logging messages. E.g. using the UiLogger:

logger = UiLogger(True)
# ...
logger.print("Some message")

Or use the FileLogger

logger = FileLogger("/Users/nagyad/Documents/log.txt")
# ...
logger.print("Some message")

That palette is not only for writing messages but can also be used to run Python scripts - see Run commands from the "Text Commands" panel

Join us for our DevDays Online webinars

Our yearly webinars about the new product API features (both cloud and desktop) are coming up at the beginning of March.

You can find all the details here if you are interested in joining us:
https://adndevblog.typepad.com/autocad/2021/01/join-us-for-our-devdays-online-webinars.html 

"Member not found" error in C# add-in

As mentioned in other blog posts (e.g. here and here) as well, using Embed Interop Types = True with the Inventor interop assembly does not work well. 

Apart from some events not firing, you might not find all the properties either. E.g. in the case of a Parameter object, when doing this: 

var unitType = param.get_Units();

I get this error:

{"Member not found. (Exception from HRESULT: 0x80020003 (DISP_E_MEMBERNOTFOUND))"}

So just set Embed Interop Types to False:

Just for completeness' sake (though the above solution should solve the problem), there could be another way as well to avoid this error.
You could declare a dynamic variable for the parameter (in order to use late-binding) and access the property through that:  

dynamic p = param;
var unitType = p.Units;

- Adam

Export profile sketch points to CSV

There is a Python script part of the Fusion 360 installation that can import points from a CSV file into a spline:

We could use the source code of that as a starting point to implement the reverse: export the points of a spline.

In this case, however, I'm changing it to export the points of a profile instead: one consisting of many short sketch lines forming a closed loop.

Because it's a closed loop, therefore it's enough to just export the coordinates of the start sketch point of each line as we iterate through the sketch lines. 

import adsk.core, adsk.fusion, traceback
import io

def run(context):
    ui = None
    try:
        app = adsk.core.Application.get()
        ui  = app.userInterface
        # Get all components in the active design.
        product = app.activeProduct
        design = adsk.fusion.Design.cast(product)
        title = 'Export Spline csv'
        if not design:
            ui.messageBox('No active Fusion design', title)
            return

        if app.userInterface.activeSelections.count != 1:
            ui.messageBox('Select profile before running command', title)
            return

        profile = app.userInterface.activeSelections.item(0).entity
        if not type(profile) is adsk.fusion.Profile:
            ui.messageBox('Selected object needs to be a profile', title)
            return

        dlg = ui.createFileDialog()
        dlg.title = 'Save CSV File'
        dlg.filter = 'Comma Separated Values (*.csv)'
        if dlg.showSave() != adsk.core.DialogResults.DialogOK :
            return
        
        filename = dlg.filename

        with io.open(filename, 'w', encoding='utf-8-sig') as f:
            profile = adsk.fusion.Profile.cast(profile)
            loop = profile.profileLoops.item(0)
            curves = loop.profileCurves
            for curve in curves:
                curve = adsk.fusion.ProfileCurve.cast(curve)
                entity = curve.sketchEntity
                point = entity.startSketchPoint
                point = adsk.fusion.SketchPoint.cast(point)
                geometry = point.geometry
                f.write(str(geometry.x) + "," + str(geometry.y) + "\n")

    except:
        if ui:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))

In order to use the above code, you can simply create a new Python Script in the "Scripts and Add-Ins" dialog and replace the code in the generated Python file with the one shown above - see Creating a Script or Add-In  

Here is the result produced by the script:

-Adam

Level Of Details in next Inventor release

As Garin mentioned in this post, one of the new features the team has been working on is Model States.

This might have an effect on some of the Level Of Details related functions, events, and properties in the API.

If you are using any of those, the best thing to do is join the beta program where you can find more details about this functionality and can also use pre-release versions (alphas and betas) of Inventor to test your add-in.

Switch to latest VS Code Python extension

In the past, you had to stick to a given version of the Python extension in Visual Studio Code in order to edit and/or debug Fusion 360 add-ins with it.

Now I've just run into the opposite problem in case of the latest update of Fusion 360: when using that version of the extension (i.e. version 2019.9.34911) the "Debug" and "Edit" buttons inside the "Scripts and Add-Ins" dialog of Fusion 360 stopped working.

The engineering team confirmed that now developers should be using the latest version of the Python extension in VS Code.
And indeed, that does work for me too 🎉