465 lines
16 KiB
Python
465 lines
16 KiB
Python
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)
|