627 lines
31 KiB
Python
627 lines
31 KiB
Python
|
#!/usr/bin/env python3
|
||
|
|
#
|
||
|
|
# An extension to generate SVG/PNG labels (stickers) for use with our item inventory system.
|
||
|
|
# It pulls a .csv file from a server URL (protected by basic auth) and exports and prints the labels to a Brother QL-720NW label printer
|
||
|
|
# Documentation: https://wiki.fablabchemnitz.de/display/TEED/Werkstattorientierung+im+FabLab+-+Digtales+Inventar
|
||
|
|
#
|
||
|
|
# Made by FabLab Chemnitz / Stadtfabrikanten e.V. - Developer: Mario Voigt (year 2021)
|
||
|
|
#
|
||
|
|
# This extension is based on the "original" barcode extension included in default InkScape Extension Set, which is licensed by the following:
|
||
|
|
#
|
||
|
|
# Copyright (C) 2009 John Beard john.j.beard@gmail.com
|
||
|
|
#
|
||
|
|
# This program is free software; you can redistribute it and/or modify
|
||
|
|
# it under the terms of the GNU General Public License as published by
|
||
|
|
# the Free Software Foundation; either version 2 of the License, or
|
||
|
|
# (at your option) any later version.
|
||
|
|
#
|
||
|
|
# This program is distributed in the hope that it will be useful,
|
||
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
# GNU General Public License for more details.
|
||
|
|
#
|
||
|
|
# You should have received a copy of the GNU General Public License
|
||
|
|
# along with this program; if not, write to the Free Software
|
||
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||
|
|
#
|
||
|
|
|
||
|
|
import csv
|
||
|
|
import os
|
||
|
|
import shutil
|
||
|
|
import urllib.request
|
||
|
|
from lxml import etree
|
||
|
|
import inkex
|
||
|
|
from inkex import Rectangle
|
||
|
|
from inkex.command import inkscape
|
||
|
|
import re
|
||
|
|
import subprocess
|
||
|
|
from subprocess import Popen, PIPE
|
||
|
|
|
||
|
|
INVALID_BIT = 2
|
||
|
|
|
||
|
|
# CODEWORD STREAM GENERATION =========================================
|
||
|
|
# take the text input and return the codewords,
|
||
|
|
# including the Reed-Solomon error-correcting codes.
|
||
|
|
# =====================================================================
|
||
|
|
|
||
|
|
def get_codewords(text, nd, nc, inter, size144):
|
||
|
|
# convert the data to the codewords
|
||
|
|
data = list(encode_to_ascii(text))
|
||
|
|
|
||
|
|
if not size144: # render a "normal" datamatrix
|
||
|
|
data_blocks = partition_data(data, nd * inter) # partition into data blocks of length nd*inter -> inter Reed-Solomon block
|
||
|
|
data_blocks = interleave(data_blocks, inter) # interleave consecutive inter blocks if required
|
||
|
|
data_blocks = reed_solomon(data_blocks, nd, nc) # generate and append the Reed-Solomon codewords
|
||
|
|
data_blocks = combine_interleaved(data_blocks, inter, nd, nc, False) # concatenate Reed-Solomon blocks bound for the same datamatrix
|
||
|
|
return data_blocks
|
||
|
|
|
||
|
|
|
||
|
|
# Takes a codeword stream and splits up into "inter" blocks.
|
||
|
|
# eg interleave( [1,2,3,4,5,6], 2 ) -> [1,3,5], [2,4,6]
|
||
|
|
def interleave(blocks, inter):
|
||
|
|
if inter == 1: # if we don"t have to interleave, just return the blocks
|
||
|
|
return blocks
|
||
|
|
else:
|
||
|
|
result = []
|
||
|
|
for block in blocks: # for each codeword block in the stream
|
||
|
|
block_length = int(len(block) / inter) # length of each interleaved block
|
||
|
|
inter_blocks = [[0] * block_length for i in range(inter)] # the interleaved blocks
|
||
|
|
|
||
|
|
for i in range(block_length): # for each element in the interleaved blocks
|
||
|
|
for j in range(inter): # for each interleaved block
|
||
|
|
inter_blocks[j][i] = block[i * inter + j]
|
||
|
|
|
||
|
|
result.extend(inter_blocks) # add the interleaved blocks to the output
|
||
|
|
|
||
|
|
return result
|
||
|
|
|
||
|
|
# Combine interleaved blocks into the groups for the same datamatrix
|
||
|
|
#
|
||
|
|
# e.g combine_interleaved( [[d1, d3, d5, e1, e3, e5], [d2, d4, d6, e2, e4, e6]], 2, 3, 3 )
|
||
|
|
# --> [[d1, d2, d3, d4, d5, d6, e1, e2, e3, e4, e5, e6]]
|
||
|
|
def combine_interleaved(blocks, inter, nd, nc, size144):
|
||
|
|
if inter == 1: # the blocks aren"t interleaved
|
||
|
|
return blocks
|
||
|
|
else:
|
||
|
|
result = []
|
||
|
|
for i in range(len(blocks) // inter): # for each group of "inter" blocks -> one full datamatrix
|
||
|
|
data_codewords = [] # interleaved data blocks
|
||
|
|
|
||
|
|
if size144:
|
||
|
|
nd_range = 1558 # 1558 = 156*8 + 155*2
|
||
|
|
nc_range = 620 # 620 = 62*8 + 62*2
|
||
|
|
else:
|
||
|
|
nd_range = nd * inter
|
||
|
|
nc_range = nc * inter
|
||
|
|
|
||
|
|
for j in range(nd_range): # for each codeword in the final list
|
||
|
|
data_codewords.append(blocks[i * inter + j % inter][j // inter])
|
||
|
|
|
||
|
|
for j in range(nc_range): # for each block, add the ecc codewords
|
||
|
|
data_codewords.append(blocks[i * inter + j % inter][nd + j // inter])
|
||
|
|
|
||
|
|
result.append(data_codewords)
|
||
|
|
return result
|
||
|
|
|
||
|
|
def encode_to_ascii(text):
|
||
|
|
"""Encode this text into chunks, ascii or digits"""
|
||
|
|
i = 0
|
||
|
|
while i < len(text):
|
||
|
|
# check for double digits, if the next char is also a digit
|
||
|
|
if text[i].isdigit() and (i < len(text) - 1) and text[i + 1].isdigit():
|
||
|
|
yield int(text[i] + text[i + 1]) + 130
|
||
|
|
i += 2 # move on 2 characters
|
||
|
|
else: # encode as a normal ascii,
|
||
|
|
yield ord(text[i]) + 1 # codeword is ASCII value + 1 (ISO 16022:2006 5.2.3)
|
||
|
|
i += 1 # next character
|
||
|
|
|
||
|
|
# partition data into blocks of the appropriate size to suit the
|
||
|
|
# Reed-Solomon block being used.
|
||
|
|
# e.g. partition_data([1,2,3,4,5], 3) -> [[1,2,3],[4,5,PAD]]
|
||
|
|
def partition_data(data, rs_data):
|
||
|
|
PAD_VAL = 129 # PAD codeword (ISO 16022:2006 5.2.3)
|
||
|
|
data_blocks = []
|
||
|
|
i = 0
|
||
|
|
while i < len(data):
|
||
|
|
if len(data) >= i + rs_data: # we have a whole block in our data
|
||
|
|
data_blocks.append(data[i:i + rs_data])
|
||
|
|
i = i + rs_data
|
||
|
|
else: # pad out with the pad codeword
|
||
|
|
data_block = data[i:len(data)] # add any remaining data
|
||
|
|
pad_pos = len(data)
|
||
|
|
padded = False
|
||
|
|
while len(data_block) < rs_data: # and then pad with randomised pad codewords
|
||
|
|
if not padded:
|
||
|
|
data_block.append(PAD_VAL) # add a normal pad codeword
|
||
|
|
padded = True
|
||
|
|
else:
|
||
|
|
data_block.append(randomise_pad_253(PAD_VAL, pad_pos))
|
||
|
|
pad_pos += 1
|
||
|
|
data_blocks.append(data_block)
|
||
|
|
break
|
||
|
|
|
||
|
|
return data_blocks
|
||
|
|
|
||
|
|
|
||
|
|
# Pad character randomisation, to prevent regular patterns appearing
|
||
|
|
# in the data matrix
|
||
|
|
def randomise_pad_253(pad_value, pad_position):
|
||
|
|
pseudo_random_number = ((149 * pad_position) % 253) + 1
|
||
|
|
randomised = pad_value + pseudo_random_number
|
||
|
|
if randomised <= 254:
|
||
|
|
return randomised
|
||
|
|
else:
|
||
|
|
return randomised - 254
|
||
|
|
|
||
|
|
# REED-SOLOMON ENCODING ROUTINES =====================================
|
||
|
|
|
||
|
|
# "prod(x,y,log,alog,gf)" returns the product "x" times "y"
|
||
|
|
def prod(x, y, log, alog, gf):
|
||
|
|
if x == 0 or y == 0:
|
||
|
|
return 0
|
||
|
|
else:
|
||
|
|
result = alog[(log[x] + log[y]) % (gf - 1)]
|
||
|
|
return result
|
||
|
|
|
||
|
|
# generate the log & antilog lists:
|
||
|
|
def gen_log_alog(gf, pp):
|
||
|
|
log = [0] * gf
|
||
|
|
alog = [0] * gf
|
||
|
|
|
||
|
|
log[0] = 1 - gf
|
||
|
|
alog[0] = 1
|
||
|
|
|
||
|
|
for i in range(1, gf):
|
||
|
|
alog[i] = alog[i - 1] * 2
|
||
|
|
|
||
|
|
if alog[i] >= gf:
|
||
|
|
alog[i] = alog[i] ^ pp
|
||
|
|
|
||
|
|
log[alog[i]] = i
|
||
|
|
|
||
|
|
return log, alog
|
||
|
|
|
||
|
|
|
||
|
|
# generate the generator polynomial coefficients:
|
||
|
|
def gen_poly_coeffs(nc, log, alog, gf):
|
||
|
|
c = [0] * (nc + 1)
|
||
|
|
c[0] = 1
|
||
|
|
|
||
|
|
for i in range(1, nc + 1):
|
||
|
|
c[i] = c[i - 1]
|
||
|
|
|
||
|
|
j = i - 1
|
||
|
|
while j >= 1:
|
||
|
|
c[j] = c[j - 1] ^ prod(c[j], alog[i], log, alog, gf)
|
||
|
|
j -= 1
|
||
|
|
|
||
|
|
c[0] = prod(c[0], alog[i], log, alog, gf)
|
||
|
|
|
||
|
|
return c
|
||
|
|
|
||
|
|
|
||
|
|
# "ReedSolomon(wd,nd,nc)" takes "nd" data codeword values in wd[]
|
||
|
|
# and adds on "nc" check codewords, all within GF(gf) where "gf" is a
|
||
|
|
# power of 2 and "pp" is the value of its prime modulus polynomial */
|
||
|
|
def reed_solomon(data, nd, nc):
|
||
|
|
# parameters of the polynomial arithmetic
|
||
|
|
gf = 256 # operating on 8-bit codewords -> Galois field = 2^8 = 256
|
||
|
|
pp = 301 # prime modulus polynomial for ECC-200 is 0b100101101 = 301 (ISO 16022:2006 5.7.1)
|
||
|
|
|
||
|
|
log, alog = gen_log_alog(gf, pp)
|
||
|
|
c = gen_poly_coeffs(nc, log, alog, gf)
|
||
|
|
|
||
|
|
for block in data: # for each block of data codewords
|
||
|
|
|
||
|
|
block.extend([0] * (nc + 1)) # extend to make space for the error codewords
|
||
|
|
|
||
|
|
# generate "nc" checkwords in the list block
|
||
|
|
for i in range(0, nd):
|
||
|
|
k = block[nd] ^ block[i]
|
||
|
|
|
||
|
|
for j in range(0, nc):
|
||
|
|
block[nd + j] = block[nd + j + 1] ^ prod(k, c[nc - j - 1], log, alog, gf)
|
||
|
|
|
||
|
|
block.pop()
|
||
|
|
|
||
|
|
return data
|
||
|
|
|
||
|
|
|
||
|
|
# MODULE PLACEMENT ROUTINES===========================================
|
||
|
|
# These routines take a steam of codewords, and place them into the
|
||
|
|
# DataMatrix in accordance with Annex F of BS ISO/IEC 16022:2006
|
||
|
|
|
||
|
|
def bit(byte, bit_ch):
|
||
|
|
"""bit() returns the bit"th bit of the byte"""
|
||
|
|
# the MSB is bit 1, LSB is bit 8
|
||
|
|
return (byte >> (8 - bit_ch)) % 2
|
||
|
|
|
||
|
|
def module(array, nrow, ncol, row, col, bit_ch):
|
||
|
|
"""place a given bit with appropriate wrapping within array"""
|
||
|
|
if row < 0:
|
||
|
|
row = row + nrow
|
||
|
|
col = col + 4 - ((nrow + 4) % 8)
|
||
|
|
|
||
|
|
if col < 0:
|
||
|
|
col = col + ncol
|
||
|
|
row = row + 4 - ((ncol + 4) % 8)
|
||
|
|
|
||
|
|
array[row][col] = bit_ch
|
||
|
|
|
||
|
|
def place_square(case, array, nrow, ncol, row, col, char):
|
||
|
|
"""Populate corner cases (0-3) and utah case (-1)"""
|
||
|
|
for i in range(8):
|
||
|
|
x, y = [
|
||
|
|
[(row - 1, 0), (row - 1, 1), (row - 1, 2), (0, col - 2),
|
||
|
|
(0, col - 1), (1, col - 1), (2, col - 1), (3, col - 1)],
|
||
|
|
[(row - 3, 0), (row - 2, 0), (row - 1, 0), (0, col - 4),
|
||
|
|
(0, col - 3), (0, col - 2), (0, col - 1), (1, col - 1)],
|
||
|
|
[(row - 3, 0), (row - 2, 0), (row - 1, 0), (0, col - 2),
|
||
|
|
(0, col - 1), (1, col - 1), (2, col - 1), (3, col - 1)],
|
||
|
|
[(row - 1, 0), (row - 1, col - 1), (0, col - 3), (0, col - 2),
|
||
|
|
(0, col - 1), (1, col - 3), (1, col - 2), (1, col - 1)],
|
||
|
|
|
||
|
|
# "utah" places the 8 bits of a utah-shaped symbol character in ECC200
|
||
|
|
[(row - 2, col -2), (row - 2, col -1), (row - 1, col - 2), (row - 1, col - 1),
|
||
|
|
(row - 1, col), (row, col - 2), (row, col - 1), (row, col)],
|
||
|
|
][case][i]
|
||
|
|
module(array, nrow, ncol, x, y, bit(char, i + 1))
|
||
|
|
return 1
|
||
|
|
|
||
|
|
def place_bits(data, nrow, ncol):
|
||
|
|
"""fill an nrow x ncol array with the bits from the codewords in data."""
|
||
|
|
# initialise and fill with -1"s (invalid value)
|
||
|
|
array = [[INVALID_BIT] * ncol for i in range(nrow)]
|
||
|
|
# Starting in the correct location for character #1, bit 8,...
|
||
|
|
char = 0
|
||
|
|
row = 4
|
||
|
|
col = 0
|
||
|
|
while True:
|
||
|
|
|
||
|
|
# first check for one of the special corner cases, then...
|
||
|
|
if (row == nrow) and (col == 0):
|
||
|
|
char += place_square(0, array, nrow, ncol, nrow, ncol, data[char])
|
||
|
|
elif (row == nrow - 2) and (col == 0) and (ncol % 4):
|
||
|
|
char += place_square(1, array, nrow, ncol, nrow, ncol, data[char])
|
||
|
|
elif (row == nrow - 2) and (col == 0) and (ncol % 8 == 4):
|
||
|
|
char += place_square(2, array, nrow, ncol, nrow, ncol, data[char])
|
||
|
|
elif (row == nrow + 4) and (col == 2) and ((ncol % 8) == 0):
|
||
|
|
char += place_square(3, array, nrow, ncol, nrow, ncol, data[char])
|
||
|
|
|
||
|
|
# sweep upward diagonally, inserting successive characters,...
|
||
|
|
while (row >= 0) and (col < ncol):
|
||
|
|
if (row < nrow) and (col >= 0) and (array[row][col] == INVALID_BIT):
|
||
|
|
char += place_square(-1, array, nrow, ncol, row, col, data[char])
|
||
|
|
row -= 2
|
||
|
|
col += 2
|
||
|
|
|
||
|
|
row += 1
|
||
|
|
col += 3
|
||
|
|
|
||
|
|
# & then sweep downward diagonally, inserting successive characters,...
|
||
|
|
while (row < nrow) and (col >= 0):
|
||
|
|
if (row >= 0) and (col < ncol) and (array[row][col] == INVALID_BIT):
|
||
|
|
char += place_square(-1, array, nrow, ncol, row, col, data[char])
|
||
|
|
row += 2
|
||
|
|
col -= 2
|
||
|
|
|
||
|
|
row += 3
|
||
|
|
col += 1
|
||
|
|
|
||
|
|
# ... until the entire array is scanned
|
||
|
|
if not ((row < nrow) or (col < ncol)):
|
||
|
|
break
|
||
|
|
|
||
|
|
# Lastly, if the lower righthand corner is untouched, fill in fixed pattern */
|
||
|
|
if array[nrow - 1][ncol - 1] == INVALID_BIT:
|
||
|
|
array[nrow - 1][ncol - 2] = 0
|
||
|
|
array[nrow - 1][ncol - 1] = 1
|
||
|
|
array[nrow - 2][ncol - 1] = 0
|
||
|
|
array[nrow - 2][ncol - 2] = 1
|
||
|
|
|
||
|
|
return array # return the array of 1"s and 0"s
|
||
|
|
|
||
|
|
def add_finder_pattern(array, data_nrow, data_ncol, reg_row, reg_col):
|
||
|
|
# get the total size of the datamatrix
|
||
|
|
nrow = (data_nrow + 2) * reg_row
|
||
|
|
ncol = (data_ncol + 2) * reg_col
|
||
|
|
|
||
|
|
datamatrix = [[0] * ncol for i in range(nrow)] # initialise and fill with 0"s
|
||
|
|
|
||
|
|
for i in range(reg_col): # for each column of data regions
|
||
|
|
for j in range(nrow):
|
||
|
|
datamatrix[j][i * (data_ncol + 2)] = 1 # vertical black bar on left
|
||
|
|
datamatrix[j][i * (data_ncol + 2) + data_ncol + 1] = j % 2 # alternating blocks
|
||
|
|
|
||
|
|
for i in range(reg_row): # for each row of data regions
|
||
|
|
for j in range(ncol):
|
||
|
|
datamatrix[i * (data_nrow + 2) + data_nrow + 1][j] = 1 # horizontal black bar at bottom
|
||
|
|
datamatrix[i * (data_nrow + 2)][j] = (j + 1) % 2 # alternating blocks
|
||
|
|
|
||
|
|
for i in range(data_nrow * reg_row):
|
||
|
|
for j in range(data_ncol * reg_col):
|
||
|
|
# offset by 1, plus two for every addition block
|
||
|
|
dest_col = j + 1 + 2 * (j // data_ncol)
|
||
|
|
dest_row = i + 1 + 2 * (i // data_nrow)
|
||
|
|
|
||
|
|
datamatrix[dest_row][dest_col] = array[i][j] # transfer from the plain bit array
|
||
|
|
|
||
|
|
return datamatrix
|
||
|
|
|
||
|
|
def get_valid_filename(s):
|
||
|
|
s = str(s).strip().replace(" ", "_")
|
||
|
|
return re.sub(r"(?u)[^-\w.]", "", s)
|
||
|
|
|
||
|
|
def splitAt(string, length):
|
||
|
|
return ' '.join(string[i:i+length] for i in range(0,len(string),length))
|
||
|
|
|
||
|
|
class InventorySticker(inkex.Effect):
|
||
|
|
|
||
|
|
def __init__(self):
|
||
|
|
inkex.Effect.__init__(self)
|
||
|
|
self.arg_parser.add_argument("--main_tabs")
|
||
|
|
self.arg_parser.add_argument("--server_address", default="https://the.domain.de/inventory.csv")
|
||
|
|
self.arg_parser.add_argument("--htuser", default="user")
|
||
|
|
self.arg_parser.add_argument("--htpassword", default="password")
|
||
|
|
self.arg_parser.add_argument("--sticker_ids", default="*")
|
||
|
|
self.arg_parser.add_argument("--target_url", default="qwa.es")
|
||
|
|
self.arg_parser.add_argument("--target_owner", default="Stadtfabrikanten e.V.")
|
||
|
|
self.arg_parser.add_argument("--export_dir", default="/home/")
|
||
|
|
self.arg_parser.add_argument("--flat_export", type=inkex.Boolean, default=False)
|
||
|
|
self.arg_parser.add_argument("--preview", type=inkex.Boolean, default=False)
|
||
|
|
self.arg_parser.add_argument("--export_svg", type=inkex.Boolean, default=True)
|
||
|
|
self.arg_parser.add_argument("--export_png", type=inkex.Boolean, default=False)
|
||
|
|
self.arg_parser.add_argument("--print_png", type=int, default=0)
|
||
|
|
self.arg_parser.add_argument("--print_device", default="04f9:2044")
|
||
|
|
|
||
|
|
def effect(self):
|
||
|
|
# Adjust the document view for the desired sticker size
|
||
|
|
root = self.svg.getElement("//svg:svg")
|
||
|
|
|
||
|
|
#our QR Code has size 16x16, each cube is sized by 16x16px -> total size is 256x256px. We use 4px padding for all directions
|
||
|
|
DataMatrix_xy = 16
|
||
|
|
DataMatrix_height = 16 * DataMatrix_xy
|
||
|
|
DataMatrix_width = DataMatrix_height
|
||
|
|
sticker_padding = 4
|
||
|
|
sticker_height = DataMatrix_height + 2 * sticker_padding
|
||
|
|
sticker_width = 696
|
||
|
|
root.set("width", str(sticker_width) + "px")
|
||
|
|
root.set("height", str(sticker_height) + "px")
|
||
|
|
root.set("viewBox", "%f %f %f %f" % (0, 0, sticker_width, sticker_height))
|
||
|
|
|
||
|
|
#clean the document (make it blank) to avoid printing duplicated things
|
||
|
|
ct = 0
|
||
|
|
for node in self.document.xpath('//*', namespaces=inkex.NSS):
|
||
|
|
ct = ct + 1
|
||
|
|
if ct > 3: #we keep svg:svg, sodipodi:namedview and svg:defs which defines the default canvas without any content inside
|
||
|
|
#inkex.errormsg(str(node))
|
||
|
|
root.remove(node)
|
||
|
|
|
||
|
|
#set the document units
|
||
|
|
self.document.getroot().find(inkex.addNS("namedview", "sodipodi")).set("inkscape:document-units", "px")
|
||
|
|
|
||
|
|
# Download the recent inventory CSV file and parse line by line to create an inventory sticker
|
||
|
|
password_mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()
|
||
|
|
password_mgr.add_password(None, self.options.server_address, self.options.htuser, self.options.htpassword)
|
||
|
|
handler = urllib.request.HTTPBasicAuthHandler(password_mgr)
|
||
|
|
opener = urllib.request.build_opener(handler)
|
||
|
|
|
||
|
|
try:
|
||
|
|
inventoryData = opener.open(self.options.server_address).read().decode("utf-8")
|
||
|
|
urllib.request.install_opener(opener)
|
||
|
|
|
||
|
|
inventoryCSVParent = os.path.join(self.options.export_dir, "InventorySticker")
|
||
|
|
inventoryCSV = os.path.join(inventoryCSVParent, "inventory.csv")
|
||
|
|
|
||
|
|
# To avoid messing with old stickers we remove the directory on Client before doing something new
|
||
|
|
shutil.rmtree(inventoryCSVParent, ignore_errors=True) #remove the output directory before doing new job
|
||
|
|
|
||
|
|
# we are going to write the imported Server CSV file temporarily. Otherwise CSV reader seems to mess with the file if passed directly
|
||
|
|
if not os.path.exists(inventoryCSVParent):
|
||
|
|
os.mkdir(inventoryCSVParent)
|
||
|
|
with open(inventoryCSV, 'w', encoding="utf-8") as f:
|
||
|
|
f.write(inventoryData)
|
||
|
|
f.close()
|
||
|
|
|
||
|
|
#parse sticker Ids from user input
|
||
|
|
if self.options.sticker_ids != "*":
|
||
|
|
sticker_ids = self.options.sticker_ids.split(",")
|
||
|
|
else:
|
||
|
|
sticker_ids = None
|
||
|
|
|
||
|
|
with open(inventoryCSV, 'r', encoding="utf-8") as csv_file:
|
||
|
|
csv_reader = csv.reader(csv_file, delimiter=",")
|
||
|
|
for row in csv_reader:
|
||
|
|
internal_id = row[0]
|
||
|
|
doc_title = row[1]
|
||
|
|
sticker_id = row[2]
|
||
|
|
level = row[3]
|
||
|
|
zone = row[4]
|
||
|
|
|
||
|
|
if sticker_ids is None or sticker_id in sticker_ids:
|
||
|
|
#create new sub directories for each non-existent FabLab zone (if flat export is disabled)
|
||
|
|
if self.options.flat_export == False:
|
||
|
|
if not zone:
|
||
|
|
zoneDir = os.path.join(inventoryCSVParent, "Keinem Bereich zugeordnet")
|
||
|
|
else:
|
||
|
|
zoneDir = os.path.join(inventoryCSVParent, zone)
|
||
|
|
if not os.path.exists(zoneDir):
|
||
|
|
os.mkdir(zoneDir)
|
||
|
|
else:
|
||
|
|
zoneDir = inventoryCSVParent #use top directory
|
||
|
|
|
||
|
|
#Generate the recent sticker content
|
||
|
|
stickerGroup = self.document.getroot().add(inkex.Group(id="InventorySticker_Id" + sticker_id)) #make a new group at root level
|
||
|
|
DataMatrixStyle = inkex.Style({"stroke": "none", "stroke-width": "1", "fill": "#000000"})
|
||
|
|
DataMatrixAttribs = {"style": str(DataMatrixStyle), "height": str(DataMatrix_xy) + "px", "width": str(DataMatrix_xy) + "px"}
|
||
|
|
|
||
|
|
#configure font sizes and box heights to define how large the font size may be at maximum (to omit overflow)
|
||
|
|
subline_fontsize = 40 #px; one line of bottom text (id and owner) creates a box of that height
|
||
|
|
objectNameMaxHeight = sticker_height - subline_fontsize - 4 * sticker_padding
|
||
|
|
objectNameMaxLines = 5
|
||
|
|
objectNameFontSize = objectNameMaxHeight / objectNameMaxLines #px; generate main font size from lines and box size
|
||
|
|
|
||
|
|
# 1 - create DataMatrix (create a 2d list corresponding to the 1"s and 0s of the DataMatrix)
|
||
|
|
encoded = self.encode(self.options.target_url + "/" + sticker_id)
|
||
|
|
DataMatrixGroup = stickerGroup.add(inkex.Group(id="DataMatrix_Id" + sticker_id)) #make a new group at root level
|
||
|
|
for x, y in self.render_data_matrix(encoded, DataMatrix_xy):
|
||
|
|
DataMatrixAttribs.update({"x": str(x + sticker_padding), "y": str(y + sticker_padding)})
|
||
|
|
etree.SubElement(DataMatrixGroup, inkex.addNS("rect","svg"), DataMatrixAttribs)
|
||
|
|
|
||
|
|
inline_size = sticker_width - DataMatrix_width - 3 * sticker_padding #remaining width for objects next to the DataMatrix
|
||
|
|
x_pos = DataMatrix_width + 2 * sticker_padding
|
||
|
|
|
||
|
|
# 2 - Add Object Name Text
|
||
|
|
objectName = etree.SubElement(stickerGroup,
|
||
|
|
inkex.addNS("text", "svg"),
|
||
|
|
{
|
||
|
|
"font-size": str(objectNameFontSize) + "px",
|
||
|
|
"x": str(x_pos) + "px",
|
||
|
|
#"xml:space": "preserve", #we cannot add this here because InkScape throws an error
|
||
|
|
#"y": "4px", #if set it does not correctly apply
|
||
|
|
"text-align" : "left",
|
||
|
|
"text-anchor": "left",
|
||
|
|
"vertical-align" : "bottom",
|
||
|
|
#style: inline-size required for text wrapping inside box; letter spacing is required to remove the additional whitespaces. The letter spacing depends to the selected font family (Miso)
|
||
|
|
"style": str(inkex.Style({"fill": "#000000", "inline-size": str(inline_size) + "px", "stroke": "none", "font-family": "Miso", "font-weight": "bold", "letter-spacing": "-3.66px"}))
|
||
|
|
}
|
||
|
|
)
|
||
|
|
objectName.set("id", "objectName_Id" + sticker_id)
|
||
|
|
objectName.set("xml:space", "preserve") #so we add it here instead .. if multiple whitespaces in text are coming after each other just render them (preserve!)
|
||
|
|
objectNameTextSpan = etree.SubElement(objectName, inkex.addNS("tspan", "svg"), {})
|
||
|
|
objectNameTextSpan.text = splitAt(doc_title, 1) #add 1 whitespace after each chacter. So we can simulate a in-word line break (break by char instead by word)
|
||
|
|
|
||
|
|
# 3 - Add Object Id Text - use the same position but revert text anchors/align
|
||
|
|
objectId = etree.SubElement(stickerGroup,
|
||
|
|
inkex.addNS("text", "svg"),
|
||
|
|
{
|
||
|
|
"font-size": str(subline_fontsize) + "px",
|
||
|
|
"x": str(x_pos) + "px",
|
||
|
|
"transform": "translate(0," + str(sticker_height - subline_fontsize) + ")",
|
||
|
|
#"y": "4px", #if set it does not correctly apply
|
||
|
|
"text-align" : "right",
|
||
|
|
"text-anchor": "right",
|
||
|
|
"vertical-align" : "bottom",
|
||
|
|
"style": str(inkex.Style({"fill": "#000000", "inline-size":str(inline_size) + "px", "stroke": "none", "font-family": "Miso", "font-weight": "bold"})) #inline-size required for text wrapping
|
||
|
|
}
|
||
|
|
)
|
||
|
|
objectId.set("id", "objectId_Id" + sticker_id)
|
||
|
|
objectIdTextSpan = etree.SubElement(objectId, inkex.addNS("tspan", "svg"), {})
|
||
|
|
objectIdTextSpan.text = sticker_id
|
||
|
|
|
||
|
|
# 4 - Add Owner Text
|
||
|
|
owner = etree.SubElement(stickerGroup,
|
||
|
|
inkex.addNS("text", "svg"),
|
||
|
|
{
|
||
|
|
"font-size": str(subline_fontsize) + "px",
|
||
|
|
"x": str(x_pos) + "px",
|
||
|
|
"transform": "translate(0," + str(sticker_height - subline_fontsize) + ")",
|
||
|
|
#"y": "4px", #if set it does not correctly apply
|
||
|
|
"text-align" : "left",
|
||
|
|
"text-anchor": "left",
|
||
|
|
"vertical-align" : "bottom",
|
||
|
|
"style": str(inkex.Style({"fill": "#000000", "inline-size":str(inline_size) + "px", "stroke": "none", "font-family": "Miso"})) #inline-size required for text wrapping
|
||
|
|
}
|
||
|
|
)
|
||
|
|
owner.set("id", "owner_Id" + sticker_id)
|
||
|
|
ownerTextSpan = etree.SubElement(owner, inkex.addNS("tspan", "svg"), {})
|
||
|
|
ownerTextSpan.text = self.options.target_owner
|
||
|
|
|
||
|
|
# 5 - Add horizontal divider line
|
||
|
|
line_thickness = 2 #px
|
||
|
|
line_x_pos = 350 #px; start of the line (left coord)
|
||
|
|
line_length = sticker_width - line_x_pos
|
||
|
|
divider = etree.SubElement(stickerGroup,
|
||
|
|
inkex.addNS("path", "svg"),
|
||
|
|
{
|
||
|
|
"d": "m " + str(line_x_pos) + "," + str(sticker_height - subline_fontsize) + " h " + str(line_length) ,
|
||
|
|
"style": str(inkex.Style({"fill": "none", "stroke": "#000000", "stroke-width": str(line_thickness) + "px", "stroke-linecap": "butt", "stroke-linejoin":"miter", "stroke-opacity": "1"})) #inline-size required for text wrapping
|
||
|
|
}
|
||
|
|
)
|
||
|
|
divider.set("id", "divider_Id" + sticker_id)
|
||
|
|
|
||
|
|
if self.options.preview == False:
|
||
|
|
export_file_name = sticker_id + "_" + get_valid_filename(doc_title)
|
||
|
|
export_file_path = os.path.join(zoneDir, export_file_name)
|
||
|
|
|
||
|
|
#"Export" as SVG by just copying the recent SVG document to the target directory. We need to remove special characters to have valid file names on Windows/Linux
|
||
|
|
export_file_svg = open(export_file_path + ".svg", "w", encoding="utf-8")
|
||
|
|
export_file_svg.write(str(etree.tostring(self.document), "utf-8"))
|
||
|
|
export_file_svg.close()
|
||
|
|
|
||
|
|
if self.options.export_png == False and self.options.export_svg == False:
|
||
|
|
inkex.errormsg("Nothing to export. Generating preview only ...")
|
||
|
|
break
|
||
|
|
|
||
|
|
if self.options.export_png == True: #we need to generate SVG before to get PNG. But if user selected PNG only we need to remove SVG afterwards
|
||
|
|
#Make PNG from SVG (slow because each file is picked up separately. Takes about 10 minutes for 600 files
|
||
|
|
inkscape(export_file_path + ".svg", actions="export-dpi:96;export-background:white;export-filename:{file_name};export-do;FileClose".format(file_name=export_file_path + ".png"))
|
||
|
|
|
||
|
|
#fix for "usb.core.USBError: [Errno 13] Access denied (insufficient permissions)"
|
||
|
|
#echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="04f9", ATTR{idProduct}=="2044", MODE="666"' > /etc/udev/rules.d/99-garmin.rules && sudo udevadm trigger
|
||
|
|
if self.options.print_png > 0:
|
||
|
|
if self.options.export_png == False:
|
||
|
|
inkex.errormsg("No file output for printing. Please set 'Export PNG' to true first.")
|
||
|
|
else:
|
||
|
|
for x in range(self.options.print_png):
|
||
|
|
command = "brother_ql -m QL-720NW --backend pyusb --printer usb://" + self.options.print_device + " print -l 62 --600dpi -r auto " + export_file_path + ".png"
|
||
|
|
p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE) #forr Windows: shell=False
|
||
|
|
stdout, stderr = p.communicate()
|
||
|
|
p.wait()
|
||
|
|
if p.returncode != 0:
|
||
|
|
inkex.errormsg("brother_ql returned: %d %s %s" % (p.returncode, stdout, stderr))
|
||
|
|
|
||
|
|
if self.options.export_svg != True: #If user selected PNG only we need to remove SVG again
|
||
|
|
os.remove(export_file_path + ".svg")
|
||
|
|
|
||
|
|
self.document.getroot().remove(stickerGroup) #remove the stickerGroup again
|
||
|
|
else: #create preview by just breaking the for loop without executing remove(stickerGroup)
|
||
|
|
break
|
||
|
|
csv_file.close()
|
||
|
|
except Exception as e:
|
||
|
|
inkex.errormsg(e)
|
||
|
|
#inkex.errormsg("Wrong inventory.csv URL or invalid credentials for Basic Auth")
|
||
|
|
|
||
|
|
# parameters for the selected datamatrix size
|
||
|
|
# drow number of rows in each data region
|
||
|
|
# dcol number of cols in each data region
|
||
|
|
# reg_row number of rows of data regions
|
||
|
|
# reg_col number of cols of data regions
|
||
|
|
# nd number of data codewords per reed-solomon block
|
||
|
|
# nc number of ECC codewords per reed-solomon block
|
||
|
|
# inter number of interleaved Reed-Solomon blocks
|
||
|
|
def encode(self, text, nrow = 16, ncol = 16, data_nrow = 14, data_ncol = 14, reg_row = 1, reg_col = 1, nd = 12, nc = 12, inter = 1):
|
||
|
|
"""
|
||
|
|
Take an input string and convert it to a sequence (or sequences)
|
||
|
|
of codewords as specified in ISO/IEC 16022:2006 (section 5.2.3)
|
||
|
|
"""
|
||
|
|
# generate the codewords including padding and ECC
|
||
|
|
codewords = get_codewords(text, nd, nc, inter, nrow == 144)
|
||
|
|
|
||
|
|
# break up into separate arrays if more than one DataMatrix is needed
|
||
|
|
module_arrays = []
|
||
|
|
for codeword_stream in codewords: # for each datamatrix
|
||
|
|
# place the codewords" bits across the array as modules
|
||
|
|
bit_array = place_bits(codeword_stream, data_nrow * reg_row, data_ncol * reg_col)
|
||
|
|
# add finder patterns around the modules
|
||
|
|
module_arrays.append(add_finder_pattern(bit_array, data_nrow, data_ncol, reg_row, reg_col))
|
||
|
|
|
||
|
|
return module_arrays
|
||
|
|
|
||
|
|
def render_data_matrix(self, module_arrays, size):
|
||
|
|
"""turn a 2D array of 1"s and 0"s into a set of black squares"""
|
||
|
|
spacing = 16 * size * 1.5
|
||
|
|
for i, line in enumerate(module_arrays):
|
||
|
|
height = len(line)
|
||
|
|
width = len(line[0])
|
||
|
|
|
||
|
|
for y in range(height): # loop over all the modules in the datamatrix
|
||
|
|
for x in range(width):
|
||
|
|
if line[y][x] == 1: # A binary 1 is a filled square
|
||
|
|
yield (x * size + i * spacing, y * size)
|
||
|
|
elif line[y][x] == INVALID_BIT: # we have an invalid bit value
|
||
|
|
inkex.errormsg("Invalid bit value, {}!".format(line[y][x]))
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
InventorySticker().run()
|