CAM: converted the refactored* postprocessors to the new (more object-oriented) API (#19006)
* CAM: converted the refactored* postprocessors to the new API
with corresponding tests
* [pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
---------
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
LarryWoestman
@@ -186,6 +186,8 @@ class CommandPathPost:
|
||||
postprocessor = PostProcessorFactory.get_post_processor(self.candidate, postprocessor_name)
|
||||
|
||||
post_data = postprocessor.export()
|
||||
# None is returned if there was an error during argument processing
|
||||
# otherwise the "usual" post_data data structure is returned.
|
||||
if not post_data:
|
||||
FreeCAD.ActiveDocument.abortTransaction()
|
||||
return
|
||||
@@ -203,8 +205,26 @@ class CommandPathPost:
|
||||
generator.set_subpartname(subpart)
|
||||
fname = next(generated_filename)
|
||||
|
||||
# write the results to the file
|
||||
self._write_file(fname, gcode, policy)
|
||||
#
|
||||
# It is useful for a postprocessor to be able to either skip writing out
|
||||
# a file or write out a zero-length file to indicate that something unusual
|
||||
# has happened. The "gcode" variable is usually a string containing gcode
|
||||
# formatted for output. If the gcode string is zero length then a zero
|
||||
# length file will be written out. If the "gcode" variable contains None
|
||||
# instead, that indicates that the postprocessor doesn't want a file to be
|
||||
# written at all.
|
||||
#
|
||||
# There is at least one old-style postprocessor that currently puts the
|
||||
# gcode file out to a file server and doesn't need to write out a file to
|
||||
# the system where FreeCAD is running. In the old-style postprocessors the
|
||||
# postprocessor code decided whether to write out a file. Eventually a
|
||||
# newer (more object-oriented) version of that postprocessor will return
|
||||
# None for the "gcode" variable value to tell this code not to write out
|
||||
# a file. There may be other uses found for this capability over time.
|
||||
#
|
||||
if gcode is not None:
|
||||
# write the results to the file
|
||||
self._write_file(fname, gcode, policy)
|
||||
|
||||
FreeCAD.ActiveDocument.commitTransaction()
|
||||
FreeCAD.ActiveDocument.recompute()
|
||||
|
||||
@@ -606,7 +606,7 @@ def process_shared_arguments(
|
||||
argstring: str,
|
||||
all_visible: Parser,
|
||||
filename: str,
|
||||
) -> Tuple[bool, Union[str, argparse.Namespace]]:
|
||||
) -> Tuple[bool, Union[None, str, argparse.Namespace]]:
|
||||
"""Process the arguments to the postprocessor."""
|
||||
args: argparse.Namespace
|
||||
argument_text: str
|
||||
@@ -725,7 +725,7 @@ def process_shared_arguments(
|
||||
values["SPINDLE_WAIT"] = args.wait_for_spindle
|
||||
|
||||
except (ArithmeticError, LookupError):
|
||||
return (False, "")
|
||||
return (False, None)
|
||||
|
||||
return (True, args)
|
||||
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2015 Dan Falck <ddfalck@gmail.com> *
|
||||
# * Copyright (c) 2020 Schildkroet *
|
||||
# * Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * Copyright (c) 2022 - 2025 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2024 Ondsel <development@ondsel.com> *
|
||||
# * *
|
||||
# * This file is part of the FreeCAD CAx development system. *
|
||||
# * *
|
||||
@@ -24,259 +23,328 @@
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
|
||||
import argparse
|
||||
|
||||
from typing import Any, Dict, Union
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
|
||||
from Path.Post.Processor import PostProcessor
|
||||
import Path.Post.UtilsArguments as PostUtilsArguments
|
||||
import Path.Post.UtilsExport as PostUtilsExport
|
||||
|
||||
# Define some types that are used throughout this file
|
||||
import Path
|
||||
import FreeCAD
|
||||
|
||||
translate = FreeCAD.Qt.translate
|
||||
|
||||
DEBUG = False
|
||||
if DEBUG:
|
||||
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
|
||||
Path.Log.trackModule(Path.Log.thisModule())
|
||||
else:
|
||||
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
|
||||
|
||||
#
|
||||
# Define some types that are used throughout this file.
|
||||
#
|
||||
Defaults = Dict[str, bool]
|
||||
FormatHelp = str
|
||||
GCodeOrNone = Optional[str]
|
||||
GCodeSections = List[Tuple[str, GCodeOrNone]]
|
||||
Parser = argparse.ArgumentParser
|
||||
ParserArgs = Union[None, str, argparse.Namespace]
|
||||
Postables = Union[List, List[Tuple[str, List]]]
|
||||
Section = Tuple[str, List]
|
||||
Sublist = List
|
||||
Units = str
|
||||
Values = Dict[str, Any]
|
||||
|
||||
#
|
||||
# The following variables need to be global variables
|
||||
# to keep the PathPostProcessor.load method happy:
|
||||
#
|
||||
# TOOLTIP
|
||||
# TOOLTIP_ARGS
|
||||
# UNITS
|
||||
#
|
||||
# The "argument_defaults", "arguments_visible", and the "values" hashes
|
||||
# need to be defined before the "init_shared_arguments" routine can be
|
||||
# called to create TOOLTIP_ARGS, so they also end up having to be globals.
|
||||
# TOOLTIP_ARGS can be defined, so they end up being global variables also.
|
||||
#
|
||||
TOOLTIP: str = """
|
||||
This is a postprocessor file for the Path workbench. It is used to
|
||||
take a pseudo-G-code fragment outputted by a Path object, and output
|
||||
real G-code suitable for a centroid 3 axis mill. This postprocessor, once placed
|
||||
in the appropriate PathScripts folder, can be used directly from inside
|
||||
FreeCAD, via the GUI importer or via python scripts with:
|
||||
|
||||
import refactored_centroid_post
|
||||
refactored_centroid_post.export(object,"/path/to/file.ncc","")
|
||||
"""
|
||||
#
|
||||
# Default to metric mode
|
||||
#
|
||||
UNITS: str = "G21"
|
||||
Visible = Dict[str, bool]
|
||||
|
||||
|
||||
def init_values(values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
# Use 4 digits for axis precision by default.
|
||||
#
|
||||
values["AXIS_PRECISION"] = 4
|
||||
values["DEFAULT_AXIS_PRECISION"] = 4
|
||||
values["DEFAULT_INCH_AXIS_PRECISION"] = 4
|
||||
#
|
||||
# Use ";" as the comment symbol
|
||||
#
|
||||
values["COMMENT_SYMBOL"] = ";"
|
||||
#
|
||||
# Use 1 digit for feed precision by default.
|
||||
#
|
||||
values["FEED_PRECISION"] = 1
|
||||
values["DEFAULT_FEED_PRECISION"] = 1
|
||||
values["DEFAULT_INCH_FEED_PRECISION"] = 1
|
||||
#
|
||||
# This value usually shows up in the post_op comment as "Finish operation:".
|
||||
# Change it to "End" to produce "End operation:".
|
||||
#
|
||||
values["FINISH_LABEL"] = "End"
|
||||
#
|
||||
# If this value is True, then a list of tool numbers
|
||||
# with their labels are output just before the preamble.
|
||||
#
|
||||
values["LIST_TOOLS_IN_PREAMBLE"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS,
|
||||
# but we are suppressing the usage message, so it doesn't show up after all.
|
||||
#
|
||||
values["MACHINE_NAME"] = "Centroid"
|
||||
#
|
||||
# This list controls the order of parameters in a line during output.
|
||||
# centroid doesn't want K properties on XY plane; Arcs need work.
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values["POSTAMBLE"] = """M99"""
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G53 G00 G17"""
|
||||
#
|
||||
# Output any messages.
|
||||
#
|
||||
values["REMOVE_MESSAGES"] = False
|
||||
#
|
||||
# Any commands in this value are output after the header but before the preamble,
|
||||
# then again after the TOOLRETURN but before the POSTAMBLE.
|
||||
#
|
||||
values["SAFETYBLOCK"] = """G90 G80 G40 G49"""
|
||||
#
|
||||
# Do not show the current machine units just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
#
|
||||
# Do not show the current operation label just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_OPERATION_LABELS"] = False
|
||||
#
|
||||
# Do not output an M5 command to stop the spindle for tool changes.
|
||||
#
|
||||
values["STOP_SPINDLE_FOR_TOOL_CHANGE"] = False
|
||||
#
|
||||
# spindle off, height offset canceled, spindle retracted
|
||||
# (M25 is a centroid command to retract spindle)
|
||||
#
|
||||
values[
|
||||
"TOOLRETURN"
|
||||
] = """M5
|
||||
class Refactored_Centroid(PostProcessor):
|
||||
"""The Refactored Centroid post processor class."""
|
||||
|
||||
def __init__(self, job) -> None:
|
||||
super().__init__(
|
||||
job=job,
|
||||
tooltip=translate("CAM", "Refactored Centroid post processor"),
|
||||
tooltipargs=[""],
|
||||
units="Metric",
|
||||
)
|
||||
self.reinitialize()
|
||||
Path.Log.debug("Refactored Centroid post processor initialized.")
|
||||
|
||||
def reinitialize(self) -> None:
|
||||
"""Initialize or reinitialize the 'core' data structures for the postprocessor."""
|
||||
#
|
||||
# This is also used to reinitialize the data structures between tests.
|
||||
#
|
||||
self.values: Values = {}
|
||||
self.init_values(self.values)
|
||||
self.argument_defaults: Defaults = {}
|
||||
self.init_argument_defaults(self.argument_defaults)
|
||||
self.arguments_visible: Visible = {}
|
||||
self.init_arguments_visible(self.arguments_visible)
|
||||
self.parser: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.arguments_visible
|
||||
)
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
self.all_arguments_visible: Visible = {}
|
||||
for k in iter(self.arguments_visible):
|
||||
self.all_arguments_visible[k] = True
|
||||
self.all_visible: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.all_arguments_visible
|
||||
)
|
||||
|
||||
def init_values(self, values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
# Use 4 digits for axis precision by default.
|
||||
#
|
||||
values["AXIS_PRECISION"] = 4
|
||||
values["DEFAULT_AXIS_PRECISION"] = 4
|
||||
values["DEFAULT_INCH_AXIS_PRECISION"] = 4
|
||||
#
|
||||
# Use ";" as the comment symbol
|
||||
#
|
||||
values["COMMENT_SYMBOL"] = ";"
|
||||
#
|
||||
# Use 1 digit for feed precision by default.
|
||||
#
|
||||
values["FEED_PRECISION"] = 1
|
||||
values["DEFAULT_FEED_PRECISION"] = 1
|
||||
values["DEFAULT_INCH_FEED_PRECISION"] = 1
|
||||
#
|
||||
# This value usually shows up in the post_op comment as "Finish operation:".
|
||||
# Change it to "End" to produce "End operation:".
|
||||
#
|
||||
values["FINISH_LABEL"] = "End"
|
||||
#
|
||||
# If this value is True, then a list of tool numbers
|
||||
# with their labels are output just before the preamble.
|
||||
#
|
||||
values["LIST_TOOLS_IN_PREAMBLE"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS.
|
||||
#
|
||||
values["MACHINE_NAME"] = "Centroid"
|
||||
#
|
||||
# This list controls the order of parameters in a line during output.
|
||||
# centroid doesn't want K properties on XY plane; Arcs need work.
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values["POSTAMBLE"] = """M99"""
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G53 G00 G17"""
|
||||
#
|
||||
# Output any messages.
|
||||
#
|
||||
values["REMOVE_MESSAGES"] = False
|
||||
#
|
||||
# Any commands in this value are output after the header but before the preamble,
|
||||
# then again after the TOOLRETURN but before the POSTAMBLE.
|
||||
#
|
||||
values["SAFETYBLOCK"] = """G90 G80 G40 G49"""
|
||||
#
|
||||
# Do not show the current machine units just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
#
|
||||
# Do not show the current operation label just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_OPERATION_LABELS"] = False
|
||||
#
|
||||
# Do not output an M5 command to stop the spindle for tool changes.
|
||||
#
|
||||
values["STOP_SPINDLE_FOR_TOOL_CHANGE"] = False
|
||||
#
|
||||
# spindle off, height offset canceled, spindle retracted
|
||||
# (M25 is a centroid command to retract spindle)
|
||||
#
|
||||
values[
|
||||
"TOOLRETURN"
|
||||
] = """M5
|
||||
M25
|
||||
G49 H0"""
|
||||
values["UNITS"] = UNITS
|
||||
#
|
||||
# Default to not outputting a G43 following tool changes
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
#
|
||||
# This was in the original centroid postprocessor file
|
||||
# but does not appear to be used anywhere.
|
||||
#
|
||||
# ZAXISRETURN = """G91 G28 X0 Z0 G90"""
|
||||
#
|
||||
values["UNITS"] = self._units
|
||||
#
|
||||
# Default to not outputting a G43 following tool changes
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
#
|
||||
# This was in the original centroid postprocessor file
|
||||
# but does not appear to be used anywhere.
|
||||
#
|
||||
# ZAXISRETURN = """G91 G28 X0 Z0 G90"""
|
||||
#
|
||||
|
||||
def init_argument_defaults(self, argument_defaults: Defaults) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
|
||||
def init_argument_defaults(argument_defaults: Dict[str, bool]) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
def init_arguments_visible(self, arguments_visible: Visible) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["axis-modal"] = False
|
||||
arguments_visible["precision"] = False
|
||||
arguments_visible["tlo"] = False
|
||||
|
||||
def init_arguments(
|
||||
self,
|
||||
values: Values,
|
||||
argument_defaults: Defaults,
|
||||
arguments_visible: Visible,
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
_parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with other postprocessors here.
|
||||
#
|
||||
return _parser
|
||||
|
||||
def init_arguments_visible(arguments_visible: Dict[str, bool]) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["axis-modal"] = False
|
||||
arguments_visible["precision"] = False
|
||||
arguments_visible["tlo"] = False
|
||||
def process_arguments(self) -> Tuple[bool, ParserArgs]:
|
||||
"""Process any arguments to the postprocessor."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
self.values, self.parser, self._job.PostProcessorArgs, self.all_visible, "-"
|
||||
)
|
||||
#
|
||||
# If the flag is True, then all of the arguments should be processed normally.
|
||||
#
|
||||
if flag:
|
||||
#
|
||||
# Process any additional arguments here.
|
||||
#
|
||||
#
|
||||
# Update any variables that might have been modified while processing the arguments.
|
||||
#
|
||||
self._units = self.values["UNITS"]
|
||||
#
|
||||
# If the flag is False, then args is either None (indicating an error while
|
||||
# processing the arguments) or a string containing the argument list formatted
|
||||
# for output. Either way the calling routine will need to handle the args value.
|
||||
#
|
||||
return (flag, args)
|
||||
|
||||
def init_arguments(
|
||||
values: Values,
|
||||
argument_defaults: Dict[str, bool],
|
||||
arguments_visible: Dict[str, bool],
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return parser
|
||||
def process_postables(self) -> GCodeSections:
|
||||
"""Postprocess the 'postables' in the job to g code sections."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
gcode: GCodeOrNone
|
||||
g_code_sections: GCodeSections
|
||||
partname: str
|
||||
postables: Postables
|
||||
section: Section
|
||||
sublist: Sublist
|
||||
|
||||
postables = self._buildPostList()
|
||||
|
||||
#
|
||||
# Creating global variables and using functions to modify them
|
||||
# is useful for being able to test things later.
|
||||
#
|
||||
global_values: Values = {}
|
||||
init_values(global_values)
|
||||
global_argument_defaults: Dict[str, bool] = {}
|
||||
init_argument_defaults(global_argument_defaults)
|
||||
global_arguments_visible: Dict[str, bool] = {}
|
||||
init_arguments_visible(global_arguments_visible)
|
||||
global_parser: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_arguments_visible
|
||||
)
|
||||
#
|
||||
# The TOOLTIP_ARGS value is created from the help information about the arguments.
|
||||
#
|
||||
TOOLTIP_ARGS: str = global_parser.format_help()
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
global_all_arguments_visible: Dict[str, bool] = {}
|
||||
k: str
|
||||
for k in iter(global_arguments_visible):
|
||||
global_all_arguments_visible[k] = True
|
||||
global_all_visible: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_all_arguments_visible
|
||||
)
|
||||
Path.Log.debug(f"postables count: {len(postables)}")
|
||||
|
||||
g_code_sections = []
|
||||
for _, section in enumerate(postables):
|
||||
partname, sublist = section
|
||||
gcode = PostUtilsExport.export_common(self.values, sublist, "-")
|
||||
g_code_sections.append((partname, gcode))
|
||||
|
||||
def export(objectslist, filename: str, argstring: str) -> str:
|
||||
"""Postprocess the objects in objectslist to filename."""
|
||||
args: Union[str, argparse.Namespace]
|
||||
flag: bool
|
||||
return g_code_sections
|
||||
|
||||
global UNITS # pylint: disable=global-statement
|
||||
def export(self) -> GCodeSections:
|
||||
"""Process the parser arguments, then postprocess the 'postables'."""
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
# print(parser.format_help())
|
||||
Path.Log.debug("Exporting the job")
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
global_values, global_parser, argstring, global_all_visible, filename
|
||||
)
|
||||
if not flag:
|
||||
return args # type: ignore
|
||||
#
|
||||
# Process any additional arguments here
|
||||
#
|
||||
(flag, args) = self.process_arguments()
|
||||
#
|
||||
# If the flag is True, then continue postprocessing the 'postables'
|
||||
#
|
||||
if flag:
|
||||
return self.process_postables()
|
||||
#
|
||||
# The flag is False meaning something unusual happened.
|
||||
#
|
||||
# If args is None then there was an error during argument processing.
|
||||
#
|
||||
if args is None:
|
||||
return None
|
||||
#
|
||||
# Otherwise args will contain the argument list formatted for output
|
||||
# instead of the "usual" gcode.
|
||||
#
|
||||
return [("allitems", args)] # type: ignore
|
||||
|
||||
#
|
||||
# Update the global variables that might have been modified
|
||||
# while processing the arguments.
|
||||
#
|
||||
UNITS = global_values["UNITS"]
|
||||
@property
|
||||
def tooltip(self):
|
||||
tooltip: str = """
|
||||
This is a postprocessor file for the CAM workbench.
|
||||
It is used to take a pseudo-gcode fragment from a CAM object
|
||||
and output 'real' GCode suitable for a centroid 3 axis mill.
|
||||
"""
|
||||
return tooltip
|
||||
|
||||
return PostUtilsExport.export_common(global_values, objectslist, filename)
|
||||
@property
|
||||
def tooltipArgs(self) -> FormatHelp:
|
||||
return self.parser.format_help()
|
||||
|
||||
@property
|
||||
def units(self) -> Units:
|
||||
return self._units
|
||||
|
||||
@@ -1,9 +1,7 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * Copyright (c) 2018, 2019 Gauthier Briere *
|
||||
# * Copyright (c) 2019, 2020 Schildkroet *
|
||||
# * Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2022 - 2025 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2024 Ondsel <development@ondsel.com> *
|
||||
# * *
|
||||
# * This file is part of the FreeCAD CAx development system. *
|
||||
# * *
|
||||
@@ -25,226 +23,299 @@
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
|
||||
import argparse
|
||||
|
||||
from typing import Any, Dict, Union
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
|
||||
from Path.Post.Processor import PostProcessor
|
||||
import Path.Post.UtilsArguments as PostUtilsArguments
|
||||
import Path.Post.UtilsExport as PostUtilsExport
|
||||
|
||||
# Define some types that are used throughout this file
|
||||
import Path
|
||||
import FreeCAD
|
||||
|
||||
translate = FreeCAD.Qt.translate
|
||||
|
||||
DEBUG = False
|
||||
if DEBUG:
|
||||
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
|
||||
Path.Log.trackModule(Path.Log.thisModule())
|
||||
else:
|
||||
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
|
||||
|
||||
#
|
||||
# Define some types that are used throughout this file.
|
||||
#
|
||||
Defaults = Dict[str, bool]
|
||||
FormatHelp = str
|
||||
GCodeOrNone = Optional[str]
|
||||
GCodeSections = List[Tuple[str, GCodeOrNone]]
|
||||
Parser = argparse.ArgumentParser
|
||||
ParserArgs = Union[None, str, argparse.Namespace]
|
||||
Postables = Union[List, List[Tuple[str, List]]]
|
||||
Section = Tuple[str, List]
|
||||
Sublist = List
|
||||
Units = str
|
||||
Values = Dict[str, Any]
|
||||
|
||||
#
|
||||
# The following variables need to be global variables
|
||||
# to keep the PathPostProcessor.load method happy:
|
||||
#
|
||||
# TOOLTIP
|
||||
# TOOLTIP_ARGS
|
||||
# UNITS
|
||||
#
|
||||
# The "argument_defaults", "arguments_visible", and the "values" hashes
|
||||
# need to be defined before the "init_shared_arguments" routine can be
|
||||
# called to create TOOLTIP_ARGS, so they also end up having to be globals.
|
||||
#
|
||||
TOOLTIP: str = """
|
||||
Generate g-code from a Path that is compatible with the grbl controller:
|
||||
|
||||
import refactored_grbl_post
|
||||
refactored_grbl_post.export(object, "/path/to/file.ncc")
|
||||
"""
|
||||
#
|
||||
# Default to metric mode
|
||||
#
|
||||
UNITS: str = "G21"
|
||||
Visible = Dict[str, bool]
|
||||
|
||||
|
||||
def init_values(values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
#
|
||||
# If this is set to True, then commands that are placed in
|
||||
# comments that look like (MC_RUN_COMMAND: blah) will be output.
|
||||
#
|
||||
values["ENABLE_MACHINE_SPECIFIC_COMMANDS"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS,
|
||||
# but we are suppressing the usage message, so it doesn't show up after all.
|
||||
#
|
||||
values["MACHINE_NAME"] = "Grbl"
|
||||
#
|
||||
# Default to outputting Path labels at the beginning of each Path.
|
||||
#
|
||||
values["OUTPUT_PATH_LABELS"] = True
|
||||
#
|
||||
# Default to not outputting M6 tool changes (comment it) as grbl
|
||||
# currently does not handle it
|
||||
#
|
||||
values["OUTPUT_TOOL_CHANGE"] = False
|
||||
#
|
||||
# The order of the parameters.
|
||||
# Arcs may only work on the XY plane (this needs to be verified).
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"U",
|
||||
"V",
|
||||
"W",
|
||||
"I",
|
||||
"J",
|
||||
"K",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M5
|
||||
class Refactored_Grbl(PostProcessor):
|
||||
"""The Refactored Grbl post processor class."""
|
||||
|
||||
def __init__(self, job) -> None:
|
||||
super().__init__(
|
||||
job=job,
|
||||
tooltip=translate("CAM", "Refactored Grbl post processor"),
|
||||
tooltipargs=[""],
|
||||
units="Metric",
|
||||
)
|
||||
self.reinitialize()
|
||||
Path.Log.debug("Refactored Grbl post processor initialized.")
|
||||
|
||||
def reinitialize(self) -> None:
|
||||
"""Initialize or reinitialize the 'core' data structures for the postprocessor."""
|
||||
#
|
||||
# This is also used to reinitialize the data structures between tests.
|
||||
#
|
||||
self.values: Values = {}
|
||||
self.init_values(self.values)
|
||||
self.argument_defaults: Defaults = {}
|
||||
self.init_argument_defaults(self.argument_defaults)
|
||||
self.arguments_visible: Visible = {}
|
||||
self.init_arguments_visible(self.arguments_visible)
|
||||
self.parser: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.arguments_visible
|
||||
)
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
self.all_arguments_visible: Visible = {}
|
||||
for k in iter(self.arguments_visible):
|
||||
self.all_arguments_visible[k] = True
|
||||
self.all_visible: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.all_arguments_visible
|
||||
)
|
||||
|
||||
def init_values(self, values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
#
|
||||
# If this is set to True, then commands that are placed in
|
||||
# comments that look like (MC_RUN_COMMAND: blah) will be output.
|
||||
#
|
||||
values["ENABLE_MACHINE_SPECIFIC_COMMANDS"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS.
|
||||
#
|
||||
values["MACHINE_NAME"] = "Grbl"
|
||||
#
|
||||
# Default to outputting Path labels at the beginning of each Path.
|
||||
#
|
||||
values["OUTPUT_PATH_LABELS"] = True
|
||||
#
|
||||
# Default to not outputting M6 tool changes (comment it) as grbl
|
||||
# currently does not handle it.
|
||||
#
|
||||
values["OUTPUT_TOOL_CHANGE"] = False
|
||||
#
|
||||
# The order of the parameters.
|
||||
# Arcs may only work on the XY plane (this needs to be verified).
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"U",
|
||||
"V",
|
||||
"W",
|
||||
"I",
|
||||
"J",
|
||||
"K",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M5
|
||||
G17 G90
|
||||
M2"""
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G90"""
|
||||
#
|
||||
# Do not show the current machine units just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
values["UNITS"] = UNITS
|
||||
#
|
||||
# Default to not outputting a G43 following tool changes
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G90"""
|
||||
#
|
||||
# Do not show the current machine units just before the PRE_OPERATION.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
values["UNITS"] = self._units
|
||||
#
|
||||
# Default to not outputting a G43 following tool changes
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
|
||||
def init_argument_defaults(self, argument_defaults: Defaults) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
argument_defaults["tlo"] = False
|
||||
argument_defaults["tool_change"] = False
|
||||
|
||||
def init_argument_defaults(argument_defaults: Dict[str, bool]) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
argument_defaults["tlo"] = False
|
||||
argument_defaults["tool_change"] = False
|
||||
def init_arguments_visible(self, arguments_visible: Visible) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["bcnc"] = True
|
||||
arguments_visible["axis-modal"] = False
|
||||
arguments_visible["return-to"] = True
|
||||
arguments_visible["tlo"] = False
|
||||
arguments_visible["tool_change"] = True
|
||||
arguments_visible["translate_drill"] = True
|
||||
arguments_visible["wait-for-spindle"] = True
|
||||
|
||||
def init_arguments(
|
||||
self,
|
||||
values: Values,
|
||||
argument_defaults: Defaults,
|
||||
arguments_visible: Visible,
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
_parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with other postprocessors here.
|
||||
#
|
||||
return _parser
|
||||
|
||||
def init_arguments_visible(arguments_visible: Dict[str, bool]) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["bcnc"] = True
|
||||
arguments_visible["axis-modal"] = False
|
||||
arguments_visible["return-to"] = True
|
||||
arguments_visible["tlo"] = False
|
||||
arguments_visible["tool_change"] = True
|
||||
arguments_visible["translate_drill"] = True
|
||||
arguments_visible["wait-for-spindle"] = True
|
||||
def process_arguments(self) -> Tuple[bool, ParserArgs]:
|
||||
"""Process any arguments to the postprocessor."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
self.values, self.parser, self._job.PostProcessorArgs, self.all_visible, "-"
|
||||
)
|
||||
#
|
||||
# If the flag is True, then all of the arguments should be processed normally.
|
||||
#
|
||||
if flag:
|
||||
#
|
||||
# Process any additional arguments here.
|
||||
#
|
||||
#
|
||||
# Update any variables that might have been modified while processing the arguments.
|
||||
#
|
||||
self._units = self.values["UNITS"]
|
||||
#
|
||||
# If the flag is False, then args is either None (indicating an error while
|
||||
# processing the arguments) or a string containing the argument list formatted
|
||||
# for output. Either way the calling routine will need to handle the args value.
|
||||
#
|
||||
return (flag, args)
|
||||
|
||||
def init_arguments(
|
||||
values: Values,
|
||||
argument_defaults: Dict[str, bool],
|
||||
arguments_visible: Dict[str, bool],
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return parser
|
||||
def process_postables(self) -> GCodeSections:
|
||||
"""Postprocess the 'postables' in the job to g code sections."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
gcode: GCodeOrNone
|
||||
g_code_sections: GCodeSections
|
||||
partname: str
|
||||
postables: Postables
|
||||
section: Section
|
||||
sublist: Sublist
|
||||
|
||||
postables = self._buildPostList()
|
||||
|
||||
#
|
||||
# Creating global variables and using functions to modify them
|
||||
# is useful for being able to test things later.
|
||||
#
|
||||
global_values: Values = {}
|
||||
init_values(global_values)
|
||||
global_argument_defaults: Dict[str, bool] = {}
|
||||
init_argument_defaults(global_argument_defaults)
|
||||
global_arguments_visible: Dict[str, bool] = {}
|
||||
init_arguments_visible(global_arguments_visible)
|
||||
global_parser: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_arguments_visible
|
||||
)
|
||||
#
|
||||
# The TOOLTIP_ARGS value is created from the help information about the arguments.
|
||||
#
|
||||
TOOLTIP_ARGS: str = global_parser.format_help()
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
global_all_arguments_visible: Dict[str, bool] = {}
|
||||
k: str
|
||||
for k in iter(global_arguments_visible):
|
||||
global_all_arguments_visible[k] = True
|
||||
global_all_visible: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_all_arguments_visible
|
||||
)
|
||||
Path.Log.debug(f"postables count: {len(postables)}")
|
||||
|
||||
g_code_sections = []
|
||||
for _, section in enumerate(postables):
|
||||
partname, sublist = section
|
||||
gcode = PostUtilsExport.export_common(self.values, sublist, "-")
|
||||
g_code_sections.append((partname, gcode))
|
||||
|
||||
def export(objectslist, filename, argstring) -> str:
|
||||
"""Postprocess the objects in objectslist to filename."""
|
||||
args: Union[str, argparse.Namespace]
|
||||
flag: bool
|
||||
return g_code_sections
|
||||
|
||||
global UNITS # pylint: disable=global-statement
|
||||
def export(self) -> Union[None, GCodeSections]:
|
||||
"""Process the parser arguments, then postprocess the 'postables'."""
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
# print(parser.format_help())
|
||||
Path.Log.debug("Exporting the job")
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
global_values, global_parser, argstring, global_all_visible, filename
|
||||
)
|
||||
if not flag:
|
||||
return args # type: ignore
|
||||
#
|
||||
# Process any additional arguments here
|
||||
#
|
||||
(flag, args) = self.process_arguments()
|
||||
#
|
||||
# If the flag is True, then continue postprocessing the 'postables'.
|
||||
#
|
||||
if flag:
|
||||
return self.process_postables()
|
||||
#
|
||||
# The flag is False meaning something unusual happened.
|
||||
#
|
||||
# If args is None then there was an error during argument processing.
|
||||
#
|
||||
if args is None:
|
||||
return None
|
||||
#
|
||||
# Otherwise args will contain the argument list formatted for output
|
||||
# instead of the "usual" gcode.
|
||||
#
|
||||
return [("allitems", args)] # type: ignore
|
||||
|
||||
#
|
||||
# Update the global variables that might have been modified
|
||||
# while processing the arguments.
|
||||
#
|
||||
UNITS = global_values["UNITS"]
|
||||
@property
|
||||
def tooltip(self):
|
||||
tooltip: str = """
|
||||
This is a postprocessor file for the CAM workbench.
|
||||
It is used to take a pseudo-gcode fragment from a CAM object
|
||||
and output 'real' GCode suitable for a Grbl 3 axis mill.
|
||||
"""
|
||||
return tooltip
|
||||
|
||||
return PostUtilsExport.export_common(global_values, objectslist, filename)
|
||||
@property
|
||||
def tooltipArgs(self) -> FormatHelp:
|
||||
return self.parser.format_help()
|
||||
|
||||
@property
|
||||
def units(self) -> Units:
|
||||
return self._units
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2022 - 2025 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2024 Ondsel <development@ondsel.com> *
|
||||
# * Copyright (c) 2024 Carl Slater <CandLWorkshopLLC@gmail.com> *
|
||||
# * *
|
||||
# * This file is part of the FreeCAD CAx development system. *
|
||||
@@ -22,7 +23,6 @@
|
||||
# * USA *
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
# ***************************************************************************
|
||||
# * Note: refactored_masso_g3_Post.py is a modified clone of this file *
|
||||
# * any changes to this file should be applied to the other *
|
||||
@@ -31,191 +31,267 @@
|
||||
|
||||
import argparse
|
||||
|
||||
from typing import Any, Dict, Union
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
|
||||
from Path.Post.Processor import PostProcessor
|
||||
import Path.Post.UtilsArguments as PostUtilsArguments
|
||||
import Path.Post.UtilsExport as PostUtilsExport
|
||||
|
||||
# Define some types that are used throughout this file
|
||||
import Path
|
||||
import FreeCAD
|
||||
|
||||
translate = FreeCAD.Qt.translate
|
||||
|
||||
DEBUG = False
|
||||
if DEBUG:
|
||||
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
|
||||
Path.Log.trackModule(Path.Log.thisModule())
|
||||
else:
|
||||
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
|
||||
|
||||
#
|
||||
# Define some types that are used throughout this file.
|
||||
#
|
||||
Defaults = Dict[str, bool]
|
||||
FormatHelp = str
|
||||
GCodeOrNone = Optional[str]
|
||||
GCodeSections = List[Tuple[str, GCodeOrNone]]
|
||||
Parser = argparse.ArgumentParser
|
||||
ParserArgs = Union[None, str, argparse.Namespace]
|
||||
Postables = Union[List, List[Tuple[str, List]]]
|
||||
Section = Tuple[str, List]
|
||||
Sublist = List
|
||||
Units = str
|
||||
Values = Dict[str, Any]
|
||||
|
||||
#
|
||||
# The following variables need to be global variables
|
||||
# to keep the PathPostProcessor.load method happy:
|
||||
#
|
||||
# TOOLTIP
|
||||
# TOOLTIP_ARGS
|
||||
# UNITS
|
||||
#
|
||||
# The "argument_defaults", "arguments_visible", and the "values" hashes
|
||||
# need to be defined before the "init_shared_arguments" routine can be
|
||||
# called to create TOOLTIP_ARGS, so they also end up having to be globals.
|
||||
#
|
||||
TOOLTIP: str = """This is a postprocessor file for the Path workbench. It is used to
|
||||
take a pseudo-gcode fragment outputted by a Path object, and output
|
||||
real GCode suitable for a linuxcnc 3 axis mill. This postprocessor, once placed
|
||||
in the appropriate PathScripts folder, can be used directly from inside
|
||||
FreeCAD, via the GUI importer or via python scripts with:
|
||||
|
||||
import refactored_linuxcnc_post
|
||||
refactored_linuxcnc_post.export(object,"/path/to/file.ncc","")
|
||||
"""
|
||||
#
|
||||
# Default to metric mode
|
||||
#
|
||||
UNITS: str = "G21"
|
||||
Visible = Dict[str, bool]
|
||||
|
||||
|
||||
def init_values(values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
values["ENABLE_COOLANT"] = True
|
||||
# the order of parameters
|
||||
# linuxcnc doesn't want K properties on XY plane; Arcs need work.
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
"D",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS,
|
||||
# but we are suppressing the usage message, so it doesn't show up after all.
|
||||
#
|
||||
values["MACHINE_NAME"] = "LinuxCNC"
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M05
|
||||
class Refactored_Linuxcnc(PostProcessor):
|
||||
"""The Refactored LinuxCNC post processor class."""
|
||||
|
||||
def __init__(self, job) -> None:
|
||||
super().__init__(
|
||||
job=job,
|
||||
tooltip=translate("CAM", "Refactored LinuxCNC post processor"),
|
||||
tooltipargs=[""],
|
||||
units="Metric",
|
||||
)
|
||||
self.reinitialize()
|
||||
Path.Log.debug("Refactored LinuxCNC post processor initialized.")
|
||||
|
||||
def reinitialize(self) -> None:
|
||||
"""Initialize or reinitialize the 'core' data structures for the postprocessor."""
|
||||
#
|
||||
# This is also used to reinitialize the data structures between tests.
|
||||
#
|
||||
self.values: Values = {}
|
||||
self.init_values(self.values)
|
||||
self.argument_defaults: Defaults = {}
|
||||
self.init_argument_defaults(self.argument_defaults)
|
||||
self.arguments_visible: Visible = {}
|
||||
self.init_arguments_visible(self.arguments_visible)
|
||||
self.parser: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.arguments_visible
|
||||
)
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
self.all_arguments_visible: Visible = {}
|
||||
for k in iter(self.arguments_visible):
|
||||
self.all_arguments_visible[k] = True
|
||||
self.all_visible: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.all_arguments_visible
|
||||
)
|
||||
|
||||
def init_values(self, values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
values["ENABLE_COOLANT"] = True
|
||||
#
|
||||
# The order of parameters.
|
||||
#
|
||||
# linuxcnc doesn't want K properties on XY plane; Arcs need work.
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
"D",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
#
|
||||
values["MACHINE_NAME"] = "Refactored_LinuxCNC"
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M05
|
||||
G17 G54 G90 G80 G40
|
||||
M2"""
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G54 G40 G49 G80 G90"""
|
||||
values["UNITS"] = UNITS
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G54 G40 G49 G80 G90"""
|
||||
values["UNITS"] = self._units
|
||||
|
||||
def init_argument_defaults(self, argument_defaults: Defaults) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
|
||||
def init_argument_defaults(argument_defaults: Dict[str, bool]) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
def init_arguments_visible(self, arguments_visible: Visible) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
|
||||
def init_arguments(
|
||||
self,
|
||||
values: Values,
|
||||
argument_defaults: Defaults,
|
||||
arguments_visible: Visible,
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
_parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return _parser
|
||||
|
||||
def init_arguments_visible(arguments_visible: Dict[str, bool]) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
def process_arguments(self) -> Tuple[bool, ParserArgs]:
|
||||
"""Process any arguments to the postprocessor."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor
|
||||
#
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
self.values, self.parser, self._job.PostProcessorArgs, self.all_visible, "-"
|
||||
)
|
||||
#
|
||||
# If the flag is True, then all of the arguments should be processed normally.
|
||||
#
|
||||
if flag:
|
||||
#
|
||||
# Process any additional arguments here.
|
||||
#
|
||||
#
|
||||
# Update any variables that might have been modified while processing the arguments.
|
||||
#
|
||||
self._units = self.values["UNITS"]
|
||||
#
|
||||
# If the flag is False, then args is either None (indicating an error while
|
||||
# processing the arguments) or a string containing the argument list formatted
|
||||
# for output. Either way the calling routine will need to handle the args value.
|
||||
#
|
||||
return (flag, args)
|
||||
|
||||
def init_arguments(
|
||||
values: Values,
|
||||
argument_defaults: Dict[str, bool],
|
||||
arguments_visible: Dict[str, bool],
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return parser
|
||||
def process_postables(self) -> GCodeSections:
|
||||
"""Postprocess the 'postables' in the job to g code sections."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
gcode: GCodeOrNone
|
||||
g_code_sections: GCodeSections
|
||||
partname: str
|
||||
postables: Postables
|
||||
section: Section
|
||||
sublist: Sublist
|
||||
|
||||
postables = self._buildPostList()
|
||||
|
||||
#
|
||||
# Creating global variables and using functions to modify them
|
||||
# is useful for being able to test things later.
|
||||
#
|
||||
global_values: Values = {}
|
||||
init_values(global_values)
|
||||
global_argument_defaults: Dict[str, bool] = {}
|
||||
init_argument_defaults(global_argument_defaults)
|
||||
global_arguments_visible: Dict[str, bool] = {}
|
||||
init_arguments_visible(global_arguments_visible)
|
||||
global_parser: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_arguments_visible
|
||||
)
|
||||
#
|
||||
# The TOOLTIP_ARGS value is created from the help information about the arguments.
|
||||
#
|
||||
TOOLTIP_ARGS: str = global_parser.format_help()
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
global_all_arguments_visible: Dict[str, bool] = {}
|
||||
for k in iter(global_arguments_visible):
|
||||
global_all_arguments_visible[k] = True
|
||||
global_all_visible: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_all_arguments_visible
|
||||
)
|
||||
Path.Log.debug(f"postables count: {len(postables)}")
|
||||
|
||||
g_code_sections = []
|
||||
for _, section in enumerate(postables):
|
||||
partname, sublist = section
|
||||
gcode = PostUtilsExport.export_common(self.values, sublist, "-")
|
||||
g_code_sections.append((partname, gcode))
|
||||
|
||||
def export(objectslist, filename: str, argstring: str) -> str:
|
||||
"""Postprocess the objects in objectslist to filename."""
|
||||
args: Union[str, argparse.Namespace]
|
||||
flag: bool
|
||||
return g_code_sections
|
||||
|
||||
global UNITS # pylint: disable=global-statement
|
||||
def export(self) -> GCodeSections:
|
||||
"""Process the parser arguments, then postprocess the 'postables'."""
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
# print(parser.format_help())
|
||||
Path.Log.debug("Exporting the job")
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
global_values, global_parser, argstring, global_all_visible, filename
|
||||
)
|
||||
if not flag:
|
||||
return args # type: ignore
|
||||
#
|
||||
# Process any additional arguments here
|
||||
#
|
||||
(flag, args) = self.process_arguments()
|
||||
#
|
||||
# If the flag is True, then continue postprocessing the 'postables'
|
||||
#
|
||||
if flag:
|
||||
return self.process_postables()
|
||||
#
|
||||
# The flag is False meaning something unusual happened.
|
||||
#
|
||||
# If args is None then there was an error during argument processing.
|
||||
#
|
||||
if args is None:
|
||||
return None
|
||||
#
|
||||
# Otherwise args will contain the argument list formatted for output
|
||||
# instead of the "usual" gcode.
|
||||
#
|
||||
return [("allitems", args)] # type: ignore
|
||||
|
||||
#
|
||||
# Update the global variables that might have been modified
|
||||
# while processing the arguments.
|
||||
#
|
||||
UNITS = global_values["UNITS"]
|
||||
@property
|
||||
def tooltip(self):
|
||||
tooltip: str = """
|
||||
This is a postprocessor file for the CAM workbench.
|
||||
It is used to take a pseudo-gcode fragment from a CAM object
|
||||
and output 'real' GCode suitable for a linuxcnc 3 axis mill.
|
||||
"""
|
||||
return tooltip
|
||||
|
||||
return PostUtilsExport.export_common(global_values, objectslist, filename)
|
||||
@property
|
||||
def tooltipArgs(self) -> FormatHelp:
|
||||
return self.parser.format_help()
|
||||
|
||||
@property
|
||||
def units(self) -> Units:
|
||||
return self._units
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2022 - 2025 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2024 Ondsel <development@ondsel.com> *
|
||||
# * *
|
||||
# * This file is part of the FreeCAD CAx development system. *
|
||||
# * *
|
||||
@@ -20,205 +21,284 @@
|
||||
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
||||
# * USA *
|
||||
# * *
|
||||
# ***************************************************************************/
|
||||
|
||||
# ***************************************************************************
|
||||
|
||||
import argparse
|
||||
|
||||
from typing import Any, Dict, Union
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
|
||||
from Path.Post.Processor import PostProcessor
|
||||
import Path.Post.UtilsArguments as PostUtilsArguments
|
||||
import Path.Post.UtilsExport as PostUtilsExport
|
||||
|
||||
# Define some types that are used throughout this file
|
||||
import Path
|
||||
import FreeCAD
|
||||
|
||||
translate = FreeCAD.Qt.translate
|
||||
|
||||
DEBUG = False
|
||||
if DEBUG:
|
||||
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
|
||||
Path.Log.trackModule(Path.Log.thisModule())
|
||||
else:
|
||||
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
|
||||
|
||||
#
|
||||
# Define some types that are used throughout this file.
|
||||
#
|
||||
Defaults = Dict[str, bool]
|
||||
FormatHelp = str
|
||||
GCodeOrNone = Optional[str]
|
||||
GCodeSections = List[Tuple[str, GCodeOrNone]]
|
||||
Parser = argparse.ArgumentParser
|
||||
ParserArgs = Union[None, str, argparse.Namespace]
|
||||
Postables = Union[List, List[Tuple[str, List]]]
|
||||
Section = Tuple[str, List]
|
||||
Sublist = List
|
||||
Units = str
|
||||
Values = Dict[str, Any]
|
||||
|
||||
#
|
||||
# The following variables need to be global variables
|
||||
# to keep the PathPostProcessor.load method happy:
|
||||
#
|
||||
# TOOLTIP
|
||||
# TOOLTIP_ARGS
|
||||
# UNITS
|
||||
#
|
||||
# The "argument_defaults", "arguments_visible", and the "values" hashes
|
||||
# need to be defined before the "init_shared_arguments" routine can be
|
||||
# called to create TOOLTIP_ARGS, so they also end up having to be globals.
|
||||
#
|
||||
TOOLTIP: str = """
|
||||
This is a postprocessor file for the Path workbench. It is used to
|
||||
take a pseudo-G-code fragment outputted by a Path object, and output
|
||||
real G-code suitable for a mach3_4 3 axis mill. This postprocessor, once placed
|
||||
in the appropriate PathScripts folder, can be used directly from inside
|
||||
FreeCAD, via the GUI importer or via python scripts with:
|
||||
|
||||
import mach3_mach4_post
|
||||
mach3_mach4_post.export(object,"/path/to/file.ncc","")
|
||||
"""
|
||||
#
|
||||
# Default to metric mode
|
||||
#
|
||||
UNITS: str = "G21"
|
||||
Visible = Dict[str, bool]
|
||||
|
||||
|
||||
def init_values(values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
values["ENABLE_COOLANT"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS,
|
||||
# but we are suppressing the usage message, so it doesn't show up after all.
|
||||
#
|
||||
values["MACHINE_NAME"] = "mach3_4"
|
||||
# Enable special processing for operations with "Adaptive" in the name
|
||||
values["OUTPUT_ADAPTIVE"] = True
|
||||
# Output the machine name for mach3_mach4 instead of the machine units alone.
|
||||
values["OUTPUT_MACHINE_NAME"] = True
|
||||
# the order of parameters
|
||||
# mach3_mach4 doesn't want K properties on XY plane; Arcs need work.
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
"D",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M05
|
||||
class Refactored_Mach3_Mach4(PostProcessor):
|
||||
"""The Refactored Mach3_Mach4 post processor class."""
|
||||
|
||||
def __init__(self, job) -> None:
|
||||
super().__init__(
|
||||
job=job,
|
||||
tooltip=translate("CAM", "Refactored Mach3_Mach4 post processor"),
|
||||
tooltipargs=[""],
|
||||
units="Metric",
|
||||
)
|
||||
self.reinitialize()
|
||||
Path.Log.debug("Refactored Mach3_Mach4 post processor initialized.")
|
||||
|
||||
def reinitialize(self) -> None:
|
||||
"""Initialize or reinitialize the 'core' data structures for the postprocessor."""
|
||||
#
|
||||
# This is also used to reinitialize the data structures between tests.
|
||||
#
|
||||
self.values: Values = {}
|
||||
self.init_values(self.values)
|
||||
self.argument_defaults: Defaults = {}
|
||||
self.init_argument_defaults(self.argument_defaults)
|
||||
self.arguments_visible: Visible = {}
|
||||
self.init_arguments_visible(self.arguments_visible)
|
||||
self.parser: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.arguments_visible
|
||||
)
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
self.all_arguments_visible: Visible = {}
|
||||
for k in iter(self.arguments_visible):
|
||||
self.all_arguments_visible[k] = True
|
||||
self.all_visible: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.all_arguments_visible
|
||||
)
|
||||
|
||||
def init_values(self, values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
values["ENABLE_COOLANT"] = True
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS.
|
||||
#
|
||||
values["MACHINE_NAME"] = "mach3_4"
|
||||
#
|
||||
# Enable special processing for operations with "Adaptive" in the name.
|
||||
#
|
||||
values["OUTPUT_ADAPTIVE"] = True
|
||||
#
|
||||
# Output the machine name for mach3_mach4 instead of the machine units alone.
|
||||
#
|
||||
values["OUTPUT_MACHINE_NAME"] = True
|
||||
#
|
||||
# The order of parameters.
|
||||
#
|
||||
# mach3_mach4 doesn't want K properties on XY plane; Arcs need work.
|
||||
#
|
||||
values["PARAMETER_ORDER"] = [
|
||||
"X",
|
||||
"Y",
|
||||
"Z",
|
||||
"A",
|
||||
"B",
|
||||
"C",
|
||||
"I",
|
||||
"J",
|
||||
"F",
|
||||
"S",
|
||||
"T",
|
||||
"Q",
|
||||
"R",
|
||||
"L",
|
||||
"H",
|
||||
"D",
|
||||
"P",
|
||||
]
|
||||
#
|
||||
# Any commands in this value will be output as the last commands
|
||||
# in the G-code file.
|
||||
#
|
||||
values[
|
||||
"POSTAMBLE"
|
||||
] = """M05
|
||||
G17 G54 G90 G80 G40
|
||||
M2"""
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G54 G40 G49 G80 G90"""
|
||||
# Output the machine name for mach3_mach4 instead of the machine units alone.
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
values["UNITS"] = UNITS
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Any commands in this value will be output after the header and
|
||||
# safety block at the beginning of the G-code file.
|
||||
#
|
||||
values["PREAMBLE"] = """G17 G54 G40 G49 G80 G90"""
|
||||
#
|
||||
# Output the machine name for mach3_mach4 instead of the machine units alone.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
values["UNITS"] = self._units
|
||||
|
||||
def init_argument_defaults(self, argument_defaults: Defaults) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
|
||||
def init_argument_defaults(argument_defaults: Dict[str, bool]) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
def init_arguments_visible(self, arguments_visible: Visible) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["axis-modal"] = True
|
||||
|
||||
def init_arguments(
|
||||
self,
|
||||
values: Values,
|
||||
argument_defaults: Defaults,
|
||||
arguments_visible: Visible,
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
_parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with other postprocessors here.
|
||||
#
|
||||
return _parser
|
||||
|
||||
def init_arguments_visible(arguments_visible: Dict[str, bool]) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
arguments_visible["axis-modal"] = True
|
||||
def process_arguments(self) -> Tuple[bool, ParserArgs]:
|
||||
"""Process any arguments to the postprocessor."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
self.values, self.parser, self._job.PostProcessorArgs, self.all_visible, "-"
|
||||
)
|
||||
#
|
||||
# If the flag is True, then all of the arguments should be processed normally.
|
||||
#
|
||||
if flag:
|
||||
#
|
||||
# Process any additional arguments here.
|
||||
#
|
||||
#
|
||||
# Update any variables that might have been modified while processing the arguments.
|
||||
#
|
||||
self._units = self.values["UNITS"]
|
||||
#
|
||||
# If the flag is False, then args is either None (indicating an error while
|
||||
# processing the arguments) or a string containing the argument list formatted
|
||||
# for output. Either way the calling routine will need to handle the args value.
|
||||
#
|
||||
return (flag, args)
|
||||
|
||||
def init_arguments(
|
||||
values: Values,
|
||||
argument_defaults: Dict[str, bool],
|
||||
arguments_visible: Dict[str, bool],
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return parser
|
||||
def process_postables(self) -> GCodeSections:
|
||||
"""Postprocess the 'postables' in the job to g code sections."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
gcode: GCodeOrNone
|
||||
g_code_sections: GCodeSections
|
||||
partname: str
|
||||
postables: Postables
|
||||
section: Section
|
||||
sublist: Sublist
|
||||
|
||||
postables = self._buildPostList()
|
||||
|
||||
#
|
||||
# Creating global variables and using functions to modify them
|
||||
# is useful for being able to test things later.
|
||||
#
|
||||
global_values: Values = {}
|
||||
init_values(global_values)
|
||||
global_argument_defaults: Dict[str, bool] = {}
|
||||
init_argument_defaults(global_argument_defaults)
|
||||
global_arguments_visible: Dict[str, bool] = {}
|
||||
init_arguments_visible(global_arguments_visible)
|
||||
global_parser: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_arguments_visible
|
||||
)
|
||||
#
|
||||
# The TOOLTIP_ARGS value is created from the help information about the arguments.
|
||||
#
|
||||
TOOLTIP_ARGS: str = global_parser.format_help()
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
global_all_arguments_visible: Dict[str, bool] = {}
|
||||
k: str
|
||||
for k in iter(global_arguments_visible):
|
||||
global_all_arguments_visible[k] = True
|
||||
global_all_visible: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_all_arguments_visible
|
||||
)
|
||||
Path.Log.debug(f"postables count: {len(postables)}")
|
||||
|
||||
g_code_sections = []
|
||||
for _, section in enumerate(postables):
|
||||
partname, sublist = section
|
||||
gcode = PostUtilsExport.export_common(self.values, sublist, "-")
|
||||
g_code_sections.append((partname, gcode))
|
||||
|
||||
def export(objectslist, filename, argstring) -> str:
|
||||
"""Postprocess the objects in objectslist to filename."""
|
||||
args: Union[str, argparse.Namespace]
|
||||
flag: bool
|
||||
return g_code_sections
|
||||
|
||||
global UNITS # pylint: disable=global-statement
|
||||
def export(self) -> GCodeSections:
|
||||
"""Process the parser arguments, then postprocess the 'postables'."""
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
# print(parser.format_help())
|
||||
Path.Log.debug("Exporting the job")
|
||||
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
global_values, global_parser, argstring, global_all_visible, filename
|
||||
)
|
||||
if not flag:
|
||||
return args # type: ignore
|
||||
#
|
||||
# Process any additional arguments here
|
||||
#
|
||||
(flag, args) = self.process_arguments()
|
||||
#
|
||||
# If the flag is True, then continue postprocessing the 'postables'.
|
||||
#
|
||||
if flag:
|
||||
return self.process_postables()
|
||||
#
|
||||
# The flag is False meaning something unusual happened.
|
||||
#
|
||||
# If args is None then there was an error during argument processing.
|
||||
#
|
||||
if args is None:
|
||||
return None
|
||||
#
|
||||
# Otherwise args will contain the argument list formatted for output
|
||||
# instead of the "usual" gcode.
|
||||
#
|
||||
return [("allitems", args)] # type: ignore
|
||||
|
||||
#
|
||||
# Update the global variables that might have been modified
|
||||
# while processing the arguments.
|
||||
#
|
||||
UNITS = global_values["UNITS"]
|
||||
@property
|
||||
def tooltip(self):
|
||||
tooltip: str = """
|
||||
This is a postprocessor file for the CAM workbench.
|
||||
It is used to take a pseudo-gcode fragment from a CAM object
|
||||
and output 'real' GCode suitable for a Mach3_4 3 axis mill.
|
||||
"""
|
||||
return tooltip
|
||||
|
||||
return PostUtilsExport.export_common(global_values, objectslist, filename)
|
||||
@property
|
||||
def tooltipArgs(self) -> FormatHelp:
|
||||
return self.parser.format_help()
|
||||
|
||||
@property
|
||||
def units(self) -> Units:
|
||||
return self._units
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# ***************************************************************************
|
||||
# * Copyright (c) 2014 sliptonic <shopinthewoods@gmail.com> *
|
||||
# * Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2022 - 2025 Larry Woestman <LarryWoestman2@gmail.com> *
|
||||
# * Copyright (c) 2024 Ondsel <development@ondsel.com> *
|
||||
# * *
|
||||
# * This file is part of the FreeCAD CAx development system. *
|
||||
# * *
|
||||
@@ -22,200 +23,264 @@
|
||||
# * *
|
||||
# ***************************************************************************
|
||||
|
||||
|
||||
import argparse
|
||||
|
||||
from typing import Any, Dict, Union
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union
|
||||
|
||||
import Path.Post.UtilsArguments as UtilsArguments
|
||||
import Path.Post.UtilsExport as UtilsExport
|
||||
from Path.Post.Processor import PostProcessor
|
||||
import Path.Post.UtilsArguments as PostUtilsArguments
|
||||
import Path.Post.UtilsExport as PostUtilsExport
|
||||
|
||||
# Define some types that are used throughout this file
|
||||
import Path
|
||||
import FreeCAD
|
||||
|
||||
translate = FreeCAD.Qt.translate
|
||||
|
||||
DEBUG = False
|
||||
if DEBUG:
|
||||
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
|
||||
Path.Log.trackModule(Path.Log.thisModule())
|
||||
else:
|
||||
Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule())
|
||||
|
||||
#
|
||||
# Define some types that are used throughout this file.
|
||||
#
|
||||
Defaults = Dict[str, bool]
|
||||
FormatHelp = str
|
||||
GCodeOrNone = Optional[str]
|
||||
GCodeSections = List[Tuple[str, GCodeOrNone]]
|
||||
Parser = argparse.ArgumentParser
|
||||
ParserArgs = Union[None, str, argparse.Namespace]
|
||||
Postables = Union[List, List[Tuple[str, List]]]
|
||||
Section = Tuple[str, List]
|
||||
Sublist = List
|
||||
Units = str
|
||||
Values = Dict[str, Any]
|
||||
|
||||
#
|
||||
# The following variables need to be global variables
|
||||
# to keep the PathPostProcessor.load method happy:
|
||||
#
|
||||
# TOOLTIP
|
||||
# TOOLTIP_ARGS
|
||||
# UNITS
|
||||
#
|
||||
# The "argument_defaults", "arguments_visible", and the "values" hashes
|
||||
# need to be defined before the "init_shared_arguments" routine can be
|
||||
# called to create TOOLTIP_ARGS, so they also end up having to be globals.
|
||||
#
|
||||
TOOLTIP: str = """This is a postprocessor file for the Path workbench. It is used to
|
||||
test the postprocessor code. It probably isn't useful for "real" gcode.
|
||||
|
||||
import refactored_test_post
|
||||
refactored_test_post.export(object,"/path/to/file.ncc","")
|
||||
"""
|
||||
#
|
||||
# Default to metric mode
|
||||
#
|
||||
UNITS: str = "G21"
|
||||
Visible = Dict[str, bool]
|
||||
|
||||
|
||||
def init_values(values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
global UNITS
|
||||
class Refactored_Test(PostProcessor):
|
||||
"""The Refactored Test post processor class."""
|
||||
|
||||
UtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
# Turn off as much functionality as possible by default.
|
||||
# Then the tests can turn back on the appropriate options as needed.
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
# This would normally show up in the usage message in the TOOLTIP_ARGS,
|
||||
# but we are suppressing the usage message, so it doesn't show up after all.
|
||||
#
|
||||
values["MACHINE_NAME"] = "test"
|
||||
#
|
||||
# Don't output comments by default
|
||||
#
|
||||
values["OUTPUT_COMMENTS"] = False
|
||||
#
|
||||
# Don't output the header by default
|
||||
#
|
||||
values["OUTPUT_HEADER"] = False
|
||||
#
|
||||
# Convert M56 tool change commands to comments,
|
||||
# which are then suppressed by default.
|
||||
#
|
||||
values["OUTPUT_TOOL_CHANGE"] = False
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Do not show the editor by default since we are testing.
|
||||
#
|
||||
values["SHOW_EDITOR"] = False
|
||||
#
|
||||
# Don't show the current machine units by default
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
#
|
||||
# Don't show the current operation label by default.
|
||||
#
|
||||
values["SHOW_OPERATION_LABELS"] = False
|
||||
#
|
||||
# Don't output an M5 command to stop the spindle after an M6 tool change by default.
|
||||
#
|
||||
values["STOP_SPINDLE_FOR_TOOL_CHANGE"] = False
|
||||
#
|
||||
# Don't output a G43 tool length command following tool changes by default.
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
values["UNITS"] = UNITS
|
||||
def __init__(self, job) -> None:
|
||||
super().__init__(
|
||||
job=job,
|
||||
tooltip=translate("CAM", "Refactored Test post processor"),
|
||||
tooltipargs=[""],
|
||||
units="Metric",
|
||||
)
|
||||
self.reinitialize()
|
||||
Path.Log.debug("Refactored Test post processor initialized")
|
||||
|
||||
def reinitialize(self) -> None:
|
||||
"""Initialize or reinitialize the 'core' data structures for the postprocessor."""
|
||||
#
|
||||
# This is also used to reinitialize the data structures between tests.
|
||||
#
|
||||
self.values: Values = {}
|
||||
self.init_values(self.values)
|
||||
self.argument_defaults: Defaults = {}
|
||||
self.init_argument_defaults(self.argument_defaults)
|
||||
self.arguments_visible: Visible = {}
|
||||
self.init_arguments_visible(self.arguments_visible)
|
||||
self.parser: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.arguments_visible
|
||||
)
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
self.all_arguments_visible: Visible = {}
|
||||
for k in iter(self.arguments_visible):
|
||||
self.all_arguments_visible[k] = True
|
||||
self.all_visible: Parser = self.init_arguments(
|
||||
self.values, self.argument_defaults, self.all_arguments_visible
|
||||
)
|
||||
|
||||
def init_argument_defaults(argument_defaults: Dict[str, bool]) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
UtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
def init_values(self, values: Values) -> None:
|
||||
"""Initialize values that are used throughout the postprocessor."""
|
||||
#
|
||||
PostUtilsArguments.init_shared_values(values)
|
||||
#
|
||||
# Set any values here that need to override the default values set
|
||||
# in the init_shared_values routine.
|
||||
#
|
||||
# Used in the argparser code as the "name" of the postprocessor program.
|
||||
#
|
||||
values["MACHINE_NAME"] = "test"
|
||||
#
|
||||
# Don't output comments by default.
|
||||
#
|
||||
values["OUTPUT_COMMENTS"] = False
|
||||
#
|
||||
# Don't output the header by default.
|
||||
#
|
||||
values["OUTPUT_HEADER"] = False
|
||||
#
|
||||
# Convert M56 tool change commands to comments,
|
||||
# which are then suppressed by default.
|
||||
#
|
||||
values["OUTPUT_TOOL_CHANGE"] = False
|
||||
values["POSTPROCESSOR_FILE_NAME"] = __name__
|
||||
#
|
||||
# Do not show the editor by default since we are testing.
|
||||
#
|
||||
values["SHOW_EDITOR"] = False
|
||||
#
|
||||
# Don't show the current machine units by default.
|
||||
#
|
||||
values["SHOW_MACHINE_UNITS"] = False
|
||||
#
|
||||
# Don't show the current operation label by default.
|
||||
#
|
||||
values["SHOW_OPERATION_LABELS"] = False
|
||||
#
|
||||
# Don't output an M5 command to stop the spindle after an M6 tool change by default.
|
||||
#
|
||||
values["STOP_SPINDLE_FOR_TOOL_CHANGE"] = False
|
||||
#
|
||||
# Don't output a G43 tool length command following tool changes by default.
|
||||
#
|
||||
values["USE_TLO"] = False
|
||||
values["UNITS"] = self._units
|
||||
|
||||
def init_argument_defaults(self, argument_defaults: Defaults) -> None:
|
||||
"""Initialize which arguments (in a pair) are shown as the default argument."""
|
||||
PostUtilsArguments.init_argument_defaults(argument_defaults)
|
||||
#
|
||||
# Modify which argument to show as the default in flag-type arguments here.
|
||||
# If the value is True, the first argument will be shown as the default.
|
||||
# If the value is False, the second argument will be shown as the default.
|
||||
#
|
||||
# For example, if you want to show Metric mode as the default, use:
|
||||
# argument_defaults["metric_inch"] = True
|
||||
#
|
||||
# If you want to show that "Don't pop up editor for writing output" is
|
||||
# the default, use:
|
||||
# argument_defaults["show-editor"] = False.
|
||||
#
|
||||
# Note: You also need to modify the corresponding entries in the "values" hash
|
||||
# to actually make the default value(s) change to match.
|
||||
#
|
||||
|
||||
def init_arguments_visible(arguments_visible: Dict[str, bool]) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
key: str
|
||||
def init_arguments_visible(self, arguments_visible: Visible) -> None:
|
||||
"""Initialize which argument pairs are visible in TOOLTIP_ARGS."""
|
||||
PostUtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
# Make all arguments invisible by default.
|
||||
#
|
||||
for key in iter(arguments_visible):
|
||||
arguments_visible[key] = False
|
||||
|
||||
UtilsArguments.init_arguments_visible(arguments_visible)
|
||||
#
|
||||
# Modify the visibility of any arguments from the defaults here.
|
||||
#
|
||||
#
|
||||
# Make all arguments invisible by default.
|
||||
#
|
||||
for key in iter(arguments_visible):
|
||||
arguments_visible[key] = False
|
||||
def init_arguments(
|
||||
self,
|
||||
values: Values,
|
||||
argument_defaults: Defaults,
|
||||
arguments_visible: Visible,
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
_parser: Parser = PostUtilsArguments.init_shared_arguments(
|
||||
values, argument_defaults, arguments_visible
|
||||
)
|
||||
#
|
||||
# Add any argument definitions that are not shared with other postprocessors here.
|
||||
#
|
||||
return _parser
|
||||
|
||||
def process_arguments(self) -> Tuple[bool, ParserArgs]:
|
||||
"""Process any arguments to the postprocessor."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
def init_arguments(
|
||||
values: Values,
|
||||
argument_defaults: Dict[str, bool],
|
||||
arguments_visible: Dict[str, bool],
|
||||
) -> Parser:
|
||||
"""Initialize the shared argument definitions."""
|
||||
parser: Parser
|
||||
(flag, args) = PostUtilsArguments.process_shared_arguments(
|
||||
self.values, self.parser, self._job.PostProcessorArgs, self.all_visible, "-"
|
||||
)
|
||||
#
|
||||
# If the flag is True, then all of the arguments should be processed normally.
|
||||
#
|
||||
if flag:
|
||||
#
|
||||
# Process any additional arguments here.
|
||||
#
|
||||
#
|
||||
# Update any variables that might have been modified while processing the arguments.
|
||||
#
|
||||
self._units = self.values["UNITS"]
|
||||
#
|
||||
# If the flag is False, then args is either None (indicating an error while
|
||||
# processing the arguments) or a string containing the argument list formatted
|
||||
# for output. Either way the calling routine will need to handle the args value.
|
||||
#
|
||||
return (flag, args)
|
||||
|
||||
parser = UtilsArguments.init_shared_arguments(values, argument_defaults, arguments_visible)
|
||||
#
|
||||
# Add any argument definitions that are not shared with all other
|
||||
# postprocessors here.
|
||||
#
|
||||
return parser
|
||||
def process_postables(self) -> GCodeSections:
|
||||
"""Postprocess the 'postables' in the job to g code sections."""
|
||||
#
|
||||
# This function is separated out to make it easier to inherit from this postprocessor.
|
||||
#
|
||||
gcode: GCodeOrNone
|
||||
g_code_sections: GCodeSections
|
||||
partname: str
|
||||
postables: Postables
|
||||
section: Section
|
||||
sublist: Sublist
|
||||
|
||||
postables = self._buildPostList()
|
||||
|
||||
#
|
||||
# Creating global variables and using functions to modify them
|
||||
# is useful for being able to test things later.
|
||||
#
|
||||
global_values: Values = {}
|
||||
init_values(global_values)
|
||||
global_argument_defaults: Dict[str, bool] = {}
|
||||
init_argument_defaults(global_argument_defaults)
|
||||
global_arguments_visible: Dict[str, bool] = {}
|
||||
init_arguments_visible(global_arguments_visible)
|
||||
global_parser: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_arguments_visible
|
||||
)
|
||||
#
|
||||
# The TOOLTIP_ARGS value is created from the help information about the arguments.
|
||||
#
|
||||
TOOLTIP_ARGS: str = global_parser.format_help()
|
||||
#
|
||||
# Create another parser just to get a list of all possible arguments
|
||||
# that may be output using --output_all_arguments.
|
||||
#
|
||||
global_all_arguments_visible: Dict[str, bool] = {}
|
||||
k: str
|
||||
for k in iter(global_arguments_visible):
|
||||
global_all_arguments_visible[k] = True
|
||||
global_all_visible: Parser = init_arguments(
|
||||
global_values, global_argument_defaults, global_all_arguments_visible
|
||||
)
|
||||
Path.Log.debug(f"postables count: {len(postables)}")
|
||||
|
||||
g_code_sections = []
|
||||
for _, section in enumerate(postables):
|
||||
partname, sublist = section
|
||||
gcode = PostUtilsExport.export_common(self.values, sublist, "-")
|
||||
g_code_sections.append((partname, gcode))
|
||||
|
||||
def export(objectslist, filename: str, argstring: str) -> str:
|
||||
"""Postprocess the objects in objectslist to filename."""
|
||||
args: Union[str, argparse.Namespace]
|
||||
flag: bool
|
||||
return g_code_sections
|
||||
|
||||
global UNITS # pylint: disable=global-statement
|
||||
def export(self) -> Union[None, GCodeSections]:
|
||||
"""Process the parser arguments, then postprocess the 'postables'."""
|
||||
args: ParserArgs
|
||||
flag: bool
|
||||
|
||||
# print(parser.format_help())
|
||||
Path.Log.debug("Exporting the job")
|
||||
|
||||
(flag, args) = UtilsArguments.process_shared_arguments(
|
||||
global_values, global_parser, argstring, global_all_visible, filename
|
||||
)
|
||||
if not flag:
|
||||
return args # type: ignore
|
||||
#
|
||||
# Process any additional arguments here
|
||||
#
|
||||
(flag, args) = self.process_arguments()
|
||||
#
|
||||
# If the flag is True, then continue postprocessing the 'postables'.
|
||||
#
|
||||
if flag:
|
||||
return self.process_postables()
|
||||
#
|
||||
# The flag is False meaning something unusual happened.
|
||||
#
|
||||
# If args is None then there was an error during argument processing.
|
||||
#
|
||||
if args is None:
|
||||
return None
|
||||
#
|
||||
# Otherwise args will contain the argument list formatted for output
|
||||
# instead of the "usual" gcode.
|
||||
#
|
||||
return [("allitems", args)] # type: ignore
|
||||
|
||||
#
|
||||
# Update the global variables that might have been modified
|
||||
# while processing the arguments.
|
||||
#
|
||||
UNITS = global_values["UNITS"]
|
||||
@property
|
||||
def tooltip(self):
|
||||
tooltip: str = """
|
||||
This is a postprocessor file for the CAM workbench. It is used
|
||||
to test the postprocessor code. It probably isn't useful for "real" gcode.
|
||||
"""
|
||||
return tooltip
|
||||
|
||||
return UtilsExport.export_common(global_values, objectslist, filename)
|
||||
@property
|
||||
def tooltipArgs(self) -> FormatHelp:
|
||||
return self.parser.format_help()
|
||||
|
||||
@property
|
||||
def units(self) -> Units:
|
||||
return self._units
|
||||
|
||||
Reference in New Issue
Block a user