Mod the Machine

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

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

Problem debugging Python code

When using the latest two versions of the Python extension inside Visual Studio Code, then instead of VS Code showing up when you click "Edit" or "Debug" inside the  "Script and Add-Ins" dialog, another instance of Fusion 360 will come up 😬

Fortunately, you can simply downgrade back to version 2019.9.34911 of the Python extension to solve the problem:
- go to the Extensions tab in VS Code 
- click on the Settings button ⚙ of the Python extension
- select "Install Another Version..."
- select 2019.9.34911

Issues with migrating to Python 3.7.3

As I mentioned it in this blog post, the new version of Python (3.7.3) that Fusion 360 migrated to seems more strict, and is causing some add-ins to fail.

Here are the main issues I've seen pop up:

1) Having an empty code block: if/else, try/except, etc
Code:

try:
except:

Error:

Sorry: IndentationError: expected an indented block (PythonTest.py, line 25)

Solution: remove the whole block or just put a "pass" inside it:

try:
  pass
except:
  pass

2) Referencing a global variable multiple times in the same function using the "global" keyword - even if from different execution paths
Code:

my_global_variable = ""

def run(context):
  if ui:
    global my_global_variable
    my_global_variable = "True"
  else: 
    global my_global_variable
    my_global_variable = "False"

Error:

SyntaxError: name 'my_global_variable' is assigned to before global declaration

Solution: use the "global" references at the beginning of the function 

my_global_variable = ""

def run(context):
  global my_global_variable
  if ui:
    my_global_variable = "True"
  else: 
    my_global_variable = "False"

3) One other issue, which is not necessarily a result of the compiler's strictness, is that you may be relying on packages that are based on an earlier version of Python. If loading those modules is causing errors then you might have to upgrade those packages. It might be done in different ways depending on where you got those packages from. 

Cannot debug my Python add-in

Just wrote an article on how to debug your Python script/add-in

One thing missing from it is about what to do if the compiler runs into problems with the main module (vs an additional module your code is loading).
In that case, checking "Raised Exceptions" in the "Breakpoints" section is not enough 🙁
Your code will fail silently and the debug process won't start

You can work around that by running Python compile on your main module/main Python file to find out what the problem is with it.

Once you started debugging your code from Fusion 360 and ended up in VS Code, you can follow these steps:

1) Open up the Terminal in VS Code (View >> Terminal)

2) Open the .vscode\settings.json file of your add-in - this will have the path to the Python version that Fusion 360 is using

3) Copy the full path set for "python.pythonPath" into the terminal

4) Add "-m py_compile" to the text in the Terminal window

5) Drag&drop your Python file's tab into the Terminal - that will copy/paste the full path of that file in the Terminal

6) Now just hit enter in the Terminal and that should run the Python compiler, which should list the first error the compiler runs into 

Let's compare the error and our Python file:

In this case, the error message is not the clearest, but at least we have something to go on 🙂
Solution to this specific error is here: Issues with migrating to Python 3.7.3

Debug Fusion 360 add-ins with VS Code

As I wrote about it in this blog post, we were switching to Visual Studio Code as the debugging tool for Fusion 360 - I think that's great 😀

At the same time, we also upgraded the Python version used in Fusion 360 to 3.7.3 
Unfortunately, some add-ins got caught up in that. It looks like the new Python version is more strict and so you might run into compiler issues.

Please do check your add-ins to make sure they are still working ok. Thank you!

Debugging to the rescue!

First of all, you need to install Visual Studio Code. If you follow the below steps and you do not have it installed yet, then you will get a notification dialog asking you to do this along with the URL to the download site - but of course, you can easily find it on the net, and I'm providing the link as well in the paragraph 🙂 

1) Select your add-in in the "Scripts and Add-Ins" dialog and select "Debug" under the "Run" drop-down menu 

2) As soon as Visual Studio Code starts up, switch over to it (in case it does not get focus automatically), select the "Debug" environment and click the "Start Debugging" button (looks like a Play button)

3) As shown in the above picture, it's a good idea to select the "Raised Exceptions" option in the "Breakpoints" section. This way you'll get a meaningful error even if the compiler runs into problems with a module you're trying to load. This won't help though if the problem is in our main module - this blog post has a workaround for that.

4) Now you have the usual options for stepping through the code, use breakpoints, etc

5) If you want to start the process again (maybe your code failed, etc) and the debugging toolbar in Visual Studio Code is still visible, then click the "Disconnect" button on it, and follow the above steps again

6) Using print() you can write information to the "Debug Console":

More information on debugging in VS Code on its website: https://code.visualstudio.com/docs/editor/debugging 

-Adam 

Insert external component

The Fusion API provides access to your A360 projects and the files as well. Through that you can insert an external component if you want.

The following sample lists your projects and the files in their root folder, and then lets you insert the selected one in the root component of your current model.

When testing the script you need to give a bit of time for the command window to pop up and the file drop down to update when you are changing the project.

Source: https://github.com/AutodeskFusion360/InsertExternalComponent 

-Adam

Run Fusion commands

The online help already has a sample on listing all the controls in the user interface which also provides the id of  the CommandDefinition that the various controls reference.  You can also get to the sample from many help topics, including "UserInterface.toolbars"

This sample is very useful when positioning your controls within existing Fusion toolbars and panels and positioning your command adjacent to an existing command

However, if you are only interested in the command names and their id's then you can get them much simpler.

When you create your command then you create a CommandDefinition object and add it to the UserInterface.commandDefinitions collection.
This collection contains the internal command definitions as well. So you can just iterate through it to get the info you want. In Python it could be:

app = adsk.core.Application.get()
ui = app.userInterface

fileDialog = ui.createFileDialog()
fileDialog.isMultiSelectEnabled = False
fileDialog.title = "Specify result filename"
fileDialog.filter = 'Text files (*.txt)'
fileDialog.filterIndex = 0
dialogResult = fileDialog.showSave()
if dialogResult == adsk.core.DialogResults.DialogOK:
    filename = fileDialog.filename
else:
    return
    
commandDefinitions = ui.commandDefinitions
result = ""

for commandDefinition in commandDefinitions:
    result += "id = " + commandDefinition.id + "; name = " + commandDefinition.name + "\n"
    
output = open(filename, 'w')
output.writelines(result)
output.close()

You can search the content of the created file to find the id of the CommandDefinition you need. Once you have it you can Execute it - e.g. in Python running the Export command:

cmdDef = ui.commandDefinitions.itemById("ExportCommand")
cmdDef.execute()

-Adam

Fusion add-in path

Some functions might require the full path to a given file. If you know it's relative path to the add-in then the following could help. The below samples show how to get the add-in folder in different programming languages - these samples are based on the API online help sample: http://fusion360.autodesk.com/learning/learning.html?caaskey=caas/CloudHelp/cloudhelp/ENU/Fusion-360-API/files/ExportManager-Sample-htm.html

Python

def getAddInFolder():
    import os
    folderPath = os.path.dirname(os.path.realpath(__file__))
    
    return folderPath

JavaScript

function getAddInFolder() {

    var url = window.location.pathname;
    var des = decodeURI(url);

    // remove the / at beginning
    if (navigator.platform.match('Win')) {
        des = des.substr(1);
    }

    var index = des.lastIndexOf('/');
    var dir = des.substring(0, index);

    return dir;
}

C++

std::string getAddInFolder()
{
#if defined(_WINDOWS) || defined(_WIN32) || defined(_WIN64)
    HMODULE hModule = NULL;
    if (!GetModuleHandleExA(
        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | 
        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
        (LPCSTR) ≥tDllPath, 
        &hModule))
        return "";

    char winTempPath[2048];
    ::GetModuleFileNameA (hModule, winTempPath, 2048);

    std::string strPath = winTempPath;
    size_t stPos = strPath.rfind('\\');
    return strPath.substr(0, stPos);
#else
    Dl_info info;
    dladdr((void*) getDllPath, ∈fo);

    std::string strPath = info.dli_fname;
    int stPos = (int)strPath.rfind('/');
    if(stPos != -1)
        return strPath.substr(0, stPos);
    else
        return "";
#endif
}

-Adam