def DrawCreator(name, type, parameter, material, thickness=0, address=dirc):
file_name = name + '.dxf' #加一步判据
file_name = re.sub('[\\\]|[\/]|[\*]', '_', file_name)
drawing = dxf.drawing(file_name)
if 'od' in parameter and not ('id' in parameter):
drawing.add(dxf.circle(radius=(parameter['od']) / 2, center=(0, 0)))
# drawing.add(dxf.text(file_name,height=parameter[0]/4,alignpoint =(0,0)))
elif 'od' in parameter and 'id' in parameter and not ('angle'
in parameter):
drawing.add(dxf.circle(radius=(parameter['od']) / 2, center=(0, 0)))
drawing.add(dxf.circle(radius=(parameter['id']) / 2, center=(0, 0)))
# drawing.add(dxf.text(file_name,height=parameter[1]/4, alignpoint =(0,0)))
elif 'od' in parameter and 'id' in parameter and 'angle' in parameter:
drawing.add(
dxf.arc(radius=parameter['od'] / 2,
center=(0, 0),
startangle=0,
endangle=parameter['angle']))
drawing.add(
dxf.arc(radius=(parameter['id']) / 2,
center=(0, 0),
startangle=0,
endangle=parameter['angle']))
drawing.add(
dxf.polyline(points=[(parameter['od'] / 2,
0), ((parameter['id']) / 2, 0)]))
drawing.add(
dxf.polyline(
points=[((parameter['od']) / 2 *
math.cos(parameter['angle'] * math.pi / 180),
(parameter['od']) / 2 *
math.sin(parameter['angle'] * math.pi / 180)),
((parameter['id']) / 2 *
math.cos(parameter['angle'] * math.pi / 180),
(parameter['id']) / 2 *
math.sin(parameter['angle'] * math.pi / 180))]))
elif 'w' in parameter and 'l' in parameter:
drawing.add(
dxf.polyline(points=[(0, 0), (
0, parameter['w']), (parameter['l'],
parameter['w']), (parameter['l'],
0), (0, 0)]))
else:
print(file_name + '无对应图形')
# 创建对应_厚度_的文件夹
if not path.exists(address + '//' + '材料_' + material + '_厚度_' +
str(thickness)):
#如果文件夹不存在创建
mkdir(address + '//' + '材料_' + material + '_厚度_' + str(thickness))
chdir(address + '\\材料_' + material + '_厚度_' + str(thickness))
drawing.save()
def main():
parser = OptionParser()
parser.add_option(
"-n",
"--name",
dest="name",
help=
"Name of the hinge. Program will load file called <name>.json and output <name>-face.dxf and <name>-temple.dxf.",
metavar="HINGENAME")
(options, args) = parser.parse_args()
if options.name == None:
sys.stderr.write("Not enough arguments")
parser.print_help()
sys.exit(0)
name = options.name
infile = open(name + ".json")
hinge = json.loads(infile.read())
face = hinge["face_contour"]
temple = hinge["temple_contour"]
face_hole_diam = hinge["drill_dia"]
temple_hole_diam = hinge["drill_dia"]
face_holes = hinge["face_holes"]
temple_holes = hinge["temple_holes"]
face_drawing = dxf.drawing("./%s-face.dxf" % name)
temple_drawing = dxf.drawing("./%s-temple.dxf" % name)
face_drawing.add_layer("OUTLINE", color=1)
face_drawing.add_layer("HOLES", color=2)
temple_drawing.add_layer("OUTLINE", color=1)
temple_drawing.add_layer("HOLES", color=2)
face_outline = dxf.polyline(layer="OUTLINE", thickness=0.1)
face_outline.add_vertices(face)
face_drawing.add(face_outline)
for hole in face_holes:
circ = dxf.circle(face_hole_diam / 2.0,
hole,
layer="HOLES",
thickness=0.1)
face_drawing.add(circ)
face_drawing.save()
temple_outline = dxf.polyline(layer="OUTLINE", thickness=0.1)
temple_outline.add_vertices(temple)
temple_drawing.add(temple_outline)
for hole in temple_holes:
circ = dxf.circle(temple_hole_diam / 2.0,
hole,
layer="HOLES",
thickness=0.1)
temple_drawing.add(circ)
temple_drawing.save()
def tile(width, height, offsetX=0, offsetY=0, drawing=None, allNegative=False):
if drawing is None:
drawing = empty_drawing()
entities = []
for x in range(0, width):
px = 32 * x + offsetX
xDir = Direction.NORTH if x % 2 == 0 else Direction.SOUTH
for y in range(0, height):
yDir = Direction.WEST if y % 2 == 0 else Direction.EAST
py = 32 * y + offsetY
# right
if x == width - 1:
right = notchedLine(px + 32, py, yDir)
if allNegative:
right = notchedLine(px + 32, py, Direction.EAST)
entities.append(right)
# top
if y == height - 1:
top = notchedLine(px, py + 32, xDir)
if allNegative:
top = notchedLine(px, py + 32, Direction.NORTH)
entities.append(top)
# bottom
bottom = dxf.line((px, py), (px + 32, py), layer='mark')
if y == 0:
bottom = notchedLine(px, py, xDir)
if allNegative:
bottom = notchedLine(px, py, Direction.SOUTH)
entities.append(bottom)
# left
left = dxf.line((px, py), (px, py + 32), layer='mark')
if x == 0:
left = notchedLine(px, py, yDir)
if allNegative:
left = notchedLine(px, py, Direction.WEST)
entities.append(left)
# circles
entities.append(
dxf.circle(radius=circle_rad,
center=(px + 4, py + 4),
layer='engrave'))
entities.append(
dxf.circle(radius=circle_rad,
center=(px + 28, py + 28),
layer='engrave'))
for entity in entities:
drawing.add(entity)
return drawing
def create_dxf(filename):
dxf_drawing = dxf.drawing(filename)
for y in range(0, 5):
x = 0
dxf_drawing.add(dxf.circle(radius=y, center=(x, y * 2)))
dxf_drawing.save()
def arc(self, end, center, layer=None):
if self.enable:
r = xyDist(end, center)
if self.svg is not None:
self.path.push_arc(self.scaleOffset(end), 0, r, \
large_arc=True, angle_dir='+', \
absolute=True)
if self.d is not None:
if layer is None:
layer = self.lPath
else:
if not layer in self.definedLayers:
self.definedLayers[layer] = True
self.d.add_layer(layer, color=self.color, lineweight=0)
p0 = self.last
p1 = end
if xyDist(p0, p1) < MIN_DIST:
self.d.add(dxf.circle(r, center, layer=layer))
else:
# dprt("p0 (%7.4f, %7.4f) p1 (%7.4f, %7.4f)" % \
# (p0[0], p0[1], p1[0], p1[1]))
# if orientation(p0, center, p1) == CCW:
# (p0, p1) = (p1, p0)
a0 = degrees(calcAngle(center, p0))
a1 = degrees(calcAngle(center, p1))
if a1 == 0.0:
a1 = 360.0
# dprt("a0 %5.1f a1 %5.1f" % (a0, a1))
self.d.add(dxf.arc(r, center, a0, a1, layer=layer))
self.last = end
def Draw(p):
lay=0
path=p['path']
n=p['nodes']
d=p['drawing']
rx=p['position'][0]
ry=p['position'][1]
if 'layer' in p.keys(): lay=p['layer']
for c in path:
if c[0]=='line':
d.add(dxf.line((rx+n[c[1]][0],ry+n[c[1]][1]),
(rx+n[c[2]][0],ry+n[c[2]][1]),layer=lay))
elif c[0]=='arc':
cr=geo.CircleFrom3Points(n[c[1]],n[c[3]],n[c[2]])
if cr['Direction']<0:
d.add(dxf.arc(center=(rx+cr['Center'][0],ry+cr['Center'][1]),
radius=cr['Radius'],
startangle=math.degrees(cr['P1Degree']),
endangle=math.degrees(cr['P3Degree']),
layer=lay))
else:
d.add(dxf.arc(center=(rx+cr['Center'][0],ry+cr['Center'][1]),
radius=cr['Radius'],
startangle=math.degrees(cr['P3Degree']),
endangle=math.degrees(cr['P1Degree']),
layer=lay))
elif c[0]=='circle':
rds=n[c[2]][0]-n[c[1]][0]
d.add(dxf.circle(rds,(rx+n[c[1]][0],ry+n[c[1]][1]),layer=lay))
def outline_circle(ai_center, ai_radius, ai_backend):
""" Generates a circle according to the selected backend.
Possible backend: freecad, mozman dxfwrite, mozman svgwrite, Tkinter.
"""
#r_outline = ''
# check the radius
if (ai_radius <= 0):
six.print_(
("ERR409: Error, the radius {:0.3f} is negative or null!".format(
ai_radius)))
sys.exit(2)
# select backend
if (ai_backend == 'freecad'):
r_outline = Part.Circle(Base.Vector(ai_center[0], ai_center[1], 0),
Base.Vector(0, 0, 1), ai_radius).toShape()
elif (ai_backend == 'svgwrite'):
svg_circle = svgwrite.shapes.Circle(center=(ai_center[0],
ai_center[1]),
r=ai_radius)
svg_circle.fill('green', opacity=0.25).stroke('black', width=1)
r_outline = [
svg_circle
] # circle wrapped in list to help the integration in the function write_figure_in_svg()
elif (ai_backend == 'dxfwrite'):
dxf_circle = DXFEngine.circle(radius=ai_radius,
center=(ai_center[0], ai_center[1]))
r_outline = [
dxf_circle
] # circle wrapped in list to help the integration in the function write_figure_in_dxf()
elif (ai_backend == 'tkinter'):
r_outline = outline_circle_with_tkinter(ai_center, ai_radius)
return (r_outline)
def build_dxf(self, scale, offset, diameter):
drawing = dxf.drawing('Drawing.dxf')
print('\n' + Fore.RESET + 'Выполняется построение объекта...')
counter = 0
for pin in self.pins:
x = int(pin[0]) * scale
y = int(pin[1]) * scale
drawing.add(dxf.circle(diameter / 2, (x, y)))
counter += 1
print('item added', x, y)
drawing.add(dxf.line((min(self.rangex) * scale - offset, min(self.rangey) * scale - offset),
(max(self.rangex) * scale + offset, min(self.rangey) * scale - offset),
color=1))
drawing.add(dxf.line((max(self.rangex) * scale + offset, min(self.rangey) * scale - offset),
(max(self.rangex) * scale + offset, max(self.rangey) * scale + offset),
color=1))
drawing.add(dxf.line((max(self.rangex) * scale + offset, max(self.rangey) * scale + offset),
(min(self.rangex) * scale - offset, max(self.rangey) * scale + offset),
color=1))
drawing.add(dxf.line((min(self.rangex) * scale - offset, max(self.rangey) * scale + offset),
(min(self.rangex) * scale - offset, min(self.rangey) * scale - offset),
color=1))
print('Построение завершено.')
printtable()
try:
drawing.save()
print('Результат сохранен в файл ' + Fore.CYAN + 'Drawing.dxf' + Fore.RESET)
except PermissionError:
print(Fore.RED + 'ФАЙЛ ЗАНЯТ ДРУГИМ ПРИЛОЖЕНИЕМ.' + Fore.RESET)
def writeDXF(self):
fname = self.ui.lineEditOutputDXF.text()
file = open(fname, 'w')
rad = 0.25
scale = 1.0
col = 7
dec = self.ui.spinBoxDecimal.value()
dwg = dxf.drawing(fname)
# create block
scalarsymbol = dxf.block(name='symbol')
scalarsymbol.add( dxf.circle(radius=rad, color=0) )
# define some attributes
scalarsymbol.add( dxf.attdef(insert=(1.25, -1.25), tag='VAL1', height=1.25, color=0) )
# add block definition to the drawing
dwg.blocks.add(scalarsymbol)
for nID in self.points:
x = self.points[nID][0]
y = self.points[nID][1]
val1 = self.points[nID][2]
values = {'VAL1': "%.{0}f".format(dec) % val1}
dwg.add(dxf.insert2(blockdef=scalarsymbol, insert=(x, y),
attribs=values,
xscale=scale,
yscale=scale,
layer='0',
color = col))
dwg.save()
def main():
parser = OptionParser()
parser.add_option("-n", "--name", dest="name",
help="Name of the hinge. Program will load file called <name>.json and output <name>-face.dxf and <name>-temple.dxf.", metavar = "HINGENAME")
(options, args) = parser.parse_args()
if options.name == None:
sys.stderr.write("Not enough arguments")
parser.print_help()
sys.exit(0)
name = options.name
infile = open(name + ".json")
hinge = json.loads(infile.read())
face = hinge["face_contour"]
temple = hinge["temple_contour"]
face_hole_diam = hinge["drill_dia"]
temple_hole_diam = hinge["drill_dia"]
face_holes = hinge["face_holes"]
temple_holes = hinge["temple_holes"]
face_drawing = dxf.drawing("./%s-face.dxf" % name)
temple_drawing = dxf.drawing("./%s-temple.dxf" % name)
face_drawing.add_layer("OUTLINE", color=1)
face_drawing.add_layer("HOLES", color=2)
temple_drawing.add_layer("OUTLINE", color=1)
temple_drawing.add_layer("HOLES", color=2)
face_outline = dxf.polyline(layer="OUTLINE", thickness = 0.1)
face_outline.add_vertices(face)
face_drawing.add(face_outline)
for hole in face_holes:
circ = dxf.circle(face_hole_diam/2.0, hole, layer="HOLES", thickness=0.1)
face_drawing.add(circ)
face_drawing.save()
temple_outline = dxf.polyline(layer="OUTLINE", thickness = 0.1)
temple_outline.add_vertices(temple)
temple_drawing.add(temple_outline)
for hole in temple_holes:
circ = dxf.circle(temple_hole_diam/2.0, hole, layer="HOLES", thickness=0.1)
temple_drawing.add(circ)
temple_drawing.save()
def circle(self, end, r, layer=None):
if self.enable:
if self.d is not None:
if layer is None:
layer = self.lHole
else:
if not layer in self.definedLayers:
self.definedLayers[layer] = True
self.d.add_layer(layer, color=self.color, lineweight=0)
self.d.add(dxf.circle(r, end, layer=layer))
self.last = end
def hole(self, end, drillSize):
if self.enable:
if self.svg is not None:
self.path.push('L', self.scaleOffset(end))
# dprt("svg line %7.4f %7.4f" % self.scaleOffset(end))
self.svg.add(Circle(self.scaleOffset(end), \
(drillSize / 2) * self.pScale, \
stroke='black', stroke_width=.5, \
fill="none"))
if self.d is not None:
self.d.add(dxf.line(self.last, end, layer=self.lPath))
self.d.add(dxf.circle(drillSize / 2, end, layer=self.lHole))
self.last = end
def samples_to_dxf(self):
print('Converting samples to dxf...')
x_center = 0
y_center = 0
for row in self.sample_data:
for sample_luminance_value in row:
circle = dxf.circle(radius=self.luminance_to_circle_radius(
sample_luminance_value))
self.dxf_drawing.add(circle, center=(x_center, y_center))
x_center += self.output_spacing
x_center = 0
y_center += self.output_spacing
print('Converting Complete.')
def create_cad():
'''
:return: a cad file(.dxf)
'''
global cad_name
project_list = []
excel_name = input("请输入Excel文件名称(粘贴复制无后辍哦~): ")
num_projects = int(input("请输入写入项目数(同Excel但除XY): "))
for project_num in range(1, num_projects + 1):
pk_num = int(input("请输入项目%s所在列号：" % project_num))
project_list.append(pk_num)
pk_x_cood = int(input("请输入排口横坐标所在列号："))
pk_y_cood = int(input("请输入排口纵坐标所在列号："))
cad_name = input("请输入要保存的CAD文件名称：")
# draw a cad picture
drawing = dxf.drawing(os.getcwd() + "/%s.dxf" % cad_name)
# read excel datas
wb = load_workbook(os.getcwd() + "/" + excel_name + ".xlsx")
ws = wb.active
for row in ws.rows:
for project_column in project_list:
if str(row[pk_x_cood - 1].value).replace(
".", "").isdigit() == True and str(
row[pk_y_cood - 1].value).replace(
".", "").isdigit() == True:
print(row[project_column - 1].value, row[pk_x_cood - 1].value,
row[pk_y_cood - 1].value)
x_cood = float(row[pk_x_cood - 1].value)
y_cood = float(row[pk_y_cood - 1].value)
pai_num = row[project_column - 1].value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num,
(x_cood, y_cood -
1.35 * project_list.index(project_column)),
height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou',
insert=(x_cood, y_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
def make_dxf(xyrra_list):
"""turn an xyrra_list (xcenter, ycenter, radius_x, radius_y, angle of rotation)
into a dxf file """
directory_now = os.path.dirname(os.path.realpath(__file__))
drawing = dxf.drawing(os.path.join(directory_now, 'test.dxf'))
for i in range(xyrra_list.shape[0]):
if i % 10000 == 0:
print(xyrra_list.shape[0] - i, 'ellipses remaining in dxf creation...', flush=True)
x,y,rx,ry,a = xyrra_list[i,:]
if rx == ry:
circ = dxf.circle(radius=rx / um, center=(x/um,y/um))
drawing.add(circ)
else:
ellipse = dxf.ellipse((x/um,y/um), rx/um, ry/um, rotation=a/degree, segments=16)
drawing.add(ellipse)
print('saving dxf...', flush=True)
drawing.save()
def outline_circle(ai_center, ai_radius, ai_backend):
""" Generates a circle according to the selected backend.
Possible backend: freecad, mozman dxfwrite, mozman svgwrite, Tkinter.
"""
#r_outline = ''
# check the radius
if(ai_radius<=0):
print("ERR409: Error, the radius {:0.3f} is negative or null!".format(ai_radius))
sys.exit(2)
# select backend
if(ai_backend=='freecad'):
r_outline = Part.Circle(Base.Vector(ai_center[0], ai_center[1], 0), Base.Vector(0,0,1), ai_radius).toShape()
elif(ai_backend=='svgwrite'):
svg_circle = svgwrite.shapes.Circle(center=(ai_center[0], ai_center[1]), r=ai_radius)
svg_circle.fill('green', opacity=0.25).stroke('black', width=1)
r_outline = [svg_circle] # circle wrapped in list to help the integration in the function write_figure_in_svg()
elif(ai_backend=='dxfwrite'):
dxf_circle = DXFEngine.circle(radius=ai_radius, center=(ai_center[0], ai_center[1]))
r_outline = [dxf_circle] # circle wrapped in list to help the integration in the function write_figure_in_dxf()
elif(ai_backend=='tkinter'):
r_outline = outline_circle_with_tkinter(ai_center, ai_radius)
return(r_outline)
def make_dxf(source=None,
target_width=200,
min_radius=0.,
max_radius=3.,
offset=True):
def scale_r(value, min_v, max_v, min_r, max_r):
return (value - min_v) * (max_r - min_r) / (max_v - min_v) + min_r
src = rgb2gray(invert(imread(source)))
dwg = dxf.drawing()
dwg.add_layer('dots')
h, w = src.shape
img_max = src.max()
img_min = src.min()
tile_w = max_radius * 2
scale = target_width / float(w)
for row, ty in enumerate(xrange(0, h, int(tile_w // scale) + 1)):
offset_x = 0
if offset and row % 2:
offset_x = int(tile_w // scale) // 2
for tx in xrange(offset_x, w, int(tile_w // scale) + 1):
# Calculate size of dot
avg = src[ty:ty + int(tile_w), tx:tx + int(tile_w)].mean()
dot_r = scale_r(avg, img_min, img_max, min_radius, max_radius)
# calculate x, y corrdinates
x = ((tx + tile_w) - tile_w // 2) * scale
y = ((ty + tile_w) - tile_w // 2) * scale
c = dxf.circle(radius=dot_r,
center=(x, (y * -1) + h * scale),
color=1,
layer='dots')
dwg.add(c)
return dwg
def make_dxf(xyrra_list):
"""turn an xyrra_list (xcenter, ycenter, radius_x, radius_y, angle of rotation)
into a dxf file """
directory_now = os.path.dirname(os.path.realpath(__file__))
drawing = dxf.drawing(os.path.join(directory_now, 'test.dxf'))
for i in range(xyrra_list.shape[0]):
if i % 10000 == 0:
print(xyrra_list.shape[0] - i,
'ellipses remaining in dxf creation...',
flush=True)
x, y, rx, ry, a = xyrra_list[i, :]
if rx == ry:
circ = dxf.circle(radius=rx / um, center=(x / um, y / um))
drawing.add(circ)
else:
ellipse = dxf.ellipse((x / um, y / um),
rx / um,
ry / um,
rotation=a / degree,
segments=16)
drawing.add(ellipse)
print('saving dxf...', flush=True)
drawing.save()
def create_cad():
'''
:return: a cad file(.dxf)
'''
global cad_name
excel_name = input("\033[1;32m请输入Excel文件名称：（粘贴复制哦~）\033[0m")
pk_num = int(input("\033[1;32m请输入排口编号所在列号：\033[0m"))
pk_x_cood = int(input("\033[1;32m请输入排口横坐标所在列号：\033[0m"))
pk_y_cood = int(input("\033[1;32m请输入排口纵坐标所在列号：\033[0m"))
cad_name = input("请输入要保存的CAD文件名称：")
# draw a cad picture
drawing = dxf.drawing(os.getcwd() + "/%s.dxf" % cad_name)
# read excel datas
wb = load_workbook(os.getcwd() + "/" + excel_name + ".xlsx")
ws = wb.active
for row in ws.rows:
if row[pk_num-1].value != None and row[pk_x_cood-1].value != None and row[pk_y_cood-1].value != None \
and is_number(row[pk_x_cood-1].value) == True and is_number(row[pk_y_cood-1].value) == True:
print(row[pk_num - 1].value, row[pk_x_cood - 1].value,
row[pk_y_cood - 1].value)
x_cood = float(row[pk_x_cood - 1].value)
y_cood = float(row[pk_y_cood - 1].value)
pai_num = row[pk_num - 1].value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num, (x_cood, y_cood), height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou', insert=(x_cood, y_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
def drawPath(self,
outlines=mePath.Outline(),
xy=[0,0],
layer=-1):
self.Paths.append(outlines)#???
lay=layer
path=outlines.Path
n=outlines.Nodes
d=self.DXFDrawing
rx=xy[0]
ry=xy[1]
for c in path:
if c[0]=='line':
d.add(dxf.line((rx+n[c[1]][0],ry+n[c[1]][1]),
(rx+n[c[2]][0],ry+n[c[2]][1]),layer=lay))
elif c[0]=='arc':
cr=geo.CircleFrom3Points(n[c[1]],n[c[3]],n[c[2]])
if cr['Direction']<0:
d.add(dxf.arc(center=(rx+cr['Center'][0],ry+cr['Center'][1]),
radius=cr['Radius'],
startangle=math.degrees(cr['P1Degree']),
endangle=math.degrees(cr['P3Degree']),
layer=lay))
else:
d.add(dxf.arc(center=(rx+cr['Center'][0],ry+cr['Center'][1]),
radius=cr['Radius'],
startangle=math.degrees(cr['P3Degree']),
endangle=math.degrees(cr['P1Degree']),
layer=lay))
elif c[0]=='circle':
rds=n[c[2]][0]-n[c[1]][0]
d.add(dxf.circle(rds,(rx+n[c[1]][0],ry+n[c[1]][1]),layer=lay))
def converttodxf(self, nazwapliku = None, points = True, d3d = True): #konwertuje uzywajac modulu dxfwrite #points - czy wstawiac punkty wybierane podczas montazu if nazwapliku == None: nazwapliku = os.path.basename(self._nazwa_pliku)[:-3]+"dxf" from dxfwrite import DXFEngine as dxf drawing = dxf.drawing(nazwapliku) for OBJ in self._objects: #print "hehe" if OBJ==None: continue if OBJ.type()=='POINT': p=OBJ.P() if d3d: drawing.add(dxf.point((p[0],p[1],p[2]))) else: drawing.add(dxf.point((p[0],p[1]))) elif OBJ.type()=='LINE': p1=OBJ.P1(); p2=OBJ.P2() drawing.add(dxf.line((p1[0], p1[1]), (p2[0], p2[1]))) #ent = adoc.CreateLine2(p1[0]/1000., p1[1]/1000., p1[2]/1000., p2[0]/1000., p2[1]/1000., p2[2]/1000.) elif OBJ.type()=='CIRCLE': p1=OBJ.O() drawing.add(dxf.circle(OBJ.d()/2.,(p1[0], p1[1]))) #ent = adoc.CreateCircle2(p1[0]/1000., p1[1]/1000., p1[2]/1000., p2[0]/1000., p2[1]/1000., p2[2]/1000.) if points and not OBJ.type()=="POINT": PTS = OBJ.meas_points() print "dodawanie punktow pomiarowych:" for pp in PTS: #print (pp[0],pp[1],pp[2]) if d3d: drawing.add(dxf.point((pp[0],pp[1],pp[2]))) else: drawing.add(dxf.point((pp[0],pp[1]))) drawing.save()
def append_to_dxf(self, drawing):
drawing.add(dxf.circle(self.radius, (self.center[0], -self.center[1])))
sample_coords = [get_random_point() for x in range(50)]
flag_symbol = [(0, 0), (0, 5), (4, 3), (0, 3)]
filename = 'flags.dxf'
dwg = dxf.drawing(filename)
dwg.add_layer('FLAGS')
# first create a block
flag = dxf.block(name='flag')
# add dxf entities to the block (the flag)
# use basepoint = (x, y) define an other basepoint than (0, 0)
flag.add(dxf.polyline(flag_symbol))
flag.add(dxf.circle(radius=.4, color=2))
# define some attributes
flag.add(dxf.attdef(insert=(0.5, -0.5), tag='NAME', height=0.5, color=3))
flag.add(dxf.attdef(insert=(0.5, -1.0), tag='XPOS', height=0.25, color=4))
flag.add(dxf.attdef(insert=(0.5, -1.5), tag='YPOS', height=0.25, color=4))
# add block definition to the drawing
dwg.blocks.add(flag)
number = 1
for point in sample_coords:
# now insert flag symbols at coordinate 'point'
# insert2 needs the block definition object as parameter 'blockdef'
# see http://packages.python.org/dxfwrite/entities/insert2.html
# fill attribtes by creating a dict(), keystr is the 'tag' name of the
# attribute
values = {
def render(self):
data = self.data
point_layers = {}
# create the drawing and add layers to it
drawing = dxf.drawing()
drawing.add_layer(self.filter_layer_name('objects'))
drawing.add_layer(self.filter_layer_name('marker'))
drawing.add_layer(self.filter_layer_name('Mesh'))
# Add layers from the doncodes
for l in set([
self.doncodes["doncodes"][lx]["CAD LAYERS"]
for lx in self.doncodes["doncodes"]
]):
if l:
drawing.add_layer(self.filter_layer_name(l))
# might need custom layers for major/minor contours
have_contour_names = []
for x in ["major", "minor"]:
if self.settings["job"].get("contours") and self.settings["job"][
"contours"][x] and self.settings["job"]["contours"][x].get(
"layer"):
drawing.add_layer(
self.filter_layer_name(
"Contour - " +
str(self.settings["job"]["contours"][x].get("layer"))))
have_contour_names.append(x)
if len(have_contour_names) < 2:
# drawing.add_layer(self.filter_layer_name('Contour'))
drawing.add_layer(self.filter_layer_name('Contour Splines'))
drawing.add_layer(self.filter_layer_name('Contour Splines Flat'))
# add the separated codes/shots/rls
for x in ["Shots", "Rls", "Codes"]:
for y in ["", "_NC", "_NL"]:
drawing.add_layer(self.filter_layer_name(x + y))
#drawing.header['$ANGBASE'] = self.bm["marker_angle"]
#drawing.header['$UCSORG'] = (0, 0, 0)
#drawing.header['$UCSXDIR'] = (1, 0, 0)
#drawing.header['$UCSYDIR'] = (0, 1, 0)
# set 3D Point
#drawing.header['$EXTMIN'] = (0, 0, -10)
#drawing.header['$EXTMAX'] = (1000, 1000, 100)
# add the mesh
if self.settings["options"]["threedMesh"] == "1":
self.render_mesh(drawing)
#add stringlines to string_lines layer
for line in data["stringlines"]:
if len(data["stringlines"][line]) > 1:
# variable to store stringline colour, thickness etc. to be passed to polyline
stringline_detail = {}
first_point = data["stringlines"][line][0]
ms_layer = first_point["doncode"].get("MS Properties")
layer_codes = self.doncodes["ms_layers"].get(ms_layer)
# make sure we have stringline properties in our doncodes array (often blank)
if layer_codes:
# print data["stringlines"][line][0]["code"], ms_layer
# print first_point["code"], layer_codes
# if we have a special colour
if layer_codes.get("Col"):
stringline_detail["color"] = int(layer_codes["Col"])
# if we have a line weight set
if layer_codes.get("Line Weight") and int(
layer_codes.get("Line Weight")):
stringline_detail["thickness"] = int(
layer_codes.get("Line Weight"))
# if we have a line style TODO: map these to their actual line styles
if layer_codes.get("Line Style") and int(
layer_codes.get("Line Style")):
stringline_detail["linetype"] = int(
layer_codes.get("Line Style"))
polyline = dxf.polyline(layer=self.filter_layer_name(
first_point["doncode"].get("CAD LAYERS")),
**stringline_detail)
polyline.add_vertices([
self.convert_point(p["point"])
for p in data["stringlines"][line]
])
drawing.add(polyline)
# add the regular (original) contour line
if self.settings["options"]["origContour"] == "1":
self.render_contour(drawing, data["contour_lines"],
lambda p: self.convert_point(
p)) # Line was previously commented.
# add splines contour line
if self.settings["options"]["splinesContour"] == "1":
# splines version
self.render_contour(drawing, data["contour_splines"],
lambda p: self.convert_point(p), " Splines")
# flat spline version
self.render_contour(
drawing, data["contour_splines"],
lambda p: self.flatten_point(self.convert_point(p)),
" Splines Flat")
# loop through the points with 2d objects on them putting Xrefs on the ones that need it
#print data["objects_2d"]
for o in data["objects_2d"]:
# //bush.position.set(objects_2d[o][0],objects_2d[o][1]+0.3,objects_2d[o][2]).multiplyScalar(psu_renderer.SCALE);
# psu_renderer.generate_obj(bush.clone());
drawing.add_xref(self.settings["global"].get("export", {}).get(
"xref_path", "") + o["code"] + ".dwg",
insert=self.convert_point(o["point"]),
layer=self.filter_layer_name(
o["doncode"].get("CAD LAYERS")))
# find and add trees to plot and tree schedule
# create the table for tree information
tree_table = dxf.table(insert=self.convert_point(
[self.bounding_box[0][1], 0, self.bounding_box[2][0] - 20]),
nrows=len(data["trees"]) + 2,
ncols=4)
tree_table.set_col_width(1, 4)
tree_table.set_col_width(2, 3)
tree_table.set_col_width(3, 5)
# table cell style
ctext = tree_table.new_cell_style('ctext',
textcolor=7,
textheight=0.5,
halign=dxfwrite.CENTER,
valign=dxfwrite.MIDDLE)
# table border style
border = tree_table.new_border_style(color=6, priority=51)
ctext.set_border_style(border, right=False)
# table header
hcell = tree_table.text_cell(0, 0, "SCHEDULE OF TREES")
hcell.span = (1, 4)
tree_table.text_cell(1, 1, "DIAMETER", style='ctext')
tree_table.text_cell(1, 2, "HEIGHT", style='ctext')
tree_table.text_cell(1, 3, "TYPE", style='ctext')
for t in range(len(data["trees"])):
tree = data["trees"][t]
diameter = tree["tree_details"].get("diameter", None)
height = tree["tree_details"].get("height", None)
spread = tree["tree_details"].get("spread", None)
note = tree["tree_details"].get("note", None)
blockname = "tree_" + str(t + 1)
layer = self.filter_layer_name(
self.doncodes["doncodes"][tree["code"]].get("CAD LAYERS"))
if diameter or spread:
tree_block = dxf.block(name=blockname)
# trunk
if diameter:
tree_block.add(
dxf.circle(float(diameter) / 2.0, [0, 0], layer=layer))
# leaves
if spread:
tree_block.add(
dxf.circle(float(spread) / 2.0, [0, 0], layer=layer))
drawing.blocks.add(tree_block)
drawing.add(
dxf.insert2(blockdef=tree_block,
insert=self.convert_point(tree["position"]),
layer=layer))
# table
# table position is left of bounding box
tree_table.text_cell(t + 2, 0, "T" + str(t + 1), style='ctext')
tree_table.text_cell(t + 2,
1,
diameter and diameter or "",
style='ctext')
tree_table.text_cell(t + 2,
2, (height and height + "m" or ""),
style='ctext')
tree_table.text_cell(t + 2,
3,
note and note.upper() or "",
style='ctext')
drawing.add(tree_table)
if not self.bm.get("fake"):
drawing.add(
dxf.point(self.convert_point(self.bm["position"]),
layer=self.filter_layer_name(
self.doncodes["doncodes"][self.bm["code"]].get(
"CAD LAYERS"))))
drawing.add(
dxf.text("BM",
self.convert_point(self.bm["position"]),
height=0.2,
layer=self.filter_layer_name(
self.doncodes["doncodes"][self.bm["code"]].get(
"CAD LAYERS"))))
# loop through the points adding labels to the layer
seen = []
for p in data["p"]:
# uniquely identify this piece of text at this position to prevent duplicates
text_id = tuple(
[p["original_code"], p.get("day_id", "")] + p["position"])
# figure out if we are NL or
layer_postfix = ""
for l in ["NL", "NC"]:
if l in p["extensions"]["function"]:
layer_postfix = "_" + l
# if this isn't a duplicate and isn't a tree
if not text_id in seen or p["code"] == "TR":
blockname = 'point_' + str(p["point_id"]) + (
p.get("day_id") and "-" + p["day_id"] or "")
point_block = dxf.block(name=blockname)
if p.get("force_point_layer"):
layer_code = p["force_point_layer"]["code"]
else:
layer_code = p["code"]
layer = self.filter_layer_name(
self.doncodes["doncodes"][layer_code].get("CAD LAYERS"))
# create a block to unite the various elements of the point
# for trees we just want to draw their ref
if p["code"] == "TR":
point_block.add(
dxf.text(
"T" +
str([t["point_id"]
for t in data["trees"]].index(p["point_id"]) +
1), [0.2, 0.2],
height=0.2,
layer="Codes" + layer_postfix))
else:
# these codes don't have the original_code text printed on the plot
if not p["code"] in ["RC", "LC"]:
# everything else gets original code printed
point_block.add(
dxf.text(p["original_code"] + " (" +
str(p["line_number"]) + ")", (0, 0),
alignpoint=(0, -0.2),
height=0.05,
rotation=-90,
layer="Codes" + layer_postfix,
valign=MIDDLE))
if not "NL" in p["extensions"]["function"]:
point_block.add(
dxf.text("%.2f" % (p["position"][1]), (0, 0),
alignpoint=(0.12, -0.12),
height=0.3,
rotation=-45,
layer="Rls" + layer_postfix,
valign=MIDDLE))
point_block.add(
dxf.point([0, 0], layer="Shots" + layer_postfix))
drawing.blocks.add(point_block)
drawing.add(
dxf.insert2(blockdef=point_block,
insert=self.convert_point(p["position"]),
layer=layer))
# print p["doncode"].get("Draw Cross Hair on Point")
if self.doncodes["doncodes"][p["code"]].get(
'Draw Cross Hair on Point',
'n').lower() in ["1", "y", "yes", "true", "x"]:
drawing.add_xref(self.settings["global"].get(
"export", {}).get("xref_path", "") + "X.dwg",
insert=self.convert_point(p["position"]),
layer="Shots" + layer_postfix)
seen.append(text_id)
# save the drawing to the binary blob and then return the DXF code
# binary blob to pretend to be a file and store our saved DXF
blob = StringIO()
drawing.save_to_fileobj(blob)
return blob.getvalue()
import xlrd, dxfwrite
from dxfwrite import DXFEngine as dxf
# draw a cad picture
drawing = dxf.drawing('排口坐标.dxf')
# read excel datas
data = xlrd.open_workbook('1.xls')
num_sheets = len(data.sheets())
for n in range(num_sheets):
table = data.sheets()[n]
nrows = table.nrows
for i in range(2, nrows):
x_cood = float(table.cell(i, 2).value)
y_cood = float(table.cell(i, 3).value)
pai_num = table.cell(i, 1).value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num, (y_cood, x_cood), height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou', insert=(y_cood, x_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
def draw_control_point(point, tangent1, tangent2=(0, 0)):
tp1 = vadd(point, tangent1)
tp2 = vadd(point, tangent2)
dwg.add(dxf.circle(0.05, center=point, color=1))
dwg.add(dxf.line(point, tp1, color=2))
dwg.add(dxf.line(point, tp2, color=2))
def temple_dxf(o, filename, hinge, reverse):
temple_contour = poly.mirror_y(o['ltemple_con'], False)
# Location in y for the center of the hinge
hinge_y = -(temple_contour[0][1]+temple_contour[-1][1])/2
temple_contour = poly.mirror_y(temple_contour, True)
# Only mirror the temple contour, not the hinge, because the hinge is modelled
# for the RIGHT hinge and we have the LEFT temple
hinge_contour = hinges.get_hinge(hinge)["temple_contour"]
hinge_holes = hinges.get_hinge(hinge)["temple_holes"]
# Temple should be at 6 degrees. We tilt the hinge instead for manufacturing
# ease.
# hinge_contour = poly.rotate(hinge_contour, 6)
# hinge_holes = poly.rotate(hinge_holes, 6)
# 0 point of hinge is center of straight edge of hinge. We want the
# center of the hinge box.
hinge_center_offset = (poly.top(hinge_contour)+poly.bottom(hinge_contour))/2
y_offset = hinge_y-hinge_center_offset
# Since we're tilted 6 degrees compared to design space we need to
# compensate on the x axis
x_offset = y_offset * math.tan(math.radians(6)) # This adjusts the hinge for the move to the center of the temple
hinge_contour = poly.translate(hinge_contour, x_offset, y_offset)
hinge_holes = poly.translate(hinge_holes, x_offset, y_offset)
# Reverse for the right temple
if reverse:
temple_contour = poly.mirror_x(temple_contour, False)
hinge_contour = poly.mirror_x(hinge_contour, False)
hinge_holes = poly.mirror_x(hinge_holes, False)
drawing = dxf.drawing(filename)
drawing.add_layer("CUT", color=1)
drawing.add_layer("POCKET", color=2)
drawing.add_layer("TEXT", color=3)
polyline = dxf.polyline(layer="CUT", color=1, thickness=0.1)
polyline.add_vertices(temple_contour)
drawing.add(polyline)
polyline = dxf.polyline(layer="POCKET", color=2, thickness = 0.1)
polyline.add_vertices(hinge_contour)
drawing.add(polyline)
for hole in hinge_holes:
c = dxf.circle(0.5, hole, layer="CUT", color=1)
drawing.add(c)
if not reverse:
# Left temple, add our company name
# First find Y position 15mm from temple top corner
xPos = temple_contour[0][0]-15
yPos = -1
yStartPos = -1
for pt in reversed(temple_contour):
if pt[0] < xPos and yPos < 0:
yPos = pt[1]-3.5
elif pt[0] < (xPos - 25):
yStartPos = pt[1] - 3.5
break
angle = math.degrees(math.atan((yPos-yStartPos)/25))
print 'text angle', angle
text = dxf.text("GUILD eyewear", style="TIMES", color=3, rotation=angle, height=2.5, alignpoint=[xPos, yPos], halign=2, valign=2)
drawing.add(text)
drawing.save()
def circle(self, radius=None, center=None, color=None):
item = dxf.circle(radius=radius, center=center, color=color)
self.add(item)
def drawCircleColouredLayer(draw, radio, pxCentre, pyCentre, colorA, capa):
circlex = dxf.circle(radio, (pxCentre, pyCentre))
circlex['color'] = colorA
circlex['layer'] = capa
draw.add(circlex)
draw.add_layer(capa, color=colorA)
def circle(drawing, geometry):
circle = findTag(geometry, 'Circle').attrib
drawing.add(dxf.circle(circle['Radius'], (circle['CenterX'], circle['CenterY'])))
def export_via_dxfwrite( dxf_fn, V):
from drawingDimensioning.XMLlib import SvgXMLTreeNode
from drawingDimensioning.svgLib import SvgTextParser, SvgPath, SvgPolygon
from drawingDimensioning.circleLib import fitCircle_to_path, findCircularArcCentrePoint, pointsAlongCircularArc
from numpy import arctan2
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing( dxf_fn)
pageSvg = open(V.page.PageResult).read()
XML_tree = SvgXMLTreeNode( pageSvg,0)
defaultHeight = 0
defaultFont = 'Verdana'
defaultAnchor = 'left'
def yT(y): #y transform
return 210-y
warningsShown = []
SelectViewObjectPoint_loc = None
for element in XML_tree.getAllElements():
clr_text = None
if 'fill' in element.parms:
clr_text = element.parms['fill']
elif 'style' in element.parms:
for part in element.parms['style'].split(';'):
if part.startswith('stroke:rgb('):
clr_text = part[ len('stroke:'):]
elif part.startswith('font-size'):
defaultHeight = part[len('font-size:')]
elif part.startswith('font-family'):
defaultFont = part[len('font-family:'):]
elif part.startswith('text-anchor'):
defaultAnchor = part[len('text-anchor:'):]
if clr_text == None or clr_text =='none' or not clr_text.startswith('rgb(') :
color_code = 0
else:
#FreeCAD.Console.PrintMessage( "color text: %s\n" % clr_text )
r,g,b = [ int(v.strip()) for v in clr_text[ len('rgb('): clr_text.find(')')].split(',') ]
color_code = colorLookup(r,g,b)[0]
if element.tag == 'circle':
x, y = element.applyTransforms( float( element.parms['cx'] ), float( element.parms['cy'] ) )
r = float( element.parms['r'] )* element.scaling2()
drawing.add( dxf.circle( r, (x,yT(y)), color=color_code) )
elif element.tag == 'line':
x1, y1 = element.applyTransforms( float( element.parms['x1'] ), float( element.parms['y1'] ) )
x2, y2 = element.applyTransforms( float( element.parms['x2'] ), float( element.parms['y2'] ) )
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code ) )
elif element.tag == 'text' and 'x' in element.parms:
x,y = element.applyTransforms( float( element.parms['x'] ), float( element.parms['y'] ) )
t = SvgTextParser(element.XML[element.pStart: element.pEnd ] )
try:
drawing.add(dxf.text( t.text, insert=(x, yT(y)), height=t.height()*0.8, rotation=t.rotation, layer='TEXTLAYER', color=color_code) )
except ValueError as e:
temp = t.text.replace('<tspan>','')
temp = temp.replace('</tspan>','')
t.text = temp
t.font_size = defaultHeight
t.font_family = defaultFont
if defaultAnchor == 'middle':
shift = t.width()/2.0
x,y = element.applyTransforms( float( element.parms['x'] )-shift, float( element.parms['y'] ) )
drawing.add(dxf.text( temp, insert=(x, yT(y)), height=t.height()*0.8, rotation=t.rotation, layer='TEXTLAYER', color=color_code) )
#FreeCAD.Console.PrintWarning('dxf_export: unable to convert text element "%s": %s, ignoring...\n' % (element.XML[element.pStart: element.pEnd ], str(e) ) )
elif element.tag == 'path':
#FreeCAD.Console.PrintMessage(element.parms['d']+'\n')
path = SvgPath( element )
for line in path.lines:
drawing.add( dxf.line( (line.x1, yT(line.y1)), (line.x2,yT(line.y2)), color=color_code) )
for arc in path.arcs:
if arc.circular:
for r, center, angle1, angle2 in arc.dxfwrite_arc_parms( yT ):
drawing.add( dxf.arc( r, center, angle1, angle2 , color=color_code) )
else:
for x1,y1,x2,y2 in arc.approximate_via_lines( 12 ):
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code) )
for bezierCurve in path.bezierCurves:
x, y, r, r_error = bezierCurve.fitCircle()
if r_error < 10**-4:
drawing.add( dxf.arc( *bezierCurve.dxfwrite_arc_parms(x, y, r), color=color_code ) )
else:
X,Y = bezierCurve.points_along_curve()
for i in range(len(X) -1):
drawing.add( dxf.line( (X[i], yT(Y[i])), (X[i+1],yT(Y[i+1])), color=color_code ) )
elif element.tag == 'polygon':
p = SvgPolygon( element )
for line in p.lines:
drawing.add( dxf.line( (line.x1, yT(line.y1)), (line.x2,yT(line.y2)), color=color_code) )
elif element.tag == 'rect':
x, y = element.applyTransforms( float( element.parms['x'] ), float( element.parms['y'] ) )
width = float( element.parms['width'] )* element.scaling2()
height = float( element.parms['height'] )* element.scaling2()
drawing.add(dxf.rectangle((x, yT(y)), width, -height, color = color_code) )
elif not element.tag in warningsShown:
FreeCAD.Console.PrintWarning('dxf_export: Warning export of %s elements not supported, ignoring...\n' % element.tag )
warningsShown.append(element.tag)
drawing.save()
FreeCAD.Console.PrintMessage("dxf_export: %s successfully created\n" % dxf_fn)
def draw_control_point(point, tangent1, tangent2=(0, 0)):
tp1 = vadd(point, tangent1)
tp2 = vadd(point, tangent2)
dwg.add(dxf.circle(0.05, center=point, color=1))
dwg.add(dxf.line(point, tp1, color=2))
dwg.add(dxf.line(point, tp2, color=2))
def create_2D_modelspace_content(dwg):
dwg.add(dxf.rectangle((5,5), 5, 5, color=2))
dwg.add(dxf.circle(2.5, (10, 5), color=3))
triangle = dxf.polyline([(10, 7.5), (15, 5), (15, 10)], color=4)
triangle.close(True)
dwg.add(triangle)
drawing.add_layer('dxfwrite')
# add a VIEWPORT-tableentry
drawing.add_vport(
'*ACTIVE',
center_point=(10,10),
height = 30,
)
# add LINE-entity
drawing.add(dxf.line((0,0),( 10,0),
color=dxfwrite.BYLAYER,
layer='dxfwrite'
))
# add a CIRCLE-entity
drawing.add(dxf.circle(center=(5,0), radius=5))
# add an ARC-entity
drawing.add(dxf.arc(center=(5,0), radius=4, startangle=30, endangle=150))
#add a POINT-entity
drawing.add(dxf.point(point=(1,1)))
# add a SOLID-entity with 4 points
drawing.add(dxf.solid([(0,0), (1,0), (1,1), (0,1)], color=2))
# add a SOLID-entity with 3 points
drawing.add(dxf.solid([(0,1), (1,1), (1,2)], color=3))
# add a 3DFACE-entity
drawing.add(dxf.face3d([(5,5), (6,5), (6,6), (5,6)], color=3))
def stacks_layers(drawing, startx, starty):
for x in range(0, 5):
centreX = 12+(22.5*x)+startx
centreY = 12+starty
# Main outline
drawing.add(dxf.circle(total_outline_radius, (centreX, centreY), layer='CUTSOUTER', color=5))
# Screw holes
# sin 45 = SQRT(2)/2
sin = math.sqrt(2)/2
offset=(total_outline_radius-1-screw_radius)*sin
drawing.add(dxf.circle(screw_radius, (centreX-offset, centreY-offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX+offset, centreY-offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX-offset, centreY+offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX+offset, centreY+offset), layer='CUTSINNER', color=4))
# not top layer or bottom layer
if ((x != 0) and (x !=4)):
drawing.add(dxf.circle(battery_space/2, (centreX, centreY), layer='CUTSINNER', color=4))
# Number each layer
# drawing.add(dxf.text(str(x), halign=dxfwrite.const.CENTER, valign=dxfwrite.const.MIDDLE, alignpoint=(centreX+2.5, centreY-7.5), height=1.5, layer='ENGRAVE', color=2))
# Slot for bar (the other end of the cufflink
if (x == 4):
# Kurf is ~0.1mm as measured by thickness of two A4 sheets.
drawing.add(dxf.rectangle((centreX-(bar_length/2), centreY-(p_thickness/2)) , bar_length, p_thickness-0.1, layer='CUTSINNER', color=4))
# engrave_text(drawing, centreX, centreY)
# serial_number(drawing, centreX, centreY, "00001")
# Hole for button
if (x == 2):
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX-(p_thickness*1.1)/2, centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX+(p_thickness*1.1)/2, centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
if ( x == 1):
# Hole for button - but only indent to hold button in
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX-(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX+(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
(centreX+(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
if ((x != 0) and (x !=4)):
# Tape hole for battery connection
drawing.add(dxf.line(
(centreX-(tape_width)/2, centreY+battery_space/3), # Should do trig, but what the hell
(centreX-(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(tape_width)/2, centreY+battery_space/3), # Should do trig, but what the hell
(centreX+(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(tape_width)/2, centreY+1.5+battery_space/2 ),
(centreX+(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
if (x == 6):
drawing.add(dxf.line(
(centreX-(bar_length/2-0.5), centreY+total_outline_radius),
(centreX-(bar_length/2-0.5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(bar_length/2-5), centreY+total_outline_radius),
(centreX-(bar_length/2-5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(bar_length/2-0.5), centreY+total_outline_radius),
(centreX+(bar_length/2-0.5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(bar_length/2-5), centreY+total_outline_radius),
(centreX+(bar_length/2-5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
def append_to_dxf(self, drawing):
drawing.add(dxf.circle(self.radius, (self.center[0], -self.center[1])))
if density > densityDesired:
print("Density Reached")
break
#------------------------------------------------------------------------------
# Export Dxf
#------------------------------------------------------------------------------
fileName=("Panel-%dx%d-0.dxf" % (Win,Hin))
fctr=0
while os.path.isfile(fileName) == True:
fctr += 1
fileName=("Panel-%dx%d-%d.dxf" % (Win,Hin,fctr))
print("Outputting DXF - %s" % fileName)
drawing = dxf.drawing(fileName)
for n in range(0,len(x)):
circle = dxf.circle(r[n], (x[n], y[n]))
drawing.add(circle)
drawing.add(dxf.rectangle((0,0),W,H))
drawing.save()
#------------------------------------------------------------------------------
# Write image to jpeg
#------------------------------------------------------------------------------
imageName=("Panel-%dx%d-0.jpg" % (Win,Hin))
fctr=0
while os.path.isfile(imageName) == True:
fctr += 1
imageName=("Panel-%dx%d-%d.jpg" % (Win,Hin,fctr))
print("Outputting JPG - %s" % imageName)
def drawCircleColouredLayer(draw, radio, pxCentre, pyCentre, colorA, capa):
circlex = dxf.circle(radio, (pxCentre, pyCentre))
circlex["color"] = colorA
circlex["layer"] = capa
draw.add(circlex)
draw.add_layer(capa, color=colorA)
def emit_dxf(self, d): color = (1,2)[self.radius == 0.0] d.add(dxf.circle(center = (self.p[0], self.p[1]), radius = self.dxf_radius, color = color))
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing("pythondxf.dxf")
# drawing.add_layer('CIRCLE2')
# drawing.add(dxf.circle((10), (10,5), layer='CIRCLE2'))
# drawing.add_layer('CIRCLE')
# drawing.add(dxf.circle((2), (5, 10), layer='CIRCLE'))
drawing.add_layer("RECT")
drawing.add(dxf.rectangle((5, 5), 6, 6, bgcolor=5, layer="RECT"))
drawing.add_layer("POLY")
polyline = dxf.polyline(linetype="LINE")
polyline.add_vertices([(7, 9.5), (6, 10), (10, 10), (10, 6), (6, 6), (6, 10)])
# polyline.add_vertices( [(6.5,10), (7,9.5)])
polyline.close(status=True)
drawing.add(polyline)
drawing.add_layer("CIRCLE")
drawing.add(dxf.circle((0.1), (6.5, 9.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (9.5, 9.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (6.5, 6.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (9.5, 6.5), layer="CIRCLE"))
drawing.save()
def ExportDXF(self,param):
output = cStringIO.StringIO()
drawing = dxf.drawing('cyclon.dxf')
cx=0
cy=0
cutid=1
nf=[]
nt=[]
nl=[]
#misure utili
htot=param['mantello']['altezza']+param['sezione_interna']['parte_esterna']+param['cono_inferiore']['altezza_totale']
d=param['mantello']['dia']
dint=param['sezione_interna']['dia']
hcono=param['cono_inferiore']['altezza_totale']-param['cono_inferiore']['tronco_diritto']
xz=0
yz=0
#Vista in Pianta
xz=0-d
yz=xz
drawing.add(dxf.circle(d/2,(xz,yz)))
drawing.add(dxf.circle(dint/2,(xz,yz)))
# Vista di Fronte
yz=d*0.5+param['cono_inferiore']['altezza_totale']
h=param['mantello']['altezza']
nf.append([xz-d/2,yz])
nf.append([xz+d/2,yz])
drawing.add(dxf.rectangle((nf[0][0],nf[0][1]),d,h))
nf.append([xz-param['cono_inferiore']['diametro_finale']/2,yz-hcono])
nf.append([xz+param['cono_inferiore']['diametro_finale']/2,yz-hcono])
nf.append([nf[2][0],nf[2][1]-param['cono_inferiore']['tronco_diritto']])
nf.append([nf[3][0],nf[3][1]-param['cono_inferiore']['tronco_diritto']])
drawing.add(dxf.line((nf[0][0],nf[0][1]),(nf[2][0],nf[2][1])))
drawing.add(dxf.line((nf[2][0],nf[2][1]),(nf[3][0],nf[3][1])))
drawing.add(dxf.line((nf[3][0],nf[3][1]),(nf[1][0],nf[1][1])))
drawing.add(dxf.line((nf[2][0],nf[2][1]),(nf[4][0],nf[4][1])))
drawing.add(dxf.line((nf[4][0],nf[4][1]),(nf[5][0],nf[5][1])))
drawing.add(dxf.line((nf[5][0],nf[5][1]),(nf[3][0],nf[3][1])))
# Vista Laterale
for i in nf:
nl.append([i[0]+d*2,i[1]])
drawing.add(dxf.rectangle((nl[0][0],nl[0][1]),d,h))
drawing.add(dxf.line((nl[0][0],nl[0][1]),(nl[2][0],nl[2][1])))
drawing.add(dxf.line((nl[2][0],nl[2][1]),(nl[3][0],nl[3][1])))
drawing.add(dxf.line((nl[3][0],nl[3][1]),(nl[1][0],nl[1][1])))
drawing.add(dxf.line((nl[2][0],nl[2][1]),(nl[4][0],nl[4][1])))
drawing.add(dxf.line((nl[4][0],nl[4][1]),(nl[5][0],nl[5][1])))
drawing.add(dxf.line((nl[5][0],nl[5][1]),(nl[3][0],nl[3][1])))
drawing.save_to_fileobj(output)
dxf_result=[output.getvalue()]
return dxf_result
def draw_circles(drawing, x, y, points):
circle = dxf.circle(radius=6, center=(x, y))
circle['color'] = 7
drawing.add(circle)
return (x, y)
sample_coords = [get_random_point() for x in range(50)]
flag_symbol = [(0,0), (0, 5), (4, 3), (0, 3)]
filename = 'flags.dxf'
dwg = dxf.drawing(filename)
dwg.add_layer('FLAGS')
# first create a block
flag = dxf.block(name='flag')
# add dxf entities to the block (the flag)
# use basepoint = (x, y) define an other basepoint than (0, 0)
flag.add( dxf.polyline(flag_symbol) )
flag.add( dxf.circle(radius=.4, color=2) )
# define some attributes
flag.add( dxf.attdef(insert=(0.5, -0.5), tag='NAME', height=0.5, color=3) )
flag.add( dxf.attdef(insert=(0.5, -1.0), tag='XPOS', height=0.25, color=4) )
flag.add( dxf.attdef(insert=(0.5, -1.5), tag='YPOS', height=0.25, color=4) )
# add block definition to the drawing
dwg.blocks.add(flag)
number = 1
for point in sample_coords:
# now insert flag symbols at coordinate 'point'
# insert2 needs the block definition object as parameter 'blockdef'
# see http://packages.python.org/dxfwrite/entities/insert2.html
# fill attribtes by creating a dict(), keystr is the 'tag' name of the
# attribute
values = {
def new_circle(self, c, r, layer = 'gearcircles', color = 0):
return dxf.circle(center=(c.real, c.imag), radius=r,
layer = layer, color = color, thickness=0)
def emit_dxf(self, d): color = (1,2)[self.radius == 0.0] d.add(dxf.circle(center = (self.x, self.y), radius = self.draw_radius, color = color))
def process_chess_sampling(img, screwDia, holeDia, width, height, resampleType,
thresholdScrew, fileName):
w = int(round(width / screwDia, 0))
h = int(round(height / screwDia, 0))
w = w * 20
h = h * 20
BWthreshold = 200
tempImg = img.resize((w, h), resampleType)
(w, h) = tempImg.size
greyscaleMap = list(tempImg.getdata())
greyscaleMap = numpy.array(greyscaleMap)
greyscaleMap = greyscaleMap.reshape((h, w))
img1 = Image.fromarray(numpy.uint8(greyscaleMap), 'L')
img1.show()
tempArray = []
for i in range(h):
for j in range(w):
if greyscaleMap[i][j] < BWthreshold:
greyscaleMap[i][j] = 0
else:
greyscaleMap[i][j] = 255
print("greyscale updated")
for row in range(0, len(greyscaleMap), 10):
arr = []
for col in range(int((row / 10) % 2) * 18, len(greyscaleMap[row]), 36):
meanImg = 0
countPoints = 0
if row == 0:
if col == 0:
for i in range(10):
for j in range(10):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r=0, c=0 index [%d][%d] unsolved" %
(i, j))
else:
for i in range(10):
for j in range(-9, 10, 1):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r=0, c!=0 index [%d][%d] unsolved" %
(i, j))
elif col == 0:
if row != 0:
for i in range(-9, 10, 1):
for j in range(10):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r!=0, c=0 index [%d][%d] unsolved" %
(i, j))
elif row == (len(greyscaleMap) - 1):
if col == (len(greyscaleMap[row]) - 1):
for i in range(-9, 1, 1):
for j in range(-9, 1, 1):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r=w, c=h index [%d][%d] unsolved" %
(i, j))
else:
for i in range(-9, 1, 1):
for j in range(-9, 10, 1):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r=w, c!=h index [%d][%d] unsolved" %
(i, j))
elif col == (len(greyscaleMap[row]) - 1):
if row != (len(greyscaleMap) - 1):
for i in range(-9, 1, 1):
for j in range(-9, 10, 1):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("r!=w, c=h index [%d][%d] unsolved" %
(i, j))
else:
for i in range(-9, 10, 1):
for j in range(-9, 10, 1):
try:
meanImg += greyscaleMap[row + i][col + j]
countPoints += 1
except:
print("index [%d][%d] unsolved" % (i, j))
meanImg /= countPoints
if meanImg / 255 > thresholdScrew:
arr.append(1)
else:
arr.append(0)
tempArray.append(arr)
for l in tempArray:
print(l)
drawing = dxf.drawing(fileName)
for row in range(len(tempArray)):
if row % 2 == 0:
for col in range(len(tempArray[row])):
if tempArray[row][col] == 0:
drawing.add(
dxf.circle(holeDia / 2, (screwDia / 2 * 3.6 * col,
(-screwDia / 2) * row)))
else:
for col in range(len(tempArray[row])):
if tempArray[row][col] == 0:
drawing.add(
dxf.circle(
holeDia / 2,
(screwDia / 2 * 3.6 * col + 1.8 * screwDia / 2,
(-screwDia / 2) * row)))
drawing.save()
print("done")
def circle_ch(r, x, y, chl=1.0, layer='0', layerch='drill'):
''' Circle with cross-hair center '''
drawing.add(dxf.circle(r, (x, y), layer=layer))
drawing.add(dxf.line((x, y - chl), (x, y + chl), layer=layerch))
drawing.add(dxf.line((x + chl, y), (x - chl, y), layer=layerch))
def writeDXF(self, dwg, pos=Point(0, 0)):
dwg.add(
dxf.circle(self._radius,
(self._center._x + pos.x, self._center._y + pos.y)))
return
def drawCircleColoured(draw, radio, pxCentre, pyCentre, colorA):
circlex = dxf.circle(radio, (pxCentre, pyCentre))
circlex['color'] = colorA
draw.add(circlex)
def circle(self, center, radius, mode, fill = False):
circle = dxf.circle(radius, center)
self._drawing_.add(circle)
def create_2D_modelspace_content(dwg):
dwg.add(dxf.rectangle((5, 5), 5, 5, color=2))
dwg.add(dxf.circle(2.5, (10, 5), color=3))
triangle = dxf.polyline([(10, 7.5), (15, 5), (15, 10)], color=4)
triangle.close(True)
dwg.add(triangle)
#!/usr/bin/env python
#coding:utf-8
# Author: mozman
# Purpose: examples for dxfwrite usage, see also tests for examples
# Created: 09.02.2010
# Copyright (C) 2010, Manfred Moitzi
# License: GPLv3
import sys
import os
try:
import dxfwrite
except ImportError:
# if dxfwrite is not 'installed' append parent dir of __file__ to sys.path
import os
curdir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.abspath(os.path.join(curdir, os.path.pardir)))
import dxfwrite
from dxfwrite import DXFEngine as dxf
name = 'spline.dxf'
dwg = dxf.drawing(name)
spline_points = [(0.0, 0.0), (1., 2.), (3., 1.), (5., 3.)]
dwg.add(dxf.spline(spline_points, color=7))
for point in spline_points:
dwg.add(dxf.circle(radius=0.1, center=point, color=1))
dwg.save()
print("drawing '%s' created.\n" % name)
def export_via_dxfwrite( dxf_fn, V):
from XMLlib import SvgXMLTreeNode
from svgLib_dd import SvgTextParser, SvgPath, SvgPolygon
from numpy import arctan2
from circleLib import fitCircle_to_path, findCircularArcCentrePoint, pointsAlongCircularArc
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing( dxf_fn)
pageSvg = open(V.page.PageResult).read()
XML_tree = SvgXMLTreeNode( pageSvg,0)
def yT(y): #y transform
return 210-y
warningsShown = []
SelectViewObjectPoint_loc = None
for element in XML_tree.getAllElements():
clr_text = None
if element.parms.has_key('fill'):
clr_text = element.parms['fill']
elif element.parms.has_key('style'):
for part in element.parms['style'].split(';'):
if part.startswith('stroke:rgb('):
clr_text = part[ len('stroke:'):]
if clr_text == None or clr_text =='none' or not clr_text.startswith('rgb(') :
color_code = 0
else:
#FreeCAD.Console.PrintMessage( "color text: %s\n" % clr_text )
r,g,b = [ int(v.strip()) for v in clr_text[ len('rgb('): clr_text.find(')')].split(',') ]
color_code = colorLookup(r,g,b)[0]
if element.tag == 'circle':
x, y = element.applyTransforms( float( element.parms['cx'] ), float( element.parms['cy'] ) )
r = float( element.parms['r'] )* element.scaling2()
drawing.add( dxf.circle( r, (x,yT(y)), color=color_code) )
elif element.tag == 'line':
x1, y1 = element.applyTransforms( float( element.parms['x1'] ), float( element.parms['y1'] ) )
x2, y2 = element.applyTransforms( float( element.parms['x2'] ), float( element.parms['y2'] ) )
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code ) )
elif element.tag == 'text' and element.parms.has_key('x'):
x,y = element.applyTransforms( float( element.parms['x'] ), float( element.parms['y'] ) )
try:
t = SvgTextParser(element.XML[element.pStart: element.pEnd ] )
drawing.add(dxf.text( t.text, insert=(x, yT(y)), height=t.height()*0.8, rotation=t.rotation, layer='TEXTLAYER', color=color_code) )
except ValueError, msg:
FreeCAD.Console.PrintWarning('dxf_export: unable to convert text element "%s": %s, ignoring...\n' % (element.XML[element.pStart: element.pEnd ], str(msg) ) )
elif element.tag == 'path':
#FreeCAD.Console.PrintMessage(element.parms['d']+'\n')
path = SvgPath( element )
for line in path.lines:
drawing.add( dxf.line( (line.x1, yT(line.y1)), (line.x2,yT(line.y2)), color=color_code) )
for arc in path.arcs:
if arc.circular:
for r, center, angle1, angle2 in arc.dxfwrite_arc_parms( yT ):
drawing.add( dxf.arc( r, center, angle1, angle2 , color=color_code) )
else:
for x1,y1,x2,y2 in arc.approximate_via_lines( 12 ):
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code) )
for bezierCurve in path.bezierCurves:
x, y, r, r_error = bezierCurve.fitCircle()
if r_error < 10**-4:
raise NotImplementedError
drawing.add( dxf.arc( *bezierCurve.dxfwrite_arc_parms(x, y, r) ) )
else:
X,Y = bezierCurve.points_along_curve()
for i in range(len(X) -1):
drawing.add( dxf.line( (X[i], yT(Y[i])), (X[i+1],yT(Y[i+1])), color=color_code ) )
drawing = dxf.drawing(name)
# add a LAYER-tableentry called 'dxfwrite'
drawing.add_layer('dxfwrite')
# add a VIEWPORT-tableentry
drawing.add_vport(
'*ACTIVE',
center_point=(10, 10),
height=30,
)
# add LINE-entity
drawing.add(dxf.line((0, 0), (10, 0), color=dxfwrite.BYLAYER,
layer='dxfwrite'))
# add a CIRCLE-entity
drawing.add(dxf.circle(center=(5, 0), radius=5))
# add an ARC-entity
drawing.add(dxf.arc(center=(5, 0), radius=4, startangle=30, endangle=150))
#add a POINT-entity
drawing.add(dxf.point(point=(1, 1)))
# add a SOLID-entity with 4 points
drawing.add(dxf.solid([(0, 0), (1, 0), (1, 1), (0, 1)], color=2))
# add a SOLID-entity with 3 points
drawing.add(dxf.solid([(0, 1), (1, 1), (1, 2)], color=3))
# add a 3DFACE-entity
drawing.add(dxf.face3d([(5, 5), (6, 5), (6, 6), (5, 6)], color=3))
def drawCircleColoured(draw, radio, pxCentre, pyCentre, colorA):
circlex = dxf.circle(radio, (pxCentre, pyCentre))
circlex["color"] = colorA
draw.add(circlex)
def draw_circles(self, d):
d.add(dxf.circle(center = (0.0, 0.0), radius = self.pr))
d = tuple(points_list[i+1])
drawing.add(dxf.line(c, d, color=7))
drawline(points_list)
# circle code
no_of_bars_above = 9
some_space_at_end = 5
center_to_center = ((lst['A'] - lst['ClearCover'] * 2 - some_space_at_end * 2) / float(no_of_bars_above - 1))
center_of_first_bar = (lst['ClearCover'] + some_space_at_end, lst['ClearCover'] + lst['Dia'] + lst['Dia'] / 2.0)
x_coord_of_center_of_bars = [(center_of_first_bar[0] + i * center_to_center) for i in xrange(no_of_bars_above)]
for x in x_coord_of_center_of_bars:
drawing.add(dxf.circle(lst['Dia'] / 2.0, (x, center_of_first_bar[1])))
# text
drawing.add(dxf.text('a', height=textsize, halign=CENTER, alignpoint=(50, 33)))
drawing.add(dxf.text('D', height=textsize, halign=CENTER, alignpoint=(115, 8)))
drawing.add(dxf.text('A', height=textsize, halign=CENTER, alignpoint=(50, -10)))
drawing.add(dxf.text('4', height=textsize, halign=CENTER, alignpoint=(-10, -13)))
drawing.add(dxf.text('4', height=textsize, halign=CENTER, alignpoint=
(106, -4)))
drawing.add(dxf.text('y > L\U+0501',height=textsize, halign=CENTER, alignpoint=(18, -15)))
drawing.add(dxf.text('Sloped footing', height=textsize, halign=CENTER, alignpoint=(20, 33)))
drawing.add(dxf.text('Uniformly deep footing', height=textsize, halign=CENTER, alignpoint=(80, 33)))
# D
def draw_circles(self, d):
d.add(dxf.circle(center = (0.0, 0.0), radius = self.dr))
d.add(dxf.circle(center = (0.0, 0.0), radius = self.br, color = 1))
d.add(dxf.circle(center = (0.0, 0.0), radius = self.pr))
d.add(dxf.circle(center = (0.0, 0.0), radius = self.ar))
