473 lines
18 KiB
Python
473 lines
18 KiB
Python
import numpy as np
|
|
import unittest
|
|
from unittest.mock import MagicMock
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
# Add workspace directory to sys.path to resolve root package name (NodeSlicer)
|
|
PROJECT_ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.append(str(PROJECT_ROOT.parent))
|
|
|
|
# Define dummy classes to avoid metaclass conflicts
|
|
class DummyNodeSocket: pass
|
|
class DummyNode: pass
|
|
class DummyObject: pass
|
|
class DummyMesh: pass
|
|
class DummyNodeSocketShader: pass
|
|
class DummyNodeCustomGroup: pass
|
|
class DummyNodeTree: pass
|
|
class DummyOperator: pass
|
|
class DummyMenu: pass
|
|
class DummyPanel: pass
|
|
class DummyPropertyGroup: pass
|
|
|
|
mock_types = MagicMock()
|
|
mock_types.NodeSocket = DummyNodeSocket
|
|
mock_types.Node = DummyNode
|
|
mock_types.Object = DummyObject
|
|
mock_types.Mesh = DummyMesh
|
|
mock_types.NodeSocketShader = DummyNodeSocketShader
|
|
mock_types.NodeCustomGroup = DummyNodeCustomGroup
|
|
mock_types.NodeTree = DummyNodeTree
|
|
mock_types.Operator = DummyOperator
|
|
mock_types.Menu = DummyMenu
|
|
mock_types.Panel = DummyPanel
|
|
mock_types.PropertyGroup = DummyPropertyGroup
|
|
|
|
if 'bpy' in sys.modules and isinstance(sys.modules['bpy'], MagicMock):
|
|
mock_bpy = sys.modules['bpy']
|
|
else:
|
|
mock_bpy = MagicMock()
|
|
sys.modules['bpy'] = mock_bpy
|
|
|
|
mock_bpy.context.scene = MagicMock()
|
|
mock_bpy.context.scene.unit_settings.scale_length = 0.001
|
|
mock_bpy.types = mock_types
|
|
|
|
sys.modules['bpy.types'] = mock_types
|
|
sys.modules['bpy.props'] = MagicMock()
|
|
sys.modules['bpy.utils'] = MagicMock()
|
|
sys.modules['bpy.utils.previews'] = MagicMock()
|
|
sys.modules['bpy.app'] = MagicMock()
|
|
sys.modules['bpy.app.handlers'] = MagicMock()
|
|
|
|
from NodeSlicer.infra.blender.blender_mesh_capture import SlicingCollection, SlicingObject
|
|
|
|
class TestTransform(unittest.TestCase):
|
|
def test_offset(self):
|
|
# Create a SlicingObject with a single triangle and a normal pointing up (+Z)
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
# Offset
|
|
so.offset(np.array([10.0, 20.0, 30.0], dtype=np.float64))
|
|
|
|
# Normals should remain unchanged, vertices shifted
|
|
np.testing.assert_allclose(so.mesh[0, 0], [11.0, 22.0, 33.0])
|
|
np.testing.assert_allclose(so.mesh[0, 1], [14.0, 25.0, 36.0])
|
|
np.testing.assert_allclose(so.mesh[0, 2], [17.0, 28.0, 39.0])
|
|
np.testing.assert_allclose(so.mesh[0, 3], [0.0, 0.0, 1.0])
|
|
|
|
def test_scale_uniform(self):
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
# Uniform Scale
|
|
so.scale(2.0)
|
|
np.testing.assert_allclose(so.mesh[0, 0], [2.0, 4.0, 6.0])
|
|
np.testing.assert_allclose(so.mesh[0, 3], [0.0, 0.0, 1.0])
|
|
|
|
def test_scale_non_uniform(self):
|
|
so = SlicingObject()
|
|
# Normal pointing at (1, 1, 0) normalized: (0.70710678, 0.70710678, 0.0)
|
|
n = np.array([1.0, 1.0, 0.0]) / np.sqrt(2.0)
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
n]], dtype=np.float64)
|
|
|
|
# Scale X by 2, Y by 0.5, Z by 1
|
|
so.scale(np.array([2.0, 0.5, 1.0]))
|
|
|
|
# Vertices check
|
|
np.testing.assert_allclose(so.mesh[0, 0], [2.0, 1.0, 3.0])
|
|
|
|
# Normals check: non-uniform scale scales normal by inverse transpose, then normalized.
|
|
# Inverse of scale is [0.5, 2.0, 1.0].
|
|
# Rotated normal: (0.7071 / 2, 0.7071 * 2, 0.0) = (0.3535, 1.414, 0.0)
|
|
# Normalized: (0.3535 / sqrt(0.3535^2 + 1.414^2), ...)
|
|
expected_n = np.array([n[0] / 2.0, n[1] / 0.5, 0.0])
|
|
expected_n /= np.linalg.norm(expected_n)
|
|
np.testing.assert_allclose(so.mesh[0, 3], expected_n, rtol=1e-6)
|
|
|
|
def test_rotate(self):
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 0.0, 0.0],
|
|
[0.0, 1.0, 0.0],
|
|
[0.0, 0.0, 1.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
# Rotate 90 degrees around Z axis (0, 0, pi/2)
|
|
so.rotate(np.array([0.0, 0.0, np.pi / 2.0]))
|
|
|
|
# Vertex [1, 0, 0] rotated around Z by 90 deg -> [0, 1, 0]
|
|
np.testing.assert_allclose(so.mesh[0, 0], [0.0, 1.0, 0.0], atol=1e-7)
|
|
# Vertex [0, 1, 0] rotated around Z by 90 deg -> [-1, 0, 0]
|
|
np.testing.assert_allclose(so.mesh[0, 1], [-1.0, 0.0, 0.0], atol=1e-7)
|
|
# Vertex [0, 0, 1] rotated around Z by 90 deg -> [0, 0, 1]
|
|
np.testing.assert_allclose(so.mesh[0, 2], [0.0, 0.0, 1.0], atol=1e-7)
|
|
# Normal [0, 0, 1] should remain [0, 0, 1]
|
|
np.testing.assert_allclose(so.mesh[0, 3], [0.0, 0.0, 1.0], atol=1e-7)
|
|
|
|
def test_collection_cache_invalidation(self):
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 0.0, 0.0],
|
|
[0.0, 1.0, 0.0],
|
|
[0.0, 0.0, 1.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
sc = SlicingCollection([], "coll")
|
|
sc.objects = [so]
|
|
|
|
# Access cached properties to populate the cache
|
|
all_v = sc.all_verts
|
|
uniq_v = sc.unique_verts
|
|
self.assertIn("all_verts", sc.__dict__)
|
|
self.assertIn("unique_verts", sc.__dict__)
|
|
|
|
# Apply transformation
|
|
sc.offset(np.array([10, 0, 0]))
|
|
|
|
# Verify cache was cleared
|
|
self.assertNotIn("all_verts", sc.__dict__)
|
|
self.assertNotIn("unique_verts", sc.__dict__)
|
|
|
|
# Verify new values are retrieved when accessed again
|
|
new_all_v = sc.all_verts
|
|
self.assertEqual(new_all_v[0, 0], 11.0)
|
|
|
|
def test_transform_node(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.mesh import SLICENODE_TransformGeometry
|
|
|
|
# Create a SlicingObject with a single triangle and a normal pointing up (+Z)
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
sc = SlicingCollection([], "coll")
|
|
sc.objects = [so]
|
|
|
|
# Init node
|
|
node = SLICENODE_TransformGeometry()
|
|
|
|
# Define mock resolver to return our inputs
|
|
def mock_resolve(fieldname):
|
|
if fieldname == "Mesh":
|
|
return sc
|
|
elif fieldname == "Translation":
|
|
return (10.0, 20.0, 30.0)
|
|
elif fieldname == "Rotation":
|
|
# Rotate 90 degrees around Z axis: (0, 0, pi / 2)
|
|
return (0.0, 0.0, np.pi / 2.0)
|
|
elif fieldname == "Scale":
|
|
return (2.0, 2.0, 2.0)
|
|
return None
|
|
|
|
node.resolve = mock_resolve
|
|
|
|
# Evaluate output
|
|
result_sc = node.evaluate_output("Mesh")
|
|
self.assertIsNotNone(result_sc)
|
|
|
|
# Ensure it's not the same object (deep copied)
|
|
self.assertIsNot(result_sc, sc)
|
|
self.assertIsNot(result_sc.objects[0], so)
|
|
|
|
# Let's check coordinates.
|
|
# SRT Order:
|
|
# 1. Scale by 2.0:
|
|
# v0 becomes [2.0, 4.0, 6.0]
|
|
# 2. Rotate by pi/2 around Z:
|
|
# v0 becomes [-4.0, 2.0, 6.0]
|
|
# 3. Translate by [10, 20, 30]:
|
|
# v0 becomes [6.0, 22.0, 36.0]
|
|
np.testing.assert_allclose(result_sc.objects[0].mesh[0, 0], [6.0, 22.0, 36.0], atol=1e-7)
|
|
|
|
def test_transform_node_slice_paths(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.mesh import SLICENODE_TransformGeometry
|
|
from NodeSlicer.core.slice import SlicePaths
|
|
|
|
path = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float64)
|
|
sp = SlicePaths([path])
|
|
|
|
node = SLICENODE_TransformGeometry()
|
|
node.resolve = lambda f: {
|
|
"Geometry": sp,
|
|
"Translation": (10.0, 20.0, 30.0),
|
|
"Rotation": (0.0, 0.0, np.pi / 2.0),
|
|
"Scale": (2.0, 2.0, 2.0)
|
|
}.get(f)
|
|
|
|
result_sp = node.evaluate_output("Geometry")
|
|
self.assertIsNotNone(result_sp)
|
|
self.assertIsInstance(result_sp, SlicePaths)
|
|
self.assertIsNot(result_sp, sp)
|
|
|
|
# Point 1: [1, 2, 3] -> scale [2, 4, 6] -> rot Z pi/2 [-4, 2, 6] -> trans [6, 22, 36]
|
|
np.testing.assert_allclose(result_sp[0][0], [6.0, 22.0, 36.0], atol=1e-7)
|
|
# Point 2: [4, 5, 6] -> scale [8, 10, 12] -> rot Z pi/2 [-10, 8, 12] -> trans [0, 28, 42]
|
|
np.testing.assert_allclose(result_sp[0][1], [0.0, 28.0, 42.0], atol=1e-7)
|
|
|
|
# Check transforms metadata
|
|
self.assertEqual(len(result_sp.transforms), 1)
|
|
self.assertEqual(result_sp.transforms[0]["type"], "transform_geometry")
|
|
|
|
def test_transform_node_list_input(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.mesh import SLICENODE_TransformGeometry
|
|
from NodeSlicer.core.slice import SlicePaths
|
|
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0], [0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
sc = SlicingCollection([], "coll")
|
|
sc.objects = [so]
|
|
|
|
path = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float64)
|
|
sp = SlicePaths([path])
|
|
|
|
geom_list = [sc, sp]
|
|
|
|
node = SLICENODE_TransformGeometry()
|
|
node.resolve = lambda f: {
|
|
"Geometry": geom_list,
|
|
"Translation": (10.0, 0.0, 0.0),
|
|
"Rotation": (0.0, 0.0, 0.0),
|
|
"Scale": (1.0, 1.0, 1.0)
|
|
}.get(f)
|
|
|
|
result_list = node.evaluate_output("Geometry")
|
|
self.assertIsInstance(result_list, list)
|
|
self.assertEqual(len(result_list), 2)
|
|
self.assertIsInstance(result_list[0], SlicingCollection)
|
|
self.assertIsInstance(result_list[1], SlicePaths)
|
|
|
|
np.testing.assert_allclose(result_list[0].objects[0].mesh[0, 0], [11.0, 2.0, 3.0])
|
|
np.testing.assert_allclose(result_list[1][0][0], [11.0, 2.0, 3.0])
|
|
|
|
def test_drop_geometry_node(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.mesh import SLICENODE_DropGeometry
|
|
|
|
# Create a SlicingObject with a single triangle having min_z = 3.0
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
sc = SlicingCollection([], "coll")
|
|
sc.objects = [so]
|
|
|
|
# Init node
|
|
node = SLICENODE_DropGeometry()
|
|
|
|
# Test case 1: Drop to Z = 0.0
|
|
node.z = 0.0
|
|
node.inputs = {}
|
|
# Mock resolve to return our inputs
|
|
def mock_resolve_no_socket(fieldname):
|
|
if fieldname == "Mesh":
|
|
return sc
|
|
elif fieldname == "Z":
|
|
return 0.0
|
|
return None
|
|
node.resolve = mock_resolve_no_socket
|
|
|
|
result_sc_1 = node.evaluate_output("Mesh")
|
|
self.assertIsNotNone(result_sc_1)
|
|
self.assertEqual(result_sc_1.min_z, 0.0)
|
|
np.testing.assert_allclose(result_sc_1.objects[0].mesh[0, 0], [1.0, 2.0, 0.0])
|
|
|
|
# Test case 2: Drop to Z = 10.0
|
|
so2 = SlicingObject()
|
|
so2.mesh = np.array([[[1.0, 2.0, 3.0],
|
|
[4.0, 5.0, 6.0],
|
|
[7.0, 8.0, 9.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
sc2 = SlicingCollection([], "coll2")
|
|
sc2.objects = [so2]
|
|
|
|
mock_socket = MagicMock()
|
|
mock_socket.is_linked = False
|
|
mock_socket.value = 10.0
|
|
node.inputs = {"Z": mock_socket}
|
|
node.z = 0.0
|
|
|
|
def mock_resolve_with_socket(fieldname):
|
|
if fieldname == "Mesh":
|
|
return sc2
|
|
elif fieldname == "Z":
|
|
return 10.0
|
|
return None
|
|
node.resolve = mock_resolve_with_socket
|
|
|
|
result_sc_2 = node.evaluate_output("Mesh")
|
|
self.assertIsNotNone(result_sc_2)
|
|
self.assertEqual(result_sc_2.min_z, 10.0)
|
|
np.testing.assert_allclose(result_sc_2.objects[0].mesh[0, 0], [1.0, 2.0, 10.0])
|
|
|
|
def test_gcode_transform_metadata(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.mesh import SLICENODE_TransformGeometry, SLICENODE_DropGeometry
|
|
from NodeSlicer.core.slice import SlicePaths, Pather
|
|
|
|
so = SlicingObject()
|
|
so.mesh = np.array([[[0.0, 0.0, 5.0],
|
|
[10.0, 0.0, 5.0],
|
|
[5.0, 10.0, 10.0],
|
|
[0.0, 0.0, 1.0]]], dtype=np.float64)
|
|
|
|
sc = SlicingCollection([], "coll")
|
|
sc.objects = [so]
|
|
|
|
# 1. Transform Geometry
|
|
t_node = SLICENODE_TransformGeometry()
|
|
t_node.resolve = lambda f: {
|
|
"Mesh": sc,
|
|
"Translation": (10.0, 20.0, 0.0),
|
|
"Rotation": (0.0, 0.0, 0.0),
|
|
"Scale": (1.0, 1.0, 1.0)
|
|
}.get(f)
|
|
|
|
sc_transformed = t_node.evaluate_output("Mesh")
|
|
self.assertIsNotNone(sc_transformed)
|
|
self.assertEqual(len(sc_transformed.transforms), 1)
|
|
self.assertEqual(sc_transformed.transforms[0]["type"], "transform_geometry")
|
|
|
|
# 2. Drop Geometry
|
|
d_node = SLICENODE_DropGeometry()
|
|
d_node.resolve = lambda f: {
|
|
"Mesh": sc_transformed,
|
|
"Z": 0.0
|
|
}.get(f)
|
|
|
|
sc_dropped = d_node.evaluate_output("Mesh")
|
|
self.assertIsNotNone(sc_dropped)
|
|
self.assertEqual(len(sc_dropped.transforms), 2)
|
|
self.assertEqual(sc_dropped.transforms[1]["type"], "drop_geometry")
|
|
|
|
# 3. Create SlicePaths from geometry
|
|
path = np.array([[10.0, 20.0, 0.0], [20.0, 20.0, 0.0], [15.0, 30.0, 0.0]])
|
|
sp = SlicePaths([path], transforms=sc_dropped.transforms)
|
|
|
|
# 4. Generate G-code with Pather
|
|
pather = Pather(sp)
|
|
gcode = pather.to_gcode(include_header=True)
|
|
|
|
self.assertIn(";PREPARATION_TRANSFORMS=", gcode)
|
|
self.assertIn(";TRANSFORM_GEOMETRY_0_TRANSLATION=10.000000,20.000000,0.000000", gcode)
|
|
self.assertIn(";DROP_GEOMETRY_1_OFFSET_Z=-5.000000", gcode)
|
|
self.assertIn(";PREPARATION_TOTAL_TRANSLATION=10.000000,20.000000,-5.000000", gcode)
|
|
|
|
# 5. Process G-code with GcodeToMesh preview node
|
|
from NodeSlicer.core.nodeslicer.nodes.preview import SLICENODE_GcodeToMesh
|
|
preview_node = SLICENODE_GcodeToMesh()
|
|
preview_node.show_e_0 = True
|
|
|
|
mock_mod_dict = {}
|
|
class MockModifier:
|
|
type = 'NODES'
|
|
node_group = MagicMock()
|
|
def __getitem__(self, k): return mock_mod_dict.get(k)
|
|
def __setitem__(self, k, v): mock_mod_dict[k] = v
|
|
def get(self, k, default=None): return mock_mod_dict.get(k, default)
|
|
|
|
mock_obj = MagicMock()
|
|
mock_obj.type = 'MESH'
|
|
mock_obj.modifiers = [MockModifier()]
|
|
|
|
import sys
|
|
sys.modules['bpy'].data.objects = {"PreviewObj": mock_obj}
|
|
sys.modules['bpy'].data.node_groups = {"Nonplanar Slicing Preview": mock_obj.modifiers[0].node_group}
|
|
|
|
preview_node._process_gcode(gcode, "PreviewObj")
|
|
|
|
# Verify modifier sockets Socket_8, Socket_6, Socket_9
|
|
self.assertEqual(mock_mod_dict.get("Socket_8"), (0.01, 0.02, -0.005))
|
|
self.assertEqual(mock_mod_dict.get("Socket_6"), (0.0, 0.0, 0.0))
|
|
|
|
# Test overwriting on an existing mesh object with pre-existing modifier values
|
|
mock_mod_dict["Socket_8"] = [0.0, 0.0, 0.0]
|
|
mock_mod_dict["Socket_6"] = [1.0, 1.0, 1.0]
|
|
mock_mod_dict["Socket_9"] = [2.0, 2.0, 2.0]
|
|
|
|
preview_node._process_gcode(gcode, "PreviewObj")
|
|
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_8")), (0.01, 0.02, -0.005))
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_6")), (0.0, 0.0, 0.0))
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_9")), (1.0, 1.0, 1.0))
|
|
|
|
# Test G-code with non-zero 3D rotation and non-uniform scale
|
|
gcode_rot = (
|
|
";PREPARATION_TOTAL_TRANSLATION=10.000000,20.000000,30.000000\n"
|
|
";PREPARATION_TOTAL_ROTATION=0.150000,0.250000,0.350000\n"
|
|
";PREPARATION_TOTAL_SCALE=1.500000,2.000000,2.500000\n"
|
|
"G1 X10 Y20 Z30 E1\n"
|
|
)
|
|
preview_node._process_gcode(gcode_rot, "PreviewObj")
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_8")), (0.01, 0.02, 0.03))
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_6")), (0.15, 0.25, 0.35))
|
|
self.assertEqual(tuple(mock_mod_dict.get("Socket_9")), (1.5, 2.0, 2.5))
|
|
|
|
def test_gcode_to_mesh_naming_convention(self):
|
|
from NodeSlicer.core.nodeslicer.nodes.preview import SLICENODE_GcodeToMesh
|
|
node = SLICENODE_GcodeToMesh()
|
|
|
|
# 1. Single part - no number suffix
|
|
node.resolve_multi_input = MagicMock(return_value=["GCODE1"])
|
|
node.resolve = MagicMock(return_value="Part")
|
|
node._process_gcode = MagicMock()
|
|
|
|
node.evaluate()
|
|
node._process_gcode.assert_called_once_with("GCODE1", "Part", None)
|
|
|
|
# 2. Three parts - padded to 2 digits (01, 02, 03)
|
|
node.resolve_multi_input = MagicMock(return_value=["GC1", "GC2", "GC3"])
|
|
node.resolve = MagicMock(return_value="Part")
|
|
node._process_gcode = MagicMock()
|
|
|
|
node.evaluate()
|
|
self.assertEqual(node._process_gcode.call_count, 3)
|
|
node._process_gcode.assert_any_call("GC1", "Part01", None)
|
|
node._process_gcode.assert_any_call("GC2", "Part02", None)
|
|
node._process_gcode.assert_any_call("GC3", "Part03", None)
|
|
|
|
# 3. Fifteen parts - padded to 2 digits (01..15)
|
|
node.resolve_multi_input = MagicMock(return_value=[f"GC{i}" for i in range(1, 16)])
|
|
node.resolve = MagicMock(return_value="Part")
|
|
node._process_gcode = MagicMock()
|
|
|
|
node.evaluate()
|
|
self.assertEqual(node._process_gcode.call_count, 15)
|
|
node._process_gcode.assert_any_call("GC1", "Part01", None)
|
|
node._process_gcode.assert_any_call("GC15", "Part15", None)
|
|
|
|
# 4. Default base name when empty name provided
|
|
node.resolve_multi_input = MagicMock(return_value=["GC1", "GC2"])
|
|
node.resolve = MagicMock(return_value="")
|
|
node._process_gcode = MagicMock()
|
|
|
|
node.evaluate()
|
|
node._process_gcode.assert_any_call("GC1", "GcodePreview01", None)
|
|
node._process_gcode.assert_any_call("GC2", "GcodePreview02", None)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|
|
|
|
|