diff options
Diffstat (limited to 'share/extensions/dxf_outlines.py')
| -rwxr-xr-x | share/extensions/dxf_outlines.py | 332 |
1 files changed, 332 insertions, 0 deletions
diff --git a/share/extensions/dxf_outlines.py b/share/extensions/dxf_outlines.py new file mode 100755 index 0000000..7217e75 --- /dev/null +++ b/share/extensions/dxf_outlines.py @@ -0,0 +1,332 @@ +#!/usr/bin/env python +# coding=utf-8 +# +# Copyright (C) 2005,2007,2008 Aaron Spike, aaron@ekips.org +# Copyright (C) 2008,2010 Alvin Penner, penner@vaxxine.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. +# +""" +This file output script for Inkscape creates a AutoCAD R14 DXF file. +The spec can be found here: http://www.autodesk.com/techpubs/autocad/acadr14/dxf/index.htm. + + File history: + - template dxf_outlines.dxf added Feb 2008 by Alvin Penner +- ROBO-Master output option added Aug 2008 +- ROBO-Master multispline output added Sept 2008 +- LWPOLYLINE output modification added Dec 2008 +- toggle between LINE/LWPOLYLINE added Jan 2010 +- support for transform elements added July 2010 +- support for layers added July 2010 +- support for rectangle added Dec 2010 +""" + +from __future__ import print_function + +import inkex +from inkex import colors, bezier, Transform, Group, Layer, Use, PathElement, \ + Rectangle, Line, Circle, Ellipse + + +def get_matrix(u, i, j): + if j == i + 2: + return (u[i]-u[i-1])*(u[i]-u[i-1])/(u[i+2]-u[i-1])/(u[i+1]-u[i-1]) + elif j == i + 1: + return ((u[i]-u[i-1])*(u[i+2]-u[i])/(u[i+2]-u[i-1]) \ + + (u[i+1]-u[i])*(u[i]-u[i-2])/(u[i+1]-u[i-2]))/(u[i+1]-u[i-1]) + elif j == i: + return (u[i+1]-u[i])*(u[i+1]-u[i])/(u[i+1]-u[i-2])/(u[i+1]-u[i-1]) + else: + return 0 + +def get_fit(u, csp, col): + return (1-u)**3*csp[0][col] + 3*(1-u)**2*u*csp[1][col] \ + + 3*(1-u)*u**2*csp[2][col] + u**3*csp[3][col] + +class DxfOutlines(inkex.OutputExtension): + def add_arguments(self, pars): + pars.add_argument("--tab") + pars.add_argument("-R", "--ROBO", type=inkex.Boolean, default=False) + pars.add_argument("-P", "--POLY", type=inkex.Boolean, default=False) + pars.add_argument("--units", default="72./96") # Points + pars.add_argument("--encoding", dest="char_encode", default="latin_1") + pars.add_argument("--layer_option", default="all") + pars.add_argument("--layer_name") + + self.dxf = [] + self.handle = 255 # handle for DXF ENTITY + self.layers = ['0'] + self.layer = '0' # mandatory layer + self.layernames = [] + self.csp_old = [[0.0, 0.0]] * 4 # previous spline + self.d = [0.0] # knot vector + self.poly = [[0.0, 0.0]] # LWPOLYLINE data + + def save(self, stream): + stream.write(b''.join(self.dxf)) + + def dxf_add(self, str): + self.dxf.append(str.encode(self.options.char_encode)) + + def dxf_line(self, csp): + """Draw a line in the DXF format""" + self.handle += 1 + self.dxf_add(" 0\nLINE\n 5\n%x\n100\nAcDbEntity\n 8\n%s\n 62\n%d\n100\nAcDbLine\n" % (self.handle, self.layer, self.color)) + self.dxf_add(" 10\n%f\n 20\n%f\n 30\n0.0\n 11\n%f\n 21\n%f\n 31\n0.0\n" % (csp[0][0], csp[0][1], csp[1][0], csp[1][1])) + + def LWPOLY_line(self, csp): + if (abs(csp[0][0] - self.poly[-1][0]) > .0001 + or abs(csp[0][1] - self.poly[-1][1]) > .0001 + or self.color_LWPOLY != self.color): # THIS LINE IS NEW + self.LWPOLY_output() # terminate current polyline + self.poly = [csp[0]] # initiallize new polyline + self.color_LWPOLY = self.color + self.layer_LWPOLY = self.layer + self.poly.append(csp[1]) + + def LWPOLY_output(self): + if len(self.poly) == 1: + return + self.handle += 1 + closed = 1 + if (abs(self.poly[0][0] - self.poly[-1][0]) > .0001 + or abs(self.poly[0][1] - self.poly[-1][1]) > .0001): + closed = 0 + self.dxf_add(" 0\nLWPOLYLINE\n 5\n%x\n100\nAcDbEntity\n 8\n%s\n 62\n%d\n100\nAcDbPolyline\n 90\n%d\n 70\n%d\n" % (self.handle, self.layer_LWPOLY, self.color_LWPOLY, len(self.poly) - closed, closed)) + for i in range(len(self.poly) - closed): + self.dxf_add(" 10\n%f\n 20\n%f\n 30\n0.0\n" % (self.poly[i][0], self.poly[i][1])) + + def dxf_spline(self, csp): + knots = 8 + ctrls = 4 + self.handle += 1 + self.dxf_add(" 0\nSPLINE\n 5\n%x\n100\nAcDbEntity\n 8\n%s\n 62\n%d\n100\nAcDbSpline\n" % (self.handle, self.layer, self.color)) + self.dxf_add(" 70\n8\n 71\n3\n 72\n%d\n 73\n%d\n 74\n0\n" % (knots, ctrls)) + for i in range(2): + for j in range(4): + self.dxf_add(" 40\n%d\n" % i) + for i in csp: + self.dxf_add(" 10\n%f\n 20\n%f\n 30\n0.0\n" % (i[0], i[1])) + + def ROBO_spline(self, csp): + """this spline has zero curvature at the endpoints, as in ROBO-Master""" + if (abs(csp[0][0] - self.csp_old[3][0]) > .0001 + or abs(csp[0][1] - self.csp_old[3][1]) > .0001 + or abs((csp[1][1] - csp[0][1]) * (self.csp_old[3][0] - self.csp_old[2][0]) - (csp[1][0] - csp[0][0]) * (self.csp_old[3][1] - self.csp_old[2][1])) > .001): + self.ROBO_output() # terminate current spline + self.xfit = [csp[0][0]] # initiallize new spline + self.yfit = [csp[0][1]] + self.d = [0.0] + self.color_ROBO = self.color + self.layer_ROBO = self.layer + self.xfit += 3 * [0.0] + self.yfit += 3 * [0.0] + self.d += 3 * [0.0] + for i in range(1, 4): + j = len(self.d) + i - 4 + self.xfit[j] = get_fit(i / 3.0, csp, 0) + self.yfit[j] = get_fit(i / 3.0, csp, 1) + self.d[j] = self.d[j - 1] + bezier.pointdistance((self.xfit[j - 1], self.yfit[j - 1]), (self.xfit[j], self.yfit[j])) + self.csp_old = csp + + def ROBO_output(self): + try: + import numpy + from numpy.linalg import solve + except ImportError: + inkex.errormsg("Failed to import the numpy or numpy.linalg modules. These modules are required by the ROBO option. Please install them and try again.") + return + + if len(self.d) == 1: + return + fits = len(self.d) + ctrls = fits + 2 + knots = ctrls + 4 + self.xfit += 2 * [0.0] # pad with 2 endpoint constraints + self.yfit += 2 * [0.0] + self.d += 6 * [0.0] # pad with 3 duplicates at each end + self.d[fits + 2] = self.d[fits + 1] = self.d[fits] = self.d[fits - 1] + + solmatrix = numpy.zeros((ctrls, ctrls), dtype=float) + for i in range(fits): + solmatrix[i, i] = get_matrix(self.d, i, i) + solmatrix[i, i + 1] = get_matrix(self.d, i, i + 1) + solmatrix[i, i + 2] = get_matrix(self.d, i, i + 2) + solmatrix[fits, 0] = self.d[2] / self.d[fits - 1] # curvature at start = 0 + solmatrix[fits, 1] = -(self.d[1] + self.d[2]) / self.d[fits - 1] + solmatrix[fits, 2] = self.d[1] / self.d[fits - 1] + solmatrix[fits + 1, fits - 1] = (self.d[fits - 1] - self.d[fits - 2]) / self.d[fits - 1] # curvature at end = 0 + solmatrix[fits + 1, fits] = (self.d[fits - 3] + self.d[fits - 2] - 2 * self.d[fits - 1]) / self.d[fits - 1] + solmatrix[fits + 1, fits + 1] = (self.d[fits - 1] - self.d[fits - 3]) / self.d[fits - 1] + xctrl = solve(solmatrix, self.xfit) + yctrl = solve(solmatrix, self.yfit) + self.handle += 1 + self.dxf_add(" 0\nSPLINE\n 5\n%x\n100\nAcDbEntity\n 8\n%s\n 62\n%d\n100\nAcDbSpline\n" % (self.handle, self.layer_ROBO, self.color_ROBO)) + self.dxf_add(" 70\n0\n 71\n3\n 72\n%d\n 73\n%d\n 74\n%d\n" % (knots, ctrls, fits)) + for i in range(knots): + self.dxf_add(" 40\n%f\n" % self.d[i - 3]) + for i in range(ctrls): + self.dxf_add(" 10\n%f\n 20\n%f\n 30\n0.0\n" % (xctrl[i], yctrl[i])) + for i in range(fits): + self.dxf_add(" 11\n%f\n 21\n%f\n 31\n0.0\n" % (self.xfit[i], self.yfit[i])) + + def process_shape(self, node, mat): + rgb = (0, 0, 0) + style = node.get('style') + if style: + style = dict(inkex.Style.parse_str(style)) + if 'stroke' in style: + if style['stroke'] and style['stroke'] != 'none' and style['stroke'][0:3] != 'url': + rgb = inkex.Color(style['stroke']).to_rgb() + hsl = colors.rgb_to_hsl(rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0) + self.color = 7 # default is black + if hsl[2]: + self.color = 1 + (int(6 * hsl[0] + 0.5) % 6) # use 6 hues + + if not isinstance(node, (PathElement, Rectangle, Line, Circle, Ellipse)): + return + + # Transforming /after/ superpath is more reliable than before + # because of some issues with arcs in transformations + for sub in node.path.to_superpath().transform(Transform(mat) * node.transform): + for i in range(len(sub) - 1): + s = sub[i] + e = sub[i + 1] + if s[1] == s[2] and e[0] == e[1]: + if self.options.POLY: + self.LWPOLY_line([s[1], e[1]]) + else: + self.dxf_line([s[1], e[1]]) + elif self.options.ROBO: + self.ROBO_spline([s[1], s[2], e[0], e[1]]) + else: + self.dxf_spline([s[1], s[2], e[0], e[1]]) + + def process_clone(self, node): + """Process a clone node, looking for internal paths""" + trans = node.get('transform') + x = node.get('x') + y = node.get('y') + mat = Transform([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) + if trans: + mat *= Transform(trans) + if x: + mat *= Transform([[1.0, 0.0, float(x)], [0.0, 1.0, 0.0]]) + if y: + mat *= Transform([[1.0, 0.0, 0.0], [0.0, 1.0, float(y)]]) + # push transform + if trans or x or y: + self.groupmat.append(Transform(self.groupmat[-1]) * mat) + # get referenced node + refid = node.get('xlink:href') + refnode = self.svg.getElementById(refid[1:]) + if refnode is not None: + if isinstance(refnode, Group): + self.process_group(refnode) + elif isinstance(refnode, Use): + self.process_clone(refnode) + else: + self.process_shape(refnode, self.groupmat[-1]) + # pop transform + if trans or x or y: + self.groupmat.pop() + + def process_group(self, group): + """Process group elements""" + if isinstance(group, Layer): + style = group.style + if style.get('display', '') == 'none' and self.options.layer_option and self.options.layer_option == 'visible': + return + layer = group.label + if self.options.layer_name and self.options.layer_option == 'name': + if not layer.lower() in self.options.layer_name: + return + + layer = layer.replace(' ', '_') + if layer in self.layers: + self.layer = layer + trans = group.get('transform') + if trans: + self.groupmat.append(Transform(self.groupmat[-1]) * Transform(trans)) + for node in group: + if isinstance(node, Group): + self.process_group(node) + elif isinstance(node, Use): + self.process_clone(node) + else: + self.process_shape(node, self.groupmat[-1]) + if trans: + self.groupmat.pop() + + def effect(self): + # Warn user if name match field is empty + if self.options.layer_option and self.options.layer_option == 'name' and not self.options.layer_name: + return inkex.errormsg("Error: Field 'Layer match name' must be filled when using 'By name match' option") + + # Split user layer data into a list: "layerA,layerb,LAYERC" becomes ["layera", "layerb", "layerc"] + if self.options.layer_name: + self.options.layer_name = self.options.layer_name.lower().split(',') + + # References: Minimum Requirements for Creating a DXF File of a 3D Model By Paul Bourke + # NURB Curves: A Guide for the Uninitiated By Philip J. Schneider + # The NURBS Book By Les Piegl and Wayne Tiller (Springer, 1995) + # self.dxf_add("999\nDXF created by Inkscape\n") # Some programs do not take comments in DXF files (KLayout 0.21.12 for example) + with open(self.get_resource('dxf14_header.txt'), 'r') as fhl: + self.dxf_add(fhl.read()) + for node in self.svg.xpath('//svg:g'): + if isinstance(node, Layer): + layer = node.label + self.layernames.append(layer.lower()) + if self.options.layer_name and self.options.layer_option and self.options.layer_option == 'name' and not layer.lower() in self.options.layer_name: + continue + layer = layer.replace(' ', '_') + if layer and layer not in self.layers: + self.layers.append(layer) + self.dxf_add(" 2\nLAYER\n 5\n2\n100\nAcDbSymbolTable\n 70\n%s\n" % len(self.layers)) + for i in range(len(self.layers)): + self.dxf_add(" 0\nLAYER\n 5\n%x\n100\nAcDbSymbolTableRecord\n100\nAcDbLayerTableRecord\n 2\n%s\n 70\n0\n 6\nCONTINUOUS\n" % (i + 80, self.layers[i])) + with open(self.get_resource('dxf14_style.txt'), 'r') as fhl: + self.dxf_add(fhl.read()) + + scale = eval(self.options.units) + if not scale: + scale = 25.4 / 96 # if no scale is specified, assume inch as baseunit + scale /= self.svg.unittouu('1px') + h = self.svg.height + doc = self.document.getroot() + # process viewBox height attribute to correct page scaling + viewBox = doc.get('viewBox') + if viewBox: + viewBox2 = viewBox.split(',') + if len(viewBox2) < 4: + viewBox2 = viewBox.split(' ') + scale *= h / self.svg.unittouu(self.svg.add_unit(viewBox2[3])) + self.groupmat = [[[scale, 0.0, 0.0], [0.0, -scale, h * scale]]] + self.process_group(doc) + if self.options.ROBO: + self.ROBO_output() + if self.options.POLY: + self.LWPOLY_output() + with open(self.get_resource('dxf14_footer.txt'), 'r') as fhl: + self.dxf_add(fhl.read()) + # Warn user if layer data seems wrong + if self.options.layer_name and self.options.layer_option and self.options.layer_option == 'name': + for layer in self.options.layer_name: + if layer not in self.layernames: + inkex.errormsg("Warning: Layer '%s' not found!" % layer) + + +if __name__ == '__main__': + DxfOutlines().run() |