meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7020__py2.py3-none-any.whl

test/test_core_plotplanner.py

@@ -1,397 +0,0 @@
-import random
-import unittest
-
-from PIL import Image, ImageDraw
-
-from meerk40t.core.cutcode.cutcode import CutCode
-from meerk40t.core.cutcode.linecut import LineCut
-from meerk40t.core.node.elem_image import ImageNode
-from meerk40t.core.node.elem_path import PathNode
-from meerk40t.core.node.op_engrave import EngraveOpNode
-from meerk40t.core.node.op_raster import RasterOpNode
-from meerk40t.core.plotplanner import PlotPlanner
-from meerk40t.device.basedevice import PLOT_AXIS, PLOT_SETTING
-from meerk40t.svgelements import Circle, Matrix, Path, Point
-
-
-class TestPlotplanner(unittest.TestCase):
-    # def test_plotplanner_constant_move_x(self):
-    #     """
-    #     With raster_smooth set to 1 we should smooth the x axis so that no y=0 occurs.
-    #     @return:
-    #     """
-    #     settings = {"power": 1000, "_constant_move_x": True}
-    #     plan = PlotPlanner(settings, ppi=False)
-    #     plan.push(LineCut(Point(0, 0), Point(20, 2), settings=settings))
-    #     plan.push(LineCut(Point(20, 2), Point(20, 5), settings=settings))
-    #     plan.push(LineCut(Point(20, 5), Point(100, 10), settings=settings))
-    #     last_x = None
-    #     last_y = None
-    #     for x, y, on in plan.gen():
-    #         if on == 4:
-    #             last_x = x
-    #             last_y = y
-    #         if on > 1:
-    #             continue
-    #         cx = x
-    #         cy = y
-    #         if cx is None:
-    #             continue
-    #         if last_x is not None:
-    #             total_dx = cx - last_x
-    #             total_dy = cy - last_y
-    #             dx = 1 if total_dx > 0 else 0 if total_dx == 0 else -1
-    #             dy = 1 if total_dy > 0 else 0 if total_dy == 0 else -1
-    #             self.assertFalse(dx == 0)
-    #             for i in range(1, max(abs(total_dx), abs(total_dy)) + 1):
-    #                 nx = last_x + (i * dx)
-    #                 ny = last_y + (i * dy)
-    #                 # print(nx, ny, on)
-    #         # print(x, y, on)
-    #         last_x = cx
-    #         last_y = cy
-    #         print(f"Moving to {x} {y}")
-
-    # def test_plotplanner_constant_move_x_ppi(self):
-    #     """
-    #     With raster_smooth set to 1 we should smooth the x axis so that no y=0 occurs.
-    #     @return:
-    #     """
-    #     settings = {"power": 500, "_constant_move_x": True}
-    #     plan = PlotPlanner(settings)
-    #     plan.push(LineCut(Point(0, 0), Point(20, 2), settings=settings))
-    #     plan.push(LineCut(Point(20, 2), Point(20, 5), settings=settings))
-    #     plan.push(LineCut(Point(20, 5), Point(100, 10), settings=settings))
-    #     last_x = None
-    #     last_y = None
-    #     last_on = None
-    #     for x, y, on in plan.gen():
-    #         if on == 4:
-    #             last_x = x
-    #             last_y = y
-    #         if on > 1:
-    #             continue
-    #         if last_on is not None:
-    #             self.assertNotEqual(last_on, on)
-    #         last_on = on
-    #         cx = x
-    #         cy = y
-    #         if cx is None:
-    #             continue
-    #         if last_x is not None:
-    #             total_dx = cx - last_x
-    #             total_dy = cy - last_y
-    #             dx = 1 if total_dx > 0 else 0 if total_dx == 0 else -1
-    #             dy = 1 if total_dy > 0 else 0 if total_dy == 0 else -1
-    #             self.assertFalse(dx == 0)
-    #             for i in range(1, max(abs(total_dx), abs(total_dy)) + 1):
-    #                 nx = last_x + (i * dx)
-    #                 ny = last_y + (i * dy)
-    #                 # print(nx, ny, on)
-    #         # print(x, y, on)
-    #         last_x = cx
-    #         last_y = cy
-    #         # print(f"Moving to {x} {y}")
-
-    # def test_plotplanner_constant_move_y(self):
-    #     """
-    #     With smooth_raster set to 2 we should never have x = 0. The x should *always* be in motion.
-    #     @return:
-    #     """
-    #     settings = {"power": 1000, "_constant_move_y": True}
-    #     plan = PlotPlanner(settings)
-    #     plan.push(LineCut(Point(0, 0), Point(2, 20), settings=settings))
-    #     plan.push(LineCut(Point(2, 20), Point(5, 20), settings=settings))
-    #     plan.push(LineCut(Point(5, 20), Point(10, 100), settings=settings))
-    #     last_x = None
-    #     last_y = None
-    #     for x, y, on in plan.gen():
-    #         if on == 4:
-    #             last_x = x
-    #             last_y = y
-    #         if on > 1:
-    #             continue
-    #         cx = x
-    #         cy = y
-    #         if cx is None:
-    #             continue
-    #         if last_x is not None:
-    #             total_dx = cx - last_x
-    #             total_dy = cy - last_y
-    #             dx = 1 if total_dx > 0 else 0 if total_dx == 0 else -1
-    #             dy = 1 if total_dy > 0 else 0 if total_dy == 0 else -1
-    #             self.assertFalse(dy == 0)
-    #             for i in range(0, max(abs(total_dx), abs(total_dy))):
-    #                 nx = last_x + (i * dx)
-    #                 ny = last_y + (i * dy)
-    #                 # print(nx, ny, on)
-    #
-    #         last_x = cx
-    #         last_y = cy
-    #         print(f"Moving to {x} {y}")
-
-    def test_plotplanner_constant_move_xy(self):
-        """
-        With raster_smooth set to 1 we should smooth the x axis so that no y=0 occurs.
-        @return:
-        """
-        settings = {"power": 1000, "_constant_move_x": True, "_constant_move_y": True}
-        plan = PlotPlanner(settings)
-        self.constant_move_x = True
-        self.constant_move_y = True
-        for i in range(100):
-            plan.push(
-                LineCut(
-                    Point(random.randint(0, 1000), random.randint(0, 1000)),
-                    Point(random.randint(0, 1000), random.randint(0, 1000)),
-                    settings=settings,
-                )
-            )
-        last_x = None
-        last_y = None
-        for x, y, on in plan.gen():
-            if on == 4:
-                last_x = x
-                last_y = y
-            if on > 1:
-                continue
-            cx = x
-            cy = y
-            if cx is None:
-                continue
-            if last_x is not None:
-                total_dx = cx - last_x
-                total_dy = cy - last_y
-                dx = 1 if total_dx > 0 else 0 if total_dx == 0 else -1
-                dy = 1 if total_dy > 0 else 0 if total_dy == 0 else -1
-                for i in range(1, max(abs(total_dx), abs(total_dy)) + 1):
-                    nx = last_x + (i * dx)
-                    ny = last_y + (i * dy)
-                    # print(nx, ny, on)
-            # print(x, y, on)
-            last_x = cx
-            last_y = cy
-            # print(f"Moving to {x} {y}")
-
-    def test_plotplanner_constant_xy_end(self):
-        """
-        With raster_smooth set to 1 we should smooth the x axis so that no y=0 occurs.
-        @return:
-        """
-        for q in range(100):
-            settings = {
-                "power": 1000,
-                "constant_move_x": bool(random.randint(0, 1)),
-                "constant_move_y": bool(random.randint(0, 1)),
-            }
-            plan = PlotPlanner(settings)
-            goal_x = None
-            goal_y = None
-            for i in range(10):
-                goal_x = random.randint(0, 100)
-                goal_y = random.randint(0, 100)
-                start_x = random.randint(0, 100)
-                start_y = random.randint(0, 100)
-                while start_x == goal_x and start_y == goal_y:
-                    # If exactly equal go ahead and randomize again.
-                    start_x = random.randint(0, 100)
-                    start_y = random.randint(0, 100)
-                plan.push(
-                    LineCut(
-                        Point(start_x, start_y),
-                        Point(goal_x, goal_y),
-                        settings=settings,
-                    )
-                )
-            break_list = list(plan.queue)
-            last_x = None
-            last_y = None
-            for x, y, on in plan.gen():
-                if on == 4:
-                    last_x = x
-                    last_y = y
-                if on > 1:
-                    continue
-                last_x = x
-                last_y = y
-
-            if last_x != goal_x:
-                print(settings.get("constant_move_x"))
-                print(settings.get("constant_move_y"))
-                for seg in break_list:
-                    print(repr(seg))
-            self.assertEqual(last_x, goal_x)
-            if last_y != goal_y:
-                print(settings.get("constant_move_x"))
-                print(settings.get("constant_move_y"))
-                for seg in break_list:
-                    print(repr(seg))
-            self.assertEqual(last_y, goal_y)
-
-    def test_plotplanner_static_issue(self):
-        settings = {
-            "power": 1000,
-            "constant_move_x": True,
-            "constant_move_y": False,
-        }
-        plan = PlotPlanner(settings)
-        plan.debug = True
-        lines = (
-            ((41, 45), (14, 43)),
-            ((32, 67), (32, 61)),
-        )
-        for line in lines:
-            plan.push(
-                LineCut(
-                    Point(line[0][0], line[0][1]),
-                    Point(line[1][0], line[1][1]),
-                    settings=settings,
-                )
-            )
-        goal_x = lines[-1][-1][0]
-        goal_y = lines[-1][-1][1]
-        break_list = list(plan.queue)
-        last_x = None
-        last_y = None
-        for x, y, on in plan.gen():
-            if on == 4:
-                last_x = x
-                last_y = y
-            if on > 1:
-                continue
-            last_x = x
-            last_y = y
-
-        if last_x != goal_x:
-            for seg in break_list:
-                print(repr(seg))
-        self.assertEqual(last_x, goal_x)
-        if last_y != goal_y:
-            for seg in break_list:
-                print(repr(seg))
-        self.assertEqual(last_y, goal_y)
-
-    def test_plotplanner_constant_move_xy_rect(self):
-        """
-        With raster_smooth set to 1 we should smooth the x axis so that no y=0 occurs.
-        @return:
-        """
-        settings = {"power": 1000, "constant_move_x": True, "constant_move_y": True}
-        plan = PlotPlanner(settings)
-        plan.push(LineCut(Point(0, 0), Point(0, 100), settings=settings))
-        plan.push(LineCut(Point(0, 100), Point(100, 100), settings=settings))
-        plan.push(LineCut(Point(100, 100), Point(100, 0), settings=settings))
-        plan.push(LineCut(Point(100, 0), Point(0, 0), settings=settings))
-        last_x = None
-        last_y = None
-        for x, y, on in plan.gen():
-            if on == 4:
-                last_x = x
-                last_y = y
-            if on > 1:
-                continue
-            cx = x
-            cy = y
-            if cx is None:
-                continue
-            if last_x is not None:
-                total_dx = cx - last_x
-                total_dy = cy - last_y
-                dx = 1 if total_dx > 0 else 0 if total_dx == 0 else -1
-                dy = 1 if total_dy > 0 else 0 if total_dy == 0 else -1
-                for i in range(1, max(abs(total_dx), abs(total_dy)) + 1):
-                    nx = last_x + (i * dx)
-                    ny = last_y + (i * dy)
-                    # print(nx, ny, on)
-            # print(x, y, on)
-            last_x = cx
-            last_y = cy
-            # print(f"Moving to {x} {y}")
-
-    def test_plotplanner_flush(self):
-        """
-        Intro test for plotplanner.
-
-        This is needlessly complex.
-
-        final value is "on", and provides commands.
-        128 means settings were changed.
-        64 indicates x_axis major
-        32 indicates x_dir, y_dir
-        256 indicates ended.
-        1 means cut.
-        0 means move.
-
-        :return:
-        """
-        settings = {"power": 1000}
-        plan = PlotPlanner(settings)
-
-        for i in range(211):
-            plan.push(LineCut(Point(0, 0), Point(5, 100), settings=settings))
-            plan.push(LineCut(Point(100, 50), Point(0, 0), settings=settings))
-            plan.push(LineCut(Point(50, -50), Point(100, -100), settings={"power": 0}))
-            q = 0
-            for x, y, on in plan.gen():
-                # print(x, y, on)
-                if q == i:
-                    # for x, y, on in plan.process_plots(None):
-                    # print("FLUSH!", x, y, on)
-                    plan.clear()
-                    break
-                q += 1
-
-    def test_plotplanner_walk_raster(self):
-        """
-        Test plotplanner operation of walking to a raster.
-
-        PLOT_FINISH = 256
-        PLOT_RAPID = 4
-        PLOT_JOG = 2
-        PLOT_SETTING = 128
-        PLOT_AXIS = 64
-        PLOT_DIRECTION = 32
-        PLOT_LEFT_UPPER = 512
-        PLOT_RIGHT_LOWER = 1024
-
-        1 means cut.
-        0 means move.
-
-        :return:
-        """
-
-        rasterop = RasterOpNode()
-        image = Image.new("RGBA", (256, 256))
-        draw = ImageDraw.Draw(image)
-        draw.ellipse((0, 0, 255, 255), "black")
-        image = image.convert("L")
-        inode = ImageNode(image=image, dpi=1000.0, matrix=Matrix())
-        inode.step_x = 1
-        inode.step_y = 1
-        inode.process_image()
-        rasterop.add_node(inode)
-        rasterop.raster_step_x = 1
-        rasterop.raster_step_y = 1
-
-        vectorop = EngraveOpNode()
-        vectorop.add_node(
-            PathNode(path=Path(Circle(cx=127, cy=127, r=128)), fill="black")
-        )
-        cutcode = CutCode()
-        cutcode.extend(vectorop.as_cutobjects())
-        cutcode.extend(rasterop.as_cutobjects())
-        settings = {"power": 500}
-        plan = PlotPlanner(settings)
-        for c in cutcode.flat():
-            plan.push(c)
-
-        setting_changed = False
-        for x, y, on in plan.gen():
-            if on > 2:
-                if setting_changed:
-                    # Settings change happens at vector to raster switch and must repost the axis.
-                    self.assertEqual(on, PLOT_AXIS)
-                if on == PLOT_SETTING:
-                    setting_changed = True
-                else:
-                    setting_changed = False

test/test_core_viewports.py

@@ -1,312 +0,0 @@
-import random
-import unittest
-
-from meerk40t.core.units import UNITS_PER_INCH, UNITS_PER_MIL, Length
-from meerk40t.core.view import View
-
-
-class TestViewport(unittest.TestCase):
-    def test_viewport_arbitrary(self):
-        """
-        Test arbitrary viewport.
-
-        :return:
-        """
-        bed_width = Length(amount=random.randint(0, 65535 * 1000)).length_mm
-        bed_height = Length(amount=random.randint(0, 65535 * 1000)).length_mm
-        for i in range(100):
-            view = View(
-                bed_width,
-                bed_height,
-                dpi_x=UNITS_PER_MIL,
-                dpi_y=UNITS_PER_MIL,
-            )
-            view.transform(
-                user_scale_x=1.0,
-                user_scale_y=1.0,
-                flip_x=bool(random.randint(0, 1)),
-                flip_y=bool(random.randint(0, 1)),
-                swap_xy=bool(random.randint(0, 1)),
-            )
-
-            x, y = view.position(0, 0)
-            x, y = view.iposition(x, y)
-            self.assertAlmostEqual(x, 0, delta=10)
-            self.assertAlmostEqual(y, 0, delta=10)
-
-    def test_viewport_lihuiyu_user_scale(self):
-        """
-        Test Lihuiyu-esque viewport. User-scaled to mm
-
-        :return:
-        """
-        bed_width = "330mm"
-        bed_height = "225mm"
-
-        view = View(
-            bed_width,
-            bed_height,
-            dpi_x=1000,
-            dpi_y=1000,
-        )
-        view.transform(
-            user_scale_x=1.2,
-            user_scale_y=1.0,
-        )
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.iposition(0, Length(bed_height).mil)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, float(Length(bed_height)), delta=10)
-
-        x, y = view.iposition(Length(bed_width).mil, Length(bed_height).mil)
-        self.assertAlmostEqual(x, float(Length(bed_width)) / 1.2, delta=10)
-        self.assertAlmostEqual(y, float(Length(bed_height)), delta=10)
-
-    def test_viewport_lihuiyu_swap_xy(self):
-        """
-        Test Lihuiyu-esque viewport. User-scaled to mm
-
-        :return:
-        """
-        bed_width = "330mm"
-        bed_height = "225mm"
-
-        view = View(bed_width, bed_height, dpi_x=1000, dpi_y=1000)
-        view.transform(
-            user_scale_x=1.2,
-            user_scale_y=1.0,
-            swap_xy=True,
-        )
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=2)
-        self.assertAlmostEqual(y, 0, delta=2)
-
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.position(0, Length(bed_height))
-        self.assertAlmostEqual(x, float(Length(bed_height).mil), delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.position(Length(bed_width), Length(bed_height))
-        self.assertAlmostEqual(x, float(Length(bed_height).mil), delta=10)
-        self.assertAlmostEqual(y, float(Length(bed_width).mil) * 1.2, delta=10)
-
-    def test_viewport_grbl(self):
-        """
-        Test GRBL-esque viewport.
-
-        :return:
-        """
-        bed_size = "225mm"
-
-        view = View(
-            bed_size,
-            bed_size,
-            native_scale_x=UNITS_PER_MIL,
-            native_scale_y=UNITS_PER_MIL,
-        )
-        view.flip_y()
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, Length(bed_size).mil, delta=10)
-
-        x, y = view.position(0, float(Length(bed_size)))
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.iposition(0, Length(bed_size).mil)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-    def test_viewport_grbl_user_scale(self):
-        """
-        Test GRBL-esque viewport. User-scaled to mm
-
-        :return:
-        """
-        bed_size = "225mm"
-
-        view = View(
-            bed_size,
-            bed_size,
-            dpi_x=1000,
-            dpi_y=1000,
-        )
-        view.transform(
-            user_scale_x=Length("1mil").mm,
-            user_scale_y=Length("1mil").mm,
-            flip_y=True,
-        )
-        x, y = view.position(0, 0)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, Length(bed_size).mm, delta=1)
-
-        x, y = view.position(0, float(Length(bed_size)))
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-        x, y = view.iposition(0, Length(bed_size).mm)
-        self.assertAlmostEqual(x, 0, delta=10)
-        self.assertAlmostEqual(y, 0, delta=10)
-
-    def test_viewport_balor_device_to_scene(self):
-        """
-        Test Balor-esque viewport.
-        Center x, y. normal_x/flip_x, normal_y/flip_y, swap and non-linear
-        :return:
-        """
-        lens_size_x = "110mm"
-        lens_size_y = "100mm"  # 10mm less
-        unit_size_x = float(Length(lens_size_x))
-        unit_size_y = float(Length(lens_size_y))
-        galvo_range = 0xFFFF
-        units_per_galvo_x = unit_size_x / galvo_range
-        units_per_galvo_y = unit_size_y / galvo_range
-        for flip_x in (False, True):
-            for flip_y in (False, True):
-                for swap_xy in (False, True):
-                    view = View(
-                        lens_size_x,
-                        lens_size_y,
-                        native_scale_x=units_per_galvo_x,
-                        native_scale_y=units_per_galvo_y,
-                    )
-                    view.transform(
-                        flip_x=flip_x,
-                        flip_y=flip_y,
-                        swap_xy=swap_xy,
-                    )
-                    sx, sy = view.iposition(0x7FFF, 0x7FFF)
-                    self.assertAlmostEqual(sx, unit_size_x / 2, delta=10)
-                    self.assertAlmostEqual(sy, unit_size_y / 2, delta=10)
-                    vx, vy = view.position("50%", "50%")
-                    self.assertAlmostEqual(vx, 0x7FFF, delta=10)
-                    self.assertAlmostEqual(vy, 0x7FFF, delta=10)
-
-    # def test_viewport_balor_device_to_show(self):
-    #     """
-    #     Test Balor-esque viewport.
-    #     Center x, y. normal_x/flip_x, normal_y/flip_y, swap and non-linear
-    #
-    #     Device to show position.
-    #
-    #     :return:
-    #     """
-    #     lens_size_x = "110mm"
-    #     lens_size_y = "100mm"  # 10mm less
-    #     unit_size_x = float(Length(lens_size_x))
-    #     unit_size_y = float(Length(lens_size_y))
-    #     galvo_range = 0xFFFF
-    #     units_per_galvo_x = unit_size_x / galvo_range
-    #     units_per_galvo_y = unit_size_y / galvo_range
-    #
-    #     for flip_x in (False, True):
-    #         for flip_y in (False, True):
-    #             for swap_xy in (False, True):
-    #                 for show_flip_x in (False, True):
-    #                     for show_flip_y in (False, True):
-    #                         view = ViewPort(
-    #                             lens_size_x,
-    #                             lens_size_y,
-    #                             native_scale_x=units_per_galvo_x,
-    #                             native_scale_y=units_per_galvo_y,
-    #                             origin_x=1.0 if flip_x else 0.0,
-    #                             origin_y=1.0 if flip_y else 0.0,
-    #                             flip_x=flip_x,
-    #                             flip_y=flip_y,
-    #                             swap_xy=swap_xy,
-    #                             show_origin_x=0.5,
-    #                             show_origin_y=0.5,
-    #                             show_flip_x=show_flip_x,
-    #                             show_flip_y=show_flip_y,
-    #                         )
-    #                         x, y = view.device_to_show_position(0x7FFF, 0x7FFF)
-    #                         self.assertAlmostEqual(x, 0, delta=10)
-    #                         self.assertAlmostEqual(y, 0, delta=10)
-    #                         x, y = view.show_to_device_position(0, 0)
-    #                         self.assertAlmostEqual(x, 0x7FFF, delta=10)
-    #                         self.assertAlmostEqual(y, 0x7FFF, delta=10)
-
-    # def test_viewport_balor_physical_to_show(self):
-    #     """
-    #     Test Balor-esque viewport.
-    #     Center x, y. flip_x, flip_y, swap and offset
-    #
-    #     :return:
-    #     """
-    #     lens_size_x = "110mm"
-    #     lens_size_y = "100mm"  # 10mm less
-    #     unit_size_x = float(Length(lens_size_x))
-    #     unit_size_y = float(Length(lens_size_y))
-    #     galvo_range = 0xFFFF
-    #     units_per_galvo_x = unit_size_x / galvo_range
-    #     units_per_galvo_y = unit_size_y / galvo_range
-    #
-    #     for flip_x in (False, True):
-    #         for flip_y in (False, True):
-    #             for swap_xy in (False, True):
-    #                 view = ViewPort(
-    #                     lens_size_x,
-    #                     lens_size_y,
-    #                     native_scale_x=units_per_galvo_x,
-    #                     native_scale_y=units_per_galvo_y,
-    #                     origin_x=1.0 if flip_x else 0.0,
-    #                     origin_y=1.0 if flip_y else 0.0,
-    #                     show_origin_x=0.5,
-    #                     show_origin_y=0.5,
-    #                     flip_x=flip_x,
-    #                     flip_y=flip_y,
-    #                     swap_xy=swap_xy,
-    #                 )
-    #                 hx, hy = view.physical_to_show_position("55mm", "50mm")
-    #                 self.assertAlmostEqual(hx, 0)
-    #                 self.assertAlmostEqual(hy, 0)
-
-    def test_viewport_balor_physical_to_scene(self):
-        """
-        Test Balor-esque viewport.
-        Center x, y. flip_x, flip_y, swap and offset
-
-        :return:
-        """
-        lens_size_x = "110mm"
-        lens_size_y = "100mm"  # 10mm less
-        unit_size_x = float(Length(lens_size_x))
-        unit_size_y = float(Length(lens_size_y))
-        galvo_range = 0xFFFF
-        units_per_galvo_x = unit_size_x / galvo_range
-        units_per_galvo_y = unit_size_y / galvo_range
-
-        for flip_x in (False, True):
-            for flip_y in (False, True):
-                for swap_xy in (False, True):
-                    view = View(
-                        lens_size_x,
-                        lens_size_y,
-                        native_scale_x=units_per_galvo_x,
-                        native_scale_y=units_per_galvo_y,
-                    )
-                    view.transform(
-                        flip_x=flip_x,
-                        flip_y=flip_y,
-                        swap_xy=swap_xy,
-                    )
-                    sx, sy = view.scene_position("50%", "50%")
-
-                    dim0 = view.unit_width / 2
-                    dim1 = view.unit_height / 2
-                    self.assertAlmostEqual(sx, dim0)
-                    self.assertAlmostEqual(sy, dim1)
-
-                    cx, cy = view.iposition(0x7FFF, 0x7FFF)
-                    self.assertAlmostEqual(sx, cx, delta=10)
-                    self.assertAlmostEqual(sy, cy, delta=10)