1639 lines
54 KiB
Python
1639 lines
54 KiB
Python
#!/usr/bin/env python3
|
|
# coding=utf-8
|
|
#
|
|
# Copyright (C) 2008-2009 Alvin Penner, penner@vaxxine.com
|
|
# 2009, Christian Mayer, inkscape@christianmayer.de
|
|
# 2020, MartinOwens, doctormo@geek-2.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.
|
|
#
|
|
"""
|
|
Input a DXF file >= (AutoCAD Release 13 == AC1012)
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import math
|
|
|
|
from collections import defaultdict
|
|
from urllib.parse import quote
|
|
from lxml import etree
|
|
|
|
import inkex
|
|
from inkex.localization import inkex_gettext as _
|
|
|
|
global defs
|
|
global block # 2021.6
|
|
global layer
|
|
global svg
|
|
global scale
|
|
global xmin
|
|
global ymin
|
|
global height
|
|
global style_font3
|
|
global style_direction
|
|
|
|
COLORS = [
|
|
"PAD",
|
|
"#FF0000",
|
|
"#FFFF00",
|
|
"#00FF00",
|
|
"#00FFFF",
|
|
"#0000FF",
|
|
"#FF00FF",
|
|
"#000000",
|
|
"#808080",
|
|
"#C0C0C0",
|
|
"#FF0000",
|
|
"#FF7F7F",
|
|
"#CC0000",
|
|
"#CC6666",
|
|
"#990000",
|
|
"#994C4C",
|
|
"#7F0000",
|
|
"#7F3F3F",
|
|
"#4C0000",
|
|
"#4C2626",
|
|
"#FF3F00",
|
|
"#FF9F7F",
|
|
"#CC3300",
|
|
"#CC7F66",
|
|
"#992600",
|
|
"#995F4C",
|
|
"#7F1F00",
|
|
"#7F4F3F",
|
|
"#4C1300",
|
|
"#4C2F26",
|
|
"#FF7F00",
|
|
"#FFBF7F",
|
|
"#CC6600",
|
|
"#CC9966",
|
|
"#994C00",
|
|
"#99724C",
|
|
"#7F3F00",
|
|
"#7F5F3F",
|
|
"#4C2600",
|
|
"#4C3926",
|
|
"#FFBF00",
|
|
"#FFDF7F",
|
|
"#CC9900",
|
|
"#CCB266",
|
|
"#997200",
|
|
"#99854C",
|
|
"#7F5F00",
|
|
"#7F6F3F",
|
|
"#4C3900",
|
|
"#4C4226",
|
|
"#FFFF00",
|
|
"#FFFF7F",
|
|
"#CCCC00",
|
|
"#CCCC66",
|
|
"#989800",
|
|
"#98984C",
|
|
"#7F7F00",
|
|
"#7F7F3F",
|
|
"#4C4C00",
|
|
"#4C4C26",
|
|
"#BFFF00",
|
|
"#DFFF7F",
|
|
"#99CC00",
|
|
"#B2CC66",
|
|
"#729800",
|
|
"#85984C",
|
|
"#5F7F00",
|
|
"#6F7F3F",
|
|
"#394C00",
|
|
"#424C26",
|
|
"#7FFF00",
|
|
"#BFFF7F",
|
|
"#66CC00",
|
|
"#99CC66",
|
|
"#4C9800",
|
|
"#72984C",
|
|
"#3F7F00",
|
|
"#5F7F3F",
|
|
"#264C00",
|
|
"#394C26",
|
|
"#3FFF00",
|
|
"#9FFF7F",
|
|
"#33CC00",
|
|
"#7FCC66",
|
|
"#269800",
|
|
"#5F984C",
|
|
"#1F7F00",
|
|
"#4F7F3F",
|
|
"#134C00",
|
|
"#2F4C26",
|
|
"#00FF00",
|
|
"#7FFF7F",
|
|
"#00CC00",
|
|
"#66CC66",
|
|
"#009800",
|
|
"#4C984C",
|
|
"#007F00",
|
|
"#3F7F3F",
|
|
"#004C00",
|
|
"#264C26",
|
|
"#00FF3F",
|
|
"#7FFF9F",
|
|
"#00CC33",
|
|
"#66CC7F",
|
|
"#009826",
|
|
"#4C985F",
|
|
"#007F1F",
|
|
"#3F7F4F",
|
|
"#004C13",
|
|
"#264C2F",
|
|
"#00FF7F",
|
|
"#7FFFBF",
|
|
"#00CC66",
|
|
"#66CC99",
|
|
"#00984C",
|
|
"#4C9872",
|
|
"#007F3F",
|
|
"#3F7F5F",
|
|
"#004C26",
|
|
"#264C39",
|
|
"#00FFBF",
|
|
"#7FFFDF",
|
|
"#00CC99",
|
|
"#66CCB2",
|
|
"#009872",
|
|
"#4C9885",
|
|
"#007F5F",
|
|
"#3F7F6F",
|
|
"#004C39",
|
|
"#264C42",
|
|
"#00FFFF",
|
|
"#7FFFFF",
|
|
"#00CCCC",
|
|
"#66CCCC",
|
|
"#009898",
|
|
"#4C9898",
|
|
"#007F7F",
|
|
"#3F7F7F",
|
|
"#004C4C",
|
|
"#264C4C",
|
|
"#00BFFF",
|
|
"#7FDFFF",
|
|
"#0099CC",
|
|
"#66B2CC",
|
|
"#007298",
|
|
"#4C8598",
|
|
"#005F7F",
|
|
"#3F6F7F",
|
|
"#00394C",
|
|
"#26424C",
|
|
"#007FFF",
|
|
"#7FBFFF",
|
|
"#0066CC",
|
|
"#6699CC",
|
|
"#004C98",
|
|
"#4C7298",
|
|
"#003F7F",
|
|
"#3F5F7F",
|
|
"#00264C",
|
|
"#26394C",
|
|
"#003FFF",
|
|
"#7F9FFF",
|
|
"#0033CC",
|
|
"#667FCC",
|
|
"#002698",
|
|
"#4C5F98",
|
|
"#001F7F",
|
|
"#3F4F7F",
|
|
"#00134C",
|
|
"#262F4C",
|
|
"#0000FF",
|
|
"#7F7FFF",
|
|
"#0000CC",
|
|
"#6666CC",
|
|
"#000098",
|
|
"#4C4C98",
|
|
"#00007F",
|
|
"#3F3F7F",
|
|
"#00004C",
|
|
"#26264C",
|
|
"#3F00FF",
|
|
"#9F7FFF",
|
|
"#3300CC",
|
|
"#7F66CC",
|
|
"#260098",
|
|
"#5F4C98",
|
|
"#1F007F",
|
|
"#4F3F7F",
|
|
"#13004C",
|
|
"#2F264C",
|
|
"#7F00FF",
|
|
"#BF7FFF",
|
|
"#6600CC",
|
|
"#9966CC",
|
|
"#4C0098",
|
|
"#724C98",
|
|
"#3F007F",
|
|
"#5F3F7F",
|
|
"#26004C",
|
|
"#39264C",
|
|
"#BF00FF",
|
|
"#DF7FFF",
|
|
"#9900CC",
|
|
"#B266CC",
|
|
"#720098",
|
|
"#854C98",
|
|
"#5F007F",
|
|
"#6F3F7F",
|
|
"#39004C",
|
|
"#42264C",
|
|
"#FF00FF",
|
|
"#FF7FFF",
|
|
"#CC00CC",
|
|
"#CC66CC",
|
|
"#980098",
|
|
"#984C98",
|
|
"#7F007F",
|
|
"#7F3F7F",
|
|
"#4C004C",
|
|
"#4C264C",
|
|
"#FF00BF",
|
|
"#FF7FDF",
|
|
"#CC0099",
|
|
"#CC66B2",
|
|
"#980072",
|
|
"#984C85",
|
|
"#7F005F",
|
|
"#7F3F6F",
|
|
"#4C0039",
|
|
"#4C2642",
|
|
"#FF007F",
|
|
"#FF7FBF",
|
|
"#CC0066",
|
|
"#CC6699",
|
|
"#98004C",
|
|
"#984C72",
|
|
"#7F003F",
|
|
"#7F3F5F",
|
|
"#4C0026",
|
|
"#4C2639",
|
|
"#FF003F",
|
|
"#FF7F9F",
|
|
"#CC0033",
|
|
"#CC667F",
|
|
"#980026",
|
|
"#984C5F",
|
|
"#7F001F",
|
|
"#7F3F4F",
|
|
"#4C0013",
|
|
"#4C262F",
|
|
"#333333",
|
|
"#5B5B5B",
|
|
"#848484",
|
|
"#ADADAD",
|
|
"#D6D6D6",
|
|
"#FFFFFF",
|
|
]
|
|
|
|
|
|
def get_rgbcolor(dxfcolor, parent_color="#000000"):
|
|
"""Returns hex color code corresponding to a color value
|
|
|
|
dxfcolor -- dxf code to convert to hex color code
|
|
0 (BYBLOCK) and 256 (BYLAYER) use parent_color
|
|
No more differentiation is currently done
|
|
Negative values are ignored (specification
|
|
allows layer to be hidden here)
|
|
Negative values also use parent_color
|
|
parent_color -- hex color code from parent layer.
|
|
Use default color '#000000' if
|
|
parent layer color undefined.
|
|
"""
|
|
rgbcolor = None
|
|
if dxfcolor in range(1, len(COLORS)):
|
|
rgbcolor = COLORS[dxfcolor]
|
|
if not rgbcolor:
|
|
rgbcolor = parent_color
|
|
return rgbcolor
|
|
|
|
|
|
class ValueConstruct(defaultdict):
|
|
"""Store values from the DXF and provide them as named attributes"""
|
|
|
|
values = {
|
|
"1": ("text", "default"),
|
|
"2": ("tag", "block_name"),
|
|
"3": ("mtext",),
|
|
"6": ("line_type",),
|
|
"7": ("text_style",),
|
|
"8": ("layer_name",),
|
|
"10": ("x1",),
|
|
"11": ("x2",),
|
|
"13": ("x3",),
|
|
"14": ("x4",),
|
|
"20": ("y1",),
|
|
"21": ("y2",),
|
|
"23": ("y3",),
|
|
"24": ("y4",),
|
|
"40": ("scale", "knots", "radius", "width_ratio"),
|
|
"41": ("ellipse_a1", "insert_scale_x", "mtext_width"),
|
|
"42": ("ellipse_a2", "bulge", "insert_scale_y"),
|
|
"50": ("angle",),
|
|
"51": ("angle2",),
|
|
"62": ("color",),
|
|
"70": ("fill", "flags"),
|
|
"71": ("attach_pos",),
|
|
"72": ("edge_type",),
|
|
"73": ("sweep",), # ccw
|
|
"92": ("path_type",),
|
|
"93": ("num_edges",),
|
|
"230": ("extrude",),
|
|
"370": ("line_weight",),
|
|
}
|
|
attrs = dict([(name, a) for a, b in values.items() for name in b])
|
|
|
|
def __init__(self):
|
|
super().__init__(list)
|
|
|
|
@classmethod
|
|
def is_valid(cls, key):
|
|
return key in cls.values
|
|
|
|
def __getattr__(self, attr):
|
|
is_list = attr.endswith("_list")
|
|
key = attr[:-5] if is_list else attr
|
|
if key in self.attrs:
|
|
ret = self[self.attrs[key]]
|
|
if not attr.endswith("_list"):
|
|
return ret[0]
|
|
return ret
|
|
if attr.startswith("has_"):
|
|
key = attr[4:]
|
|
if key in self.attrs:
|
|
return self.attrs[key] in self
|
|
raise AttributeError(f"Can't find dxf attribute '{key}' {attr}")
|
|
|
|
def __setattr__(self, attr, value):
|
|
if not attr in self.attrs:
|
|
raise AttributeError(f"Can't set bad dxf attribute '{attr}'")
|
|
if not isinstance(value, list):
|
|
value = [value]
|
|
self[self.attrs[attr]] = value
|
|
|
|
def adjust_coords(self, xmin, ymin, scale, extrude, height):
|
|
"""Adjust the x,y coordinates to fit on the page"""
|
|
for xgrp in set(["10", "11", "13", "14"]) & set(self): # scale/reflect x values
|
|
for i in range(len(self[xgrp])):
|
|
self[xgrp][i] = scale * (extrude * self[xgrp][i] - xmin)
|
|
for ygrp in set(["20", "21", "23", "24"]) & set(self): # scale y values
|
|
for i in range(len(self[ygrp])):
|
|
self[ygrp][i] = height - scale * (self[ygrp][i] - ymin)
|
|
|
|
|
|
export_viewport = False
|
|
export_endsec = False
|
|
|
|
|
|
def re_hex2unichar(m):
|
|
# return unichr(int(m.group(1), 16))
|
|
return chr(int(m.group(1), 16))
|
|
|
|
|
|
def formatStyle(style):
|
|
return str(inkex.Style(style))
|
|
|
|
|
|
def export_text(vals):
|
|
# mandatory group codes : (11, 12, 72, 73) (fit_x, fit_y, horizon, vertical)
|
|
# TODO: position to display at by (x2,y2) according to 72(horizon),73(vertical)
|
|
# groupcode 72:0(left),1(center),2(right),3(both side),4(middle),5(fit)
|
|
# grouocode 73:0(standard),1(floor),2(center),3(ceiling)
|
|
vals["71"].append(1) # attach=pos left in mtext
|
|
vals["70"].append(1) # text: flags=1
|
|
return export_mtext(vals)
|
|
|
|
|
|
def export_mtext(vals):
|
|
# mandatory group codes : (1 or 3, 10, 20) (text, x, y)
|
|
# TODO: text-format: \Font; \W; \Q; \L..\l etc
|
|
if (vals.has_text or vals.has_mtext) and vals.has_x1 and vals.has_y1:
|
|
x = vals.x1
|
|
y = vals.y1
|
|
# optional group codes : (21, 40, 50) (direction, text height mm, text angle)
|
|
# optional group codes : 2: char style is defined at TABLES Section
|
|
size = 12 # default fontsize in px
|
|
if vals.has_scale:
|
|
size = scale * textscale * vals.scale
|
|
|
|
dx = dy = 0
|
|
if not vals.has_flags: # as mtext, putting in the box
|
|
dy = size
|
|
|
|
anchor = "start"
|
|
if vals.has_attach_pos:
|
|
if vals.attach_pos in (2, 5, 8):
|
|
anchor = "middle"
|
|
elif vals.attach_pos in (3, 6, 9):
|
|
anchor = "end"
|
|
if vals.attach_pos in (4, 5, 6):
|
|
dy = size / 2
|
|
# if vals.has_text_style and vals.text_style in style_font3 :
|
|
# attribs = {'x': '%f' % x, 'y': '%f' % y, 'style': 'font-size: %.3fpx; fill: %s; font-family: %s' \
|
|
# % (size, color, style_font3[vals.text_style])}
|
|
# else :
|
|
# attribs = {'x': '%f' % x, 'y': '%f' % y, 'style': 'font-size: %.3fpx; fill: %s; font-family: %s' % (size, color, options.font)}
|
|
attribs = {
|
|
"x": "%f" % x,
|
|
"y": "%f" % y,
|
|
"style": "font-size: %.3fpx; fill: %s; font-family: %s; text-anchor: %s"
|
|
% (size, color, options.font, anchor),
|
|
}
|
|
|
|
angle = 0 # default angle in degrees
|
|
bVertical = False
|
|
if vals.has_angle: # TEXT only
|
|
if vals.angle != 0:
|
|
angle = vals.angle
|
|
# attribs.update({'transform': 'rotate (%f %f %f)' % (-angle, x, y)})
|
|
elif vals.has_y2 and vals.has_x2:
|
|
# MTEXT
|
|
# recover original data
|
|
# (x,y)=(scale*(x-xmin), height-scale*(y-ymin)
|
|
orgx = vals.x2 / scale + xmin
|
|
orgy = -(vals.y2 - height) / scale + ymin
|
|
unit = math.sqrt(orgy * orgy + orgx * orgx)
|
|
if (unit < 1.01) and (unit > 0.99):
|
|
ang1 = math.atan2(orgy, orgx)
|
|
angle = 180 * ang1 / math.pi
|
|
# attribs.update({'transform': 'rotate (%f %f %f)' % (-angle, x, y)})
|
|
|
|
if vals.has_text_style and vals.text_style in style_direction:
|
|
if style_direction[vals.text_style] & 4:
|
|
# angle = -90
|
|
# attribs.update({'transform': 'rotate (%f %f %f)' % (-angle, x, y)})
|
|
bVertical = True
|
|
angle = 0
|
|
dx = size
|
|
attribs = {
|
|
"x": "%f" % x,
|
|
"y": "%f" % y,
|
|
"style": "font-size: %.3fpx; fill: %s; font-family: %s; text-anchor: %s; writing-mode: tb"
|
|
% (size, color, options.font, anchor),
|
|
}
|
|
if angle != 0:
|
|
attribs.update({"transform": "rotate (%f %f %f)" % (-angle, x, y)})
|
|
|
|
node = layer.add(inkex.TextElement(**attribs))
|
|
node.set("sodipodi:linespacing", "125%")
|
|
text = ""
|
|
if vals.has_mtext:
|
|
text = "".join(vals.mtext_list)
|
|
if vals.has_text:
|
|
text += vals.text
|
|
# folding long text
|
|
if vals.has_mtext_width and vals.has_scale:
|
|
if vals.mtext_width > 10.0 and vals.scale > 1.0:
|
|
charsperline = vals.mtext_width * 2 / vals.scale # or 1.6?
|
|
nochars = int(charsperline)
|
|
if len(text) > charsperline:
|
|
# plain text only no \P,{} better divide by space
|
|
if (text.find(r"\P") < 0) and (text.find(r"{") < 0):
|
|
pos = 0
|
|
while len(text) > pos:
|
|
text = text[:pos] + r"\P" + text[pos:]
|
|
pos += nochars + 2
|
|
|
|
text = mtext_normalize(text)
|
|
lines = 0
|
|
found = text.find(r"\P") # new line
|
|
while found > -1:
|
|
tspan = node.add(inkex.Tspan())
|
|
if bVertical:
|
|
tspan.set("y", "%f" % y)
|
|
if lines > 0:
|
|
tspan.set("dx", "%f" % size)
|
|
else:
|
|
tspan.set("sodipodi:role", "line")
|
|
if lines > 0:
|
|
tspan.set("x", x + dx)
|
|
else:
|
|
tspan.set("dx", "%f" % dx)
|
|
tspan.set("dy", "%f" % dy)
|
|
# tspan.text = text[:found]
|
|
text1 = text[:found]
|
|
mtext_separate(node, tspan, text1)
|
|
text = text[(found + 2) :]
|
|
found = text.find(r"\P")
|
|
lines += 1
|
|
|
|
tspan = node.add(inkex.Tspan())
|
|
if bVertical:
|
|
tspan.set("y", "%f" % y)
|
|
if lines > 0:
|
|
tspan.set("dx", "%f" % dx)
|
|
else:
|
|
tspan.set("sodipodi:role", "line")
|
|
if lines > 0:
|
|
tspan.set("x", x + dx)
|
|
else:
|
|
tspan.set("dx", "%f" % dx)
|
|
tspan.set("dy", "%f" % dy)
|
|
# tspan.text = text
|
|
text1 = text
|
|
mtext_separate(node, tspan, text1)
|
|
|
|
|
|
def mtext_normalize(text):
|
|
# { \P } -> { }\P{ }
|
|
found = text.find(r"\P")
|
|
while found > -1:
|
|
nest = False
|
|
posL = text.rfind(r"{", 0, found)
|
|
posR = text.rfind(r"}", 0, found)
|
|
if posL > -1:
|
|
if posR == -1:
|
|
nest = True
|
|
else:
|
|
if posL > posR:
|
|
nest = True
|
|
if nest:
|
|
# paste }\P{
|
|
control = ""
|
|
if text[posL + 1] == "\\":
|
|
posC = text.find(r";", posL)
|
|
if posC != -1 and (posC - posL) < 20:
|
|
control = text[posL + 1 : posC + 1]
|
|
text = text[:found] + r"}\P{" + control + text[found + 2 :]
|
|
found = text.find(r"\P", found + 2)
|
|
return text
|
|
|
|
|
|
def mtext_separate(node, tspan, text):
|
|
# sparate aaa{bbb}(ccc) -> aaa,bbb.ccc
|
|
tspanAdd = True
|
|
found = text.find(r"{")
|
|
while found > -1:
|
|
if found == 0:
|
|
found1 = text.find(r"}")
|
|
if found1 < 1:
|
|
break
|
|
text1 = text[:found1] # tspan
|
|
text1 = text1[found + 1 :]
|
|
if tspanAdd == False:
|
|
tspan = node.add(inkex.Tspan())
|
|
mtext_ctrl(tspan, text1)
|
|
# tspan.text = text1 +'+1'
|
|
tspanAdd = False
|
|
text = text[found1 + 1 :]
|
|
found = text.find(r"{")
|
|
else:
|
|
text1 = text[:found] # tspan
|
|
if tspanAdd == False:
|
|
tspan = node.add(inkex.Tspan())
|
|
mtext_ctrl(tspan, text1)
|
|
# tspan.text = text1 +'+2'
|
|
tspanAdd = False
|
|
text = text[found:]
|
|
found = 0
|
|
|
|
if len(text) > 0:
|
|
text1 = text
|
|
if tspanAdd == False:
|
|
tspan = node.add(inkex.Tspan())
|
|
mtext_ctrl(tspan, text1)
|
|
# tspan.text = text1 +'+3'
|
|
tspanAdd = False
|
|
|
|
|
|
def mtext_ctrl(tspan, phrase):
|
|
if len(phrase) == 0:
|
|
return
|
|
if phrase[0] != "\\":
|
|
tspan.text = phrase
|
|
return
|
|
# if you'll add the function, you should remove the auto re.sub at setting group code:1
|
|
if phrase[1].upper() in ("C", "H", "T", "Q", "W", "A"):
|
|
# get the value
|
|
found = phrase.find(r";")
|
|
if found > 2:
|
|
cvalue = phrase[:found]
|
|
cvalue = cvalue[2:]
|
|
try:
|
|
value = float(cvalue)
|
|
except ValueError:
|
|
done = False
|
|
else:
|
|
done = True
|
|
if phrase[1].upper() == "C":
|
|
i = int(value)
|
|
color = get_rgbcolor(i)
|
|
tspan.set("style", "stroke: %s" % color)
|
|
elif phrase[1].upper() == "H":
|
|
value *= scale
|
|
tspan.set("style", "font-size: %.3fpx;" % value)
|
|
elif phrase[1].upper() == "T":
|
|
tspan.set("style", "letter-spacing: %f;" % value)
|
|
elif phrase[1].upper() == "A":
|
|
if value == 0:
|
|
tspan.set("dominant-baseline", "text-bottom")
|
|
elif value == 1:
|
|
tspan.set("dominant-baseline", "central")
|
|
elif value == 2:
|
|
tspan.set("dominant-baseline", "text-top")
|
|
tspan.text = phrase[found + 1 :]
|
|
else:
|
|
tspan.text = phrase
|
|
else:
|
|
if phrase[1].upper() == "F":
|
|
# get the value font-name & style & cut from text 2022.March
|
|
# \FArial|b0|i0|c0|p0; b:bold,i:italic,c:charset,ppitch
|
|
found = phrase.find(r";")
|
|
if found > 2:
|
|
cvalue = phrase[:found]
|
|
tspan.text = phrase[found + 1 :]
|
|
else:
|
|
tspan.text = phrase
|
|
|
|
|
|
def export_point(vals, w):
|
|
# mandatory group codes : (10, 20) (x, y)
|
|
if vals.has_x1 and vals.has_y1:
|
|
if vals["70"]:
|
|
inkex.errormsg("$PDMODE is ignored. A point is displayed as normal.")
|
|
if options.gcodetoolspoints:
|
|
generate_gcodetools_point(vals.x1, vals.y1)
|
|
else:
|
|
generate_ellipse(vals.x1, vals.y1, w / 2, 0.0, 1.0, 0.0, 0.0)
|
|
|
|
|
|
def export_line(vals):
|
|
"""Draw a straight line from the dxf"""
|
|
# mandatory group codes : (10, 11, 20, 21) (x1, x2, y1, y2)
|
|
if vals.has_x1 and vals.has_x2 and vals.has_y1 and vals.has_y2:
|
|
path = inkex.PathElement()
|
|
path.style = style
|
|
path.path = "M %f,%f %f,%f" % (vals.x1, vals.y1, vals.x2, vals.y2)
|
|
layer.add(path)
|
|
|
|
|
|
def export_solid(vals):
|
|
# arrows of dimension
|
|
# mandatory group codes : (10, 11, 12, 20, 21, 22) (x1, x2, x3, y1, y2, y3)
|
|
# TODO: 4th point
|
|
if (
|
|
vals.has_x1
|
|
and vals.has_x2
|
|
and vals.has_x3
|
|
and vals.has_y1
|
|
and vals.has_y2
|
|
and vals.has_y3
|
|
):
|
|
path = inkex.PathElement()
|
|
path.style = style
|
|
path.path = "M %f,%f %f,%f %f,%f z" % (
|
|
vals.x1,
|
|
vals.y1,
|
|
vals.x2,
|
|
vals.y2,
|
|
vals.x3,
|
|
vals.y3,
|
|
)
|
|
layer.add(path)
|
|
|
|
|
|
def export_spline(vals):
|
|
# see : http://www.mactech.com/articles/develop/issue_25/schneider.html
|
|
# mandatory group codes : (10, 20, 40, 70) (x[], y[], knots[], flags)
|
|
if (
|
|
vals.has_flags
|
|
and vals.has_knots
|
|
and vals.x1_list
|
|
and len(vals.x1_list) == len(vals.y1_list)
|
|
):
|
|
knots = vals.knots_list
|
|
ctrls = len(vals.x1_list)
|
|
if ctrls > 3 and len(knots) == ctrls + 4: # cubic
|
|
if ctrls > 4:
|
|
for i in range(len(knots) - 5, 3, -1):
|
|
if knots[i] != knots[i - 1] and knots[i] != knots[i + 1]:
|
|
a0 = (knots[i] - knots[i - 2]) / (knots[i + 1] - knots[i - 2])
|
|
a1 = (knots[i] - knots[i - 1]) / (knots[i + 2] - knots[i - 1])
|
|
vals.x1_list.insert(
|
|
i - 1,
|
|
(1.0 - a1) * vals.x1_list[i - 2] + a1 * vals.x1_list[i - 1],
|
|
)
|
|
vals.y1_list.insert(
|
|
i - 1,
|
|
(1.0 - a1) * vals.y1_list[i - 2] + a1 * vals.y1_list[i - 1],
|
|
)
|
|
vals.x1_list[i - 2] = (1.0 - a0) * vals.x1_list[
|
|
i - 3
|
|
] + a0 * vals.x1_list[i - 2]
|
|
vals.y1_list[i - 2] = (1.0 - a0) * vals.y1_list[
|
|
i - 3
|
|
] + a0 * vals.y1_list[i - 2]
|
|
knots.insert(i, knots[i])
|
|
for i in range(len(knots) - 6, 3, -2):
|
|
if (
|
|
knots[i] != knots[i + 2]
|
|
and knots[i - 1] != knots[i + 1]
|
|
and knots[i - 2] != knots[i]
|
|
):
|
|
a1 = (knots[i] - knots[i - 1]) / (knots[i + 2] - knots[i - 1])
|
|
vals.x1_list.insert(
|
|
i - 1,
|
|
(1.0 - a1) * vals.x1_list[i - 2] + a1 * vals.x1_list[i - 1],
|
|
)
|
|
vals.y1_list.insert(
|
|
i - 1,
|
|
(1.0 - a1) * vals.y1_list[i - 2] + a1 * vals.y1_list[i - 1],
|
|
)
|
|
ctrls = len(vals.x1_list)
|
|
path = "M %f,%f" % (vals.x1, vals.y1)
|
|
for i in range(0, (ctrls - 1) // 3):
|
|
path += " C %f,%f %f,%f %f,%f" % (
|
|
vals.x1_list[3 * i + 1],
|
|
vals.y1_list[3 * i + 1],
|
|
vals.x1_list[3 * i + 2],
|
|
vals.y1_list[3 * i + 2],
|
|
vals.x1_list[3 * i + 3],
|
|
vals.y1_list[3 * i + 3],
|
|
)
|
|
if vals.flags & 1: # closed path
|
|
path += " z"
|
|
attribs = {"d": path, "style": style}
|
|
etree.SubElement(layer, "path", attribs)
|
|
if ctrls == 3 and len(knots) == 6: # quadratic
|
|
path = "M %f,%f Q %f,%f %f,%f" % (
|
|
vals.x1,
|
|
vals.y1,
|
|
vals.x1_list[1],
|
|
vals.y1_list[1],
|
|
vals.x1_list[2],
|
|
vals.y1_list[2],
|
|
)
|
|
attribs = {"d": path, "style": style}
|
|
etree.SubElement(layer, "path", attribs)
|
|
if ctrls == 5 and len(knots) == 8: # spliced quadratic
|
|
path = "M %f,%f Q %f,%f %f,%f Q %f,%f %f,%f" % (
|
|
vals.x1,
|
|
vals.y1,
|
|
vals.x1_list[1],
|
|
vals.y1_list[1],
|
|
vals.x1_list[2],
|
|
vals.y1_list[2],
|
|
vals.x1_list[3],
|
|
vals.y1_list[3],
|
|
vals.x1_list[4],
|
|
vals.y1_list[4],
|
|
)
|
|
attribs = {"d": path, "style": style}
|
|
etree.SubElement(layer, "path", attribs)
|
|
|
|
|
|
def export_circle(vals):
|
|
# mandatory group codes : (10, 20, 40) (x, y, radius)
|
|
if vals.has_x1 and vals.has_y1 and vals.has_radius:
|
|
generate_ellipse(vals.x1, vals.y1, scale * vals.radius, 0.0, 1.0, 0.0, 0.0)
|
|
|
|
|
|
def export_arc(vals):
|
|
# mandatory group codes : (10, 20, 40, 50, 51) (x, y, radius, angle1, angle2)
|
|
if (
|
|
vals.has_x1
|
|
and vals.has_y1
|
|
and vals.has_radius
|
|
and vals.has_angle
|
|
and vals.has_angle2
|
|
):
|
|
generate_ellipse(
|
|
vals.x1,
|
|
vals.y1,
|
|
scale * vals.radius,
|
|
0.0,
|
|
1.0,
|
|
vals.angle * math.pi / 180.0,
|
|
vals.angle2 * math.pi / 180.0,
|
|
)
|
|
|
|
|
|
def export_ellipse(vals):
|
|
# mandatory group codes : (10, 11, 20, 21, 40, 41, 42) (xc, xm, yc, ym, width ratio, angle1, angle2)
|
|
if (
|
|
vals.has_x1
|
|
and vals.has_x2
|
|
and vals.has_y1
|
|
and vals.has_y2
|
|
and vals.has_width_ratio
|
|
and vals.has_ellipse_a1
|
|
and vals.has_ellipse_a2
|
|
):
|
|
# generate_ellipse(vals.x1, vals.y1, scale*vals.x2, scale*vals.y2, vals.width_ratio, vals.ellipse_a1, vals.ellipse_a2)
|
|
# vals are through adjust_coords : recover proper value
|
|
# (x,y)=(scale*x-xmin, height-scale*y-ymin)
|
|
x2 = vals.x2 + xmin
|
|
y2 = -vals.y2 + ymin + height
|
|
generate_ellipse(
|
|
vals.x1, vals.y1, x2, y2, vals.width_ratio, vals.ellipse_a1, vals.ellipse_a2
|
|
)
|
|
|
|
|
|
def export_leader(vals):
|
|
# mandatory group codes : (10, 20) (x, y)
|
|
if vals.has_x1 and vals.has_y1:
|
|
if len(vals.x1_list) > 1 and len(vals.y1_list) == len(vals.x1_list):
|
|
path = "M %f,%f" % (vals.x1, vals.y1)
|
|
for i in range(1, len(vals.x1_list)):
|
|
path += " %f,%f" % (vals.x1_list[i], vals.y1_list[i])
|
|
attribs = {"d": path, "style": style}
|
|
etree.SubElement(layer, "path", attribs)
|
|
|
|
|
|
def export_polyline(vals):
|
|
return export_lwpolyline(vals)
|
|
|
|
|
|
def export_lwpolyline(vals):
|
|
# mandatory group codes : (10, 20, 70) (x, y, flags)
|
|
if vals.has_x1 and vals.has_y1 and vals.has_flags:
|
|
if len(vals.x1_list) > 1 and len(vals.y1_list) == len(vals.x1_list):
|
|
# optional group codes : (42) (bulge)
|
|
iseqs = 0
|
|
ibulge = 0
|
|
if vals.flags & 1: # closed path
|
|
seqs.append("20")
|
|
vals.x1_list.append(vals.x1)
|
|
vals.y1_list.append(vals.y1)
|
|
while seqs[iseqs] != "20":
|
|
iseqs += 1
|
|
path = "M %f,%f" % (vals.x1, vals.y1)
|
|
xold = vals.x1
|
|
yold = vals.y1
|
|
for i in range(1, len(vals.x1_list)):
|
|
bulge = 0
|
|
iseqs += 1
|
|
while seqs[iseqs] != "20":
|
|
if seqs[iseqs] == "42":
|
|
bulge = vals.bulge_list[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.x1_list[i] - xold) ** 2 + (vals.y1_list[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.x1_list[i],
|
|
vals.y1_list[i],
|
|
)
|
|
else:
|
|
path += " L %f,%f" % (vals.x1_list[i], vals.y1_list[i])
|
|
xold = vals.x1_list[i]
|
|
yold = vals.y1_list[i]
|
|
if vals.flags & 1: # closed path
|
|
path += " z"
|
|
attribs = {"d": path, "style": style}
|
|
etree.SubElement(layer, "path", attribs)
|
|
|
|
|
|
def export_hatch(vals):
|
|
# mandatory group codes : (10, 20, 70, 72, 92, 93) (x, y, fill, Edge Type, Path Type, Number of edges)
|
|
# TODO: Hatching Pattern
|
|
if (
|
|
vals.has_x1
|
|
and vals.has_y1
|
|
and vals.has_fill
|
|
and vals.has_edge_type
|
|
and vals.has_path_type
|
|
and vals.has_num_edges
|
|
):
|
|
if len(vals.x1_list) > 1 and len(vals.y1_list) == len(vals.x1_list):
|
|
# 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.num_edges_list)):
|
|
xc = vals.x1_list[i10]
|
|
yc = vals.y1_list[i10]
|
|
if vals.edge_type_list[i72] == 2: # arc
|
|
rm = scale * vals.radius_list[i40]
|
|
a1 = vals.angle_list[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.num_edges_list[i]):
|
|
if vals.path_type_list[i] & 2: # polyline
|
|
if j > 0:
|
|
path += "L %f,%f " % (vals.x1_list[i10], vals.y1_list[i10])
|
|
if j == vals.path_type_list[i] - 1:
|
|
i72 += 1
|
|
elif vals.edge_type_list[i72] == 2: # arc
|
|
xc = vals.x1_list[i10]
|
|
yc = vals.y1_list[i10]
|
|
rm = scale * vals.radius_list[i40]
|
|
a2 = vals.angle2_list[i40]
|
|
diff = (a2 - a1 + 360) % 360
|
|
sweep = 1 - vals.sweep_list[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.edge_type_list[i72] == 1: # line
|
|
path += "L %f,%f " % (vals.x2_list[i11], vals.y2_list[i11])
|
|
i11 += 1
|
|
i72 += 1
|
|
i10 += 1
|
|
path += "z "
|
|
if vals.has_fill:
|
|
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(vals):
|
|
# mandatory group codes : (10, 11, 13, 14, 20, 21, 23, 24) (x1..4, y1..4)
|
|
# block_name: dimension definition for 10mm
|
|
if vals.has_x1 and vals.has_x2 and vals.has_y1 and vals.has_y2:
|
|
if vals.has_block_name:
|
|
attribs = {
|
|
inkex.addNS("href", "xlink"): "#%s" % (vals.block_name)
|
|
} # not use quote because name *D2 etc. changed to %2AD2
|
|
tform = "translate(0 0)"
|
|
# if vals.has_angle :
|
|
# tform += ' rotate(%f,%f,%f)' % (vals.angle,vals.x4,vals.y4)
|
|
attribs.update({"transform": tform})
|
|
etree.SubElement(layer, "use", attribs)
|
|
else:
|
|
# TODO: improve logic when INSERT in BLOCK
|
|
dx = abs(vals.x1 - vals.x3)
|
|
dy = abs(vals.y1 - vals.y3)
|
|
if (vals.x1 == vals.x4) and dx > 0.00001:
|
|
d = dx / scale
|
|
dy = 0
|
|
path = "M %f,%f %f,%f" % (vals.x1, vals.y1, vals.x3, vals.y1)
|
|
elif (vals.y1 == vals.y4) and dy > 0.00001:
|
|
d = dy / scale
|
|
dx = 0
|
|
path = "M %f,%f %f,%f" % (vals.x1, vals.y1, vals.x1, vals.y3)
|
|
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 = vals.x2
|
|
y = vals.y2
|
|
size = 12 # default fontsize in px
|
|
if vals.has_mtext:
|
|
if vals.mtext in DIMTXT:
|
|
size = scale * textscale * DIMTXT[vals.mtext]
|
|
if size < 2:
|
|
size = 2
|
|
attribs = {
|
|
"x": "%f" % x,
|
|
"y": "%f" % y,
|
|
"style": "font-size: %.3fpx; 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(vals):
|
|
# mandatory group codes : (2, 10, 20) (block name, x, y)
|
|
# TODO: repeat by row and column
|
|
# (times,interval)= row(70,44), column(71,45)
|
|
|
|
if vals.has_block_name and vals.has_x1 and vals.has_y1:
|
|
# vals are through adjust_coords except block
|
|
# block (x,y)=(0,0) : (scale*x-xmin, height-scale*y-ymin)
|
|
# translate(move x units,move y units)
|
|
# 2021.6 translate..ok scale..x rotate X
|
|
# as scale, the line is wider ->same width -> you should fix
|
|
global height
|
|
cx = scale * xmin # transorm-origin:
|
|
cy = scale * ymin + height # center of rotation
|
|
|
|
x = vals.x1 + scale * xmin
|
|
y = vals.y1 - scale * ymin - height
|
|
ixscale = iyscale = 1
|
|
if vals.has_insert_scale_y:
|
|
ixscale = vals.insert_scale_x
|
|
if vals.has_insert_scale_y:
|
|
iyscale = vals.insert_scale_y
|
|
x += cx * (iyscale - 1)
|
|
y -= cy * (iyscale - 1)
|
|
|
|
elem = layer.add(inkex.Use())
|
|
elem.set(
|
|
inkex.addNS("href", "xlink"),
|
|
"#" + quote(vals.block_name.replace(" ", "_").encode("utf-8")),
|
|
)
|
|
|
|
# add style stroke-width=1px for reducing thick line
|
|
fwide = abs(0.5 / ixscale) # better to use w/ixscale
|
|
elem.style["stroke-width"] = "%.3fpx" % fwide
|
|
|
|
elem.transform.add_translate(x, y)
|
|
if vals.has_insert_scale_x and vals.has_insert_scale_y:
|
|
elem.transform.add_scale(ixscale, iyscale)
|
|
if vals.has_angle:
|
|
rotated_angle = vals.angle
|
|
if ixscale * iyscale > 0:
|
|
rotated_angle = 360 - rotated_angle
|
|
elem.transform.add_rotate(rotated_angle, -cx, cy)
|
|
|
|
|
|
def export_block(vals):
|
|
# mandatory group codes : (2) (block name)
|
|
if vals.has_block_name:
|
|
global block
|
|
block = etree.SubElement(
|
|
defs, "symbol", {"id": vals.block_name.replace(" ", "_")}
|
|
)
|
|
|
|
|
|
def export_endblk(vals):
|
|
global block
|
|
block = defs # initiallize with dummy
|
|
|
|
|
|
def export_attdef(vals):
|
|
# mandatory group codes : (1, 2) (default, tag)
|
|
if vals.has_default and vals.has_tag:
|
|
vals.text_list.append(vals.tag)
|
|
export_mtext(vals)
|
|
|
|
|
|
def generate_ellipse(xc, yc, xm, ym, w, a1, a2):
|
|
rm = math.sqrt(xm * xm + ym * ym)
|
|
a = math.atan2(ym, xm) # x-axis-rotation
|
|
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 0, 0 %f,%f A %f,%f %f 0, 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
|
|
|
|
|
|
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("--textscale", default="1.0")
|
|
pars.add_argument("--xmin", default="0.0")
|
|
pars.add_argument("--ymin", default="0.0")
|
|
pars.add_argument("--gcodetoolspoints", default=False, 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 seqs
|
|
global style
|
|
global layer
|
|
global scale
|
|
global textscale
|
|
global color
|
|
global extrude
|
|
global xmin
|
|
global ymin
|
|
global height
|
|
global DIMTXT
|
|
global block
|
|
global svg
|
|
global style_font3
|
|
global style_direction
|
|
global be_extrude
|
|
|
|
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
|
|
ltscale = 1.0 # $LTSCALE:global scale of line-style
|
|
height = 297.0 * 96.0 / 25.4 # default A4 height in pixels
|
|
measurement = 0 # default inches
|
|
flag = 0 # (0, 1, 2, 3, 4) = (none, LAYER, LTYPE, DIMTXT, STYLE)
|
|
layer_colors = {} # store colors by layer
|
|
layer_nodes = {} # store nodes by layer
|
|
linetypes = {} # store linetypes by name
|
|
DIMTXT = {} # store DIMENSION text sizes
|
|
# style_name = {} # style name
|
|
style_font3 = {} # style font 1byte
|
|
style_font4 = {} # style font 2byte
|
|
style_direction = {} # style display direction
|
|
be_extrude = False
|
|
line = get_line()
|
|
|
|
if line[0] == "AutoCAD Binary DXF":
|
|
inkex.errormsg(
|
|
_(
|
|
"Inkscape cannot read binary DXF files. \n"
|
|
"Please convert to ASCII format first."
|
|
)
|
|
+ str(len(line[0]))
|
|
+ " "
|
|
+ str(len(line[1]))
|
|
)
|
|
self.document = doc
|
|
return
|
|
|
|
inENTITIES = False
|
|
style_name = "*"
|
|
layername = None
|
|
linename = None
|
|
stylename = None
|
|
style_name = None
|
|
errno = 0
|
|
pdmode_err = False
|
|
while line[0] and line[1] != "BLOCKS":
|
|
line = get_line()
|
|
if line[1] == "ENTITIES": # no BLOCK SECTION
|
|
inENTITIES = True
|
|
break
|
|
if line[1] == "$PDMODE" and not pdmode_err:
|
|
inkex.errormsg("$PDMODE is ignored. A point is displayed as normal.")
|
|
pdmode_err = True
|
|
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 line[1] == "$LTSCALE":
|
|
ltscale = get_group("40")
|
|
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 flag == 4 and line[0] == "2":
|
|
style_name = line[1]
|
|
style_font3[style_name] = []
|
|
style_font4[style_name] = []
|
|
style_direction[style_name] = []
|
|
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 line[0] == "2" and line[1] == "STYLE":
|
|
flag = 4
|
|
if flag == 1 and line[0] == "62":
|
|
if layername is None:
|
|
errno = 1
|
|
break
|
|
layer_colors[layername] = int(line[1])
|
|
if flag == 2 and line[0] == "49":
|
|
if linename is None:
|
|
errno = 2
|
|
break
|
|
linetypes[linename].append(float(line[1]))
|
|
if flag == 3 and line[0] == "140":
|
|
if stylename is None:
|
|
errno = 3
|
|
break
|
|
DIMTXT[stylename] = float(line[1])
|
|
if flag == 4 and line[0] == "3":
|
|
if style_name is None:
|
|
errno = 4
|
|
break
|
|
style_font3[style_name].append(line[1])
|
|
if flag == 4 and line[0] == "4":
|
|
if style_name is None:
|
|
errno = 4
|
|
break
|
|
style_font4[style_name].append(line[1])
|
|
if flag == 4 and line[0] == "70": # not no of STYLE
|
|
if style_name != "*":
|
|
style_direction[style_name] = int(line[1])
|
|
if line[0] == "0" and line[1] == "ENDTAB":
|
|
flag = 0
|
|
if errno != 0:
|
|
if errno == 1:
|
|
errMsg = "LAYER"
|
|
elif errno == 2:
|
|
errMsg = "LTYPE"
|
|
elif errno == 3:
|
|
errMsg = "DIMSTYLE"
|
|
else: # errno == 4
|
|
errMsg = "STYLE"
|
|
inkex.errormsg(
|
|
"Import stopped. DXF is incorrect.\ngroup code 2 ("
|
|
+ errMsg
|
|
+ ") is missing"
|
|
)
|
|
self.document = doc
|
|
return
|
|
|
|
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.desc = "%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
|
|
textscale = float(options.textscale)
|
|
|
|
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 * ltscale)
|
|
if linetype == "":
|
|
linetypes[linename] = "stroke-linecap: round"
|
|
else:
|
|
linetypes[linename] = "stroke-dasharray:" + linetype
|
|
|
|
entity = ""
|
|
block = defs # initiallize with dummy
|
|
while line[0] and (line[1] != "ENDSEC" or not inENTITIES):
|
|
line = get_line()
|
|
if line[1] == "ENTITIES":
|
|
inENTITIES = True
|
|
if entity and vals.is_valid(line[0]):
|
|
seqs.append(line[0]) # list of group codes
|
|
if line[0] in ("1", "2", "3", "6", "7", "8"): # text value
|
|
# TODO: if add funs of export_mtext, delete the line
|
|
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) {\\C; '}' in mtext
|
|
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] in ("62", "70", "92", "93"):
|
|
val = int(line[1])
|
|
else: # unscaled float value
|
|
val = float(line[1])
|
|
vals[line[0]].append(val)
|
|
elif has_export(line[1]):
|
|
if has_export(entity):
|
|
if block != defs: # in a BLOCK
|
|
layer = block
|
|
elif vals.has_layer_name: # use Common Layer Name
|
|
if not vals.layer_name:
|
|
vals.layer_name = "0" # use default name
|
|
if vals.layer_name not in layer_nodes:
|
|
# attribs = {inkex.addNS('groupmode','inkscape') :
|
|
# 'layer', inkex.addNS('label','inkscape') : '%s' % vals.layer_name}
|
|
# layer_nodes[vals.layer_name] = etree.SubElement(doc.getroot(), 'g', attribs)
|
|
layer_nodes[vals.layer_name] = svg.add(
|
|
inkex.Layer.new(vals.layer_name)
|
|
)
|
|
layer = layer_nodes[vals.layer_name]
|
|
color = "#000000" # default color
|
|
if vals.has_layer_name:
|
|
if vals.layer_name in layer_colors:
|
|
color = get_rgbcolor(layer_colors[vals.layer_name], color)
|
|
if vals.has_color: # Common Color Number
|
|
color = get_rgbcolor(vals.color, color)
|
|
style = formatStyle({"stroke": "%s" % color, "fill": "none"})
|
|
w = 0.5 # default lineweight for POINT
|
|
if vals.has_line_weight: # Common Lineweight
|
|
if vals.line_weight > 0:
|
|
w = 96.0 / 25.4 * vals.line_weight / 100.0
|
|
w *= scale # real wide : line_weight /144 inch
|
|
if w < 0.5:
|
|
w = 0.5
|
|
if (
|
|
block == defs
|
|
): # not in a BLOCK for INSERT except stroke-width 2021.july
|
|
style = formatStyle(
|
|
{
|
|
"stroke": "%s" % color,
|
|
"fill": "none",
|
|
"stroke-width": "%.3f" % w,
|
|
}
|
|
)
|
|
if vals.has_line_type: # Common Linetype
|
|
if vals.line_type in linetypes:
|
|
style += ";" + linetypes[vals.line_type]
|
|
extrude = 1.0
|
|
if vals.has_extrude:
|
|
if (entity != "LINE") and (entity != "POINT"):
|
|
extrude = float(vals.extrude)
|
|
if extrude < 1.0:
|
|
be_extrude = True
|
|
|
|
vals.adjust_coords(xmin, ymin, scale, extrude, height)
|
|
|
|
if extrude == -1.0: # reflect angles
|
|
if vals.has_angle and vals.has_angle2:
|
|
vals.angle2, vals.angle = (
|
|
180.0 - vals.angle,
|
|
180.0 - vals.angle2,
|
|
)
|
|
exporter = get_export(entity)
|
|
if exporter:
|
|
if entity == "POINT":
|
|
exporter(vals, w)
|
|
else:
|
|
exporter(vals)
|
|
|
|
if line[1] == "POLYLINE":
|
|
inVertexs = False
|
|
entity = "LWPOLYLINE"
|
|
vals = ValueConstruct()
|
|
seqs = []
|
|
flag70 = 0 # default closed-line or not
|
|
val8 = "0" # default layer name
|
|
val10 = 0 # x
|
|
val20 = 0 # y
|
|
val42 = 0 # bulge
|
|
valid = True
|
|
while line[0] and (line[1] != "SEQEND"):
|
|
line = get_line()
|
|
if line[1] == "VERTEX":
|
|
if inVertexs == True:
|
|
if valid:
|
|
seqs.append("10")
|
|
vals["10"].append(val10)
|
|
seqs.append("20")
|
|
vals["20"].append(val20)
|
|
seqs.append("42")
|
|
vals["42"].append(val42)
|
|
val42 = 0
|
|
inVertexs = True
|
|
valid = True
|
|
if inVertexs == False:
|
|
if line[0] == "6": # 6:line style
|
|
seqs.append(line[0])
|
|
vals[line[0]].append(line[1])
|
|
if line[0] == "8": # 8:layer
|
|
val8 = line[1]
|
|
if line[0] == "70": # flag
|
|
flag70 = int(line[1])
|
|
else:
|
|
if line[0] == "70":
|
|
if int(line[1]) == 16: # control point
|
|
valid = False
|
|
if line[0] in ("10", "20", "42"): # vertexs
|
|
val = float(line[1])
|
|
if line[0] == "10":
|
|
val10 = val
|
|
elif line[0] == "20":
|
|
val20 = val
|
|
else:
|
|
val42 = val
|
|
if valid:
|
|
seqs.append("8") # layer_name
|
|
vals["8"].append(val8)
|
|
seqs.append("10")
|
|
vals["10"].append(val10)
|
|
seqs.append("20")
|
|
vals["20"].append(val20)
|
|
seqs.append("42") # bulge
|
|
vals["42"].append(val42)
|
|
seqs.append("70") # closed line?
|
|
vals["70"].append(flag70)
|
|
continue
|
|
|
|
entity = line[1]
|
|
vals = ValueConstruct()
|
|
seqs = []
|
|
|
|
# for debug
|
|
# tree = etree.ElementTree(svg)
|
|
# tree.write('c:\Python\svgCH2.xml')
|
|
if be_extrude:
|
|
inkex.errormsg(
|
|
_(
|
|
"An object that has the extrude parameter set was detected. "
|
|
"The imported figure may be displayed incorrectly."
|
|
)
|
|
)
|
|
self.document = doc
|
|
|
|
|
|
def get_export(opt):
|
|
return globals().get("export_" + opt.lower(), None)
|
|
|
|
|
|
def has_export(opt):
|
|
return get_export(opt) is not None
|
|
|
|
|
|
if __name__ == "__main__":
|
|
DxfInput().run()
|
|
|