diff --git a/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.inx b/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.inx
new file mode 100644
index 0000000..07a5948
--- /dev/null
+++ b/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.inx
@@ -0,0 +1,14 @@
+
+
+ AI compatible EPS output
+ fablabchemnitz.de.ai_compatible_eps_output
+
+
+
\ No newline at end of file
diff --git a/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.py b/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.py
new file mode 100644
index 0000000..a29d1ac
--- /dev/null
+++ b/extensions/fablabchemnitz/ai_compatible_eps_output/ai_compatible_eps_output.py
@@ -0,0 +1,1190 @@
+#!/usr/bin/env python3
+"""
+Mainly written by Andras Prim github_at_primandras.hu
+
+Arc to bezier converting method is ported from:
+http://code.google.com/p/core-framework/source/browse/trunk/plugins/svg.js
+written by Angel Kostadinov, with MIT license
+"""
+
+try:
+ from lxml import etree as ET
+except Exception:
+ import xml.etree.ElementTree as ET
+
+import math
+import re
+import sys
+
+def wrap(text, width):
+ """ A word-wrap function that preserves existing line breaks """
+ retstr = ""
+ for word in text.split(' '):
+ if len(retstr)-retstr.rfind('\n')-1 + len(word.split('\n',1)[0]) >= width:
+ retstr += ' \n' + word
+ else:
+ retstr += ' ' + word
+ return retstr
+
+def css2dict(css):
+ """returns a dictionary representing the given css string"""
+ cssdict = {}
+ if None == css:
+ return cssdict
+ for pair in css.split(';'): #TODO: what about escaped separators
+ if pair.find(':') >= 0:
+ key, value = pair.split(':')
+ cssdict[ key.strip() ] = value.strip()
+ return cssdict
+
+def cssColor2Eps(cssColor, colors='RGB'):
+ """converts css color definition (a hexa code with leading # or 'rgb()')
+ to eps color definition"""
+ if '#' == cssColor[0]:
+ r = float(int(cssColor[1:3],16)) / 255
+ g = float(int(cssColor[3:5],16)) / 255
+ b = float(int(cssColor[5:7],16)) / 255
+ else:
+ # assume 'rgb()' color
+ rgb = re.sub('[^0-9]+', ' ', cssColor).strip().split()
+ r = float(int(rgb[0], 10)) / 255
+ g = float(int(rgb[1], 10)) / 255
+ b = float(int(rgb[2], 10)) / 255
+
+ if colors == 'RGB':
+ return "%f %f %f" % (r, g, b)
+ elif colors == 'CMYKRGB':
+ if (r == 0) and (g == 0) and (b == 0):
+ c = 0
+ m = 0
+ y = 0
+ k = 1
+ else:
+ c = 1 - r
+ m = 1 - g
+ y = 1 - b
+
+ # extract out k [0,1]
+ min_cmy = min(c, m, y)
+ c = (c - min_cmy) / (1 - min_cmy)
+ m = (m - min_cmy) / (1 - min_cmy)
+ y = (y - min_cmy) / (1 - min_cmy)
+ k = min_cmy
+
+ return "%f %f %f %f %f %f %f" % (c, m, y, k, r, g, b)
+
+class Point:
+ """Class representing a 2D point"""
+ def __init__(self, x, y, relativeTo = None):
+ self.x = float(x)
+ self.y = float(y)
+ if isinstance(relativeTo, Point):
+ self.x += relativeTo.x
+ self.y += relativeTo.y
+
+ def get_distance(self, otherPoint):
+ """Returns the distance between this and the other point"""
+ return math.hypot(self.x - otherPoint.x, self.y - otherPoint.y)
+
+ def get_angle(self, otherPoint):
+ """Returns the angle of the vector pointing from this to the other point"""
+ deltax = otherPoint.x - self.x
+ deltay = otherPoint.y - self.y
+ return math.atan2(deltay, deltax) * 180 / math.pi
+
+ def get_manhattan_distance(self, otherPoint):
+ """Returns the manhattan distance of this and the other point"""
+ return abs(self.x - otherPoint.x) + abs(self.y - otherPoint.y)
+
+class TransformationMatrix:
+ """Class representing a 2D transformation matrix"""
+ def __init__(self, matrix = (1, 0, 0, 1, 0, 0)):
+ self.matrix = matrix
+
+ def multiply(self, matrix):
+ return TransformationMatrix((
+ self.matrix[0] * matrix[0] + self.matrix[2] * matrix[1], # + self.matrix[4] * 0
+ self.matrix[1] * matrix[0] + self.matrix[3] * matrix[1], # + self.matrix[5] * 0
+ self.matrix[0] * matrix[2] + self.matrix[2] * matrix[3], # + self.matrix[4] * 0
+ self.matrix[1] * matrix[2] + self.matrix[3] * matrix[3], # + self.matrix[5] * 0
+ self.matrix[0] * matrix[4] + self.matrix[2] * matrix[5] + self.matrix[4],
+ self.matrix[1] * matrix[4] + self.matrix[3] * matrix[5] + self.matrix[5],
+ ))
+
+ def translate(self, tx, ty):
+ return self.multiply((1, 0, 0, 1, tx, ty))
+
+ def scale(self, sx, sy):
+ return self.multiply((sx, 0, 0, sy, 0, 0))
+
+ def rotate(self, alphaDegree, cx, cy):
+ """Applies alpha degree rotation around cx, cy center point to the matrix"""
+ alphaRadian = math.radians(alphaDegree)
+ rotateMatrix = (
+ math.cos(alphaRadian), math.sin(alphaRadian),
+ -math.sin(alphaRadian), math.cos(alphaRadian),
+ 0, 0
+ )
+ if cx == 0 and cy == 0:
+ return self.multiply(rotateMatrix)
+
+ newMatrix = self.multiply((1, 0, 0, 1, cx, cy)) # compensate for center
+ newMatrix = newMatrix.multiply(rotateMatrix)
+
+ return newMatrix.multiply((1, 0, 0, 1, -cx, -cy)) # compensate back for center
+
+class TransformationMatrixStack:
+ """2D transformation matrix stack"""
+ def __init__(self, matrix = None):
+ self.matrices = [matrix if matrix != None else TransformationMatrix()]
+
+ def push_matrix_multiply(self, matrix):
+ """Matrix multiplies the current matrix with the passed one, and pushes it on the stack"""
+ currentMatrix = self.matrices[-1]
+ transformedMatrix = currentMatrix.multiply(matrix.matrix)
+ self.matrices.append(transformedMatrix)
+
+ def pop(self):
+ """Removes last matrix from stack"""
+ assert len(self.matrices) > 1, "Cannot pop last matrix from stack"
+ self.matrices.pop()
+
+ def transform_point(self, point):
+ """Transforms the passed point using the current transformation matrix"""
+ # todo: move to TransformationMatrix
+ matrix = self.matrices[-1].matrix
+ transformedX = matrix[0] * point.x + matrix[2] * point.y + matrix[4]
+ transformedY = matrix[1] * point.x + matrix[3] * point.y + matrix[5]
+
+ return Point(transformedX, transformedY)
+
+ def transform_length(self, length):
+ """Transforms the passed length using the current transformation matrix"""
+ # todo: move to TransformationMatrix
+ matrix = self.matrices[-1].matrix
+ transformedX = matrix[0] * length
+ transformedY = matrix[1] * length
+
+ return math.sqrt(transformedX ** 2 + transformedY ** 2)
+
+class svg2eps:
+ def __init__(self, filename=None):
+ self.filename = filename
+ self.svg = None
+ self.rePathDSplit = re.compile('[^a-zA-Z0-9.-]+')
+ self.reTransformFind = re.compile('([a-z]+)\\(([^)]+)\\)')
+ self.reNumberFind = re.compile('[0-9.eE+-]+')
+ # must update reNumberUnitFind, if e is a valid character in a unit
+ self.reNumberUnitFind = re.compile('([0-9.eE+-]+)([a-z]*)')
+ # px to pt conversion rate varies based on inkscape versions, it is added during parsing
+ self.toPt = {'in': 72.0, 'pt': 1.0, 'mm': 2.8346456695, 'cm': 28.346456695, 'm': 2834.6456695, 'pc': 12.0}
+
+ def unitConv(self, string, toUnit):
+ match = self.reNumberUnitFind.search(string)
+ number = float(match.group(1))
+ unit = match.group(2)
+ if unit not in self.toPt:
+ unit = 'uu'
+
+ if unit == toUnit:
+ return number
+ else:
+ return number * self.toPt[unit] / self.toPt[toUnit]
+
+ def coordConv(self, point):
+ """converts svgx, svgy coordinates to eps coordinates using the current transformation matrix"""
+ return self.matrices.transform_point(point)
+
+ def alert(self, string, elem):
+ """adds an alert to the collection"""
+ if not string in self.alerts:
+ self.alerts[string] = set()
+ elemId = elem.get('id')
+ if elemId != None:
+ self.alerts[string].add(elemId)
+
+ def showAlerts(self):
+ """show alerts collected by the alert() function"""
+ for string, ids in self.alerts.iteritems():
+ idstring = ', '.join(ids)
+ print(string, idstring)
+
+ def elemSvg(self, elem):
+ """handles the