import gzip import os import xml.dom from typing import BinaryIO from barcode.version import version try: import Image import ImageDraw import ImageFont except ImportError: try: from PIL import Image # lint:ok from PIL import ImageDraw from PIL import ImageFont except ImportError: import logging log = logging.getLogger("pyBarcode") log.info("Pillow not found. Image output disabled") Image = ImageDraw = ImageFont = None # lint:ok def mm2px(mm, dpi=300): return (mm * dpi) / 25.4 def pt2mm(pt): return pt * 0.352777778 def _set_attributes(element, **attributes): for key, value in attributes.items(): element.setAttribute(key, value) def create_svg_object(with_doctype=False): imp = xml.dom.getDOMImplementation() doctype = imp.createDocumentType( "svg", "-//W3C//DTD SVG 1.1//EN", "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd", ) document = imp.createDocument(None, "svg", doctype if with_doctype else None) _set_attributes( document.documentElement, version="1.1", xmlns="http://www.w3.org/2000/svg" ) return document SIZE = "{0:.3f}mm" COMMENT = f"Autogenerated with python-barcode {version}" PATH = os.path.dirname(os.path.abspath(__file__)) class BaseWriter: """Baseclass for all writers. Initializes the basic writer options. Childclasses can add more attributes and can set them directly or using `self.set_options(option=value)`. :parameters: initialize : Function Callback for initializing the inheriting writer. Is called: `callback_initialize(raw_code)` paint_module : Function Callback for painting one barcode module. Is called: `callback_paint_module(xpos, ypos, width, color)` paint_text : Function Callback for painting the text under the barcode. Is called: `callback_paint_text(xpos, ypos)` using `self.text` as text. finish : Function Callback for doing something with the completely rendered output. Is called: `return callback_finish()` and must return the rendered output. """ def __init__( self, initialize=None, paint_module=None, paint_text=None, finish=None, ) -> None: self._callbacks = { "initialize": initialize, "paint_module": paint_module, "paint_text": paint_text, "finish": finish, } self.module_width = 10 self.module_height = 10 self.font_path = os.path.join(PATH, "fonts", "DejaVuSansMono.ttf") self.font_size = 10 self.quiet_zone = 6.5 self.background = "white" self.foreground = "black" self.text = "" self.human = "" # human readable text self.text_distance = 5 self.text_line_distance = 1 self.center_text = True self.guard_height_factor = 1.1 self.margin_top = 1 self.margin_bottom = 1 def calculate_size(self, modules_per_line, number_of_lines): """Calculates the size of the barcode in pixel. :parameters: modules_per_line : Integer Number of modules in one line. number_of_lines : Integer Number of lines of the barcode. :returns: Width and height of the barcode in pixel. :rtype: Tuple """ width = 2 * self.quiet_zone + modules_per_line * self.module_width height = ( self.margin_bottom + self.margin_top + self.module_height * number_of_lines ) number_of_text_lines = len(self.text.splitlines()) if self.font_size and self.text: height += ( pt2mm(self.font_size) / 2 * number_of_text_lines + self.text_distance ) height += self.text_line_distance * (number_of_text_lines - 1) return width, height def save(self, filename, output): """Saves the rendered output to `filename`. :parameters: filename : String Filename without extension. output : String The rendered output. :returns: The full filename with extension. :rtype: String """ raise NotImplementedError def register_callback(self, action, callback): """Register one of the three callbacks if not given at instance creation. :parameters: action : String One of 'initialize', 'paint_module', 'paint_text', 'finish'. callback : Function The callback function for the given action. """ self._callbacks[action] = callback def set_options(self, options): """Sets the given options as instance attributes (only if they are known). :parameters: options : Dict All known instance attributes and more if the childclass has defined them before this call. :rtype: None """ for key, val in options.items(): key = key.lstrip("_") if hasattr(self, key): setattr(self, key, val) def packed(self, line): """ Pack line to list give better gfx result, otherwise in can result in aliasing gaps '11010111' -> [2, -1, 1, -1, 3] This method will yield a sequence of pairs (width, height_factor). :parameters: line: String A string matching the writer spec (only contain 0 or 1 or G). """ line += " " c = 1 for i in range(0, len(line) - 1): if line[i] == line[i + 1]: c += 1 else: if line[i] == "1": yield (c, 1) elif line[i] == "G": yield (c, self.guard_height_factor) else: yield (-c, self.guard_height_factor) c = 1 def render(self, code): """Renders the barcode to whatever the inheriting writer provides, using the registered callbacks. :parameters: code : List List of strings matching the writer spec (only contain 0 or 1 or G). """ if self._callbacks["initialize"] is not None: self._callbacks["initialize"](code) ypos = self.margin_top base_height = self.module_height for cc, line in enumerate(code): # Left quiet zone is x startposition xpos = self.quiet_zone bxs = xpos # x start of barcode text = { "start": [], # The x start of a guard "end": [], # The x end of a guard "xpos": [], # The x position where to write a text block # Flag that indicates if the previous mod was part of an guard block: "was_guard": False, } for mod, height_factor in self.packed(line): if mod < 1: color = self.background else: color = self.foreground if text["was_guard"] and height_factor == 1: # The current guard ended, store its x position text["end"].append(xpos) text["was_guard"] = False elif not text["was_guard"] and height_factor != 1: # A guard started, store its x position text["start"].append(xpos) text["was_guard"] = True self.module_height = base_height * height_factor # remove painting for background colored tiles? self._callbacks["paint_module"]( xpos, ypos, self.module_width * abs(mod), color ) xpos += self.module_width * abs(mod) else: if height_factor != 1: text["end"].append(xpos) self.module_height = base_height bxe = xpos # Add right quiet zone to every line, except last line, # quiet zone already provided with background, # should it be removed completely? if (cc + 1) != len(code): self._callbacks["paint_module"]( xpos, ypos, self.quiet_zone, self.background ) ypos += self.module_height if self.text and self._callbacks["paint_text"] is not None: if not text["start"]: # If we don't have any start value, print the entire ean ypos += self.text_distance xpos = bxs + (bxe - bxs) / 2.0 if self.center_text else bxs self._callbacks["paint_text"](xpos, ypos) else: # Else, divide the ean into blocks and print each block # in the expected position. text["xpos"] = [bxs - 4 * self.module_width] # Calculates the position of the text by getting the difference # between a guard end and the next start text["start"].pop(0) for s, e in zip(text["start"], text["end"]): text["xpos"].append(e + (s - e) / 2) # The last text block is always put after the last guard end text["xpos"].append(text["end"][-1] + 4 * self.module_width) # Split the ean into its blocks self.text = self.text.split(" ") ypos += pt2mm(self.font_size) blocks = self.text for text_, xpos in zip(blocks, text["xpos"]): self.text = text_ self._callbacks["paint_text"](xpos, ypos) return self._callbacks["finish"]() class SVGWriter(BaseWriter): def __init__(self) -> None: BaseWriter.__init__( self, self._init, self._create_module, self._create_text, self._finish ) self.compress = False self.with_doctype = True self._document = None self._root = None self._group = None def _init(self, code): width, height = self.calculate_size(len(code[0]), len(code)) self._document = create_svg_object(self.with_doctype) self._root = self._document.documentElement attributes = { "width": SIZE.format(width), "height": SIZE.format(height), } _set_attributes(self._root, **attributes) if COMMENT: self._root.appendChild(self._document.createComment(COMMENT)) # create group for easier handling in 3rd party software # like corel draw, inkscape, ... group = self._document.createElement("g") attributes = {"id": "barcode_group"} _set_attributes(group, **attributes) self._group = self._root.appendChild(group) background = self._document.createElement("rect") attributes = { "width": "100%", "height": "100%", "style": f"fill:{self.background}", } _set_attributes(background, **attributes) self._group.appendChild(background) def _create_module(self, xpos, ypos, width, color): # Background rect has been provided already, so skipping "spaces" if color != self.background: element = self._document.createElement("rect") attributes = { "x": SIZE.format(xpos), "y": SIZE.format(ypos), "width": SIZE.format(width), "height": SIZE.format(self.module_height), "style": f"fill:{color};", } _set_attributes(element, **attributes) self._group.appendChild(element) def _create_text(self, xpos, ypos): # check option to override self.text with self.human (barcode as # human readable data, can be used to print own formats) barcodetext = self.human if self.human != "" else self.text for subtext in barcodetext.split("\n"): element = self._document.createElement("text") attributes = { "x": SIZE.format(xpos), "y": SIZE.format(ypos), "style": "fill:{};font-size:{}pt;text-anchor:middle;".format( self.foreground, self.font_size, ), } _set_attributes(element, **attributes) text_element = self._document.createTextNode(subtext) element.appendChild(text_element) self._group.appendChild(element) ypos += pt2mm(self.font_size) + self.text_line_distance def _finish(self): if self.compress: return self._document.toxml(encoding="UTF-8") return self._document.toprettyxml( indent=4 * " ", newl=os.linesep, encoding="UTF-8" ) def save(self, filename, output): if self.compress: _filename = f"{filename}.svgz" f = gzip.open(_filename, "wb") f.write(output) f.close() else: _filename = f"{filename}.svg" with open(_filename, "wb") as f: f.write(output) return _filename def write(self, content, fp: BinaryIO): """Write `content` into a file-like object. Content should be a barcode rendered by this writer. """ fp.write(content) if Image is None: ImageWriter = None else: class ImageWriter(BaseWriter): # type: ignore[no-redef] format: str mode: str dpi: int def __init__(self, format="PNG", mode="RGB") -> None: """Initialise a new write instance. :params format: The file format for the generated image. This parameter can take any value that Pillow accepts. :params mode: The colour-mode for the generated image. Set this to RGBA if you wish to use colours with transparency. """ BaseWriter.__init__( self, self._init, self._paint_module, self._paint_text, self._finish ) self.format = format self.mode = mode self.dpi = 300 self._image = None self._draw = None def _init(self, code): width, height = self.calculate_size(len(code[0]), len(code)) size = (int(mm2px(width, self.dpi)), int(mm2px(height, self.dpi))) self._image = Image.new(self.mode, 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) - 1, mm2px(ypos + self.module_height, self.dpi), ), ] self._draw.rectangle(size, outline=color, fill=color) def _paint_text(self, xpos, ypos): font_size = int(mm2px(pt2mm(self.font_size), self.dpi)) font = ImageFont.truetype(self.font_path, font_size) for subtext in self.text.split("\n"): pos = ( mm2px(xpos, self.dpi), mm2px(ypos, self.dpi), ) self._draw.text( pos, subtext, font=font, fill=self.foreground, anchor="md" ) ypos += pt2mm(self.font_size) / 2 + self.text_line_distance def _finish(self): return self._image def save(self, filename, output): filename = f"{filename}.{self.format.lower()}" output.save(filename, self.format.upper()) return filename def write(self, content, fp: BinaryIO): """Write `content` into a file-like object. Content should be a barcode rendered by this writer. """ content.save(fp, format=self.format)