Translating output to Open5x compatible gcode

[BrendonBuilds]

After a handful of unsuccessful conversations with ChatGPT I was finally able to get it to create a functional python script which can translate the files produced in output_gcode into gcode which is compatible with Open5x machines. A nozzle offset of 0mm is required NOZZLE_OFFSET = 0.

PXL_20250501_000819004_edit.mp4

If you are interested, here is the conversation: ChatGPT: Gcode Translation 5-Axis

Here is the script from the conversation, without modification.

import sys
import math

def parse_gcode_line(line):
    result = {'cmd': None, 'x': None, 'y': None, 'z': None, 'b': None, 'c': None, 'other': ''}
    tokens = line.strip().split()
    if not tokens:
        return result

    result['cmd'] = tokens[0]
    for token in tokens[1:]:
        prefix = token[0].lower()
        if prefix in result:
            try:
                result[prefix] = float(token[1:])
            except ValueError:
                result['other'] += f" {token}"
        else:
            result['other'] += f" {token}"
    return result

def format_gcode_line(cmd, x=None, y=None, z=None, b=None, c=None, other=''):
    parts = [cmd]
    if x is not None: parts.append(f"X{x:.5f}")
    if y is not None: parts.append(f"Y{y:.5f}")
    if z is not None: parts.append(f"Z{z:.5f}")
    if b is not None: parts.append(f"B{b:.5f}")
    if c is not None: parts.append(f"C{c:.5f}")
    if other: parts.append(other.strip())
    return ' '.join(parts)

def rotate_point_b(x, y, z, b_deg):
    """Rotate around Y axis (bed B rotation) by +B degrees"""
    b_rad = math.radians(b_deg)
    cos_b, sin_b = math.cos(b_rad), math.sin(b_rad)
    x_new = cos_b * x + sin_b * z
    z_new = -sin_b * x + cos_b * z
    return x_new, y, z_new

def transform_gcode(input_file, output_file):
    current_b = 0.0

    with open(input_file, 'r') as f_in, open(output_file, 'w') as f_out:
        for line in f_in:
            stripped = line.strip()
            if not stripped or stripped.startswith(';'):
                f_out.write(line)
                continue

            parsed = parse_gcode_line(stripped)
            if parsed['cmd'] and parsed['cmd'].startswith(('G0', 'G1')):
                x, y, z = parsed['x'], parsed['y'], parsed['z']
                b = parsed['b']
                c = parsed['c']

                if b is not None:
                    current_b = b

                # Default values if None
                x_in = x if x is not None else 0
                y_in = y if y is not None else 0
                z_in = z if z is not None else 0

                # Apply rotation with +B to simulate bed rotation matching original tool orientation
                x_rot, y_rot, z_rot = rotate_point_b(x_in, y_in, z_in, current_b)

                x, y, z = x_rot, y_rot, z_rot
                new_b = current_b  # Keep B as is (not negated)

                newline = format_gcode_line(parsed['cmd'], x, y, z, new_b, c, parsed['other'])
                f_out.write(newline + '\n')
            else:
                f_out.write(line)

if __name__ == '__main__':
    if len(sys.argv) != 3:
        print("Usage: python transform_gcode.py input.gcode output.gcode")
        sys.exit(1)
    transform_gcode(sys.argv[1], sys.argv[2])

[jyjblrd]

Nice!

It would probably be easier to do this conversion within the S4 slicer notebook itself. The following block of code in the notebook is what converts the toolpath from a python array to a gcode file:

# save transformed gcode
with open(f'output_gcode/{model_name}.gcode', 'w') as fh:
    # write header
    # ...

    for i, point in enumerate(new_gcode_points):
        position = point["position"]
        rotation = point["rotation"]
        # ....

As you can see, it gives you the position and rotation of each point in the toolpath.

A few lines later, I generate the actual gcode string for that point in the toolpath:

string = f"{point['command']} C{np.rad2deg(theta_accum):.5f} X{r:.5f} Z{z:.5f} B{np.rad2deg(rotation):.5f}" # polar printer
# string = f"{point['command']} X{position[0]:.5f} Y{position[1]:.5f} Z{position[2]} B{np.rad2deg(rotation):.5f}" # cartesian printer (3 axis)

I have the "cartesian printer" line commented out, but if you uncomment it, it would give gcode with XYZ defining the location of the nozzle in space, and B defining the rotation of the nozzle perpendicular to the radial axis. You would probably need to tweak this a bit to give the A and B rotation axis instead (which rotate around the X and Y axis respectively), which I assume the open5x printers use? But this should be a simple addition.

[BrendonBuilds]

It definitely makes more sense to do in the notebook itself but my initial goals were something that would process the output of your notebook, with the assumption being that any progress/updates to the notebook could be more easily digested in post-processing rather than merging changes.

I have previously had success with the cartesian output but had wanted to use the polar output as it results in two axis of rotation (b/c) after translation, instead of moving in x/y rather than c.

As far as I know Open5x machines are primarily xyzbc (translation to xyzac is trivial). Best case scenario: all 5 axis are being used at once to create an ideal nozzle orientation to the part being printed. To me and the other builders leveraging the Open5x configuration, this adaptation of your notebook would be an absolutely massive improvement to the ecosystem and would likely result in additional resources being capable of pushing things further.

[jyjblrd]

Oh yeah, you're right it is XYZBC, which makes it's kinematics system actually very similar to my Core R-Theta printer. Looking at the ChatGPT code, it is a very simple conversion, you just need to adjust the XYZ position of the gantry to account for the B axis rotation.

As discussed in other posts here, the notebook could also be improved to allow 5 axis printing, instead of the current 4 axis printing. This will better utilize the Open5x hardware, and allow for better toolpaths.

[BrendonBuilds]

How complicated is the shift to 5-axis printing?

[jyjblrd]

I briefly discuss it in #1

[yamy1]

I tried the original model pi 3mm g-code, but all my y values show 0, is that reasonable

[jyjblrd]

This slicer is currently set up to use 4 axes, and therefore the Y axis will always be 0. It would be possible to make it work with 5 axes, however.

[yamy1]

thanks

[Notso25]

Hi! I’ve been trying to use the code you provided, but my prints are coming out with a strange shape, its like the shape is rounded. I’m not sure what’s causing it, since I’m using the same configuration as you (Open5X). Do you have any ideas what might be going wrong?
ive tried set the nozzle offset into 0 too

[tienanhbbf1]

Hi, may I ask how can I add the input gcode to create an output gcode? I'm using Visual Studio and I tried to use this line but it doesn't work: transform_gcode('output_gcode\pi3mm.gcode', 'pi3mmfinal.gcode')

[PixlRainbow]

What do you mean "doesn't work"?

[tienanhbbf1]

After I had obtained the 4s slicer GCode for Dino, I tried to use this command on the terminal (given that the transform_gcode.py and the dino.gcode are in the same filepath): python transform_gcode.py dino.gcode dino.gcode. Then the Gcode file went empty. Could you please tell me what am I doing wrong here?

[PixlRainbow]

The script transforms the gcode from input file to output file, one line at a time. If the input and output file are the same file path, the file is overwritten and replaced before the first line of gcode can be processed. Therefore, they must be separate file paths/file names.