Adding upstream version 1.0.2.upstream/1.0.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 629 insertions, 0 deletions

diff --git a/share/extensions/dxf_input.py b/share/extensions/dxf_input.py
new file mode 100755
index 0000000..fdd4cf2
--- /dev/null
+++ b/share/extensions/dxf_input.py
@@ -0,0 +1,629 @@
+#!/usr/bin/env python
+# coding=utf-8
+#
+# Copyright (C) 2008, 2009 Alvin Penner, penner@vaxxine.com
+# Copyright (C) 2009 Christian Mayer, inkscape@christianmayer.de
+#
+# 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.
+#
+"""
+Input a DXF file >= (AutoCAD Release 13 == AC1012)
+"""
+# thanks to Aaron Spike for inkex without which this would not have been possible
+
+from __future__ import absolute_import, unicode_literals
+
+import os
+import re
+import sys
+import math
+
+from lxml import etree
+
+import inkex
+
+if sys.version_info[0] < 3:
+    from urllib import quote
+else:
+    from urllib.parse import quote
+
+    unichr = chr
+
+
+def re_hex2unichar(m):
+    return unichr(int(m.group(1), 16))
+
+
+def formatStyle(style):
+    return str(inkex.Style(style))
+
+
+def export_MTEXT():
+    # mandatory group codes : (1 or 3, 10, 20) (text, x, y)
+    if (vals[groups['1']] or vals[groups['3']]) and vals[groups['10']] and vals[groups['20']]:
+        x = vals[groups['10']][0]
+        y = vals[groups['20']][0]
+        # optional group codes : (21, 40, 50) (direction, text height mm, text angle)
+        size = 12  # default fontsize in px
+        if vals[groups['40']] and vals[groups['40']][0]:
+            size = scale * vals[groups['40']][0]
+        attribs = {'x': '%f' % x, 'y': '%f' % y, 'style': 'font-size: %.1fpx; fill: %s; font-family: %s' % (size, color, options.font)}
+        angle = 0  # default angle in degrees
+        if vals[groups['50']]:
+            angle = vals[groups['50']][0]
+            attribs.update({'transform': 'rotate (%f %f %f)' % (-angle, x, y)})
+        elif vals[groups['21']]:
+            if vals[groups['21']][0] == 1.0:
+                attribs.update({'transform': 'rotate (%f %f %f)' % (-90, x, y)})
+            elif vals[groups['21']][0] == -1.0:
+                attribs.update({'transform': 'rotate (%f %f %f)' % (90, x, y)})
+        node = layer.add(inkex.Text(**attribs))
+        node.set('sodipodi:linespacing', '125%')
+        text = ''
+        if vals[groups['3']]:
+            for i in range(0, len(vals[groups['3']])):
+                text += vals[groups['3']][i]
+        if vals[groups['1']]:
+            text += vals[groups['1']][0]
+        found = text.find(r'\P')  # new line
+        while found > -1:
+            tspan = node.add(inkex.Tspan())
+            tspan.set('sodipodi:role', 'line')
+            tspan.text = text[:found]
+            text = text[(found + 2):]
+            found = text.find(r'\P')
+        tspan = node.add(inkex.Tspan())
+        tspan.set('sodipodi:role', 'line')
+        tspan.text = text
+
+
+def export_POINT(w):
+    # mandatory group codes : (10, 20) (x, y)
+    if vals[groups['10']] and vals[groups['20']]:
+        if options.gcodetoolspoints:
+            generate_gcodetools_point(vals[groups['10']][0], vals[groups['20']][0])
+        else:
+            generate_ellipse(vals[groups['10']][0], vals[groups['20']][0], w / 2, 0.0, 1.0, 0.0, 0.0)
+
+
+def export_LINE():
+    # mandatory group codes : (10, 11, 20, 21) (x1, x2, y1, y2)
+    if vals[groups['10']] and vals[groups['11']] and vals[groups['20']] and vals[groups['21']]:
+        path = 'M %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], scale * (extrude * vals[groups['11']][0] - xmin), height - scale * (vals[groups['21']][0] - ymin))
+        attribs = {'d': path, 'style': style}
+        etree.SubElement(layer, 'path', attribs)
+
+
+def export_SPLINE():
+    # see : http://www.mactech.com/articles/develop/issue_25/schneider.html
+    # mandatory group codes : (10, 20, 40, 70) (x[], y[], knots[], flags)
+    if vals[groups['70']] and len(vals[groups['10']]) == len(vals[groups['20']]) and vals[groups['10']] and vals[groups['20']] and vals[groups['40']]:
+        knots = len(vals[groups['40']])
+        ctrls = len(vals[groups['10']])
+        if ctrls > 3 and knots == ctrls + 4:  # cubic
+            if ctrls > 4:
+                for i in range(knots - 5, 3, -1):
+                    if vals[groups['40']][i] != vals[groups['40']][i - 1] and vals[groups['40']][i] != vals[groups['40']][i + 1]:
+                        a0 = (vals[groups['40']][i] - vals[groups['40']][i - 2]) / (vals[groups['40']][i + 1] - vals[groups['40']][i - 2])
+                        a1 = (vals[groups['40']][i] - vals[groups['40']][i - 1]) / (vals[groups['40']][i + 2] - vals[groups['40']][i - 1])
+                        vals[groups['10']].insert(i - 1, (1.0 - a1) * vals[groups['10']][i - 2] + a1 * vals[groups['10']][i - 1])
+                        vals[groups['20']].insert(i - 1, (1.0 - a1) * vals[groups['20']][i - 2] + a1 * vals[groups['20']][i - 1])
+                        vals[groups['10']][i - 2] = (1.0 - a0) * vals[groups['10']][i - 3] + a0 * vals[groups['10']][i - 2]
+                        vals[groups['20']][i - 2] = (1.0 - a0) * vals[groups['20']][i - 3] + a0 * vals[groups['20']][i - 2]
+                        vals[groups['40']].insert(i, vals[groups['40']][i])
+                knots = len(vals[groups['40']])
+                for i in range(knots - 6, 3, -2):
+                    if vals[groups['40']][i] != vals[groups['40']][i + 2] and vals[groups['40']][i - 1] != vals[groups['40']][i + 1] and vals[groups['40']][i - 2] != vals[groups['40']][i]:
+                        a1 = (vals[groups['40']][i] - vals[groups['40']][i - 1]) / (vals[groups['40']][i + 2] - vals[groups['40']][i - 1])
+                        vals[groups['10']].insert(i - 1, (1.0 - a1) * vals[groups['10']][i - 2] + a1 * vals[groups['10']][i - 1])
+                        vals[groups['20']].insert(i - 1, (1.0 - a1) * vals[groups['20']][i - 2] + a1 * vals[groups['20']][i - 1])
+            ctrls = len(vals[groups['10']])
+            path = 'M %f,%f' % (vals[groups['10']][0], vals[groups['20']][0])
+            for i in range(0, (ctrls - 1) // 3):
+                path += ' C %f,%f %f,%f %f,%f' % (vals[groups['10']][3 * i + 1], vals[groups['20']][3 * i + 1], vals[groups['10']][3 * i + 2], vals[groups['20']][3 * i + 2], vals[groups['10']][3 * i + 3], vals[groups['20']][3 * i + 3])
+            if vals[groups['70']][0] & 1:  # closed path
+                path += ' z'
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+        if ctrls == 3 and knots == 6:  # quadratic
+            path = 'M %f,%f Q %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['10']][1], vals[groups['20']][1], vals[groups['10']][2], vals[groups['20']][2])
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+        if ctrls == 5 and knots == 8:  # spliced quadratic
+            path = 'M %f,%f Q %f,%f %f,%f Q %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['10']][1], vals[groups['20']][1], vals[groups['10']][2], vals[groups['20']][2], vals[groups['10']][3], vals[groups['20']][3], vals[groups['10']][4], vals[groups['20']][4])
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+
+
+def export_CIRCLE():
+    # mandatory group codes : (10, 20, 40) (x, y, radius)
+    if vals[groups['10']] and vals[groups['20']] and vals[groups['40']]:
+        generate_ellipse(vals[groups['10']][0], vals[groups['20']][0], scale * vals[groups['40']][0], 0.0, 1.0, 0.0, 0.0)
+
+
+def export_ARC():
+    # mandatory group codes : (10, 20, 40, 50, 51) (x, y, radius, angle1, angle2)
+    if vals[groups['10']] and vals[groups['20']] and vals[groups['40']] and vals[groups['50']] and vals[groups['51']]:
+        generate_ellipse(vals[groups['10']][0], vals[groups['20']][0], scale * vals[groups['40']][0], 0.0, 1.0, vals[groups['50']][0] * math.pi / 180.0, vals[groups['51']][0] * math.pi / 180.0)
+
+
+def export_ELLIPSE():
+    # mandatory group codes : (10, 11, 20, 21, 40, 41, 42) (xc, xm, yc, ym, width ratio, angle1, angle2)
+    if vals[groups['10']] and vals[groups['11']] and vals[groups['20']] and vals[groups['21']] and vals[groups['40']] and vals[groups['41']] and vals[groups['42']]:
+        generate_ellipse(vals[groups['10']][0], vals[groups['20']][0], scale * vals[groups['11']][0], scale * vals[groups['21']][0], vals[groups['40']][0], vals[groups['41']][0], vals[groups['42']][0])
+
+
+def export_LEADER():
+    # mandatory group codes : (10, 20) (x, y)
+    if vals[groups['10']] and vals[groups['20']]:
+        if len(vals[groups['10']]) > 1 and len(vals[groups['20']]) == len(vals[groups['10']]):
+            path = 'M %f,%f' % (vals[groups['10']][0], vals[groups['20']][0])
+            for i in range(1, len(vals[groups['10']])):
+                path += ' %f,%f' % (vals[groups['10']][i], vals[groups['20']][i])
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+
+
+def export_LWPOLYLINE():
+    # mandatory group codes : (10, 20, 70) (x, y, flags)
+    if vals[groups['10']] and vals[groups['20']] and vals[groups['70']]:
+        if len(vals[groups['10']]) > 1 and len(vals[groups['20']]) == len(vals[groups['10']]):
+            # optional group codes : (42) (bulge)
+            iseqs = 0
+            ibulge = 0
+            if vals[groups['70']][0] & 1:  # closed path
+                seqs.append('20')
+                vals[groups['10']].append(vals[groups['10']][0])
+                vals[groups['20']].append(vals[groups['20']][0])
+            while seqs[iseqs] != '20':
+                iseqs += 1
+            path = 'M %f,%f' % (vals[groups['10']][0], vals[groups['20']][0])
+            xold = vals[groups['10']][0]
+            yold = vals[groups['20']][0]
+            for i in range(1, len(vals[groups['10']])):
+                bulge = 0
+                iseqs += 1
+                while seqs[iseqs] != '20':
+                    if seqs[iseqs] == '42':
+                        bulge = vals[groups['42']][ibulge]
+                        ibulge += 1
+                    iseqs += 1
+                if bulge:
+                    sweep = 0  # sweep CCW
+                    if bulge < 0:
+                        sweep = 1  # sweep CW
+                        bulge = -bulge
+                    large = 0  # large-arc-flag
+                    if bulge > 1:
+                        large = 1
+                    r = math.sqrt((vals[groups['10']][i] - xold) ** 2 + (vals[groups['20']][i] - yold) ** 2)
+                    r = 0.25 * r * (bulge + 1.0 / bulge)
+                    path += ' A %f,%f 0.0 %d %d %f,%f' % (r, r, large, sweep, vals[groups['10']][i], vals[groups['20']][i])
+                else:
+                    path += ' L %f,%f' % (vals[groups['10']][i], vals[groups['20']][i])
+                xold = vals[groups['10']][i]
+                yold = vals[groups['20']][i]
+            if vals[groups['70']][0] & 1:  # closed path
+                path += ' z'
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+
+
+def export_HATCH():
+    # mandatory group codes : (10, 20, 70, 72, 92, 93) (x, y, fill, Edge Type, Path Type, Number of edges)
+    if vals[groups['10']] and vals[groups['20']] and vals[groups['70']] and vals[groups['72']] and vals[groups['92']] and vals[groups['93']]:
+        if len(vals[groups['10']]) > 1 and len(vals[groups['20']]) == len(vals[groups['10']]):
+            # optional group codes : (11, 21, 40, 50, 51, 73) (x, y, r, angle1, angle2, CCW)
+            i10 = 1  # count start points
+            i11 = 0  # count line end points
+            i40 = 0  # count circles
+            i72 = 0  # count edge type flags
+            path = ''
+            for i in range(0, len(vals[groups['93']])):
+                xc = vals[groups['10']][i10]
+                yc = vals[groups['20']][i10]
+                if vals[groups['72']][i72] == 2:  # arc
+                    rm = scale * vals[groups['40']][i40]
+                    a1 = vals[groups['50']][i40]
+                    path += 'M %f,%f ' % (xc + rm * math.cos(a1 * math.pi / 180.0), yc + rm * math.sin(a1 * math.pi / 180.0))
+                else:
+                    a1 = 0
+                    path += 'M %f,%f ' % (xc, yc)
+                for j in range(0, vals[groups['93']][i]):
+                    if vals[groups['92']][i] & 2:  # polyline
+                        if j > 0:
+                            path += 'L %f,%f ' % (vals[groups['10']][i10], vals[groups['20']][i10])
+                        if j == vals[groups['93']][i] - 1:
+                            i72 += 1
+                    elif vals[groups['72']][i72] == 2:  # arc
+                        xc = vals[groups['10']][i10]
+                        yc = vals[groups['20']][i10]
+                        rm = scale * vals[groups['40']][i40]
+                        a2 = vals[groups['51']][i40]
+                        diff = (a2 - a1 + 360) % 360
+                        sweep = 1 - vals[groups['73']][i40]  # sweep CCW
+                        large = 0  # large-arc-flag
+                        if diff:
+                            path += 'A %f,%f 0.0 %d %d %f,%f ' % (rm, rm, large, sweep, xc + rm * math.cos(a2 * math.pi / 180.0), yc + rm * math.sin(a2 * math.pi / 180.0))
+                        else:
+                            path += 'A %f,%f 0.0 %d %d %f,%f ' % (rm, rm, large, sweep, xc + rm * math.cos((a1 + 180.0) * math.pi / 180.0), yc + rm * math.sin((a1 + 180.0) * math.pi / 180.0))
+                            path += 'A %f,%f 0.0 %d %d %f,%f ' % (rm, rm, large, sweep, xc + rm * math.cos(a1 * math.pi / 180.0), yc + rm * math.sin(a1 * math.pi / 180.0))
+                        i40 += 1
+                        i72 += 1
+                    elif vals[groups['72']][i72] == 1:  # line
+                        path += 'L %f,%f ' % (scale * (extrude * vals[groups['11']][i11] - xmin), height - scale * (vals[groups['21']][i11] - ymin))
+                        i11 += 1
+                        i72 += 1
+                    i10 += 1
+                path += "z "
+            if vals[groups['70']][0]:
+                style = formatStyle({'fill': '%s' % color})
+            else:
+                style = formatStyle({'fill': 'url(#Hatch)', 'fill-opacity': '1.0'})
+            attribs = {'d': path, 'style': style}
+            etree.SubElement(layer, 'path', attribs)
+
+
+def export_DIMENSION():
+    # mandatory group codes : (10, 11, 13, 14, 20, 21, 23, 24) (x1..4, y1..4)
+    if vals[groups['10']] and vals[groups['11']] and vals[groups['13']] and vals[groups['14']] and vals[groups['20']] and vals[groups['21']] and vals[groups['23']] and vals[groups['24']]:
+        dx = abs(vals[groups['10']][0] - vals[groups['13']][0])
+        dy = abs(vals[groups['20']][0] - vals[groups['23']][0])
+        if (vals[groups['10']][0] == vals[groups['14']][0]) and dx > 0.00001:
+            d = dx / scale
+            dy = 0
+            path = 'M %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['13']][0], vals[groups['20']][0])
+        elif (vals[groups['20']][0] == vals[groups['24']][0]) and dy > 0.00001:
+            d = dy / scale
+            dx = 0
+            path = 'M %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['10']][0], vals[groups['23']][0])
+        else:
+            return
+        attribs = {'d': path, 'style': style + '; marker-start: url(#DistanceX); marker-end: url(#DistanceX); stroke-width: 0.25px'}
+        etree.SubElement(layer, 'path', attribs)
+        x = scale * (extrude * vals[groups['11']][0] - xmin)
+        y = height - scale * (vals[groups['21']][0] - ymin)
+        size = 12  # default fontsize in px
+        if vals[groups['3']]:
+            if vals[groups['3']][0] in DIMTXT:
+                size = scale * DIMTXT[vals[groups['3']][0]]
+                if size < 2:
+                    size = 2
+        attribs = {'x': '%f' % x, 'y': '%f' % y, 'style': 'font-size: %.1fpx; fill: %s; font-family: %s; text-anchor: middle; text-align: center' % (size, color, options.font)}
+        if dx == 0:
+            attribs.update({'transform': 'rotate (%f %f %f)' % (-90, x, y)})
+        node = etree.SubElement(layer, 'text', attribs)
+        tspan = node.add(inkex.Tspan())
+        tspan.set('sodipodi:role', 'line')
+        tspan.text = str(float('%.2f' % d))
+
+
+def export_INSERT():
+    # mandatory group codes : (2, 10, 20) (block name, x, y)
+    if vals[groups['2']] and vals[groups['10']] and vals[groups['20']]:
+        x = vals[groups['10']][0] + scale * xmin
+        y = vals[groups['20']][0] - scale * ymin - height
+        elem = layer.add(inkex.Use())
+        elem.set('xlink:href', '#' + quote(vals[groups['2']][0].replace(" ", "_").encode("utf-8")))
+        elem.transform = 'translate(%f, %f)' % (x, y)
+        if vals[groups['41']] and vals[groups['42']]:
+            elem.transform.add_scale(vals[groups['41']][0], vals[groups['42']][0])
+
+
+def export_BLOCK():
+    # mandatory group codes : (2) (block name)
+    if vals[groups['2']]:
+        global block
+        block = etree.SubElement(defs, 'symbol', {'id': vals[groups['2']][0].replace(" ", "_")})
+
+
+def export_ENDBLK():
+    global block
+    block = defs  # initiallize with dummy
+
+
+def export_ATTDEF():
+    # mandatory group codes : (1, 2) (default, tag)
+    if vals[groups['1']] and vals[groups['2']]:
+        vals[groups['1']][0] = vals[groups['2']][0]
+        export_MTEXT()
+
+
+def generate_ellipse(xc, yc, xm, ym, w, a1, a2):
+    rm = math.sqrt(xm * xm + ym * ym)
+    a = math.atan2(ym, xm)
+    diff = (a2 - a1 + 2 * math.pi) % (2 * math.pi)
+    if abs(diff) > 0.0000001 and abs(diff - 2 * math.pi) > 0.0000001:  # open arc
+        large = 0  # large-arc-flag
+        if diff > math.pi:
+            large = 1
+        xt = rm * math.cos(a1)
+        yt = w * rm * math.sin(a1)
+        x1 = xt * math.cos(a) - yt * math.sin(a)
+        y1 = xt * math.sin(a) + yt * math.cos(a)
+        xt = rm * math.cos(a2)
+        yt = w * rm * math.sin(a2)
+        x2 = xt * math.cos(a) - yt * math.sin(a)
+        y2 = xt * math.sin(a) + yt * math.cos(a)
+        path = 'M %f,%f A %f,%f %f %d 0 %f,%f' % (xc + x1, yc - y1, rm, w * rm, -180.0 * a / math.pi, large, xc + x2, yc - y2)
+    else:  # closed arc
+        path = 'M %f,%f A %f,%f %f 1 0 %f,%f %f,%f %f 1 0 %f,%f z' % (xc + xm, yc - ym, rm, w * rm, -180.0 * a / math.pi, xc - xm, yc + ym, rm, w * rm, -180.0 * a / math.pi, xc + xm, yc - ym)
+    attribs = {'d': path, 'style': style}
+    etree.SubElement(layer, 'path', attribs)
+
+
+def generate_gcodetools_point(xc, yc):
+    elem = layer.add(inkex.PathElement())
+    elem.style = 'stroke:none;fill:#ff0000'
+    elem.set('inkscape:dxfpoint', '1')
+    elem.path = 'm %s,%s 2.9375,-6.34375 0.8125,1.90625 6.84375,-6.84375 0,0 0.6875,0.6875 -6.84375,6.84375 1.90625,0.8125 z' % (xc, yc)
+
+
+#   define DXF Entities and specify which Group Codes to monitor
+
+entities = {'MTEXT': export_MTEXT, 'TEXT': export_MTEXT, 'POINT': export_POINT, 'LINE': export_LINE, 'SPLINE': export_SPLINE, 'CIRCLE': export_CIRCLE, 'ARC': export_ARC, 'ELLIPSE': export_ELLIPSE, 'LEADER': export_LEADER, 'LWPOLYLINE': export_LWPOLYLINE, 'HATCH': export_HATCH, 'DIMENSION': export_DIMENSION, 'INSERT': export_INSERT, 'BLOCK': export_BLOCK, 'ENDBLK': export_ENDBLK, 'ATTDEF': export_ATTDEF, 'VIEWPORT': False, 'ENDSEC': False}
+groups = {'1': 0, '2': 1, '3': 2, '6': 3, '8': 4, '10': 5, '11': 6, '13': 7, '14': 8, '20': 9, '21': 10, '23': 11, '24': 12, '40': 13, '41': 14, '42': 15, '50': 16, '51': 17, '62': 18, '70': 19, '72': 20, '73': 21, '92': 22, '93': 23, '230': 24, '370': 25}
+colors = {1: '#FF0000', 2: '#FFFF00', 3: '#00FF00', 4: '#00FFFF', 5: '#0000FF', 6: '#FF00FF', 7: '#000000', 8: '#808080',
+          9: '#C0C0C0', 10: '#FF0000', 11: '#FF7F7F', 12: '#CC0000', 13: '#CC6666', 14: '#990000', 15: '#994C4C', 16: '#7F0000', 17: '#7F3F3F',
+          18: '#4C0000', 19: '#4C2626', 20: '#FF3F00', 21: '#FF9F7F', 22: '#CC3300', 23: '#CC7F66', 24: '#992600', 25: '#995F4C', 26: '#7F1F00',
+          27: '#7F4F3F', 28: '#4C1300', 29: '#4C2F26', 30: '#FF7F00', 31: '#FFBF7F', 32: '#CC6600', 33: '#CC9966', 34: '#994C00', 35: '#99724C',
+          36: '#7F3F00', 37: '#7F5F3F', 38: '#4C2600', 39: '#4C3926', 40: '#FFBF00', 41: '#FFDF7F', 42: '#CC9900', 43: '#CCB266', 44: '#997200',
+          45: '#99854C', 46: '#7F5F00', 47: '#7F6F3F', 48: '#4C3900', 49: '#4C4226', 50: '#FFFF00', 51: '#FFFF7F', 52: '#CCCC00', 53: '#CCCC66',
+          54: '#989800', 55: '#98984C', 56: '#7F7F00', 57: '#7F7F3F', 58: '#4C4C00', 59: '#4C4C26', 60: '#BFFF00', 61: '#DFFF7F', 62: '#99CC00',
+          63: '#B2CC66', 64: '#729800', 65: '#85984C', 66: '#5F7F00', 67: '#6F7F3F', 68: '#394C00', 69: '#424C26', 70: '#7FFF00', 71: '#BFFF7F',
+          72: '#66CC00', 73: '#99CC66', 74: '#4C9800', 75: '#72984C', 76: '#3F7F00', 77: '#5F7F3F', 78: '#264C00', 79: '#394C26', 80: '#3FFF00',
+          81: '#9FFF7F', 82: '#33CC00', 83: '#7FCC66', 84: '#269800', 85: '#5F984C', 86: '#1F7F00', 87: '#4F7F3F', 88: '#134C00', 89: '#2F4C26',
+          90: '#00FF00', 91: '#7FFF7F', 92: '#00CC00', 93: '#66CC66', 94: '#009800', 95: '#4C984C', 96: '#007F00', 97: '#3F7F3F', 98: '#004C00',
+          99: '#264C26', 100: '#00FF3F', 101: '#7FFF9F', 102: '#00CC33', 103: '#66CC7F', 104: '#009826', 105: '#4C985F', 106: '#007F1F',
+          107: '#3F7F4F', 108: '#004C13', 109: '#264C2F', 110: '#00FF7F', 111: '#7FFFBF', 112: '#00CC66', 113: '#66CC99', 114: '#00984C',
+          115: '#4C9872', 116: '#007F3F', 117: '#3F7F5F', 118: '#004C26', 119: '#264C39', 120: '#00FFBF', 121: '#7FFFDF', 122: '#00CC99',
+          123: '#66CCB2', 124: '#009872', 125: '#4C9885', 126: '#007F5F', 127: '#3F7F6F', 128: '#004C39', 129: '#264C42', 130: '#00FFFF',
+          131: '#7FFFFF', 132: '#00CCCC', 133: '#66CCCC', 134: '#009898', 135: '#4C9898', 136: '#007F7F', 137: '#3F7F7F', 138: '#004C4C',
+          139: '#264C4C', 140: '#00BFFF', 141: '#7FDFFF', 142: '#0099CC', 143: '#66B2CC', 144: '#007298', 145: '#4C8598', 146: '#005F7F',
+          147: '#3F6F7F', 148: '#00394C', 149: '#26424C', 150: '#007FFF', 151: '#7FBFFF', 152: '#0066CC', 153: '#6699CC', 154: '#004C98',
+          155: '#4C7298', 156: '#003F7F', 157: '#3F5F7F', 158: '#00264C', 159: '#26394C', 160: '#003FFF', 161: '#7F9FFF', 162: '#0033CC',
+          163: '#667FCC', 164: '#002698', 165: '#4C5F98', 166: '#001F7F', 167: '#3F4F7F', 168: '#00134C', 169: '#262F4C', 170: '#0000FF',
+          171: '#7F7FFF', 172: '#0000CC', 173: '#6666CC', 174: '#000098', 175: '#4C4C98', 176: '#00007F', 177: '#3F3F7F', 178: '#00004C',
+          179: '#26264C', 180: '#3F00FF', 181: '#9F7FFF', 182: '#3300CC', 183: '#7F66CC', 184: '#260098', 185: '#5F4C98', 186: '#1F007F',
+          187: '#4F3F7F', 188: '#13004C', 189: '#2F264C', 190: '#7F00FF', 191: '#BF7FFF', 192: '#6600CC', 193: '#9966CC', 194: '#4C0098',
+          195: '#724C98', 196: '#3F007F', 197: '#5F3F7F', 198: '#26004C', 199: '#39264C', 200: '#BF00FF', 201: '#DF7FFF', 202: '#9900CC',
+          203: '#B266CC', 204: '#720098', 205: '#854C98', 206: '#5F007F', 207: '#6F3F7F', 208: '#39004C', 209: '#42264C', 210: '#FF00FF',
+          211: '#FF7FFF', 212: '#CC00CC', 213: '#CC66CC', 214: '#980098', 215: '#984C98', 216: '#7F007F', 217: '#7F3F7F', 218: '#4C004C',
+          219: '#4C264C', 220: '#FF00BF', 221: '#FF7FDF', 222: '#CC0099', 223: '#CC66B2', 224: '#980072', 225: '#984C85', 226: '#7F005F',
+          227: '#7F3F6F', 228: '#4C0039', 229: '#4C2642', 230: '#FF007F', 231: '#FF7FBF', 232: '#CC0066', 233: '#CC6699', 234: '#98004C',
+          235: '#984C72', 236: '#7F003F', 237: '#7F3F5F', 238: '#4C0026', 239: '#4C2639', 240: '#FF003F', 241: '#FF7F9F', 242: '#CC0033',
+          243: '#CC667F', 244: '#980026', 245: '#984C5F', 246: '#7F001F', 247: '#7F3F4F', 248: '#4C0013', 249: '#4C262F', 250: '#333333',
+          251: '#5B5B5B', 252: '#848484', 253: '#ADADAD', 254: '#D6D6D6', 255: '#FFFFFF'}
+
+
+class DxfInput(inkex.InputExtension):
+    def add_arguments(self, pars):
+        pars.add_argument("--tab", default="Options")
+        pars.add_argument("--scalemethod", default="manual")
+        pars.add_argument("--scale", default="1.0")
+        pars.add_argument("--xmin", default="0.0")
+        pars.add_argument("--ymin", default="0.0")
+        pars.add_argument("--gcodetoolspoints", default=True, type=inkex.Boolean)
+        pars.add_argument("--encoding", dest="input_encode", default="latin_1")
+        pars.add_argument("--font", default="Arial")
+
+    def load(self, stream):
+        return stream
+
+    def effect(self):
+        global options
+        global defs
+        global entity
+        global vals
+        global seqs
+        global style
+        global layer
+        global scale
+        global color
+        global extrude
+        global xmin
+        global ymin
+        global height
+
+        options = self.options
+
+        doc = self.get_template(width=210 * 96 / 25.4, height=297 * 96 / 25.4)
+        svg = doc.getroot()
+        defs = svg.defs
+        marker = etree.SubElement(defs, 'marker', {'id': 'DistanceX', 'orient': 'auto', 'refX': '0.0', 'refY': '0.0', 'style': 'overflow:visible'})
+        etree.SubElement(marker, 'path', {'d': 'M 3,-3 L -3,3 M 0,-5 L  0,5', 'style': 'stroke:#000000; stroke-width:0.5'})
+        pattern = etree.SubElement(defs, 'pattern', {'id': 'Hatch', 'patternUnits': 'userSpaceOnUse', 'width': '8', 'height': '8', 'x': '0', 'y': '0'})
+        etree.SubElement(pattern, 'path', {'d': 'M8 4 l-4,4', 'stroke': '#000000', 'stroke-width': '0.25', 'linecap': 'square'})
+        etree.SubElement(pattern, 'path', {'d': 'M6 2 l-4,4', 'stroke': '#000000', 'stroke-width': '0.25', 'linecap': 'square'})
+        etree.SubElement(pattern, 'path', {'d': 'M4 0 l-4,4', 'stroke': '#000000', 'stroke-width': '0.25', 'linecap': 'square'})
+
+        def _get_line():
+            return self.document.readline().strip().decode(options.input_encode)
+
+        def get_line():
+            return _get_line(), _get_line()
+
+        def get_group(group):
+            line = get_line()
+            if line[0] == group:
+                return float(line[1])
+            return 0.0
+
+        xmax = xmin = ymin = 0.0
+        height = 297.0 * 96.0 / 25.4  # default A4 height in pixels
+        measurement = 0  # default inches
+        line = get_line()
+        polylines = 0
+        flag = 0  # (0, 1, 2, 3) = (none, LAYER, LTYPE, DIMTXT)
+        layer_colors = {}  # store colors by layer
+        layer_nodes = {}  # store nodes by layer
+        linetypes = {}  # store linetypes by name
+        DIMTXT = {}  # store DIMENSION text sizes
+
+        while line[0] and line[1] != 'BLOCKS':
+            line = get_line()
+            if options.scalemethod == 'file':
+                if line[1] == '$MEASUREMENT':
+                    measurement = get_group('70')
+            elif options.scalemethod == 'auto':
+                if line[1] == '$EXTMIN':
+                    xmin = get_group('10')
+                    ymin = get_group('20')
+                if line[1] == '$EXTMAX':
+                    xmax = get_group('10')
+            if flag == 1 and line[0] == '2':
+                layername = line[1]
+                layer_nodes[layername] = svg.add(inkex.Layer.new(layername))
+            if flag == 2 and line[0] == '2':
+                linename = line[1]
+                linetypes[linename] = []
+            if flag == 3 and line[0] == '2':
+                stylename = line[1]
+            if line[0] == '2' and line[1] == 'LAYER':
+                flag = 1
+            if line[0] == '2' and line[1] == 'LTYPE':
+                flag = 2
+            if line[0] == '2' and line[1] == 'DIMSTYLE':
+                flag = 3
+            if flag == 1 and line[0] == '62':
+                layer_colors[layername] = int(line[1])
+            if flag == 2 and line[0] == '49':
+                linetypes[linename].append(float(line[1]))
+            if flag == 3 and line[0] == '140':
+                DIMTXT[stylename] = float(line[1])
+            if line[0] == '0' and line[1] == 'ENDTAB':
+                flag = 0
+
+        if options.scalemethod == 'file':
+            scale = 25.4  # default inches
+            if measurement == 1.0:
+                scale = 1.0  # use mm
+        elif options.scalemethod == 'auto':
+            scale = 1.0
+            if xmax > xmin:
+                scale = 210.0 / (xmax - xmin)  # scale to A4 width
+        else:
+            scale = float(options.scale)  # manual scale factor
+            xmin = float(options.xmin)
+            ymin = float(options.ymin)
+        svg.description('%s - scale = %f, origin = (%f, %f), method = %s' % (
+            os.path.basename(options.input_file), scale, xmin, ymin, options.scalemethod))
+        scale *= 96.0 / 25.4  # convert from mm to pixels
+
+        if '0' not in layer_nodes:
+            layer_nodes['0'] = svg.add(inkex.Layer.new('0'))
+
+            layer_colors['0'] = 7
+
+        for linename in linetypes.keys():  # scale the dashed lines
+            linetype = ''
+            for length in linetypes[linename]:
+                if length == 0:  # test for dot
+                    linetype += ' 0.5,'
+                else:
+                    linetype += '%.4f,' % math.fabs(length * scale)
+            if linetype == '':
+                linetypes[linename] = 'stroke-linecap: round'
+            else:
+                linetypes[linename] = 'stroke-dasharray:' + linetype
+
+        entity = ''
+        inENTITIES = False
+        block = defs  # initiallize with dummy
+        while line[0] and (line[1] != 'ENDSEC' or not inENTITIES):
+            line = get_line()
+            if line[1] == 'ENTITIES':
+                inENTITIES = True
+            elif line[1] == 'POLYLINE':
+                polylines += 1
+            if entity and line[0] in groups:
+                seqs.append(line[0])  # list of group codes
+                if line[0] in ('1', '2', '3', '6', '8'):  # text value
+                    val = line[1].replace(r'\~', ' ')
+                    val = re.sub(r'\\A.*;', '', val)
+                    val = re.sub(r'\\H.*;', '', val)
+                    val = re.sub(r'\^I', '', val)
+                    val = re.sub(r'{\\L', '', val)
+                    val = re.sub(r'}', '', val)
+                    val = re.sub(r'\\S.*;', '', val)
+                    val = re.sub(r'\\W.*;', '', val)
+                    val = val
+                    val = re.sub(r'\\U\+([0-9A-Fa-f]{4})', re_hex2unichar, val)
+                elif line[0] == '62' or line[0] == '70' or line[0] == '92' or line[0] == '93':
+                    val = int(line[1])
+                else:  # unscaled float value
+                    val = float(line[1])
+                vals[groups[line[0]]].append(val)
+            elif line[1] in entities:
+                if entity in entities:
+                    if block != defs:  # in a BLOCK
+                        layer = block
+                    elif vals[groups['8']]:  # use Common Layer Name
+                        if not vals[groups['8']][0]:
+                            vals[groups['8']][0] = '0'  # use default name
+                        if vals[groups['8']][0] not in layer_nodes:
+                            layer_nodes[vals[groups['8']][0]] = svg.add(inkex.Layer.new(vals[groups['8']][0]))
+                        layer = layer_nodes[vals[groups['8']][0]]
+                    color = '#000000'  # default color
+                    if vals[groups['8']]:
+                        if vals[groups['8']][0] in layer_colors:
+                            if layer_colors[vals[groups['8']][0]] in colors:
+                                color = colors[layer_colors[vals[groups['8']][0]]]
+                    if vals[groups['62']]:  # Common Color Number
+                        if vals[groups['62']][0] in colors:
+                            color = colors[vals[groups['62']][0]]
+                    style = formatStyle({'stroke': '%s' % color, 'fill': 'none'})
+                    w = 0.5  # default lineweight for POINT
+                    if vals[groups['370']]:  # Common Lineweight
+                        if vals[groups['370']][0] > 0:
+                            w = 96.0 / 25.4 * vals[groups['370']][0] / 100.0
+                            if w < 0.5:
+                                w = 0.5
+                            style = formatStyle({'stroke': '%s' % color, 'fill': 'none', 'stroke-width': '%.1f' % w})
+                    if vals[groups['6']]:  # Common Linetype
+                        if vals[groups['6']][0] in linetypes:
+                            style += ';' + linetypes[vals[groups['6']][0]]
+                    extrude = 1.0
+                    if vals[groups['230']]:
+                        extrude = float(vals[groups['230']][0])
+                    for xgrp in ['10', '13', '14']:  # scale/reflect x values
+                        if vals[groups[xgrp]]:
+                            for i in range(0, len(vals[groups[xgrp]])):
+                                vals[groups[xgrp]][i] = scale * (extrude * vals[groups[xgrp]][i] - xmin)
+                    for ygrp in ['20', '23', '24']:  # scale y values
+                        if vals[groups[ygrp]]:
+                            for i in range(0, len(vals[groups[ygrp]])):
+                                vals[groups[ygrp]][i] = height - scale * (vals[groups[ygrp]][i] - ymin)
+                    if extrude == -1.0:  # reflect angles
+                        if vals[groups['50']] and vals[groups['51']]:
+                            temp = vals[groups['51']][0]
+                            vals[groups['51']][0] = 180.0 - vals[groups['50']][0]
+                            vals[groups['50']][0] = 180.0 - temp
+                    if entities[entity]:
+                        if entity == 'POINT':
+                            entities[entity](w)
+                        else:
+                            entities[entity]()
+                entity = line[1]
+                vals = [[], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]
+                seqs = []
+
+        if polylines:
+            inkex.errormsg(_('%d ENTITIES of type POLYLINE encountered and ignored. Please try to convert to Release 13 format using QCad.') % polylines)
+        self.document = doc
+
+
+if __name__ == '__main__':
+    DxfInput().run()