Merge pull request #25 from maresb/clean-up-barcode

Clean up barcodes

Author: tomers

src/labelle/lib/barcode_to_image.py

@@ -0,0 +1,114 @@
+# === LICENSE STATEMENT ===
+# Copyright (c) 2011 Sebastian J. Bronner <[email protected]>
+#
+# Copying and distribution of this file, with or without modification, are
+# permitted in any medium without royalty provided the copyright notice and
+# this notice are preserved.
+# === END LICENSE STATEMENT ===
+
+from typing import List, Tuple, Union
+
+from PIL import Image, ImageDraw
+
+from labelle.lib.barcode_writer import BinaryString
+
+
+def _mm2px(mm: float, dpi: float = 25.4) -> float:
+    return (mm * dpi) / 25.4
+
+
+def _list_of_runs(line: BinaryString) -> List[int]:
+    # Pack line to list give better gfx result, otherwise in can
+    # result in aliasing gaps
+    # '11010111' -> [2, -1, 1, -1, 3]
+    c = 1
+    mlist = []
+    for i in range(0, len(line)):
+        if i + 1 < len(line) and line[i] == line[i + 1]:
+            c += 1
+        else:
+            if line[i] == "1":
+                mlist.append(c)
+            else:
+                mlist.append(-c)
+            c = 1
+    return mlist
+
+
+def _calculate_size(
+    *,
+    modules_per_line: int,
+    quiet_zone: float,
+    module_width: float,
+    module_height: float,
+    vertical_margin: float,
+    dpi: float = 25.4,
+) -> Tuple[int, int]:
+    width = 2 * quiet_zone + modules_per_line * module_width
+    height = vertical_margin * 2 + module_height
+    return int(_mm2px(width, dpi)), int(_mm2px(height, dpi))
+
+
+def convert_binary_string_to_barcode_image(
+    line: BinaryString, quiet_zone: float, module_height: float
+) -> Image.Image:
+    """Render a barcode string into an image.
+
+    line: A string of 0s and 1s representing the barcode.
+    """
+    module_width = 2
+    vertical_margin = 8
+    dpi = 25.4
+
+    width, height = _calculate_size(
+        modules_per_line=len(line),
+        dpi=dpi,
+        quiet_zone=quiet_zone,
+        module_width=module_width,
+        module_height=module_height,
+        vertical_margin=vertical_margin,
+    )
+    image = Image.new("1", (width, height), 0)
+    draw = ImageDraw.Draw(image)
+
+    ypos = vertical_margin
+    mlist = _list_of_runs(line)
+    # Left quiet zone is x startposition
+    xpos = quiet_zone
+    for mod in mlist:
+        if mod < 1:
+            color = 0
+        else:
+            color = 1
+        # remove painting for background colored tiles?
+        _paint_module(
+            xpos=xpos,
+            ypos=ypos,
+            width=module_width * abs(mod),
+            color=color,
+            dpi=dpi,
+            module_height=module_height,
+            draw=draw,
+        )
+        xpos += module_width * abs(mod)
+    return image
+
+
+def _paint_module(
+    *,
+    xpos: float,
+    ypos: float,
+    width: float,
+    color: Union[int, str],
+    dpi: float,
+    module_height: float,
+    draw: ImageDraw.ImageDraw,
+) -> None:
+    size = (
+        (_mm2px(xpos, dpi), _mm2px(ypos, dpi)),
+        (
+            _mm2px(xpos + width, dpi),
+            _mm2px(ypos + module_height, dpi),
+        ),
+    )
+    draw.rectangle(size, outline=color, fill=color)

src/labelle/lib/barcode_writer.py

@@ -6,106 +6,29 @@
 # this notice are preserved.
 # === END LICENSE STATEMENT ===
 
-from typing import Optional
+from typing import List, NamedTuple, NewType
 
 from barcode.writer import BaseWriter
-from PIL import Image, ImageDraw
 
+BinaryString = NewType("BinaryString", str)
+"""A string that's been validated to contain only '0's and '1's."""
 
-def mm2px(mm, dpi=25.4):
-    return (mm * dpi) / 25.4
 
+def _validate_string_as_binary(s: str) -> BinaryString:
+    if not all(c in ("0", "1") for c in s):
+        raise ValueError("Barcode can only contain 0 and 1")
+    return BinaryString(s)
 
-class BarcodeImageWriter(BaseWriter):
-    _draw: Optional[ImageDraw.ImageDraw]
 
-    def __init__(self):
-        super().__init__(self._init, self._paint_module, None, self._finish)
-        self.format = "PNG"
-        self.dpi = 25.4
-        self._image = None
-        self._draw = None
-        self.vertical_margin = 0
+class BarcodeResult(NamedTuple):
+    line: BinaryString
+    quiet_zone: float
 
-    def calculate_size(self, modules_per_line, number_of_lines, dpi=25.4):
-        width = 2 * self.quiet_zone + modules_per_line * self.module_width
-        height = self.vertical_margin * 2 + self.module_height * number_of_lines
-        return int(mm2px(width, dpi)), int(mm2px(height, dpi))
 
-    def render(self, code):
-        """Render the barcode.
-
-        Uses whichever inheriting writer is provided via the registered callbacks.
-
-        :parameters:
-            code : List
-                List of strings matching the writer spec
-                (only contain 0 or 1).
-        """
-        if self._callbacks["initialize"] is not None:
-            self._callbacks["initialize"](code)
-        ypos = self.vertical_margin
-        for cc, line in enumerate(code):
-            # Pack line to list give better gfx result, otherwise in can
-            # result in aliasing gaps
-            # '11010111' -> [2, -1, 1, -1, 3]
-            line += " "
-            c = 1
-            mlist = []
-            for i in range(0, len(line) - 1):
-                if line[i] == line[i + 1]:
-                    c += 1
-                else:
-                    if line[i] == "1":
-                        mlist.append(c)
-                    else:
-                        mlist.append(-c)
-                    c = 1
-            # Left quiet zone is x startposition
-            xpos = self.quiet_zone
-            for mod in mlist:
-                if mod < 1:
-                    color = self.background
-                else:
-                    color = self.foreground
-                # remove painting for background colored tiles?
-                self._callbacks["paint_module"](
-                    xpos, ypos, self.module_width * abs(mod), color
-                )
-                xpos += self.module_width * abs(mod)
-            # Add right quiet zone to every line, except last line,
-            # quiet zone already provided with background,
-            # should it be removed complety?
-            if (cc + 1) != len(code):
-                self._callbacks["paint_module"](
-                    xpos, ypos, self.quiet_zone, self.background
-                )
-            ypos += self.module_height
-        return self._callbacks["finish"]()
-
-    def _init(self, code):
-        size = self.calculate_size(len(code[0]), len(code), self.dpi)
-        self._image = Image.new("1", size, self.background)
-        self._draw = ImageDraw.Draw(self._image)
-
-    def _paint_module(self, xpos, ypos, width, color):
-        size = (
-            (mm2px(xpos, self.dpi), mm2px(ypos, self.dpi)),
-            (
-                mm2px(xpos + width, self.dpi),
-                mm2px(ypos + self.module_height, self.dpi),
-            ),
-        )
-        assert self._draw is not None
-        self._draw.rectangle(size, outline=color, fill=color)
-
-    def _finish(self):
-        # although Image mode set to "1", draw function writes white as 255
-        assert self._image is not None
-        self._image = self._image.point(lambda x: 1 if x > 0 else 0, mode="1")
-        return self._image
-
-    def save(self, filename, output):
-        filename = f"{filename}.{self.format.lower()}"
-        output.save(filename, self.format.upper())
-        return filename
+class SimpleBarcodeWriter(BaseWriter):
+    def render(self, code: List[str]) -> BarcodeResult:
+        """Extract the barcode string from the code and render it into an image."""
+        if len(code) != 1:
+            raise ValueError("Barcode expected to have only one line")
+        line = _validate_string_as_binary(code[0])
+        return BarcodeResult(line=line, quiet_zone=self.quiet_zone)

src/labelle/lib/render_engines/barcode.py

@@ -3,13 +3,11 @@
 import barcode as barcode_module
 from PIL import Image
 
-from labelle.lib.barcode_writer import BarcodeImageWriter
+from labelle.lib.barcode_to_image import convert_binary_string_to_barcode_image
+from labelle.lib.barcode_writer import SimpleBarcodeWriter
 from labelle.lib.constants import DEFAULT_BARCODE_TYPE, BarcodeType
 from labelle.lib.render_engines.render_context import RenderContext
-from labelle.lib.render_engines.render_engine import (
-    RenderEngine,
-    RenderEngineException,
-)
+from labelle.lib.render_engines.render_engine import RenderEngine, RenderEngineException
 
 if DEFAULT_BARCODE_TYPE != BarcodeType.CODE128:
     # Ensure that we fail fast if the default barcode type is adjusted
@@ -44,19 +42,15 @@ def render(self, context: RenderContext) -> Image.Image:
             # in the GUI before the user entered a barcode.
             self.content = " "
         try:
-            code = barcode_module.get(
-                self.barcode_type, self.content, writer=BarcodeImageWriter()
-            )
-            bitmap = code.render(
-                {
-                    "font_size": 0,
-                    "vertical_margin": 8,
-                    "module_height": context.height_px - 16,
-                    "module_width": 2,
-                    "background": "black",
-                    "foreground": "white",
-                }
+            code_obj = barcode_module.get(
+                self.barcode_type, self.content, writer=SimpleBarcodeWriter()
             )
+            result = code_obj.render()
         except BaseException as e:
             raise BarcodeRenderError from e
+        bitmap = convert_binary_string_to_barcode_image(
+            line=result.line,
+            quiet_zone=result.quiet_zone,
+            module_height=context.height_px - 16,
+        )
         return bitmap