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

meerk40t/gui/zmatrix.py

@@ -1,102 +1,102 @@
-from wx import AffineMatrix2D, Matrix2D, Point2D
-
-
-class ZMatrix(AffineMatrix2D):
-    def __init__(self, matrix=None):
-        AffineMatrix2D.__init__(self)
-        if matrix is not None:
-            self.Set(
-                Matrix2D(
-                    matrix.value_scale_x(),
-                    matrix.value_skew_x(),
-                    matrix.value_skew_y(),
-                    matrix.value_scale_y(),
-                ),
-                Point2D(matrix.value_trans_x(), matrix.value_trans_y()),
-            )
-
-    def __str__(self):
-        m = self.Get()[0]
-        p = self.Get()[1]
-        return (
-            f"["
-            f"{m.m_11:3f}, {m.m_12:3f}, {0:3f},\n "
-            f"{m.m_21:3f}, {m.m_22:3f}, {0:3f},\n "
-            f"{p.x:3f}, {p.y:3f}, {1:3f}"
-            f"]"
-        )
-
-    def Reset(self):
-        AffineMatrix2D.__init__(self)
-
-    def PostScale(self, sx, sy=None, ax=0, ay=0):
-        self.Invert()
-        if sy is None:
-            sy = sx
-        if ax == 0 and ay == 0:
-            self.Scale(1.0 / sx, 1.0 / sy)
-        else:
-            self.Translate(ax, ay)
-            self.Scale(1.0 / sx, 1.0 / sy)
-            self.Translate(-ax, -ay)
-        self.Invert()
-
-    def PostTranslate(self, px, py):
-        self.Invert()
-        self.Translate(-px, -py)
-        self.Invert()
-
-    def PostRotate(self, radians, rx=0, ry=0):
-        self.Invert()
-        if rx == 0 and ry == 0:
-            self.Rotate(-radians)
-        else:
-            self.Translate(rx, ry)
-            self.Rotate(-radians)
-            self.Translate(-rx, -ry)
-        self.Invert()
-
-    def PreScale(self, sx, sy=None, ax=0, ay=0):
-        if sy is None:
-            sy = sx
-        if ax == 0 and ay == 0:
-            self.Scale(sx, sy)
-        else:
-            self.Translate(ax, ay)
-            self.Scale(sx, sy)
-            self.Translate(-ax, -ay)
-
-    def PreTranslate(self, px, py):
-        self.Translate(px, py)
-
-    def PreRotate(self, radians, rx=0, ry=0):
-        if rx == 0 and ry == 0:
-            self.Rotate(radians)
-        else:
-            self.Translate(rx, ry)
-            self.Rotate(radians)
-            self.Translate(-rx, -ry)
-
-    def GetScaleX(self):
-        return self.Get()[0].m_11
-
-    def GetScaleY(self):
-        return self.Get()[0].m_22
-
-    def GetSkewX(self):
-        return self.Get()[0].m_12
-
-    def GetSkewY(self):
-        return self.Get()[0].m_21
-
-    def GetTranslateX(self):
-        return self.Get()[1].x
-
-    def GetTranslateY(self):
-        return self.Get()[1].y
-
-    def InverseTransformPoint(self, position):
-        self.Invert()
-        converted_point = self.TransformPoint(position)
-        self.Invert()
-        return converted_point
+from wx import AffineMatrix2D, Matrix2D, Point2D
+
+
+class ZMatrix(AffineMatrix2D):
+    def __init__(self, matrix=None):
+        AffineMatrix2D.__init__(self)
+        if matrix is not None:
+            self.Set(
+                Matrix2D(
+                    matrix.value_scale_x(),
+                    matrix.value_skew_x(),
+                    matrix.value_skew_y(),
+                    matrix.value_scale_y(),
+                ),
+                Point2D(matrix.value_trans_x(), matrix.value_trans_y()),
+            )
+
+    def __str__(self):
+        m = self.Get()[0]
+        p = self.Get()[1]
+        return (
+            f"["
+            f"{m.m_11:3f}, {m.m_12:3f}, {0:3f},\n "
+            f"{m.m_21:3f}, {m.m_22:3f}, {0:3f},\n "
+            f"{p.x:3f}, {p.y:3f}, {1:3f}"
+            f"]"
+        )
+
+    def Reset(self):
+        AffineMatrix2D.__init__(self)
+
+    def PostScale(self, sx, sy=None, ax=0, ay=0):
+        self.Invert()
+        if sy is None:
+            sy = sx
+        if ax == 0 and ay == 0:
+            self.Scale(1.0 / sx, 1.0 / sy)
+        else:
+            self.Translate(ax, ay)
+            self.Scale(1.0 / sx, 1.0 / sy)
+            self.Translate(-ax, -ay)
+        self.Invert()
+
+    def PostTranslate(self, px, py):
+        self.Invert()
+        self.Translate(-px, -py)
+        self.Invert()
+
+    def PostRotate(self, radians, rx=0, ry=0):
+        self.Invert()
+        if rx == 0 and ry == 0:
+            self.Rotate(-radians)
+        else:
+            self.Translate(rx, ry)
+            self.Rotate(-radians)
+            self.Translate(-rx, -ry)
+        self.Invert()
+
+    def PreScale(self, sx, sy=None, ax=0, ay=0):
+        if sy is None:
+            sy = sx
+        if ax == 0 and ay == 0:
+            self.Scale(sx, sy)
+        else:
+            self.Translate(ax, ay)
+            self.Scale(sx, sy)
+            self.Translate(-ax, -ay)
+
+    def PreTranslate(self, px, py):
+        self.Translate(px, py)
+
+    def PreRotate(self, radians, rx=0, ry=0):
+        if rx == 0 and ry == 0:
+            self.Rotate(radians)
+        else:
+            self.Translate(rx, ry)
+            self.Rotate(radians)
+            self.Translate(-rx, -ry)
+
+    def GetScaleX(self):
+        return self.Get()[0].m_11
+
+    def GetScaleY(self):
+        return self.Get()[0].m_22
+
+    def GetSkewX(self):
+        return self.Get()[0].m_12
+
+    def GetSkewY(self):
+        return self.Get()[0].m_21
+
+    def GetTranslateX(self):
+        return self.Get()[1].x
+
+    def GetTranslateY(self):
+        return self.Get()[1].y
+
+    def InverseTransformPoint(self, position):
+        self.Invert()
+        converted_point = self.TransformPoint(position)
+        self.Invert()
+        return converted_point

meerk40t/image/__init__.py

@@ -1 +1 @@
-name = "image"
+name = "image"

meerk40t/image/dither.py

@@ -0,0 +1,429 @@
+"""
+This function and the associated _DIFFUSION_MAPS taken from hitherdither. MIT License.
+:copyright: 2016-2017 by hbldh <henrik.blidh@nedomkull.com>
+https://github.com/hbldh/hitherdither
+
+Suggestion to use Numba via Sophist https://github.com/meerk40t/meerk40t/issues/2332
+referencing: https://www.youtube.com/watch?v=Ld_cz1JwRHk
+"""
+
+import numpy as np
+from PIL import Image
+
+try:
+    from numba import njit
+except Exception as e:
+    # Jit does not exist, add a dummy decorator and continue.
+    # print (f"Encountered error: {e}")
+    def njit(*args, **kwargs):
+        def inner(func):
+            return func
+
+        return inner
+
+"""
+_DIFFUSION_MAPS = {
+    "legacy-floyd-steinberg": (
+        (1, 0, 7 / 16),
+        (-1, 1, 3 / 16),
+        (0, 1, 5 / 16),
+        (1, 1, 1 / 16),
+    ),
+    "shiau-fan": (
+        (1, 0, .5),
+        (-2, 1, 1/8),
+        (-1, 1, 1/8),
+        (0, 1, 2/8),
+    ),
+    "shiau-fan-2": (
+        (1, 0, 0.5),
+        (-3, 1, 1/16),
+        (-2, 1, 1/16),
+        (1, 1, 2/16),
+        (0, 1, 4/16),
+    ),
+    "atkinson": (
+        (1, 0, 1 / 8),
+        (2, 0, 1 / 8),
+        (-1, 1, 1 / 8),
+        (0, 1, 1 / 8),
+        (1, 1, 1 / 8),
+        (0, 2, 1 / 8),
+    ),
+    "jarvis-judice-ninke": (
+        (1, 0, 7 / 48),
+        (2, 0, 5 / 48),
+        (-2, 1, 3 / 48),
+        (-1, 1, 5 / 48),
+        (0, 1, 7 / 48),
+        (1, 1, 5 / 48),
+        (2, 1, 3 / 48),
+        (-2, 2, 1 / 48),
+        (-1, 2, 3 / 48),
+        (0, 2, 5 / 48),
+        (1, 2, 3 / 48),
+        (2, 2, 1 / 48),
+    ),
+    "stucki": (
+        (1, 0, 8 / 42),
+        (2, 0, 4 / 42),
+        (-2, 1, 2 / 42),
+        (-1, 1, 4 / 42),
+        (0, 1, 8 / 42),
+        (1, 1, 4 / 42),
+        (2, 1, 2 / 42),
+        (-2, 2, 1 / 42),
+        (-1, 2, 2 / 42),
+        (0, 2, 4 / 42),
+        (1, 2, 2 / 42),
+        (2, 2, 1 / 42),
+    ),
+    "burkes": (
+        (1, 0, 8 / 32),
+        (2, 0, 4 / 32),
+        (-2, 1, 2 / 32),
+        (-1, 1, 4 / 32),
+        (0, 1, 8 / 32),
+        (1, 1, 4 / 32),
+        (2, 1, 2 / 32),
+    ),
+    "sierra3": (
+        (1, 0, 5 / 32),
+        (2, 0, 3 / 32),
+        (-2, 1, 2 / 32),
+        (-1, 1, 4 / 32),
+        (0, 1, 5 / 32),
+        (1, 1, 4 / 32),
+        (2, 1, 2 / 32),
+        (-1, 2, 2 / 32),
+        (0, 2, 3 / 32),
+        (1, 2, 2 / 32),
+    ),
+    "sierra2": (
+        (1, 0, 4 / 16),
+        (2, 0, 3 / 16),
+        (-2, 1, 1 / 16),
+        (-1, 1, 2 / 16),
+        (0, 1, 3 / 16),
+        (1, 1, 2 / 16),
+        (2, 1, 1 / 16),
+    ),
+    "sierra-2-4a": (
+        (1, 0, 2 / 4),
+        (-1, 1, 1 / 4),
+        (0, 1, 1 / 4),
+    ),
+}
+"""
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def floyd_steinberg(image):
+    diff_map = (
+        (1, 0, 7 / 16),
+        (-1, 1, 3 / 16),
+        (0, 1, 5 / 16),
+        (1, 1, 1 / 16),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def atkinson(image):
+    diff_map = (
+        (1, 0, 1 / 8),
+        (2, 0, 1 / 8),
+        (-1, 1, 1 / 8),
+        (0, 1, 1 / 8),
+        (1, 1, 1 / 8),
+        (0, 2, 1 / 8),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def jarvis_judice_ninke(image):
+    diff_map = (
+        (1, 0, 7 / 48),
+        (2, 0, 5 / 48),
+        (-2, 1, 3 / 48),
+        (-1, 1, 5 / 48),
+        (0, 1, 7 / 48),
+        (1, 1, 5 / 48),
+        (2, 1, 3 / 48),
+        (-2, 2, 1 / 48),
+        (-1, 2, 3 / 48),
+        (0, 2, 5 / 48),
+        (1, 2, 3 / 48),
+        (2, 2, 1 / 48),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def stucki(image):
+    diff_map = (
+        (1, 0, 8 / 42),
+        (2, 0, 4 / 42),
+        (-2, 1, 2 / 42),
+        (-1, 1, 4 / 42),
+        (0, 1, 8 / 42),
+        (1, 1, 4 / 42),
+        (2, 1, 2 / 42),
+        (-2, 2, 1 / 42),
+        (-1, 2, 2 / 42),
+        (0, 2, 4 / 42),
+        (1, 2, 2 / 42),
+        (2, 2, 1 / 42),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def burkes(image):
+    diff_map = (
+        (1, 0, 8 / 32),
+        (2, 0, 4 / 32),
+        (-2, 1, 2 / 32),
+        (-1, 1, 4 / 32),
+        (0, 1, 8 / 32),
+        (1, 1, 4 / 32),
+        (2, 1, 2 / 32),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def sierra3(image):
+    diff_map = (
+        (1, 0, 5 / 32),
+        (2, 0, 3 / 32),
+        (-2, 1, 2 / 32),
+        (-1, 1, 4 / 32),
+        (0, 1, 5 / 32),
+        (1, 1, 4 / 32),
+        (2, 1, 2 / 32),
+        (-1, 2, 2 / 32),
+        (0, 2, 3 / 32),
+        (1, 2, 2 / 32),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def sierra2(image):
+    diff_map = (
+        (1, 0, 4 / 16),
+        (2, 0, 3 / 16),
+        (-2, 1, 1 / 16),
+        (-1, 1, 2 / 16),
+        (0, 1, 3 / 16),
+        (1, 1, 2 / 16),
+        (2, 1, 1 / 16),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def sierra_2_4a(image):
+    diff_map = (
+        (1, 0, 2 / 4),
+        (-1, 1, 1 / 4),
+        (0, 1, 1 / 4),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def shiau_fan(image):
+    diff_map = (
+        (1, 0, .5),
+        (-2, 1, 1/8),
+        (-1, 1, 1/8),
+        (0, 1, 2/8),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+@njit("f4[:,:](f4[:,:])", nogil=True)
+def shiau_fan_2(image):
+    diff_map = (
+        (1, 0, 0.5),
+        (-3, 1, 1/16),
+        (-2, 1, 1/16),
+        (1, 1, 2/16),
+        (0, 1, 4/16),
+    )
+    width, height = image.shape
+    for y in range(height):
+        for x in range(width):
+            pixel = image[x, y]
+            image[x, y] = 0 if pixel <= 127 else 255
+            error = pixel - image[x, y]
+            for dx, dy, diffusion_coefficient in diff_map:
+                xn, yn = x + dx, y + dy
+                if (0 <= xn < width) and (0 <= yn < height):
+                    image[xn, yn] += error * diffusion_coefficient
+    return image
+
+def bayer_dither(image):
+    """
+    4x4 variant
+    bayer_matrix = np.array([
+            [0, 128, 32, 160],
+            [192, 64, 224, 96],
+            [48, 176, 16, 144],
+            [240, 112, 208, 80]
+        ], dtype=np.uint8)
+    """
+    bayer_matrix = np.array([
+        [0, 48, 12, 60, 3, 51, 15, 63],
+        [32, 16, 44, 28, 35, 19, 47, 31],
+        [8, 56, 4, 52, 11, 59, 7, 55],
+        [40, 24, 36, 20, 43, 27, 39, 23],
+        [2, 50, 14, 62, 1, 49, 13, 61],
+        [34, 18, 46, 30, 33, 17, 45, 29],
+        [10, 58, 6, 54, 9, 57, 5, 53],
+        [42, 26, 38, 22, 41, 25, 37, 21]
+        ], dtype=np.uint8)
+    height, width = image.shape
+    matrix_size = bayer_matrix.shape[0]
+
+    # Repeat the Bayer matrix to match the image size
+    tiled_bayer_matrix = np.tile(bayer_matrix, (height // matrix_size + 1, width // matrix_size + 1))
+    tiled_bayer_matrix = tiled_bayer_matrix[:height, :width]
+
+    # Apply Bayer matrix dithering
+    return np.where(image > tiled_bayer_matrix, 255, 0)
+
+def bayer_blue_dither(image):
+    """
+    http://cv.ulichney.com/papers/1993-void-cluster.pdf
+    """
+    blue_noise = np.random.randint(0, 256, (10, 10), dtype=np.uint8)
+    dithered_image = bayer_dither(image)
+    height, width = image.shape
+
+    # Repeat the blue noise to match the image size
+    tiled_blue_noise = np.tile(blue_noise, (height // blue_noise.shape[0] + 1, width // blue_noise.shape[1] + 1))
+    tiled_blue_noise = tiled_blue_noise[:height, :width]
+
+    # Add blue noise to the image
+    noisy_image = dithered_image + tiled_blue_noise * np.random.uniform(-1.0, 1.0, image.shape)
+    noisy_image = np.clip(noisy_image, 0, 255).astype(np.uint8)
+    return noisy_image
+
+
+function_map = {
+    "atkinson": atkinson,
+    "legacy-floyd-steinberg": floyd_steinberg,
+    "jarvis-judice-ninke": jarvis_judice_ninke,
+    "stucki": stucki,
+    "burkes": burkes,
+    "sierra3": sierra3,
+    "sierra2": sierra2,
+    "sierra-2-4a": sierra_2_4a,
+    "shiau-fan": shiau_fan,
+    "shiau-fan-2": shiau_fan_2,
+    "bayer": bayer_dither,
+    "bayer-blue": bayer_blue_dither,
+}
+
+def dither(image, method="Legacy-Floyd-Steinberg"):
+    method = method.lower()
+    dither_function = function_map.get(method)
+    if not dither_function:
+        raise NotImplementedError
+
+    diff = image.convert("F")
+    data = np.array(diff).astype(np.float32)
+    dither_function(data)
+    diff = Image.fromarray(data)
+    return diff