Mod the Machine

Fusion 360 Affiliate Program

Are you a huge fan of Autodesk Fusion 360? Do you have a robust community or following that trusts your opinion on software (and other things)? The Fusion 360 Marketing Team has a lucrative proposal for you: join our affiliate program!

Affiliate marketing is a process by which an affiliate earns a commission for selling another company’s products. At Autodesk, potential affiliates apply to our program and, once approved, are given unique links and visuals to use when mentioning our products on their channels. Members receive a commission on every verified sale made through their unique link.

What’s in it for me?

The team at Fusion 360 is looking for passionate community members with a following that would respect their opinion on design and manufacturing software solutions. We think such valuable voices deserve compensation for any sales they help make happen, so we offer a starting commission of 7% on verified digital sales.

The Fusion 360 team is really excited to launch a program that recognizes and rewards our community members in everyone’s favorite way: cash! If you’re interested, please reach out to the Fusion 360 social media manager at [email protected], or simply DM us on social media to get in touch.

-Muna Idriss

Important info if your add-in uses pyc files

Fusion 360 is migrating to a newer engine of Python and it will make your add-in fail if it's relying on compiled Python files (*.pyc)

For more info see https://help.autodesk.com/view/fusion360/ENU/?guid=GUID-36B1FFB5-5291-4532-8F11-90E912769B34  

-Adam

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

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

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 🎉

Stricter call checks in Fusion 360 API

Last time it was the Python compiler that got stricter, in the latest update it's Fusion 360 that got stricter on API calls.

Previously, you could get away with trying to set a read-only property - it had no effect but did not cause an error either.

This change is good because now you'll get an error and will be notified as you're developing your add-in when you're trying to do something that does not make sense.

The only problem is if you happen to have a published add-in that includes such a call 🙄

If your add-in stopped working (like mine 🤫 ) in the latest Fusion 360 update then this might be it. 

-Adam

Fusion 360 JavaScript API support ending this December

We stopped fully supporting the JavaScript API a few years ago, but your existing add-ins using it kept running.
Not anymore. In December they will stop running, and you need to migrate your add-ins to another programming language: either C++ or Python.

See post from product management: Notice: Javascript API is being fully retired

Edit: looks like now there is also a pop-up dialog warning you if you have a JavaScript add-in installed:

-Adam

Drive all revolute joints

I have two blog posts on driving revolute joints of a model:
Drive robot arm in Fusion and Drive robot arm in Fusion - update

However, in those cases you have to select the joints you want to drive and use the keyboard.
If you prefer driving all the revolute joints' rotation values through a slider, then here is a sample script you could use.
This also takes limits into consideration.

Python script code:

#Author-
#Description-

import adsk.core, adsk.fusion, adsk.cam, math, traceback

# Global variable used to maintain a reference to all event handlers.
handlers = []

# Other global variables
joints = None
commandName = "DriveJoints"
app = adsk.core.Application.get()
if app:
    ui = app.userInterface
            
# Event handler for the inputChanged event.
class MyInputChangedHandler(adsk.core.InputChangedEventHandler):
    def __init__(self):
        super().__init__()
    def notify(self, args):
        eventArgs = adsk.core.InputChangedEventArgs.cast(args)
        commandInput = eventArgs.input
        
# Event handler for the executePreview event.
class MyExecutePreviewHandler(adsk.core.CommandEventHandler):
    def __init__(self):
        super().__init__()
    def notify(self, args):
        eventArgs = adsk.core.CommandEventArgs.cast(args)
        inputs = eventArgs.command.commandInputs

        for i in inputs:
            joint = joints.itemByName(i.name)
            rot = i.valueOne
            motion = joint.jointMotion
            motion.rotationValue = rot

        # Make it accept the changes whatever happens
        eventArgs.isValidResult = True
        

class MyCommandCreatedHandler(adsk.core.CommandCreatedEventHandler):    
    def __init__(self):
        super().__init__()        
    def notify(self, args):
        try:
            command = adsk.core.Command.cast(args.command)
            
            # Subscribe to the various command events
            onInputChanged = MyInputChangedHandler()
            command.inputChanged.add(onInputChanged)
            handlers.append(onInputChanged)

            onExecutePreview = MyExecutePreviewHandler()
            command.executePreview.add(onExecutePreview)
            handlers.append(onExecutePreview)
        
            onDestroy = MyCommandDestroyHandler()
            command.destroy.add(onDestroy)
            handlers.append(onDestroy)
            
            inputs = command.commandInputs

            for joint in joints:
                if joint.jointMotion.objectType == adsk.fusion.RevoluteJointMotion.classType():
                    minRot = 0
                    maxRot = math.pi * 2

                    limits = joint.jointMotion.rotationLimits
                    if (limits.isMinimumValueEnabled and limits.isMaximumValueEnabled):
                        minRot = limits.minimumValue
                        maxRot = limits.maximumValue

                    rev = inputs.addFloatSliderCommandInput(
                        commandName + joint.name,
                        joint.name,
                        'rad',
                        minRot,
                        maxRot,
                        False)
                    rev.valueOne = joint.jointMotion.rotationValue

            command.isAutoExecute = True
                
        except:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))              
            
            
class MyCommandDestroyHandler(adsk.core.CommandEventHandler):
    def __init__(self):
        super().__init__()
    def notify(self, args):
        try:
            commandDefinitions = ui.commandDefinitions
            # Check the command exists or not
            cmdDef = commandDefinitions.itemById(commandName)
            if cmdDef:
                cmdDef.deleteMe                
                
            # When the command is done, terminate the script
            # this will release all globals which will remove all event handlers
            adsk.terminate()
            
        except:
            ui.messageBox('Failed:\n{}'.format(traceback.format_exc()))        
            
            
def run(context):
    try:
        product = app.activeProduct
        design = adsk.fusion.Design.cast(product)
        if not design:
            ui.messageBox('It is not supported in current workspace, please change to MODEL workspace and try again.')
            return
        
        global joints
        joints = design.rootComponent.joints
         
        commandDefinitions = ui.commandDefinitions
        # Check the command exists or not
        cmdDef = commandDefinitions.itemById(commandName)
        if not cmdDef:
            cmdDef = commandDefinitions.addButtonDefinition(
                commandName, commandName, commandName, '') 

        # Subscribe to events 
        onCommandCreated = MyCommandCreatedHandler()
        cmdDef.commandCreated.add(onCommandCreated)
        # Keep the handler referenced beyond this function
        handlers.append(onCommandCreated)
        
        # Run the command
        inputs = adsk.core.NamedValues.create()
        cmdDef.execute(inputs)

        # Prevent this module from being terminated when the script returns, 
        # because we are waiting for event handlers to fire
        adsk.autoTerminate(False)

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

-Adam