966 lines
34 KiB
Python
966 lines
34 KiB
Python
import math
|
|
import datetime
|
|
from affine import Affine
|
|
from boxes.extents import Extents
|
|
|
|
try:
|
|
from xml.etree import cElementTree as ET
|
|
except ImportError:
|
|
from xml.etree import ElementTree as ET
|
|
|
|
EPS = 1e-4
|
|
PADDING = 10
|
|
|
|
RANDOMIZE_COLORS = False # enable to ease check for continuity of pathes
|
|
|
|
|
|
def points_equal(x1, y1, x2, y2):
|
|
return abs(x1 - x2) < EPS and abs(y1 - y2) < EPS
|
|
|
|
|
|
def pdiff(p1, p2):
|
|
x1, y1 = p1
|
|
x2, y2 = p2
|
|
return (x1 - x2, y1 - y2)
|
|
|
|
|
|
class Surface:
|
|
|
|
scale = 1.0
|
|
invert_y = False
|
|
|
|
def __init__(self, fname):
|
|
self._fname = fname
|
|
self.parts = []
|
|
self._p = self.new_part("default")
|
|
|
|
def set_metadata(self, metadata):
|
|
self.metadata = metadata
|
|
|
|
def flush(self):
|
|
pass
|
|
|
|
def finish(self):
|
|
pass
|
|
|
|
def _adjust_coordinates(self):
|
|
extents = self.extents()
|
|
extents.xmin -= PADDING
|
|
extents.ymin -= PADDING
|
|
extents.xmax += PADDING
|
|
extents.ymax += PADDING
|
|
|
|
m = Affine.translation(-extents.xmin, -extents.ymin)
|
|
if self.invert_y:
|
|
m = Affine.scale(self.scale, -self.scale) * m
|
|
m = Affine.translation(0, self.scale*extents.height) * m
|
|
else:
|
|
m = Affine.scale(self.scale, self.scale) * m
|
|
|
|
self.transform(self.scale, m, self.invert_y)
|
|
|
|
return Extents(0, 0, extents.width * self.scale, extents.height * self.scale)
|
|
|
|
def render(self, renderer):
|
|
renderer.init(**self.args)
|
|
for p in self.parts:
|
|
p.render(renderer)
|
|
renderer.finish()
|
|
|
|
def transform(self, f, m, invert_y=False):
|
|
for p in self.parts:
|
|
p.transform(f, m, invert_y)
|
|
|
|
def new_part(self, name="part"):
|
|
if self.parts and len(self.parts[-1].pathes) == 0:
|
|
return self._p
|
|
p = Part(name)
|
|
self.parts.append(p)
|
|
self._p = p
|
|
return p
|
|
|
|
def append(self, *path):
|
|
self._p.append(*path)
|
|
|
|
def stroke(self, **params):
|
|
return self._p.stroke(**params)
|
|
|
|
def move_to(self, *xy):
|
|
self._p.move_to(*xy)
|
|
|
|
def extents(self):
|
|
if not self.parts:
|
|
return Extents()
|
|
return sum([p.extents() for p in self.parts])
|
|
|
|
|
|
class Part:
|
|
def __init__(self, name):
|
|
self.pathes = []
|
|
self.path = []
|
|
|
|
def extents(self):
|
|
if not self.pathes:
|
|
return Extents()
|
|
return sum([p.extents() for p in self.pathes])
|
|
|
|
def transform(self, f, m, invert_y=False):
|
|
assert(not self.path)
|
|
for p in self.pathes:
|
|
p.transform(f, m, invert_y)
|
|
|
|
def append(self, *path):
|
|
self.path.append(list(path))
|
|
|
|
def stroke(self, **params):
|
|
if len(self.path) == 0:
|
|
return
|
|
# search for path ending at new start coordinates to append this path to
|
|
xy0 = self.path[0][1:3]
|
|
for p in reversed(self.pathes):
|
|
if self.path[0][0] == "T":
|
|
break
|
|
xy1 = p.path[-1][1:3]
|
|
if points_equal(*xy0, *xy1):
|
|
# todo: check for same color and linewidth
|
|
p.path.extend(self.path[1:])
|
|
self.path = []
|
|
return p
|
|
p = Path(self.path, params)
|
|
self.pathes.append(p)
|
|
self.path = []
|
|
return p
|
|
|
|
def move_to(self, *xy):
|
|
if len(self.path) == 0:
|
|
self.path.append(["M", *xy])
|
|
elif self.path[-1][0] == "M":
|
|
self.path[-1] = ["M", *xy]
|
|
else:
|
|
xy0 = self.path[-1][1:3]
|
|
if not points_equal(*xy0, *xy):
|
|
self.path.append(["M", *xy])
|
|
|
|
|
|
class Path:
|
|
def __init__(self, path, params):
|
|
self.path = path
|
|
self.params = params
|
|
|
|
def __repr__(self):
|
|
l = len(self.path)
|
|
# x1,y1 = self.path[0][1:3]
|
|
if l>0:
|
|
x2, y2 = self.path[-1][1:3]
|
|
return f"Path[{l}] to ({x2:.2f},{y2:.2f})"
|
|
return f"empty Path"
|
|
|
|
def extents(self):
|
|
e = Extents()
|
|
for p in self.path:
|
|
e.add(*p[1:3])
|
|
if p[0] == 'T':
|
|
m, text, params = p[3:]
|
|
h = params['fs']
|
|
l = len(text) * h * 0.7
|
|
align = params.get('align', 'left')
|
|
start, end = {
|
|
'left' : (0, 1),
|
|
'middle' : (-0.5, 0.5),
|
|
'end' : (-1, 0),
|
|
}[align]
|
|
for x in (start*l, end*l):
|
|
for y in (0, h):
|
|
x_, y_ = m * (x, y)
|
|
e.add(x_, y_)
|
|
return e
|
|
|
|
def transform(self, f, m, invert_y=False):
|
|
self.params["lw"] *= f
|
|
for c in self.path:
|
|
C = c[0]
|
|
c[1], c[2] = m * (c[1], c[2])
|
|
if C == 'C':
|
|
c[3], c[4] = m * (c[3], c[4])
|
|
c[5], c[6] = m * (c[5], c[6])
|
|
if C == "T":
|
|
c[3] = m * c[3]
|
|
if invert_y:
|
|
c[3] *= Affine.scale(1, -1)
|
|
|
|
def faster_edges(self, inner_corners):
|
|
if inner_corners == "backarc":
|
|
return
|
|
|
|
for (i, p) in enumerate(self.path):
|
|
if p[0] == "C" and i > 1 and i < len(self.path) - 1:
|
|
if self.path[i - 1][0] == "L" and self.path[i + 1][0] == "L":
|
|
p11 = self.path[i - 2][1:3]
|
|
p12 = self.path[i - 1][1:3]
|
|
p21 = p[1:3]
|
|
p22 = self.path[i + 1][1:3]
|
|
if (((p12[0]-p21[0])**2 + (p12[1]-p21[1])**2) >
|
|
self.params["lw"]**2):
|
|
continue
|
|
lines_intersect, x, y = line_intersection((p11, p12), (p21, p22))
|
|
if lines_intersect:
|
|
self.path[i - 1] = ("L", x, y)
|
|
if inner_corners == "loop":
|
|
self.path[i] = ("C", x, y, *p12, *p21)
|
|
else:
|
|
self.path[i] = ("L", x, y)
|
|
# filter duplicates
|
|
if len(self.path) > 1: # no need to find duplicates if only one element in path
|
|
self.path = [p for n, p in enumerate(self.path) if p != self.path[n-1]]
|
|
|
|
class Context:
|
|
def __init__(self, surface, *al, **ad):
|
|
self._renderer = self._dwg = surface
|
|
|
|
self._bounds = Extents()
|
|
self._padding = PADDING
|
|
|
|
self._stack = []
|
|
self._m = Affine.translation(0, 0)
|
|
self._xy = (0, 0)
|
|
self._mxy = self._m * self._xy
|
|
self._lw = 0
|
|
self._rgb = (0, 0, 0)
|
|
self._ff = "sans-serif"
|
|
self._fs = 10
|
|
self._last_path = None
|
|
|
|
def _update_bounds_(self, mx, my):
|
|
self._bounds.update(mx, my)
|
|
|
|
def save(self):
|
|
self._stack.append(
|
|
(self._m, self._xy, self._lw, self._rgb, self._mxy, self._last_path)
|
|
)
|
|
self._xy = (0, 0)
|
|
|
|
def restore(self):
|
|
(
|
|
self._m,
|
|
self._xy,
|
|
self._lw,
|
|
self._rgb,
|
|
self._mxy,
|
|
self._last_path,
|
|
) = self._stack.pop()
|
|
|
|
## transformations
|
|
|
|
def translate(self, x, y):
|
|
self._m *= Affine.translation(x, y)
|
|
self._xy = (0, 0)
|
|
|
|
def scale(self, sx, sy):
|
|
self._m *= Affine.scale(sx, sy)
|
|
|
|
def rotate(self, r):
|
|
self._m *= Affine.rotation(180 * r / math.pi)
|
|
|
|
def set_line_width(self, lw):
|
|
self._lw = lw
|
|
|
|
def set_source_rgb(self, r, g, b):
|
|
self._rgb = (r, g, b)
|
|
|
|
## path methods
|
|
|
|
def _line_to(self, x, y):
|
|
self._add_move()
|
|
x1, y1 = self._mxy
|
|
self._xy = x, y
|
|
x2, y2 = self._mxy = self._m * self._xy
|
|
if not points_equal(x1, y1, x2, y2):
|
|
self._dwg.append("L", x2, y2)
|
|
|
|
def _add_move(self):
|
|
self._dwg.move_to(*self._mxy)
|
|
|
|
def move_to(self, x, y):
|
|
self._xy = (x, y)
|
|
self._mxy = self._m * self._xy
|
|
|
|
def line_to(self, x, y):
|
|
self._line_to(x, y)
|
|
|
|
def _arc(self, xc, yc, radius, angle1, angle2, direction):
|
|
if abs(angle1 - angle2) < EPS or radius < EPS:
|
|
return
|
|
x1, y1 = radius * math.cos(angle1) + xc, radius * math.sin(angle1) + yc
|
|
x4, y4 = radius * math.cos(angle2) + xc, radius * math.sin(angle2) + yc
|
|
|
|
# XXX direction seems not needed for small arcs
|
|
ax = x1 - xc
|
|
ay = y1 - yc
|
|
bx = x4 - xc
|
|
by = y4 - yc
|
|
q1 = ax * ax + ay * ay
|
|
q2 = q1 + ax * bx + ay * by
|
|
k2 = 4/3 * ((2 * q1 * q2)**0.5 - q2) / (ax * by - ay * bx)
|
|
|
|
x2 = xc + ax - k2 * ay
|
|
y2 = yc + ay + k2 * ax
|
|
x3 = xc + bx + k2 * by
|
|
y3 = yc + by - k2 * bx
|
|
|
|
mx1, my1 = self._m * (x1, y1)
|
|
mx2, my2 = self._m * (x2, y2)
|
|
mx3, my3 = self._m * (x3, y3)
|
|
mx4, my4 = self._m * (x4, y4)
|
|
mxc, myc = self._m * (xc, yc)
|
|
|
|
self._add_move()
|
|
self._dwg.append("C", mx4, my4, mx2, my2, mx3, my3)
|
|
self._xy = (x4, y4)
|
|
self._mxy = (mx4, my4)
|
|
|
|
def arc(self, xc, yc, radius, angle1, angle2):
|
|
self._arc(xc, yc, radius, angle1, angle2, 1)
|
|
|
|
def arc_negative(self, xc, yc, radius, angle1, angle2):
|
|
self._arc(xc, yc, radius, angle1, angle2, -1)
|
|
|
|
def curve_to(self, x1, y1, x2, y2, x3, y3):
|
|
# mx0,my0 = self._m*self._xy
|
|
mx1, my1 = self._m * (x1, y1)
|
|
mx2, my2 = self._m * (x2, y2)
|
|
mx3, my3 = self._m * (x3, y3)
|
|
self._add_move()
|
|
self._dwg.append("C", mx3, my3, mx1, my1, mx2, my2) # destination first!
|
|
self._xy = (x3, y3)
|
|
self._mxy = (mx3, my3)
|
|
|
|
def stroke(self):
|
|
# print('stroke stack-level=',len(self._stack),'lastpath=',self._last_path,)
|
|
self._last_path = self._dwg.stroke(rgb=self._rgb, lw=self._lw)
|
|
self._xy = (0, 0)
|
|
|
|
def fill(self):
|
|
self._xy = (0, 0)
|
|
raise NotImplementedError()
|
|
|
|
def set_font(self, style, bold=False, italic=False):
|
|
if style not in ("serif", "sans-serif", "monospaced"):
|
|
raise ValueError("Unknown font style")
|
|
self._ff = (style, bold, italic)
|
|
|
|
def set_font_size(self, fs):
|
|
self._fs = fs
|
|
|
|
def show_text(self, text, **args):
|
|
params = {"ff": self._ff, "fs": self._fs, "lw": self._lw, "rgb": self._rgb}
|
|
params.update(args)
|
|
mx0, my0 = self._m * self._xy
|
|
m = self._m
|
|
self._dwg.append("T", mx0, my0, m, text, params)
|
|
|
|
def text_extents(self, text):
|
|
fs = self._fs
|
|
# XXX ugly hack! Fix Boxes.text() !
|
|
return (0, 0, 0.6 * fs * len(text), 0.65 * fs, fs * 0.1, 0)
|
|
|
|
def rectangle(self, x, y, width, height):
|
|
|
|
# todo: better check for empty path?
|
|
self.stroke()
|
|
|
|
self.move_to(x, y)
|
|
self.line_to(x + width, y)
|
|
self.line_to(x + width, y + height)
|
|
self.line_to(x, y + height)
|
|
self.line_to(x, y)
|
|
self.stroke()
|
|
|
|
def get_current_point(self):
|
|
return self._xy
|
|
|
|
def flush(self):
|
|
pass
|
|
# todo: check, if needed
|
|
# self.stroke()
|
|
|
|
## additional methods
|
|
def new_part(self):
|
|
self._dwg.new_part()
|
|
|
|
|
|
class SVGSurface(Surface):
|
|
|
|
invert_y = True
|
|
|
|
fonts = {
|
|
'serif' : 'TimesNewRoman, "Times New Roman", Times, Baskerville, Georgia, serif',
|
|
'sans-serif' : '"Helvetica Neue", Helvetica, Arial, sans-serif',
|
|
'monospaced' : '"Courier New", Courier, "Lucida Sans Typewriter"'
|
|
}
|
|
|
|
def _addTag(self, parent, tag, text, first=False):
|
|
if first:
|
|
t = ET.Element(tag)
|
|
else:
|
|
t = ET.SubElement(parent, tag)
|
|
t.text = text
|
|
t.tail = '\n'
|
|
if first:
|
|
parent.insert(0, t)
|
|
return t
|
|
|
|
def _add_metadata(self, root):
|
|
md = self.metadata
|
|
|
|
# Add Inkscape style rdf meta data
|
|
root.set("xmlns:dc", "http://purl.org/dc/elements/1.1/")
|
|
root.set("xmlns:cc", "http://creativecommons.org/ns#")
|
|
root.set("xmlns:rdf","http://www.w3.org/1999/02/22-rdf-syntax-ns#")
|
|
|
|
title = "{group} - {name}".format(**md)
|
|
date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
m = self._addTag(root, "metadata", '\n', True)
|
|
r = ET.SubElement(m, 'rdf:RDF')
|
|
w = ET.SubElement(r, 'cc:Work')
|
|
w.text = '\n'
|
|
|
|
self._addTag(w, 'dc:title', title)
|
|
self._addTag(w, 'dc:date', date)
|
|
|
|
if "url" in md and md["url"]:
|
|
self._addTag(w, 'dc:source', md["url"])
|
|
else:
|
|
self._addTag(w, 'dc:source', md["cli"])
|
|
|
|
desc = md["short_description"] or ""
|
|
if "description" in md and md["description"]:
|
|
desc += "\n\n" + md["description"]
|
|
desc += "\n\nCreated with Boxes.py (https://festi.info/boxes.py)\n"
|
|
desc += "Command line: %s\n" % md["cli"]
|
|
if md["url"]:
|
|
desc += "Url: %s\n" % md["url"]
|
|
desc += "SettingsUrl: %s\n" % md["url"].replace("&render=1", "")
|
|
self._addTag(w, 'dc:description', desc)
|
|
|
|
# title
|
|
self._addTag(root, "title", md["name"], True)
|
|
|
|
# Add XML comment
|
|
txt = """
|
|
{name} - {short_description}
|
|
""".format(**md)
|
|
if md["description"]:
|
|
txt += """
|
|
|
|
{description}
|
|
|
|
""".format(**md)
|
|
txt += """
|
|
Created with Boxes.py (https://festi.info/boxes.py)
|
|
Creation date: {date}
|
|
""".format(date=date, **md)
|
|
|
|
txt += "Command line (remove spaces between dashes): %s\n" % md["cli"]
|
|
|
|
if md["url"]:
|
|
txt += "Url: %s\n" % md["url"]
|
|
txt += "SettingsUrl: %s\n" % md["url"].replace("&render=1", "")
|
|
m = ET.Comment(txt.replace("--", "- -").replace("--", "- -")) # ----
|
|
m.tail = '\n'
|
|
root.insert(0, m)
|
|
|
|
def finish(self, inner_corners="loop"):
|
|
extents = self._adjust_coordinates()
|
|
w = extents.width * self.scale
|
|
h = extents.height * self.scale
|
|
|
|
|
|
nsmap = {
|
|
"dc": "http://purl.org/dc/elements/1.1/",
|
|
"cc": "http://creativecommons.org/ns#",
|
|
"rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
|
|
"svg": "http://www.w3.org/2000/svg",
|
|
"xlink": "http://www.w3.org/1999/xlink",
|
|
"inkscape": "http://www.inkscape.org/namespaces/inkscape",
|
|
}
|
|
ET.register_namespace("", "http://www.w3.org/2000/svg")
|
|
ET.register_namespace("xlink", "http://www.w3.org/1999/xlink")
|
|
svg = ET.Element('svg', width=f"{w:.2f}mm", height=f"{h:.2f}mm",
|
|
viewBox=f"0.0 0.0 {w:.2f} {h:.2f}",
|
|
xmlns="http://www.w3.org/2000/svg")
|
|
for name, value in nsmap.items():
|
|
svg.set(f"xmlns:{name}", value)
|
|
svg.text = "\n"
|
|
tree = ET.ElementTree(svg)
|
|
|
|
self._add_metadata(svg)
|
|
|
|
for i, part in enumerate(self.parts):
|
|
if not part.pathes:
|
|
continue
|
|
g = ET.SubElement(svg, "g", id=f"p-{i}",
|
|
style="fill:none;stroke-linecap:round;stroke-linejoin:round;")
|
|
g.text = "\n "
|
|
g.tail = "\n"
|
|
for j, path in enumerate(part.pathes):
|
|
p = []
|
|
x, y = 0, 0
|
|
start = None
|
|
last = None
|
|
path.faster_edges(inner_corners)
|
|
for c in path.path:
|
|
x0, y0 = x, y
|
|
C, x, y = c[0:3]
|
|
if C == "M":
|
|
if start and points_equal(start[1], start[2],
|
|
last[1], last[2]):
|
|
p.append("Z")
|
|
start = c
|
|
p.append(f"M {x:.3f} {y:.3f}")
|
|
elif C == "L":
|
|
if abs(x - x0) < EPS:
|
|
p.append(f"V {y:.3f}")
|
|
elif abs(y - y0) < EPS:
|
|
p.append(f"H {x:.3f}")
|
|
else:
|
|
p.append(f"L {x:.3f} {y:.3f}")
|
|
elif C == "C":
|
|
x1, y1, x2, y2 = c[3:]
|
|
p.append(
|
|
f"C {x1:.3f} {y1:.3f} {x2:.3f} {y2:.3f} {x:.3f} {y:.3f}"
|
|
)
|
|
elif C == "T":
|
|
m, text, params = c[3:]
|
|
m = m * Affine.translation(0, -params['fs'])
|
|
tm = " ".join((f"{m[i]:.3f}" for i in (0, 3, 1, 4, 2, 5)))
|
|
font, bold, italic = params['ff']
|
|
fontweight = ("normal", "bold")[bool(bold)]
|
|
fontstyle = ("normal", "italic")[bool(italic)]
|
|
|
|
style = f"font-family: {font} ; font-weight: {fontweight}; font-style: {fontstyle}; fill: {rgb_to_svg_color(*params['rgb'])}"
|
|
t = ET.SubElement(g, "text",
|
|
#x=f"{x:.3f}", y=f"{y:.3f}",
|
|
transform=f"matrix( {tm} )",
|
|
style=style)
|
|
t.text = text
|
|
t.set("font-size", f"{params['fs']}px")
|
|
t.set("text-anchor", params.get('align', 'left'))
|
|
t.set("alignment-baseline", 'hanging')
|
|
else:
|
|
print("Unknown", c)
|
|
|
|
last = c
|
|
|
|
if start and start is not last and \
|
|
points_equal(start[1], start[2], last[1], last[2]):
|
|
p.append("Z")
|
|
color = (
|
|
random_svg_color()
|
|
if RANDOMIZE_COLORS
|
|
else rgb_to_svg_color(*path.params["rgb"])
|
|
)
|
|
if p and p[-1][0] == "M":
|
|
p.pop()
|
|
if p: # might be empty if only contains text
|
|
t = ET.SubElement(g, "path", d=" ".join(p), stroke=color)
|
|
t.set("stroke-width", f'{path.params["lw"]:.2f}')
|
|
t.tail = "\n "
|
|
t.tail = "\n"
|
|
tree.write(open(self._fname, "wb"), xml_declaration=True, method="xml")
|
|
|
|
class PSSurface(Surface):
|
|
|
|
scale = 72 / 25.4 # 72 dpi
|
|
|
|
fonts = {
|
|
('serif', False, False) : 'Times-Roman',
|
|
('serif', False, True) : 'Times-Italic',
|
|
('serif', True, False) : 'Times-Bold',
|
|
('serif', True, True) : 'Times-BoldItalic',
|
|
('sans-serif', False, False) : 'Helvetica',
|
|
('sans-serif', False, True) : 'Helvetica-Oblique',
|
|
('sans-serif', True, False) : 'Helvetica-Bold',
|
|
('sans-serif', True, True) : 'Helvetica-BoldOblique',
|
|
('monospaced', False, False) : 'Courier',
|
|
('monospaced', False, True) : 'Courier-Oblique',
|
|
('monospaced', True, False) : 'Courier-Bold',
|
|
('monospaced', True, True) : 'Courier-BoldOblique',
|
|
}
|
|
|
|
def _metadata(self):
|
|
md = self.metadata
|
|
|
|
desc = ""
|
|
desc += "%%Title: Boxes.py - {group} - {name}\n".format(**md)
|
|
desc += f'%%CreationDate: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}\n'
|
|
desc += f'%%Keywords: boxes.py, laser, laser cutter\n'
|
|
desc += f'%%Creator: {md.get("url") or md["cli"]}\n'
|
|
desc += "%%CreatedBy: Boxes.py (https://festi.info/boxes.py)\n"
|
|
for line in (md["short_description"] or "").split("\n"):
|
|
desc += "%% %s\n" % line
|
|
desc += "%\n"
|
|
if "description" in md and md["description"]:
|
|
desc += "%\n"
|
|
for line in md["description"].split("\n"):
|
|
desc += "%% %s\n" % line
|
|
desc += "%\n"
|
|
|
|
desc += "%% Command line: %s\n" % md["cli"]
|
|
if md["url"]:
|
|
desc += f'%%Url: {md["url"]}\n'
|
|
desc += f'%%SettingsUrl: {md["url"].replace("&render=1", "")}\n'
|
|
return desc
|
|
|
|
def finish(self, inner_corners="loop"):
|
|
|
|
extents = self._adjust_coordinates()
|
|
w = extents.width
|
|
h = extents.height
|
|
|
|
f = open(self._fname, "w", encoding="latin1", errors="replace")
|
|
|
|
f.write("%!PS-Adobe-2.0\n")
|
|
f.write(f"%%BoundingBox: 0 0 {w:.0f} {h:.0f}\n")
|
|
f.write(self._metadata())
|
|
f.write("""
|
|
1 setlinecap
|
|
1 setlinejoin
|
|
0.0 0.0 0.0 setrgbcolor
|
|
""")
|
|
f.write("""
|
|
/ReEncode { % inFont outFont encoding | -
|
|
/MyEncoding exch def
|
|
exch findfont
|
|
dup length dict
|
|
begin
|
|
{def} forall
|
|
/Encoding MyEncoding def
|
|
currentdict
|
|
end
|
|
definefont
|
|
} def
|
|
|
|
""")
|
|
for font in self.fonts.values():
|
|
f.write(f"/{font} /{font}-Latin1 ISOLatin1Encoding ReEncode\n")
|
|
# f.write(f"%%DocumentMedia: \d+x\d+mm ((\d+) (\d+)) 0 \("
|
|
# dwg['width']=f'{w:.2f}mm'
|
|
# dwg['height']=f'{h:.2f}mm'
|
|
|
|
for i, part in enumerate(self.parts):
|
|
if not part.pathes:
|
|
continue
|
|
for j, path in enumerate(part.pathes):
|
|
p = []
|
|
x, y = 0, 0
|
|
path.faster_edges(inner_corners)
|
|
|
|
for c in path.path:
|
|
x0, y0 = x, y
|
|
C, x, y = c[0:3]
|
|
if C == "M":
|
|
p.append(f"{x:.3f} {y:.3f} moveto")
|
|
elif C == "L":
|
|
p.append(f"{x:.3f} {y:.3f} lineto")
|
|
elif C == "C":
|
|
x1, y1, x2, y2 = c[3:]
|
|
p.append(
|
|
f"{x1:.3f} {y1:.3f} {x2:.3f} {y2:.3f} {x:.3f} {y:.3f} curveto"
|
|
)
|
|
elif C == "T":
|
|
m, text, params = c[3:]
|
|
tm = " ".join((f"{m[i]:.3f}" for i in (0, 3, 1, 4, 2, 5)))
|
|
text = text.replace("(", "r\(").replace(")", r"\)")
|
|
color = " ".join((f"{c:.2f}"
|
|
for c in params["rgb"]))
|
|
align = params.get('align', 'left')
|
|
f.write(f"/{self.fonts[params['ff']]}-Latin1 findfont\n")
|
|
f.write(f"{params['fs']} scalefont\n")
|
|
f.write("setfont\n")
|
|
#f.write(f"currentfont /Encoding ISOLatin1Encoding put\n")
|
|
f.write(f"{color} setrgbcolor\n")
|
|
f.write("matrix currentmatrix") # save current matrix
|
|
f.write(f"[ {tm} ] concat\n")
|
|
if align == "left":
|
|
f.write(f"0.0\n")
|
|
else:
|
|
f.write(f"({text}) stringwidth pop ")
|
|
if align == "middle":
|
|
f.write(f"-0.5 mul\n")
|
|
else: # end
|
|
f.write(f"neg\n")
|
|
# offset y by descender
|
|
f.write("currentfont dup /FontBBox get 1 get \n")
|
|
f.write("exch /FontMatrix get 3 get mul neg moveto \n")
|
|
|
|
f.write(f"({text}) show\n") # text created by dup above
|
|
f.write("setmatrix\n\n") # restore matrix
|
|
else:
|
|
print("Unknown", c)
|
|
color = (
|
|
random_svg_color()
|
|
if RANDOMIZE_COLORS
|
|
else rgb_to_svg_color(*path.params["rgb"])
|
|
)
|
|
if p: # todo: might be empty since text is not implemented yet
|
|
color = " ".join((f"{c:.2f}"
|
|
for c in path.params["rgb"]))
|
|
f.write("newpath\n")
|
|
f.write("\n".join(p))
|
|
f.write("\n")
|
|
f.write(f"{path.params['lw']} setlinewidth\n")
|
|
f.write(f"{color} setrgbcolor\n")
|
|
f.write("stroke\n\n")
|
|
f.write(
|
|
"""
|
|
showpage
|
|
%%Trailer
|
|
%%EOF
|
|
"""
|
|
)
|
|
f.close()
|
|
|
|
class LBRN2Surface(Surface):
|
|
|
|
|
|
invert_y = False
|
|
dbg = False
|
|
|
|
fonts = {
|
|
'serif' : 'Times New Roman',
|
|
'sans-serif' : 'Arial',
|
|
'monospaced' : 'Courier New'
|
|
}
|
|
|
|
def finish(self, inner_corners="loop"):
|
|
if self.dbg: print("LBRN2 save")
|
|
extents = self._adjust_coordinates()
|
|
w = extents.width * self.scale
|
|
h = extents.height * self.scale
|
|
|
|
svg = ET.Element('LightBurnProject', AppVersion="1.0.06", FormatVersion="1", MaterialHeight="0", MirrorX="False", MirrorY="False")
|
|
svg.text = "\n"
|
|
num = 0
|
|
txtOffset = {}
|
|
|
|
tree = ET.ElementTree(svg)
|
|
if self.dbg: print ("8", num)
|
|
|
|
for i, part in enumerate(self.parts):
|
|
if self.dbg: print ("7", num)
|
|
if not part.pathes:
|
|
continue
|
|
gp = ET.SubElement(svg, "Shape", Type="Group")
|
|
gp.text = "\n "
|
|
gp.tail = "\n"
|
|
children = ET.SubElement(gp, "Children")
|
|
children.text = "\n "
|
|
children.tail = "\n"
|
|
|
|
for j, path in enumerate(part.pathes):
|
|
Color = 2*int(path.params["rgb"][0])+4*int(path.params["rgb"][1])+int(path.params["rgb"][2])
|
|
if Color == 4: # 4 is yellow in Lightburn
|
|
Color = 3 # use green instead
|
|
p = []
|
|
x, y = 0, 0
|
|
C = ""
|
|
start = None
|
|
last = None
|
|
path.faster_edges(inner_corners)
|
|
num = 0
|
|
cnt = 1
|
|
ende = len(path.path)-1
|
|
if self.dbg:
|
|
for c in path.path:
|
|
print ("6",num, c)
|
|
num += 1
|
|
num = 0
|
|
|
|
c = path.path[num]
|
|
C, x, y = c[0:3]
|
|
if self.dbg: print("ende:" ,ende)
|
|
while num < ende or (C == "T" and num <= ende): #len(path.path):
|
|
if self.dbg: print ("0", num)
|
|
c = path.path[num]
|
|
if self.dbg: print("first: ", num, c)
|
|
|
|
C, x, y = c[0:3]
|
|
if C == "M":
|
|
if self.dbg: print ("1", num)
|
|
sh = ET.SubElement(children, "Shape", Type="Path", CutIndex=str(Color))
|
|
sh.text = "\n "
|
|
sh.tail = "\n"
|
|
vl = ET.SubElement(sh, "VertList")
|
|
vl.text = f"V{x:.3f} {y:.3f}c0x1c1x1"
|
|
vl.tail = "\n"
|
|
pl = ET.SubElement(sh, "PrimList")
|
|
pl.text = ""#f"L{cnt} {cnt+1}"
|
|
pl.tail = "\n"
|
|
start = c
|
|
x0, y0 = x, y
|
|
# do something with M
|
|
done = False
|
|
bspline = False
|
|
while done == False and num < ende: #len(path.path):
|
|
num += 1
|
|
c = path.path[num]
|
|
if self.dbg: print ("next: ",num, c)
|
|
C, x, y = c[0:3]
|
|
if C == "M":
|
|
if start and points_equal(start[1], start[2], x, y):
|
|
pl.text = "LineClosed"
|
|
start = c
|
|
cnt = 1
|
|
if self.dbg: print ("next, because M")
|
|
done = True
|
|
elif C == "T":
|
|
if self.dbg: print ("next, because T")
|
|
done = True
|
|
else:
|
|
if C == "L":
|
|
vl.text+=(f"V{x:.3f} {y:.3f}c0x1c1x1")
|
|
pl.text += f"L{cnt-1} {cnt}"
|
|
cnt +=1
|
|
elif C == "C":
|
|
x1, y1, x2, y2 = c[3:]
|
|
if self.dbg: print ("C: ",x0, y0, x1, y1, x, y, x2, y2)
|
|
vl.text+=(f"V{x0:.3f} {y0:.3f}c0x{(x1):.3f}c0y{(y1):.3f}c1x1V{x:.3f} {y:.3f}c0x1c1x{(x2):.3f}c1y{(y2):.3f}")
|
|
pl.text += f"L{cnt-1} {cnt}B{cnt} {cnt+1}"
|
|
cnt +=2
|
|
bspline = True
|
|
else:
|
|
print("unknown", c)
|
|
if done == False:
|
|
x0, y0 = x, y
|
|
|
|
if start and points_equal(start[1], start[2], x0, y0):
|
|
if bspline == False:
|
|
pl.text = "LineClosed"
|
|
start = c
|
|
if self.dbg: print ("2", num)
|
|
elif C == "T":
|
|
cnt = 1
|
|
#C = ""
|
|
if self.dbg: print ("3", num)
|
|
m, text, params = c[3:]
|
|
m = m * Affine.translation(0, params['fs'])
|
|
if self.dbg: print ("T: ",x, y, c)
|
|
num += 1
|
|
font, bold, italic = params['ff']
|
|
if params.get('font', 'Arial')=='Arial':
|
|
f = self.fonts[font]
|
|
else:
|
|
f = params.get('font', 'Arial')
|
|
fontColor = 2*int(params['rgb'][0])+4*int(params['rgb'][1])+int(params['rgb'][2])
|
|
if fontColor == 4: # 4 is yellow in Lightburn
|
|
fontColor = 3 # use green instead
|
|
|
|
#alignment can be left|middle|end
|
|
if params.get('align', 'left')=='middle':
|
|
hor = '1'
|
|
else:
|
|
if params.get('align', 'left')=='end':
|
|
hor = '2'
|
|
else:
|
|
hor = '0'
|
|
ver = 2 # vertical is always bottom, text is shifted in box class
|
|
|
|
pos = text.find('%')
|
|
offs = 0
|
|
if pos >- 1:
|
|
if self.dbg: print ("p: ", pos, text[pos+1:pos+3])
|
|
texttype = '2'
|
|
if self.dbg: print("l ", len(text[pos+1:pos+3]))
|
|
if text[pos+1:pos+2].isnumeric():
|
|
if self.dbg: print ("t0", text[pos+1:pos+3])
|
|
if text[pos+1:pos+3].isnumeric() and len(text[pos+1:pos+3]) == 2:
|
|
if self.dbg: print ("t1")
|
|
if text[pos:pos+3] in txtOffset:
|
|
if self.dbg: print ("t2")
|
|
offs = txtOffset[text[pos:pos+3]] + 1
|
|
else:
|
|
if self.dbg: print ("t3")
|
|
offs = 0
|
|
txtOffset[text[pos:pos+3]] = offs
|
|
else:
|
|
if self.dbg: print ("t4")
|
|
if text[pos:pos+2] in txtOffset:
|
|
if self.dbg: print ("t5")
|
|
offs = txtOffset[text[pos:pos+2]] + 1
|
|
else:
|
|
offs = 0
|
|
if self.dbg: print ("t6")
|
|
txtOffset[text[pos:pos+2]] = offs
|
|
else:
|
|
if self.dbg: print ("t7")
|
|
texttype = '0'
|
|
else:
|
|
texttype = '0'
|
|
if self.dbg: print ("t8")
|
|
if self.dbg: print ("o: ", text, txtOffset, offs)
|
|
|
|
if not text:
|
|
if self.dbg: print ("T: text with empty string - ",x, y, c)
|
|
else:
|
|
sh = ET.SubElement(children, "Shape", Type="Text", CutIndex=str(fontColor), Font=f"{f}", H=f"{(params['fs']*1.75*0.6086434):.3f}", Str=f"{text}", Bold=f"{'1' if bold else '0'}", Italic=f"{'1' if italic else '0'}", Ah=f"{str(hor)}", Av=f"{str(ver)}", Eval=f"{texttype}", VariableOffset=f"{str(offs)}") # 1mm = 1.75 Lightburn H units
|
|
sh.text = "\n "
|
|
sh.tail = "\n"
|
|
xf = ET.SubElement(sh, "XForm")
|
|
xf.text = " ".join((f"{m[i]:.3f}" for i in (0, 3, 1, 4, 2, 5)))
|
|
xf.tail = "\n"
|
|
else:
|
|
if self.dbg: print ("4", num)
|
|
print ("next, because not M")
|
|
num += 1
|
|
|
|
url = self.metadata["url"].replace("&render=1", "") # remove render argument to get web form again
|
|
|
|
pl = ET.SubElement(svg, "Notes", ShowOnLoad="1", Notes="File created by Boxes.py script, programmed by Florian Festi.\nLightburn output by Klaus Steinhammer.\n\nURL with settings:\n" + str(url))
|
|
pl.text = ""
|
|
pl.tail = "\n"
|
|
|
|
if self.dbg: print ("5", num)
|
|
tree.write(open(self._fname, "wb"), xml_declaration=True, method="xml", encoding="UTF-8")
|
|
from random import random
|
|
|
|
|
|
def random_svg_color():
|
|
r, g, b = random(), random(), random()
|
|
return f"rgb({r*255:.0f},{g*255:.0f},{b*255:.0f})"
|
|
|
|
|
|
def rgb_to_svg_color(r, g, b):
|
|
return f"rgb({r*255:.0f},{g*255:.0f},{b*255:.0f})"
|
|
|
|
|
|
def line_intersection(line1, line2):
|
|
|
|
xdiff = (line1[0][0] - line1[1][0], line2[0][0] - line2[1][0])
|
|
ydiff = (line1[0][1] - line1[1][1], line2[0][1] - line2[1][1])
|
|
|
|
def det(a, b):
|
|
return a[0] * b[1] - a[1] * b[0]
|
|
|
|
div = det(xdiff, ydiff)
|
|
if div == 0:
|
|
# todo: deal with paralel line intersection / overlay
|
|
return False, None, None
|
|
|
|
d = (det(*line1), det(*line2))
|
|
x = det(d, xdiff) / div
|
|
y = det(d, ydiff) / div
|
|
|
|
on_segments = (
|
|
(x + EPS >= min(line1[0][0], line1[1][0])),
|
|
(x + EPS >= min(line2[0][0], line2[1][0])),
|
|
(x - EPS <= max(line1[0][0], line1[1][0])),
|
|
(x - EPS <= max(line2[0][0], line2[1][0])),
|
|
(y + EPS >= min(line1[0][1], line1[1][1])),
|
|
(y + EPS >= min(line2[0][1], line2[1][1])),
|
|
(y - EPS <= max(line1[0][1], line1[1][1])),
|
|
(y - EPS <= max(line2[0][1], line2[1][1])),
|
|
)
|
|
|
|
return min(on_segments), x, y
|