lasercut-scripts: comparison stuff/(Cad.py) Plotting with Z axis movement.py

--1:000000000000
+:ee535cb8fb1a
+#!/usr/bin/env python
+#
+# cad.py
+#
+# Neil Gershenfeld
+#
+# (c) Massachusetts Institute of Technology 2007
+# Permission granted for experimental and personal use;
+# license for commercial sale available from MIT.
+#
+#Altered by R Parsons (AKA: Capo) to output gcode with the '.gcode' extension as opposed to '.g'.
+#Also the default variables were changed to metric values
+DATE = "7/12/010"
+from numpy import *
+import scipy.signal.signaltools
+from string import *
+from Tkinter import *
+from tkFileDialog import *
+import Image, ImageTk, ImageDraw, ImageFont, ImageOps
+import os, struct
+#import time
+class point:
+#
+# an xyz point
+#
+def __init__(self,x,y,z=0):
+self.x = x
+self.y = y
+self.z = z
+class cad_variables:
+#
+# cad variables
+#
+def __init__(self):
+self.xmin = 0 # minimum x value to render
+self.xmax = 0 # maximum x value to render
+self.ymin = 0 # minimum y value to render
+self.ymax = 0 # maximum y value to render
+self.zmin = 0 # minimum z value to render
+self.zmax = 0 # maximum z value to render
+self.zlist = [] # z values to render
+self.nx = 0 # number of x points to render
+self.ny = 0 # number of y points to render
+self.nz = 1 # number of z points to render
+self.rz = 0 # perspective view z rotation (degrees)
+self.rx = 0 # perspective view x rotation (degrees)
+self.units = 'in' # file units
+self.function = '0' # cad function
+self.toolpaths = [] # toolpaths
+self.x = [] # x triangulation
+self.y = [] # y triangulation
+self.z = [] # z triangulation
+self.labels = [] # display labels
+self.image_r = array(0) # red array
+self.image_g = array(0) # green array
+self.image_b = array(0) # blue array
+self.image_min = 0 # image min value
+self.image_max = 0 # image max value
+self.stop = 0 # stop rendering
+self.nplot = 200 # plot window size
+self.inches_per_unit = 1 # file units
+self.views = 'xyzr'
+self.cam = '' # CAM export type
+self.editor_width = 30 # editor width
+self.editor_height = 10 # editor height
+def view(self,arg):
+global canvas_xy,canvas_yz,canvas_xz,canvas_xyz
+if (arg == 'xy'):
+view_frame2.grid_forget()
+view_frame3.grid_forget()
+canvas_xy.grid_forget()
+self.views = 'xy'
+self.nplot = 2*int(string_window_size.get()) # plot window size
+canvas_xy = Canvas(view_frame2, width=self.nplot, height=self.nplot)
+imxy = Image.new("RGBX",(self.nplot,self.nplot),'black')
+image_xy = ImageTk.PhotoImage(imxy)
+canvas_xy.create_image(self.nplot/2,self.nplot/2,image=image_xy)
+canvas_xy.bind('<Motion>',msg_xy)
+canvas_xy.grid(row=0,column=0)
+view_frame2.grid(row=2,column=0)
+elif (arg == 'xyzr'):
+view_frame2.grid_forget()
+view_frame3.grid_forget()
+canvas_xy.grid_forget()
+canvas_yz.grid_forget()
+canvas_xz.grid_forget()
+canvas_xyz.grid_forget()
+self.views = 'xyzr'
+self.nplot = int(string_window_size.get()) # plot window size
+canvas_xy = Canvas(view_frame3, width=self.nplot, height=self.nplot)
+canvas_yz = Canvas(view_frame3, width=self.nplot, height=self.nplot)
+canvas_xz = Canvas(view_frame3, width=self.nplot, height=self.nplot)
+canvas_xyz = Canvas(view_frame3, width=self.nplot, height=cad.nplot)
+imxy = Image.new("RGBX",(self.nplot,self.nplot),'black')
+image_xy = ImageTk.PhotoImage(imxy)
+canvas_xy.create_image(self.nplot/2,self.nplot/2,image=image_xy)
+canvas_xy.bind('<Motion>',msg_xy)
+canvas_xy.grid(row=0,column=0)
+imyz = Image.new("RGBX",(self.nplot,self.nplot),'black')
+image_yz = ImageTk.PhotoImage(imyz)
+canvas_yz.create_image(self.nplot/2,self.nplot/2,image=image_yz)
+canvas_yz.bind('<Motion>',msg_yz)
+canvas_yz.grid(row=0,column=1)
+imxz = Image.new("RGBX",(self.nplot,self.nplot),'black')
+image_xz = ImageTk.PhotoImage(imxz)
+canvas_xz.create_image(self.nplot/2,self.nplot/2,image=image_xz)
+canvas_xz.bind('<Motion>',msg_xz)
+canvas_xz.grid(row=1,column=0)
+imxyz = Image.new("RGBX",(self.nplot,self.nplot),'black')
+image_xyz = ImageTk.PhotoImage(imxyz)
+canvas_xyz.create_image(self.nplot/2,self.nplot/2,image=image_xyz)
+canvas_xyz.bind('<Motion>',msg_nomsg)
+canvas_xyz.grid(row=1,column=1)
+view_frame3.grid(row=2,column=0)
+else:
+print "view not supported"
+def nxplot(self):
+xwidth = self.xmax - self.xmin
+ywidth = self.ymax - self.ymin
+zwidth = self.zmax - self.zmin
+if ((xwidth >= ywidth) & (xwidth >= zwidth)):
+n = int(self.nplot*xwidth/float(xwidth))
+elif ((ywidth >= xwidth) & (ywidth >= zwidth)):
+n = int(self.nplot*xwidth/float(ywidth))
+else:
+n = int(self.nplot*xwidth/float(zwidth))
+return n
+def nyplot(self):
+xwidth = self.xmax - self.xmin
+ywidth = self.ymax - self.ymin
+zwidth = self.zmax - self.zmin
+if ((xwidth >= ywidth) & (xwidth >= zwidth)):
+n = int(self.nplot*ywidth/float(xwidth))
+elif ((ywidth >= xwidth) & (ywidth >= zwidth)):
+n = int(self.nplot*ywidth/float(ywidth))
+else:
+n = int(self.nplot*ywidth/float(zwidth))
+return n
+def nzplot(self):
+xwidth = self.xmax - self.xmin
+ywidth = self.ymax - self.ymin
+zwidth = self.zmax - self.zmin
+if ((xwidth >= ywidth) & (xwidth >= zwidth)):
+n = int(self.nplot*zwidth/float(xwidth))
+elif ((ywidth >= xwidth) & (ywidth >= zwidth)):
+n = int(self.nplot*zwidth/float(ywidth))
+else:
+n = int(self.nplot*zwidth/float(zwidth))
+return n
+cad = cad_variables()
+class cad_text:
+def __init__(self,x,y,z=0,text='',size=10,color='#ff0000',anchor=CENTER):
+self.x = x
+self.y = y
+self.z = z
+self.text = text
+self.size = size
+self.color = color
+self.anchor = anchor
+class im_class:
+#
+# for PIL images
+#
+def __init__(self):
+self.xy = 0
+self.xz = 0
+self.yz = 0
+self.xyz = 0
+self.intensity_xy = 0
+self.intensity_xz = 0
+self.intensity_yz = 0
+self.intensity_xyz = 0
+im = im_class()
+class images_class:
+#
+# for PhotoImages
+#
+def __init__(self):
+self.xy = 0
+self.xz = 0
+self.yz = 0
+self.xyz = 0
+images = images_class()
+class CA_states:
+#
+# CA state definition class
+#
+def __init__(self):
+self.empty = 0
+self.interior = 1
+self.edge = (1 << 1) # 2
+self.north = (1 << 2) # 4
+self.west = (2 << 2) # 8
+self.east = (3 << 2) # 12
+self.south = (4 << 2) # 16
+self.stop = (5 << 2) # 20
+self.corner = (6 << 2) # 24
+class rule_table:
+#
+# CA rule table class
+#
+# 0 = empty
+# 1 = interior
+# 2 = edge
+# edge+direction = start
+#
+def __init__(self):
+self.table = zeros(2**(9*2),uint32)
+self.s = CA_states()
+#
+# 1 0:
+#
+# 011
+# 111
+# 111
+self.add_rule(0,1,1,1,1,1,1,1,1,self.s.north)
+# 101
+# 111
+# 111
+self.add_rule(1,0,1,1,1,1,1,1,1,self.s.east)
+#
+# 2 0's:
+#
+# 001
+# 111
+# 111
+self.add_rule(0,0,1,1,1,1,1,1,1,self.s.east)
+# 100
+# 111
+# 111
+self.add_rule(1,0,0,1,1,1,1,1,1,self.s.east)
+# 010
+# 111
+# 111
+self.add_rule(0,1,0,1,1,1,1,1,1,self.s.east)
+# 011
+# 110
+# 111
+self.add_rule(0,1,1,1,1,0,1,1,1,self.s.south)
+# 110
+# 011
+# 111
+self.add_rule(1,1,0,0,1,1,1,1,1,self.s.east)
+# 101
+# 011
+# 111
+self.add_rule(1,0,1,0,1,1,1,1,1,self.s.east)
+# 101
+# 110
+# 111
+self.add_rule(1,0,1,1,1,0,1,1,1,self.s.south)
+# 011
+# 111
+# 110
+self.add_rule(0,1,1,1,1,1,1,1,0,self.s.corner)
+# 011
+# 111
+# 101
+self.add_rule(0,1,1,1,1,1,1,0,1,self.s.north)
+# 110
+# 111
+# 101
+self.add_rule(1,1,0,1,1,1,1,0,1,self.s.west)
+# 101
+# 111
+# 110
+self.add_rule(1,0,1,1,1,1,1,1,0,self.s.south)
+# 101
+# 111
+# 011
+self.add_rule(1,0,1,1,1,1,0,1,1,self.s.east)
+#
+# 3 0's:
+#
+# 001
+# 011
+# 111
+self.add_rule(0,0,1,0,1,1,1,1,1,self.s.east)
+# 010
+# 011
+# 111
+self.add_rule(0,1,0,0,1,1,1,1,1,self.s.east)
+# 010
+# 110
+# 111
+self.add_rule(0,1,0,1,1,0,1,1,1,self.s.south)
+# 010
+# 111
+# 011
+self.add_rule(0,1,0,1,1,1,0,1,1,self.s.east)
+# 010
+# 111
+# 110
+self.add_rule(0,1,0,1,1,1,1,1,0,self.s.south)
+# 110
+# 011
+# 011
+self.add_rule(1,1,0,0,1,1,0,1,1,self.s.east)
+# 011
+# 110
+# 110
+self.add_rule(0,1,1,1,1,0,1,1,0,self.s.south)
+# 101
+# 011
+# 011
+self.add_rule(1,0,1,0,1,1,0,1,1,self.s.east)
+# 101
+# 110
+# 110
+self.add_rule(1,0,1,1,1,0,1,1,0,self.s.south)
+# 011
+# 011
+# 011
+self.add_rule(0,1,1,0,1,1,0,1,1,self.s.north)
+#
+# 4 0's:
+#
+# 001
+# 011
+# 011
+self.add_rule(0,0,1,0,1,1,0,1,1,self.s.east)
+# 100
+# 110
+# 110
+self.add_rule(1,0,0,1,1,0,1,1,0,self.s.south)
+# 010
+# 011
+# 011
+self.add_rule(0,1,0,0,1,1,0,1,1,self.s.east)
+# 010
+# 110
+# 110
+self.add_rule(0,1,0,1,1,0,1,1,0,self.s.south)
+# 001
+# 110
+# 110
+self.add_rule(0,0,1,1,1,0,1,1,0,self.s.south)
+# 100
+# 011
+# 011
+self.add_rule(1,0,0,0,1,1,0,1,1,self.s.east)
+#
+# 5 0's:
+#
+# 000
+# 011
+# 011
+self.add_rule(0,0,0,0,1,1,0,1,1,self.s.east)
+#
+# edge states
+#
+# 200
+# 211
+# 211
+self.add_rule(2,0,0,2,1,1,2,1,1,self.s.east+self.s.edge)
+# 201
+# 211
+# 211
+self.add_rule(2,0,1,2,1,1,2,1,1,self.s.east+self.s.edge)
+# 210
+# 211
+# 211
+self.add_rule(2,1,0,2,1,1,2,1,1,self.s.east+self.s.edge)
+# 002
+# 112
+# 112
+self.add_rule(0,0,2,1,1,2,1,1,2,self.s.stop)
+# 102
+# 112
+# 112
+self.add_rule(1,0,2,1,1,2,1,1,2,self.s.stop)
+# 002
+# 112
+# 102
+self.add_rule(0,0,2,1,1,2,1,0,2,self.s.stop)
+# 012
+# 112
+# 112
+self.add_rule(0,1,2,1,1,2,1,1,2,self.s.stop)
+# 012
+# 112
+# 102
+self.add_rule(0,1,2,1,1,2,1,0,2,self.s.stop)
+def add_rule(self,nw,nn,ne,ww,cc,ee,sw,ss,se,rule):
+#
+# add a CA rule, with rotations
+#
+s = CA_states()
+#
+# add the rule
+#
+state = \
+(nw <<  0) + (nn <<  2) + (ne <<  4) + \
+(ww <<  6) + (cc <<  8) + (ee << 10) + \
+(sw << 12) + (ss << 14) + (se << 16)
+self.table[state] = rule
+#
+# rotate 90 degrees
+#
+state = \
+(sw <<  0) + (ww <<  2) + (nw <<  4) + \
+(ss <<  6) + (cc <<  8) + (nn << 10) + \
+(se << 12) + (ee << 14) + (ne << 16)
+if (rule == s.east):
+self.table[state] = s.south
+elif (rule == s.south):
+self.table[state] = s.west
+elif (rule == s.west):
+self.table[state] = s.north
+elif (rule == s.north):
+self.table[state] = s.east
+elif (rule == (s.east+s.edge)):
+self.table[state] = s.south+s.edge
+elif (rule == (s.south+s.edge)):
+self.table[state] = s.west+s.edge
+elif (rule == (s.west+s.edge)):
+self.table[state] = s.north+s.edge
+elif (rule == (s.north+s.edge)):
+self.table[state] = s.east+s.edge
+elif (rule == s.corner):
+self.table[state] = s.corner
+elif (rule == s.stop):
+self.table[state] = s.stop
+#
+# rotate 180 degrees
+#
+state = \
+(se <<  0) + (ss <<  2) + (sw <<  4) + \
+(ee <<  6) + (cc <<  8) + (ww << 10) + \
+(ne << 12) + (nn << 14) + (nw << 16)
+if (rule == s.east):
+self.table[state] = s.west
+elif (rule == s.south):
+self.table[state] = s.north
+elif (rule == s.west):
+self.table[state] = s.east
+elif (rule == s.north):
+self.table[state] = s.south
+elif (rule == (s.east+s.edge)):
+self.table[state] = s.west+s.edge
+elif (rule == (s.south+s.edge)):
+self.table[state] = s.north+s.edge
+elif (rule == (s.west+s.edge)):
+self.table[state] = s.east+s.edge
+elif (rule == (s.north+s.edge)):
+self.table[state] = s.south+s.edge
+elif (rule == s.corner):
+self.table[state] = s.corner
+elif (rule == s.stop):
+self.table[state] = s.stop
+#
+# rotate 270 degrees
+#
+state = \
+(ne <<  0) + (ee <<  2) + (se <<  4) + \
+(nn <<  6) + (cc <<  8) + (ss << 10) + \
+(nw << 12) + (ww << 14) + (sw << 16)
+if (rule == s.east):
+self.table[state] = s.north
+elif (rule == s.south):
+self.table[state] = s.east
+elif (rule == s.west):
+self.table[state] = s.south
+elif (rule == s.north):
+self.table[state] = s.west
+elif (rule == (s.east+s.edge)):
+self.table[state] = s.north+s.edge
+elif (rule == (s.south+s.edge)):
+self.table[state] = s.east+s.edge
+elif (rule == (s.west+s.edge)):
+self.table[state] = s.south+s.edge
+elif (rule == (s.north+s.edge)):
+self.table[state] = s.west+s.edge
+elif (rule == s.corner):
+self.table[state] = s.corner
+elif (rule == s.stop):
+self.table[state] = s.stop
+def evaluate_state(arr):
+#
+# assemble the state bit strings
+#
+(ny, nx) = shape(arr)
+s = CA_states()
+nn = concatenate(([s.edge+zeros(nx,uint32)],arr[:(ny-1)]))
+ss = concatenate((arr[1:],[s.edge+zeros(nx,uint32)]))
+ww = concatenate((reshape(s.edge+zeros(ny,uint32),(ny,1)),arr[:,:(nx-1)]),1)
+ee = concatenate((arr[:,1:],reshape(s.edge+zeros(ny,uint32),(ny,1))),1)
+cc = arr
+nw = concatenate(([s.edge+zeros(nx,uint32)],ww[:(ny-1)]))
+ne = concatenate(([s.edge+zeros(nx,uint32)],ee[:(ny-1)]))
+sw = concatenate((ww[1:],[s.edge+zeros(nx,uint32)]))
+se = concatenate((ee[1:],[s.edge+zeros(nx,uint32)]))
+state = (nw <<  0) + (nn <<  2) + (ne <<  4) + \
+(ww <<  6) + (cc <<  8) + (ee << 10) + \
+(sw << 12) + (ss << 14) + (se << 16)
+return state
+def vectorize_toolpaths(arr):
+#
+# convert lattice toolpath directions to vectors
+#
+s = CA_states()
+toolpaths = []
+max_dist = float(string_vector_error.get())
+start_sites = (arr == (s.north+s.edge)) | (arr == (s.south+s.edge)) | \
+(arr == (s.east+s.edge)) | (arr == (s.west+s.edge))
+num_start_sites = sum(sum(1.0*start_sites))
+path_sites = (arr == s.north) | (arr == s.south) | (arr == s.east) | \
+(arr == s.west)
+num_path_sites = sum(sum(1.0*path_sites))
+remaining_sites = num_start_sites + num_path_sites
+while (remaining_sites != 0):
+#print remaining_sites
+if (num_start_sites > 0):
+#
+# begin segment on a start state
+#
+if (argmax(start_sites[0,:],axis=0) != 0):
+x = argmax(start_sites[0,:],axis=0)
+y = 0
+elif (argmax(start_sites[:,0],axis=0) != 0):
+x = 0
+y = argmax(start_sites[:,0],axis=0)
+elif (argmax(start_sites[-1,:],axis=0) != 0):
+x = argmax(start_sites[-1,:],axis=0)
+y = cad.ny-1
+elif (argmax(start_sites[:,-1],axis=0) != 0):
+x = cad.nx-1
+y = argmax(start_sites[:,-1],axis=0)
+else:
+print "error: internal start"
+sys.exit()
+#print "start from ",x,y
+else:
+#
+# no start states; begin segment on upper-left boundary point
+#
+maxcols = argmax(path_sites,axis=1)
+y = argmax(argmax(path_sites,axis=1))
+x = maxcols[y]
+arr[y][x] += s.edge
+#print "segment from ",x,y
+segment = [point(x,y)]
+vector = [point(x,y)]
+while 1:
+#
+# follow path
+#
+y = vector[-1].y
+x = vector[-1].x
+state = arr[y][x]
+#
+# if start state, set stop
+#
+if (state == (s.north + s.edge)):
+state = s.north
+arr[y][x] = s.stop
+elif (state == (s.south + s.edge)):
+state = s.south
+arr[y][x] = s.stop
+elif (state == (s.east + s.edge)):
+state = s.east
+arr[y][x] = s.stop
+elif (state == (s.west + s.edge)):
+state = s.west
+arr[y][x] = s.stop
+#print "x,y,state,arr: ",x,y,state,arr[y][x]
+#
+# move if a valid direction
+#
+if (state == s.north):
+direction = "north"
+#print "north"
+ynew = y - 1
+xnew = x
+elif (state == s.south):
+direction = "south"
+#print "south"
+ynew = y + 1
+xnew = x
+elif (state == s.east):
+direction = "east"
+#print "east"
+ynew = y
+xnew = x + 1
+elif (state == s.west):
+direction = "west"
+#print "west"
+ynew = y
+xnew = x - 1
+elif (state == s.corner):
+#print "corner"
+if (direction == "east"):
+#print "south"
+xnew = x
+ynew = y + 1
+elif (direction == "west"):
+#print "north"
+xnew = x
+ynew = y - 1
+elif (direction == "north"):
+#print "east"
+ynew = y
+xnew = x + 1
+elif (direction == "south"):
+#print "west"
+ynew = y
+xnew = x - 1
+else:
+#
+# not a valid direction, terminate segment on previous point
+#
+print "unexpected path termination at",x,y
+#sys.exit()
+segment.append(point(x,y))
+toolpaths.append(segment)
+arr[y][x] = s.interior
+break
+#print "xnew,ynew,snew",xnew,ynew,arr[ynew][xnew]
+#
+# check if stop reached
+#
+if (arr[ynew][xnew] == s.stop):
+#print "stop at ",xnew,ynew
+segment.append(point(xnew,ynew))
+toolpaths.extend([segment])
+if (state != s.corner):
+arr[y][x] = s.interior
+arr[ynew][xnew] = s.interior
+break
+#
+# find max transverse distance from vector to new point
+#
+dmax = 0
+dx = xnew - vector[0].x
+dy = ynew - vector[0].y
+norm = sqrt(dx**2 + dy**2)
+nx = dy / norm
+ny = -dx / norm
+for i in range(len(vector)):
+dx = vector[i].x - vector[0].x
+dy = vector[i].y - vector[0].y
+d = abs(nx*dx + ny*dy)
+if (d > dmax):
+dmax = d
+#
+# start new vector if transverse distance > max_dist
+#
+if (dmax >= max_dist):
+#print "max at ",x,y
+segment.append(point(x,y))
+vector = [point(x,y)]
+#
+# otherwise add point to vector
+#
+else:
+#print "add ",xnew,ynew
+vector.append(point(xnew,ynew))
+if ((arr[y][x] != s.corner) & (arr[y][x] != s.stop)):
+arr[y][x] = s.interior
+start_sites = (arr == (s.north+s.edge)) | (arr == (s.south+s.edge)) | \
+(arr == (s.east+s.edge)) | (arr == (s.west+s.edge))
+num_start_sites = sum(sum(1.0*start_sites))
+path_sites = (arr == s.north) | (arr == s.south) | (arr == s.east) | \
+(arr == s.west)
+num_path_sites = sum(sum(1.0*path_sites))
+remaining_sites = num_start_sites + num_path_sites
+#
+# reverse segment order, to start from inside to out
+#
+newpaths = []
+for segment in range(len(toolpaths)):
+newpaths.append(toolpaths[-1-segment])
+root.update()
+return newpaths
+def evaluate():
+#
+# evaluate .cad program/image
+#
+if (len(widget_cad_text.get("1.0",END)) > 1):
+#
+# .cad
+#
+cad.zlist = []
+cad_text_string = widget_cad_text.get("1.0",END)
+exec cad_text_string in globals()
+widget_function_text.config(state=NORMAL)
+widget_function_text.delete("1.0",END)
+widget_function_text.insert("1.0",cad.function)
+widget_function_text.config(state=DISABLED)
+if (cad.image_r.size > 1):
+#
+# image
+#
+cad.xmin = float(string_image_xmin.get())
+xwidth = float(string_image_xwidth.get())
+cad.xmax = cad.xmin + xwidth
+cad.ymin = float(string_image_ymin.get())
+yheight = float(string_image_yheight.get())
+cad.ymax = cad.ymin + yheight
+cad.image_min = float(string_image_min.get())
+cad.image_max = float(string_image_max.get())
+cad.zmin = float(string_image_zmin.get())
+cad.zmax = float(string_image_zmax.get())
+cad.nz = int(string_image_nz.get())
+cad.inches_per_unit = float(string_image_units.get())
+def render(view='xyzr'):
+render_stop_flag = 0
+cad.stop = 0
+#
+# if .cad doesn't call render, delete windows and add stop button
+#
+if (find(widget_cad_text.get("1.0",END),"render(") == -1):
+string_msg.set("render ...")
+widget_stop.pack()
+delete_windows()
+#
+# initialize variables
+#
+cad.toolpaths = []
+rx = pi*cad.rx/180.
+rz = pi*cad.rz/180.
+r = rule_table()
+s = CA_states()
+#
+# evaluate coordinate arrays
+#
+Xarray = outer(ones((cad.ny,1)),cad.xmin+(cad.xmax-cad.xmin)*arange(cad.nx)/(cad.nx-1.0))
+Yarray = outer(cad.ymin+(cad.ymax-cad.ymin)*arange(cad.ny-1,-1,-1)/(cad.ny-1.0),ones((1,cad.nx)))
+if (cad.zlist == []):
+if ((cad.nz == 1) & (cad.image_r.size != 1)):
+cad.zlist = [cad.zmax]
+cad.view('xy')
+elif (cad.nz == 1):
+cad.zlist = [cad.zmin]
+cad.view('xy')
+else:
+cad.zlist = cad.zmin + (cad.zmax-cad.zmin)*arange(cad.nz)/(cad.nz-1.0)
+cad.view('xyzr')
+else:
+cad.nz = len(cad.zlist)
+cad.zmin = cad.zlist[0]
+cad.zmax = cad.zlist[-1]
+#
+# draw orthogonal views
+#
+X = Xarray
+Y = Yarray
+accum_r = zeros((cad.ny,cad.nx),uint32)
+accum_g = zeros((cad.ny,cad.nx),uint32)
+accum_b = zeros((cad.ny,cad.nx),uint32)
+im.intensity_yz = zeros((cad.ny,cad.nz),uint32)
+im.intensity_xz = zeros((cad.nz,cad.nx),uint32)
+im.intensity_xyz = zeros((cad.nz,cad.nx),uint32)
+for layer in range(cad.nz):
+#
+# check render stop button
+#
+if (cad.stop == 1):
+break
+#
+# xy view
+#
+Z = cad.zlist[layer]
+string_msg.set("render z = %.3f"%Z)
+# root.update()
+if (cad.image_r.size == 1):
+#
+# .cad
+#
+array_r = eval(cad.function)
+array_g = array_r
+array_b = array_r
+if ((cad.zmax == cad.zmin) | (cad.nz == 1)):
+zi = array([255],uint32)
+else:
+zi = array([55.0 + 200.0*layer/(cad.nz-1.0)],uint32)
+accum_r = where(((zi*array_r) > accum_r),(zi*array_r),accum_r)
+accum_g = where(((zi*array_g) > accum_g),(zi*array_g),accum_g)
+accum_b = where(((zi*array_b) > accum_b),(zi*array_b),accum_b)
+im.intensity_xy = (1 << 16)*accum_b + (1 << 8)*accum_g + (1 << 0)*accum_r
+else:
+#
+# bitmap
+#
+array_r = (cad.image_r[0,] >= (cad.image_min + (cad.image_max-cad.image_min)*(Z-cad.zmin)/float(cad.zmax-cad.zmin)))
+array_g = (cad.image_g[0,] >= (cad.image_min + (cad.image_max-cad.image_min)*(Z-cad.zmin)/float(cad.zmax-cad.zmin)))
+array_b = (cad.image_b[0,] >= (cad.image_min + (cad.image_max-cad.image_min)*(Z-cad.zmin)/float(cad.zmax-cad.zmin)))
+image_z = int(cad.image_min + (cad.image_max-cad.image_min)*(Z-cad.zmin)/float(cad.zmax-cad.zmin))
+intensity_r = where((cad.image_r[0,] <= image_z),cad.image_r[0,],image_z)
+intensity_g = where((cad.image_g[0,] <= image_z),cad.image_g[0,],image_z)
+intensity_b = where((cad.image_b[0,] <= image_z),cad.image_b[0,],image_z)
+im.intensity_xy = (1 << 16)*intensity_b + (1 << 8)*intensity_g + (1 << 0)*intensity_r
+im.xy = Image.fromarray(im.intensity_xy,mode="RGBX")
+im.xy_draw = ImageDraw.Draw(im.xy)
+im.xy = im.xy.resize((cad.nxplot(),cad.nyplot()))
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+# root.update()
+#
+# find toolpaths if needed
+#
+ncontours = int(string_num_contours.get())
+if (ncontours == -1):
+ncontours = 2**20 # a big number
+cad.toolpaths.append([])
+"""
+if (ncontours != 0):
+#
+# grassfire convolve (to come)
+#
+interior = (array_r | array_g | array_b)
+print shape(X[interior])
+conv_array = interior
+"""
+for contour in range(ncontours):
+#
+# check render stop button
+#
+if (cad.stop == 1):
+break
+#
+# convolve tool for contour
+#
+string_msg.set(" convolve tool ... ")
+#
+# FFT convolve
+#
+# root.update()
+tool_rad = float(string_tool_dia.get())/2.0
+tool_dia = float(string_tool_dia.get())
+tool_overlap = float(string_tool_overlap.get())
+kernel_rad = tool_rad + contour*tool_overlap*tool_dia
+ikernel_rad = 1 + int(cad.nx*kernel_rad/(cad.xmax-cad.xmin))
+if (ikernel_rad > (((cad.nx/2),(cad.ny/2))[(cad.ny/2) > (cad.nx/2)])):
+break
+kx = 1+outer(ones((2*ikernel_rad,1)),arange(2*ikernel_rad))
+ky = 1+outer(arange(2*ikernel_rad),ones((1,2*ikernel_rad)))
+k = (((kx-ikernel_rad)**2 + (ky-ikernel_rad)**2) < ikernel_rad**2).astype('uint32')
+interior = (array_r == s.interior).astype('uint32')
+#tstart = time.time()
+conv = scipy.signal.signaltools.fftconvolve(interior,k,mode='same')
+conv = where(conv > 0.01,s.interior,0)
+conv_array = conv + (conv != s.interior)*array_r
+#tend = time.time()
+#print 'convolve:',tend-tstart
+#
+# use CA rule table to find edge directions
+#
+string_msg.set("  follow edges ... ")
+# root.update()
+state = evaluate_state(conv_array)
+toolpath = r.table[state]
+tool_array = toolpath + (toolpath == s.empty)*conv_array
+tool_intensity = \
+((0 << 16) +   (0 << 8) +   (0 << 0))*(tool_array == s.empty).astype('uint32') +\
+((255 << 16) + (255 << 8) + (255 << 0))*(tool_array == s.interior).astype('uint32') +\
+((  0 << 16) + (  0 << 8) + (255 << 0))*(tool_array == s.north).astype('uint32') +\
+((  0 << 16) + (255 << 8) + (  0 << 0))*(tool_array == s.south).astype('uint32') +\
+((255 << 16) + (  0 << 8) + (  0 << 0))*(tool_array == s.east).astype('uint32') +\
+((  0 << 16) + (255 << 8) + (255 << 0))*(tool_array == s.west ).astype('uint32') +\
+((128 << 16) + (  0 << 8) + (128 << 0))*(tool_array == s.stop).astype('uint32')
+#
+# show CA
+#
+"""
+im.xy = Image.fromarray(tool_intensity,mode="RGBX")
+im.xy = im.xy.resize((cad.nplot,cad.nplot))
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+"""
+#
+# vectorize contour
+#
+#tstart = time.time()
+string_msg.set("    vectorize ...    ")
+# root.update()
+new_paths = vectorize_toolpaths(tool_array)
+if (len(new_paths) == 0):
+break
+cad.toolpaths[layer].extend(new_paths)
+#tend = time.time()
+#print 'vector:',tend-tstart
+#
+# draw toolpath
+#
+im.xy_draw = ImageDraw.Draw(im.xy)
+for segment in range(len(cad.toolpaths[layer])):
+x = cad.nxplot()*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)
+y = cad.nyplot()*(cad.toolpaths[layer][segment][0].y+0.5)/float(cad.ny)
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+xnew = cad.nxplot()*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)
+ynew = cad.nyplot()*(cad.toolpaths[layer][segment][vertex].y+0.5)/float(cad.ny)
+im.xy_draw.line([x,y,xnew,ynew],fill="#ffa0a0",width=1)
+x = xnew
+y = ynew
+#
+# show xy toolpath view
+#
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+#
+# add send_to button
+#
+string_send_to_time.set("")
+send_to_frame.pack()
+# root.update()
+#
+# draw labels
+#
+for label in range(len(cad.labels)):
+x = cad.nplot/2. + cad.nxplot()*(cad.labels[label].x-(cad.xmax+cad.xmin)/2.0)/(cad.xmax-cad.xmin)
+y = cad.nplot/2. - cad.nyplot()*(cad.labels[label].y-(cad.ymax+cad.ymin)/2.0)/(cad.ymax-cad.ymin)
+string = cad.labels[label].text
+size = cad.labels[label].size
+color = cad.labels[label].color
+anch = cad.labels[label].anchor
+canvas_xy.create_text(x,y,text=string,font=('arial',size,'bold'),fill=color,anchor=anch,justify=CENTER)
+#
+# draw origin
+#
+x0 = cad.nplot/2. + cad.nxplot()*(0-(cad.xmax+cad.xmin)/2.)/(cad.xmax-cad.xmin)
+y0 = cad.nplot/2. - cad.nyplot()*(0-(cad.ymax+cad.ymin)/2.)/(cad.ymax-cad.ymin)
+dxy = .025*cad.nplot
+canvas_xy.create_line([x0-dxy,y0,x0+dxy,y0],fill="green")
+canvas_xy.create_line([x0,y0-dxy,x0,y0+dxy],fill="green")
+#
+# yz view
+#
+if (cad.views == 'xyzr'):
+accum_yz_r = zeros(cad.ny,uint32)
+accum_yz_g = zeros(cad.ny,uint32)
+accum_yz_b = zeros(cad.ny,uint32)
+for vertex in range(cad.nx):
+xi = array([55.0 + 200.0*vertex/(cad.nx-1.0)],uint32)
+slice_r = array_r[:,vertex]
+slice_g = array_g[:,vertex]
+slice_b = array_b[:,vertex]
+accum_yz_r = where(((xi*slice_r) >= accum_yz_r),(xi*slice_r),accum_yz_r)
+accum_yz_g = where(((xi*slice_g) >= accum_yz_g),(xi*slice_g),accum_yz_g)
+accum_yz_b = where(((xi*slice_b) >= accum_yz_b),(xi*slice_b),accum_yz_b)
+im.intensity_yz[:,layer] = (1 << 16)*accum_yz_b + (1 << 8)*accum_yz_g + (1 << 0)*accum_yz_r
+im.yz = Image.fromarray(im.intensity_yz,mode="RGBX")
+im.yz = im.yz.transpose(Image.FLIP_LEFT_RIGHT)
+im.yz = im.yz.resize((cad.nzplot(),cad.nyplot()))
+images.yz = ImageTk.PhotoImage(im.yz)
+canvas_yz.create_image(cad.nplot/2,cad.nplot/2,image=images.yz)
+#
+# draw origin
+#
+z0 = cad.nplot/2. - cad.nzplot()*(0-(cad.zmax+cad.zmin)/2.)/(cad.zmax-cad.zmin)
+y0 = cad.nplot/2. - cad.nyplot()*(0-(cad.ymax+cad.ymin)/2.)/(cad.ymax-cad.ymin)
+canvas_yz.create_line([z0-dxy,y0,z0+dxy,y0],fill="green")
+canvas_yz.create_line([z0,y0-dxy,z0,y0+dxy],fill="green")
+#
+# xz view
+#
+if (cad.views == 'xyzr'):
+accum_xz_r = zeros(cad.nx,uint32)
+accum_xz_g = zeros(cad.nx,uint32)
+accum_xz_b = zeros(cad.nx,uint32)
+for vertex in range(cad.ny):
+yi = array([55.0+200.0*vertex/(cad.ny-1.0)],uint32)
+slice_r = array_r[vertex,:]
+slice_g = array_g[vertex,:]
+slice_b = array_b[vertex,:]
+accum_xz_r = where(((yi*slice_r) >= accum_xz_r),(yi*slice_r),accum_xz_r)
+accum_xz_g = where(((yi*slice_g) >= accum_xz_g),(yi*slice_g),accum_xz_g)
+accum_xz_b = where(((yi*slice_b) >= accum_xz_b),(yi*slice_b),accum_xz_b)
+im.intensity_xz[(cad.nz-1-layer),:] = (1 << 16)*accum_xz_b + (1 << 8)*accum_xz_g + (1 << 0)*accum_xz_r
+im.xz = Image.fromarray(im.intensity_xz,mode="RGBX")
+im.xz = im.xz.resize((cad.nxplot(),cad.nzplot()))
+images.xz = ImageTk.PhotoImage(im.xz)
+canvas_xz.create_image(cad.nplot/2,cad.nplot/2,image=images.xz)
+#
+# draw origin
+#
+x0 = cad.nplot/2. + cad.nxplot()*(0-(cad.xmax+cad.xmin)/2.)/(cad.xmax-cad.xmin)
+z0 = cad.nplot/2. - cad.nzplot()*(0-(cad.zmax+cad.zmin)/2.)/(cad.zmax-cad.zmin)
+canvas_xz.create_line([x0-dxy,z0,x0+dxy,z0],fill="green")
+canvas_xz.create_line([x0,z0-dxy,x0,z0+dxy],fill="green")
+#
+# draw it
+#
+root.update()
+#
+# rotated view
+#
+if ((cad.views == 'xyzr') & (cad.image_r.size == 1)):
+accum = zeros((cad.ny,cad.nx),uint32)
+for z in cad.zlist:
+#
+# check render stop button
+#
+if (cad.stop == 1):
+break
+string_msg.set("render z = %.3f"%z)
+dY = cos(rx)*(Yarray-(cad.ymax+cad.ymin)/2.0) - sin(rx)*(z-(cad.zmax+cad.zmin)/2.0)
+Z = (cad.zmax+cad.zmin)/2.0 + sin(rx)*(Yarray-(cad.ymax+cad.ymin)/2.0) + cos(rx)*(z-(cad.zmax+cad.zmin)/2.0)
+X = (cad.xmax+cad.xmin)/2.0 + cos(rz)*(Xarray-(cad.xmax+cad.xmin)/2.0) - sin(rz)*dY
+Y = (cad.ymax+cad.ymin)/2.0 + sin(rz)*(Xarray-(cad.xmax+cad.xmin)/2.0) + cos(rz)*dY
+arr = eval(cad.function)
+if (cad.zmax == cad.zmin):
+zi = array([255],uint32)
+else:
+zi = array([55.0 + 200.0*(z-cad.zmin)/(cad.zmax-cad.zmin)],uint32)
+accum = where(((zi*arr) > accum),(zi*arr),accum)
+im.intensity_xyz = ((1 << 16) + (1 << 8) + (1 << 0)) * accum
+im.xyz = Image.fromarray(im.intensity_xyz,mode="RGBX")
+im.xyz = im.xyz.resize((cad.nxplot(),cad.nyplot()))
+images.xyz = ImageTk.PhotoImage(im.xyz)
+canvas_xyz.create_image(cad.nplot/2,cad.nplot/2,image=images.xyz)
+root.update()
+#
+# return
+#
+cad.zwrite = cad.zlist
+cad.zlist = []
+widget_stop.pack_forget()
+string_msg.set("done")
+root.update()
+return
+def draw_toolpath():
+im.xy = Image.new("RGBX",(cad.nxplot(),cad.nyplot()),'white')
+im.xy_draw = ImageDraw.Draw(im.xy)
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+x = cad.nxplot()*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)
+y = cad.nyplot()*(cad.toolpaths[layer][segment][0].y+0.5)/float(cad.ny)
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+xnew = cad.nxplot()*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)
+ynew = cad.nyplot()*(cad.toolpaths[layer][segment][vertex].y+0.5)/float(cad.ny)
+im.xy_draw.line([x,y,xnew,ynew],fill="black")
+x = xnew
+y = ynew
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+def delete_windows():
+im.xy = Image.new("RGBX",(cad.nplot,cad.nplot),'black')
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+im.yz = Image.new("RGBX",(cad.nplot,cad.nplot),'black')
+images.yz = ImageTk.PhotoImage(im.yz)
+canvas_yz.create_image(cad.nplot/2,cad.nplot/2,image=images.yz)
+im.xz = Image.new("RGBX",(cad.nplot,cad.nplot),'black')
+images.xz = ImageTk.PhotoImage(im.xz)
+canvas_xz.create_image(cad.nplot/2,cad.nplot/2,image=images.xz)
+im.xyz = Image.new("RGBX",(cad.nplot,cad.nplot),'black')
+images.xyz = ImageTk.PhotoImage(im.xyz)
+canvas_xyz.create_image(cad.nplot/2,cad.nplot/2,image=images.xyz)
+root.update()
+def select_cad():
+image_x_frame.pack_forget()
+image_y_frame.pack_forget()
+image_z_frame.pack_forget()
+image_intensity_frame.pack_forget()
+image_units_frame.pack_forget()
+image_invert_frame.pack_forget()
+cad_input_frame.pack_forget()
+widget_cad_text.delete("1.0",END)
+widget_cad_text.insert("1.0",cad_template)
+editor_frame.pack()
+cad.image = array(0)
+cad_input_frame.pack()
+cad.toolpaths = []
+string_num_contours.set('0')
+widget_cad_save.pack(side='left')
+delete_windows()
+def select_image():
+editor_frame.pack_forget()
+cad_input_frame.pack_forget()
+image_x_frame.pack()
+image_y_frame.pack()
+image_z_frame.pack()
+image_intensity_frame.pack()
+image_units_frame.pack()
+image_invert_frame.pack()
+cad_input_frame.pack()
+cad.toolpaths = []
+string_num_contours.set('0')
+widget_cad_save.pack_forget()
+delete_windows()
+def input_open():
+filename = askopenfilename()
+string_input_file.set(filename)
+if (find(filename,'.cad') != -1):
+cad_load(0)
+elif ((find(filename,'.jpg') != -1) | (find(filename,'.JPG') != -1) |
+(find(filename,'.png') != -1) | (find(filename,'.PNG') != -1) |
+(find(filename,'.gif') != -1) | (find(filename,'.GIF') != -1)):
+widget_cad_text.delete("1.0",END)
+image_load(0)
+else:
+string_msg.set("unsupported input file format")
+root.update()
+def cad_load(event):
+global cad
+cad = cad_variables()
+cam_pack_forget()
+select_cad()
+input_file_name = string_input_file.get()
+input_file = open(input_file_name,'rb')
+cad_text_string = input_file.read()
+widget_cad_text.delete("1.0",END)
+widget_cad_text.insert("1.0",cad_text_string)
+input_file.close()
+cad.toolpaths = []
+cad.image = array(0)
+cad.nz = 1
+string_num_contours.set('0')
+evaluate()
+if (find(widget_cad_text.get("1.0",END),"render(") == -1):
+render()
+def image_load(event):
+global cad
+cad = cad_variables()
+cam_pack_forget()
+select_image()
+function_string_frame.pack_forget()
+input_file_name = string_input_file.get()
+input_file = open(input_file_name,'rb')
+input_file.close()
+cad.toolpaths = []
+string_num_contours.set('0')
+image = Image.open(input_file_name)
+num_layers = 1
+while 1: # check number of layers
+try:
+image.seek(image.tell()+1)
+num_layers += 1
+except:
+break
+image = Image.open(input_file_name)
+if image.mode != "RGBX":
+image = image.convert("RGBX")
+(cad.nx,cad.ny) = image.size
+info = image.info
+if ('dpi' in info):
+(xdpi,ydpi) = info['dpi']
+else:
+xdpi = cad.nx
+ydpi = xdpi
+string_image_nx.set(" nx = "+str(cad.nx))
+string_image_ny.set(" ny = "+str(cad.ny))
+cad.nz = 1
+string_image_nz.set(str(cad.nz))
+cad.xmin = 0
+string_image_xmin.set('0')
+cad.xmax = cad.nx/float(xdpi)
+string_image_xwidth.set(str(cad.xmax-cad.xmin))
+cad.ymin = 0
+string_image_ymin.set('0')
+cad.ymax = cad.ny/float(ydpi)
+string_image_yheight.set(str(cad.ymax-cad.ymin))
+cad.zmin = -.005
+string_image_zmin.set('-0.05')
+cad.zmax = 0.05
+string_image_zmax.set('0.05')
+cad.inches_per_unit = 1.0
+string_image_units.set('25.4')
+data = zeros((num_layers,cad.nx*cad.ny,3),uint32)
+data[0,] = array(image.convert("RGB").getdata(),uint32)
+for layer in range(1,num_layers):
+image.seek(image.tell()+1)
+data[layer,] = array(image.convert("RGB").getdata(),uint32)
+cad.image_r = array(data[:,:,0],uint32)
+cad.image_r = cad.image_r.reshape((num_layers,cad.ny,cad.nx))
+cad.image_g = array(data[:,:,1],uint32)
+cad.image_g = cad.image_g.reshape((num_layers,cad.ny,cad.nx))
+cad.image_b = array(data[:,:,2],uint32)
+cad.image_b = cad.image_b.reshape((num_layers,cad.ny,cad.nx))
+cad.image_min = 1
+string_image_min.set(str(cad.image_min))
+cad.image_max = 255
+string_image_max.set(str(cad.image_max))
+evaluate()
+render()
+def invert_image(event):
+cad.image_r = 255 - cad.image_r
+cad.image_g = 255 - cad.image_g
+cad.image_b = 255 - cad.image_b
+evaluate()
+render()
+def cad_save(event):
+input_file_name = string_input_file.get()
+input_file = open(input_file_name,'wb')
+cad_text_string = widget_cad_text.get("1.0",END)
+input_file.write(cad_text_string)
+input_file.close()
+string_msg.set(input_file_name+" saved")
+root.update()
+def render_button(event):
+cam_pack_forget()
+cad.cam = ''
+if (cad.image_r.size == 1):
+function_string_frame.pack()
+cad.toolpaths = []
+string_num_contours.set('0')
+evaluate()
+if (find(widget_cad_text.get("1.0",END),"render(") == -1):
+render()
+def render_stop(event):
+cad.stop = 1
+widget_stop.pack_forget()
+def cam(event):
+function_string_frame.pack_forget()
+cam_file_frame.pack()
+string_num_contours.set('1')
+root.update()
+def contour(event):
+evaluate()
+if (find(widget_cad_text.get("1.0",END),"render(") == -1):
+render()
+def triangulate(event):
+#
+# triangulate for STL
+#
+# evaluate .cad
+#
+evaluate()
+#
+# initialize variables
+#
+render_stop_flag = 0
+cad.stop = 0
+widget_stop.pack()
+delete_windows()
+cad.toolpaths = []
+cad.zwrite = []
+cad.x = zeros(0)
+cad.y = zeros(0)
+cad.z = zeros(0)
+ixlr = array([])
+iylrs = array([])
+iylre = array([])
+izlr = array([])
+ixfbs = array([])
+ixfbe = array([])
+iyfb = array([])
+izfb = array([])
+ixtbs = array([])
+ixtbe = array([])
+iytb = array([])
+iztb = array([])
+#
+# evaluate coordinate arrays
+#
+(IY,IX) = indices((cad.ny,cad.nx))
+IY = IY[::-1,:]
+X = cad.xmin+(cad.xmax-cad.xmin)*IX/(cad.nx-1.0)
+Y = cad.ymin+(cad.ymax-cad.ymin)*IY/(cad.ny-1.0)
+cad.zwrite = cad.zmin + (cad.zmax-cad.zmin)*arange(cad.nz)/(cad.nz-1.0)
+#
+# set up drawing images
+#
+im.xy = Image.new("RGBX",(cad.nxplot(),cad.nyplot()),'white')
+im.xy_draw = ImageDraw.Draw(im.xy)
+im.xz = Image.new("RGBX",(cad.nxplot(),cad.nzplot()),'white')
+im.xz_draw = ImageDraw.Draw(im.xz)
+im.yz = Image.new("RGBX",(cad.nzplot(),cad.nyplot()),'white')
+im.yz_draw = ImageDraw.Draw(im.yz)
+#
+# loop over layers
+#
+Z = cad.zwrite[0]
+array0 = eval(cad.function)
+Z = cad.zwrite[1]
+array1 = eval(cad.function)
+for layer in range(2,len(cad.zwrite)):
+#
+# check render stop button
+#
+if (cad.stop == 1):
+break
+#
+# evaluate new layer
+#
+Z = cad.zwrite[layer]
+string_msg.set("triangulate z = %.3f"%Z)
+root.update()
+array2 = eval(cad.function)
+#
+# find left faces and merge y
+#
+elements = hstack((reshape((array1[:,0] == True),(cad.ny,1)),((array1[:,1:] == True) & (array1[:,:-1] == False))))
+starts = vstack((((elements[:-1,:] == True) & (elements[1:,:] == False)),reshape((elements[-1,:] == True),(1,cad.nx))))
+ends = vstack((reshape((elements[0,:] == True),(1,cad.nx)),((elements[1:,:] == True) & (elements[:-1,:] == False))))
+IY_t = transpose(IY) # for starts and ends to be read in same row
+IX_t = transpose(IX)
+starts_t = transpose(starts)
+ends_t = transpose(ends)
+ixlr = append(ixlr,IX_t[starts_t])
+iylrs = append(iylrs,IY_t[starts_t])
+iylre = append(iylre,1+IY_t[ends_t])
+izlr = append(izlr,(layer-1)*ones(len(IX_t[starts_t])))
+#
+# find right faces and merge y
+#
+elements = hstack((((array1[:,1:] == False) & (array1[:,:-1] == True)),reshape((array1[:,1] == True),(cad.ny,1))))
+starts = vstack((((elements[:-1,:] == True) & (elements[1:,:] == False)),reshape((elements[-1,:] == True),(1,cad.nx))))
+ends = vstack((reshape((elements[0,:] == True),(1,cad.nx)),((elements[1:,:] == True) & (elements[:-1,:] == False))))
+IY_t = transpose(IY) # for starts and ends to be read in same row
+IX_t = transpose(IX)
+starts_t = transpose(starts)
+ends_t = transpose(ends)
+ixlr = append(ixlr,1+IX_t[starts_t])
+iylre = append(iylre,IY_t[starts_t])
+iylrs = append(iylrs,1+IY_t[ends_t])
+izlr = append(izlr,(layer-1)*ones(len(IX_t[starts_t])))
+#
+# find front faces and merge x
+#
+elements = vstack((((array1[:-1,:] == True) & (array1[1:,:] == False)),reshape((array1[0,:] == True),(1,cad.nx))))
+starts = hstack((reshape((elements[:,0] == True),(cad.ny,1)),((elements[:,1:] == True) & (elements[:,:-1] == False))))
+ends = hstack((((elements[:,:-1] == True) & (elements[:,1:] == False)),reshape((elements[:,-1] == True),(cad.ny,1))))
+ixfbs = append(ixfbs,IX[starts])
+ixfbe = append(ixfbe,1+IX[ends])
+iyfb = append(iyfb,IY[starts])
+izfb = append(izfb,(layer-1)*ones(len(IX[starts])))
+#
+# find back faces and merge x
+#
+elements = vstack((reshape((array1[-1,:] == True),(1,cad.nx)),((array1[1:,:] == True) & (array1[:-1,:] == False))))
+starts = hstack((reshape((elements[:,0] == True),(cad.ny,1)),((elements[:,1:] == True) & (elements[:,:-1] == False))))
+ends = hstack((((elements[:,:-1] == True) & (elements[:,1:] == False)),reshape((elements[:,-1] == True),(cad.ny,1))))
+ixfbe = append(ixfbe,IX[starts])
+ixfbs = append(ixfbs,1+IX[ends])
+iyfb = append(iyfb,1+IY[starts])
+izfb = append(izfb,(layer-1)*ones(len(IX[starts])))
+#
+# find top faces and merge x
+#
+elements = ((array2 == False) & (array1 == True))
+starts = hstack((reshape((elements[:,0] == True),(cad.ny,1)),((elements[:,1:] == True) & (elements[:,:-1] == False))))
+ends = hstack((((elements[:,:-1] == True) & (elements[:,1:] == False)),reshape((elements[:,-1] == True),(cad.ny,1))))
+ixtbs = append(ixtbs,IX[starts])
+ixtbe = append(ixtbe,1+IX[ends])
+iytb = append(iytb,IY[starts])
+iztb = append(iztb,layer*ones(len(IX[starts])))
+#
+# find bottom faces and merge x
+#
+elements = ((array0 == False) & (array1 == True))
+starts = hstack((reshape((elements[:,0] == True),(cad.ny,1)),((elements[:,1:] == True) & (elements[:,:-1] == False))))
+ends = hstack((((elements[:,:-1] == True) & (elements[:,1:] == False)),reshape((elements[:,-1] == True),(cad.ny,1))))
+ixtbe = append(ixtbe,IX[starts])
+ixtbs = append(ixtbs,1+IX[ends])
+iytb = append(iytb,IY[starts])
+iztb = append(iztb,(layer-1)*ones(len(IX[starts])))
+#
+# push array stack
+#
+array0 = array1
+array1 = array2
+#
+# z merge front/back faces
+#
+index = lexsort(keys=(izfb,ixfbe,ixfbs,iyfb))
+merge = (iyfb[index[1:]] == iyfb[index[:-1]]) & \
+(ixfbe[index[1:]] == ixfbe[index[:-1]]) & \
+(ixfbs[index[1:]] == ixfbs[index[:-1]]) & \
+((izfb[index[1:]] - izfb[index[:-1]]) == 1)
+merge = append(False,merge).astype(bool_)
+starts = ((merge[1:] == True) & (merge[:-1] == False))
+starts = append(starts,False).astype(bool_)
+ends = ((merge[1:] == False) & (merge[:-1] == True))
+if (merge[-1] == True):
+ends = append(ends,True)
+else:
+ends = append(ends,False)
+ends = ends.astype(bool_)
+xs = ixfbs[index][starts | ~merge]
+xe = ixfbe[index][starts | ~merge]
+y = iyfb[index][starts | ~merge]
+zs = izfb[index][starts | ~merge]
+ze = izfb[index][ends | ~(merge | starts)]+1
+cad.x = ravel(transpose(vstack((xs,xe,xs,xs,xe,xe))))
+cad.y = ravel(transpose(vstack((y,y,y,y,y,y))))
+cad.z = ravel(transpose(vstack((zs,ze,ze,zs,zs,ze))))
+#
+# z merge left/right faces
+#
+index = lexsort(keys=(izlr,iylre,iylrs,ixlr))
+merge = (ixlr[index[1:]] == ixlr[index[:-1]]) & \
+(iylre[index[1:]] == iylre[index[:-1]]) & \
+(iylrs[index[1:]] == iylrs[index[:-1]]) & \
+((izlr[index[1:]] - izlr[index[:-1]]) == 1)
+merge = append(False,merge).astype(bool_)
+starts = ((merge[1:] == True) & (merge[:-1] == False))
+starts = append(starts,False).astype(bool_)
+ends = ((merge[1:] == False) & (merge[:-1] == True))
+if (merge[-1] == True):
+ends = append(ends,True)
+else:
+ends = append(ends,False)
+ends = ends.astype(bool_)
+x = ixlr[index][starts | ~merge]
+ys = iylrs[index][starts | ~merge]
+ye = iylre[index][starts | ~merge]
+zs = izlr[index][starts | ~merge]
+ze = izlr[index][ends | ~(merge | starts)]+1
+cad.x = append(cad.x,ravel(transpose(vstack((x,x,x,x,x,x)))))
+cad.y = append(cad.y,ravel(transpose(vstack((ys,ye,ys,ys,ye,ye)))))
+cad.z = append(cad.z,ravel(transpose(vstack((zs,ze,ze,zs,zs,ze)))))
+#
+# y merge top/bottom faces
+#
+index = lexsort(keys=(iytb,ixtbe,ixtbs,iztb))
+merge = (iztb[index[1:]] == iztb[index[:-1]]) & \
+(ixtbe[index[1:]] == ixtbe[index[:-1]]) & \
+(ixtbs[index[1:]] == ixtbs[index[:-1]]) & \
+((iytb[index[1:]] - iytb[index[:-1]]) == 1)
+merge = append(False,merge).astype(bool_)
+starts = ((merge[1:] == True) & (merge[:-1] == False))
+starts = append(starts,False).astype(bool_)
+ends = ((merge[1:] == False) & (merge[:-1] == True))
+if (merge[-1] == True):
+ends = append(ends,True)
+else:
+ends = append(ends,False)
+ends = ends.astype(bool_)
+xs = ixtbs[index][starts | ~merge]
+xe = ixtbe[index][starts | ~merge]
+ys = iytb[index][starts | ~merge]
+ye = iytb[index][ends | ~(merge | starts)]+1
+z = iztb[index][starts | ~merge]
+cad.x = append(cad.x,ravel(transpose(vstack((xs,xe,xs,xs,xe,xe)))))
+cad.y = append(cad.y,ravel(transpose(vstack((ys,ye,ye,ys,ys,ye)))))
+cad.z = append(cad.z,ravel(transpose(vstack((z,z,z,z,z,z)))))
+#
+# draw triangulation
+#
+widget_stop.pack_forget()
+string_msg.set("draw ...")
+root.update()
+N = len(cad.x)
+for i in range(0,N,3):
+string_msg.set("draw triangle %d/%d"%(i/3,N/3))
+root.update()
+x0 = cad.nxplot()*(cad.x[i]+0.5)/float(cad.nx)
+y0 = cad.nyplot()*(cad.ny-cad.y[i]+0.5)/float(cad.ny)
+z0 = cad.nzplot()*(cad.nz-cad.z[i]+0.5)/float(cad.nz)
+x1 = cad.nxplot()*(cad.x[i+1]+0.5)/float(cad.nx)
+y1 = cad.nyplot()*(cad.ny-cad.y[i+1]+0.5)/float(cad.ny)
+z1 = cad.nzplot()*(cad.nz-cad.z[i+1]+0.5)/float(cad.nz)
+x2 = cad.nxplot()*(cad.x[i+2]+0.5)/float(cad.nx)
+y2 = cad.nyplot()*(cad.ny-cad.y[i+2]+0.5)/float(cad.ny)
+z2 = cad.nzplot()*(cad.nz-cad.z[i+2]+0.5)/float(cad.nz)
+im.xy_draw.line([x0,y0,x1,y1,x2,y2,x0,y0],fill="black")
+im.xz_draw.line([x0,z0,x1,z1,x2,z2,x0,z0],fill="black")
+im.yz_draw.line([z0,y0,z1,y1,z2,y2,z0,y0],fill="black")
+images.xy = ImageTk.PhotoImage(im.xy)
+images.xz = ImageTk.PhotoImage(im.xz)
+images.yz = ImageTk.PhotoImage(im.yz)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+canvas_xz.create_image(cad.nplot/2,cad.nplot/2,image=images.xz)
+canvas_yz.create_image(cad.nplot/2,cad.nplot/2,image=images.yz)
+im.xyz = Image.new("RGBX",(cad.nplot,cad.nplot),'white')
+images.xyz = ImageTk.PhotoImage(im.xyz)
+canvas_xyz.create_image(cad.nplot/2,cad.nplot/2,image=images.xyz)
+string_msg.set("done")
+root.update()
+def flash(event):
+#
+# convert to Gerber flashes
+#
+# evaluate .cad
+#
+evaluate()
+#
+# initialize variables
+#
+render_stop_flag = 0
+cad.stop = 0
+widget_stop.pack()
+delete_windows()
+cad.toolpaths = []
+cad.zwrite = []
+cad.x = zeros(0)
+cad.y = zeros(0)
+cad.z = zeros(0)
+ixs = array([])
+ixe = array([])
+iy = array([])
+iz = array([])
+#
+# evaluate coordinate arrays
+#
+(IY,IX) = indices((cad.ny,cad.nx))
+IY = IY[::-1,:]
+IZ = arange(cad.nz)
+X = cad.xmin+(cad.xmax-cad.xmin)*IX/(cad.nx-1.0)
+Y = cad.ymin+(cad.ymax-cad.ymin)*IY/(cad.ny-1.0)
+if (cad.zwrite == []):
+if (cad.nz > 1):
+cad.zwrite = cad.zmin + (cad.zmax-cad.zmin)*arange(cad.nz)/(cad.nz-1.0)
+else:
+cad.zwrite = [cad.zmin]
+#
+# set up drawing image
+#
+im.xy = Image.new("RGBX",(cad.nxplot(),cad.nyplot()),'white')
+im.xy_draw = ImageDraw.Draw(im.xy)
+#
+# loop over layers
+#
+for layer in range(len(cad.zwrite)):
+#
+# check render stop button
+#
+if (cad.stop == 1):
+break
+#
+# evaluate layer
+#
+Z = cad.zwrite[layer]
+string_msg.set("convert z = %.3f"%Z)
+root.update()
+elements = eval(cad.function)
+#
+# merge x
+#
+starts = hstack((reshape((elements[:,0] == TRUE),(cad.ny,1)),((elements[:,1:] == TRUE) & (elements[:,:-1] == FALSE))))
+ends = hstack((((elements[:,:-1] == TRUE) & (elements[:,1:] == FALSE)),reshape((elements[:,-1] == TRUE),(cad.ny,1))))
+ixs = append(ixs,IX[starts])
+ixe = append(ixe,1+IX[ends])
+iy = append(iy,IY[starts])
+iz = append(iz,IZ[layer-1]*ones(len(IX[starts])))
+#
+# merge y
+#
+index = lexsort(keys=(iy,ixe,ixs,iz))
+merge = (iz[index[1:]] == iz[index[:-1]]) & \
+(ixe[index[1:]] == ixe[index[:-1]]) & \
+(ixs[index[1:]] == ixs[index[:-1]]) & \
+((iy[index[1:]] - iy[index[:-1]]) == 1)
+merge = append(FALSE,merge).astype(bool_)
+starts = ((merge[1:] == TRUE) & (merge[:-1] == FALSE))
+starts = append(starts,FALSE).astype(bool_)
+ends = ((merge[1:] == FALSE) & (merge[:-1] == TRUE))
+if (merge[-1] == TRUE):
+ends = append(ends,TRUE)
+else:
+ends = append(ends,FALSE)
+ends = ends.astype(bool_)
+xs = ixs[index][starts | ~merge]
+xe = ixe[index][starts | ~merge]
+ys = iy[index][starts | ~merge]
+ye = iy[index][ends | ~(merge | starts)]+1
+cad.x = ravel(transpose(vstack((xs,xe))))
+cad.y = ravel(transpose(vstack((ys,ye))))
+#
+# draw flashes
+#
+widget_stop.pack_forget()
+cad.view('xy')
+string_msg.set("draw ...")
+root.update()
+N = len(cad.x)
+for i in range(0,N,2):
+string_msg.set("draw flash %d/%d"%(i/4,N/4))
+root.update()
+x0 = cad.nxplot()*(cad.x[i]+0.5)/float(cad.nx)
+y0 = cad.nyplot()*(cad.ny-cad.y[i]+0.5)/float(cad.ny)
+x1 = cad.nxplot()*(cad.x[i]+0.5)/float(cad.nx)
+y1 = cad.nyplot()*(cad.ny-cad.y[i+1]+0.5)/float(cad.ny)
+x2 = cad.nxplot()*(cad.x[i+1]+0.5)/float(cad.nx)
+y2 = cad.nyplot()*(cad.ny-cad.y[i+1]+0.5)/float(cad.ny)
+x3 = cad.nxplot()*(cad.x[i+1]+0.5)/float(cad.nx)
+y3 = cad.nyplot()*(cad.ny-cad.y[i]+0.5)/float(cad.ny)
+im.xy_draw.line([x0,y0,x1,y1,x2,y2,x3,y3,x0,y0],fill="black")
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+string_msg.set("done")
+root.update()
+def select_epi():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.epi')
+cad.cam = 'epi'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+laser_frame1.pack()
+if ((cad.nz > 1) | (cad.image_r.size > 1)):
+laser_frame2.pack()
+laser_frame3.pack()
+string_laser_rate.set("2500")
+string_laser_power.set("90")
+string_laser_speed.set("50")
+string_laser_min_power.set("10")
+string_laser_max_power.set("100")
+string_tool_dia.set("0.01")
+root.update()
+def select_camm():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.camm')
+cad.cam = 'camm'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+cut_frame.pack()
+string_cut_force.set("45")
+string_cut_velocity.set("2")
+string_tool_dia.set("0.01")
+root.update()
+def select_ps():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.ps')
+cad.cam = 'ps'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+fill_frame.pack()
+string_tool_dia.set("0.0")
+root.update()
+def select_ord():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.ord')
+cad.cam = 'ord'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+string_tool_dia.set("0.01")
+waterjet_frame.pack()
+string_lead_in.set("0.05")
+string_quality.set("-3")
+root.update()
+def select_g():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.gcode')
+cad.cam = 'g'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+string_tool_dia.set("0.0156")
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+string_g_feed_rate.set("20")
+string_g_spindle_speed.set("5000")
+string_g_tool.set("1")
+integer_g_cool.set("0")
+g_frame.pack()
+root.update()
+def select_rml():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.rml')
+cad.cam = 'rml'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+speed_frame.pack()
+rml_move_frame.pack()
+string_tool_dia.set("0.0156")
+string_xy_speed.set("4")
+string_z_speed.set("4")
+string_rml_x_move.set("1")
+string_rml_y_move.set("1")
+root.update()
+def select_sbp():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.sbp')
+cad.cam = 'sbp'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+jog_frame.pack()
+speed_frame.pack()
+string_tool_dia.set("0.125")
+string_xy_speed.set("1.1")
+string_z_speed.set("1.1")
+string_jog_xy_speed.set("7")
+string_jog_z_speed.set("7")
+string_jog_z.set(".25")
+root.update()
+def select_oms():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.oms')
+cad.cam = 'oms'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+excimer_frame.pack()
+string_pulse_period.set("10000")
+string_tool_dia.set("0.001")
+string_cut_vel.set("0.1")
+string_cut_accel.set("5.0")
+root.update()
+def select_dxf():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.dxf')
+cad.cam = 'dxf'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+string_tool_dia.set("0.0")
+root.update()
+def select_uni():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.uni')
+cad.cam = 'uni'
+cam_pack_forget()
+cam_file_frame.pack()
+cam_vector_frame.pack()
+cam_dia_frame.pack()
+cam_contour_frame.pack()
+laser_frame1.pack()
+if ((cad.nz > 1) | (cad.image_r.size > 1)):
+laser_frame2.pack()
+string_laser_rate.set("500")
+string_laser_power.set("60")
+string_laser_speed.set("15")
+string_tool_dia.set("0.01")
+string_laser_min_power.set("10")
+string_laser_max_power.set("100")
+string_vector_error.set('1.1')
+root.update()
+def select_jpg():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.jpg')
+cad.cam = 'jpg'
+cam_pack_forget()
+cam_file_frame.pack()
+root.update()
+def select_png():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.png')
+cad.cam = 'png'
+cam_pack_forget()
+cam_file_frame.pack()
+root.update()
+def select_stl():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.stl')
+cad.cam = 'stl'
+cam_pack_forget()
+cam_file_frame.pack()
+STL_frame.pack()
+root.update()
+def select_gerber():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.grb')
+cad.cam = 'grb'
+cam_pack_forget()
+cam_file_frame.pack()
+Gerber_frame.pack()
+root.update()
+def select_excellon():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.drl')
+cad.cam = 'drl'
+cam_pack_forget()
+cam_file_frame.pack()
+Excellon_frame.pack()
+root.update()
+def select_ca():
+input_file_name = string_input_file.get()
+string_cam_file.set(input_file_name[0:-4]+'.ca')
+cad.cam = 'ca'
+cam_pack_forget()
+cam_file_frame.pack()
+root.update()
+def cam_pack_forget():
+cam_file_frame.pack_forget()
+cam_vector_frame.pack_forget()
+cam_dia_frame.pack_forget()
+cam_contour_frame.pack_forget()
+laser_frame1.pack_forget()
+laser_frame2.pack_forget()
+laser_frame3.pack_forget()
+cut_frame.pack_forget()
+speed_frame.pack_forget()
+jog_frame.pack_forget()
+rml_move_frame.pack_forget()
+waterjet_frame.pack_forget()
+excimer_frame.pack_forget()
+STL_frame.pack_forget()
+Gerber_frame.pack_forget()
+Excellon_frame.pack_forget()
+fill_frame.pack_forget()
+g_frame.pack_forget()
+send_to_frame.pack_forget()
+def save_cam(event):
+#
+# write toolpath
+#
+if (cad.cam == "epi"):
+write_epi()
+elif (cad.cam == "camm"):
+write_camm()
+elif (cad.cam == "ps"):
+write_ps()
+elif (cad.cam == "ord"):
+write_ord()
+elif (cad.cam == "g"):
+write_G()
+elif (cad.cam == "rml"):
+write_rml()
+elif (cad.cam == "sbp"):
+write_sbp()
+elif (cad.cam == "oms"):
+write_oms()
+elif (cad.cam == "dxf"):
+write_dxf()
+elif (cad.cam == "uni"):
+write_uni()
+elif (cad.cam == "jpg"):
+write_jpg()
+elif (cad.cam == "png"):
+write_png()
+elif (cad.cam == "stl"):
+write_stl()
+elif (cad.cam == "grb"):
+write_gerber()
+elif (cad.cam == "drl"):
+write_excellon()
+elif (cad.cam == "ca"):
+write_ca()
+else:
+string_msg.set("unsupported output file format")
+root.update()
+def write_epi():
+#
+# Epilog lasercutter output
+# todo: try 1200 DPI
+#
+units = 600*cad.inches_per_unit
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+if (integer_laser_autofocus.get() == 0):
+#
+# init with autofocus off
+#
+file.write("%-12345X@PJL JOB NAME="+string_cam_file.get()+"\r\nE@PJL ENTER LANGUAGE=PCL\r\n&y0A&l0U&l0Z&u600D*p0X*p0Y*t600R*r0F&y50P&z50S*r6600T*r5100S*r1A*rC%1BIN;XR"+string_laser_rate.get()+";YP"+string_laser_power.get()+";ZS"+string_laser_speed.get()+";")
+else:
+#
+# init with autofocus on
+#
+file.write("%-12345X@PJL JOB NAME="+string_cam_file.get()+"\r\nE@PJL ENTER LANGUAGE=PCL\r\n&y1A&l0U&l0Z&u600D*p0X*p0Y*t600R*r0F&y50P&z50S*r6600T*r5100S*r1A*rC%1BIN;XR"+string_laser_rate.get()+";YP"+string_laser_power.get()+";ZS"+string_laser_speed.get()+";")
+power = float(string_laser_power.get())
+min_power = float(string_laser_min_power.get())
+max_power = float(string_laser_max_power.get())
+for layer in range(len(cad.toolpaths)):
+if ((len(cad.zwrite) > 1) & (len(cad.toolpaths[layer]) > 0)):
+fraction = (cad.zwrite[layer]-cad.zwrite[0])/(cad.zwrite[-1]-cad.zwrite[0])
+layer_power = min_power + fraction*(max_power-min_power)
+file.write("YP%f;"%layer_power)
+for segment in range(len(cad.toolpaths[layer])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)))
+y = int(units*(-cad.ymin - ((cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))))
+file.write("PU"+str(x)+","+str(y)+";")
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)))
+y = int(units*(-cad.ymin - ((cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))))
+file.write("PD"+str(x)+","+str(y)+";")
+file.write("%0B%1BPUE%-12345X@PJL EOJ \r\n")
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_camm():
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+units = 1016*cad.inches_per_unit
+file.write("PA;PA;!ST1;!FS"+string_cut_force.get()+";VS"+string_cut_velocity.get()+";")
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny)))
+file.write("PU"+str(x)+","+str(y)+";")
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny)))
+file.write("PD"+str(x)+","+str(y)+";")
+file.write("PU0,0;")
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_ps():
+#
+# Postscript output
+#
+units = cad.inches_per_unit
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("%! cad.py output\n")
+file.write("%%%%BoundingBox: 0 0 %.3f %.3f\n"%
+(72.0*(cad.xmax-cad.xmin),72.0*(cad.ymax-cad.ymin)))
+file.write("/m {moveto} def\n")
+file.write("/l {lineto} def\n")
+file.write("72 72 scale\n")
+file.write(".005 setlinewidth\n")
+file.write("%f %f translate\n"%(0.5,0.5))
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))
+file.write("%f %f m\n"%(x,y))
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))
+file.write("%f %f l\n"%(x,y))
+if (integer_fill.get() == 0):
+file.write("stroke\n")
+else:
+file.write("fill\n")
+file.write("showpage\n")
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_ord():
+#
+# OMAX waterjet output
+#
+units = cad.inches_per_unit
+lead_in = float(string_lead_in.get())
+quality = int(string_quality.get())
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+xlead = []
+ylead = []
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+#
+# calculate and write lead-in
+#
+x0 = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx))
+y0 = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))
+x1 = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][1].x+0.5)/float(cad.nx))
+y1 = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][1].y)+0.5)/float(cad.ny))
+dx = x1 - x0
+dy = y1 - y0
+norm_x = -dy
+norm_y = dx
+norm = sqrt(norm_x**2 + norm_y**2)
+norm_x = norm_x/norm
+norm_y = norm_y/norm
+xlead.append(x0 + norm_x*lead_in)
+ylead.append(y0 + norm_y*lead_in)
+file.write("%f, %f, 0, %d\n"%(xlead[segment],ylead[segment],quality))
+#
+# loop over segment
+#
+for vertex in range(len(cad.toolpaths[layer][segment])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))
+file.write("%f, %f, 0, %d\n"%(x,y,quality))
+#
+# write lead-out
+#
+file.write("%f, %f, 0, 0\n"%(x0,y0))
+file.write("%f, %f, 0, 0\n"%(xlead[segment],ylead[segment]))
+file.close()
+#
+# draw toolpath with lead-in/out
+#
+im.xy = Image.new("RGBX",(cad.nxplot(),cad.nyplot()),'white')
+im.xy_draw = ImageDraw.Draw(im.xy)
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+x = cad.nxplot()*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)
+y = cad.nyplot()*(cad.toolpaths[layer][segment][0].y+0.5)/float(cad.ny)
+xl = cad.nxplot()*(xlead[segment]-cad.xmin)/(cad.xmax-cad.xmin)
+yl = cad.nyplot()-cad.nyplot()*(ylead[segment]-cad.ymin)/(cad.ymax-cad.ymin)
+im.xy_draw.line([xl,yl,x,y],fill="black")
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+xnew = cad.nxplot()*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)
+ynew = cad.nyplot()*(cad.toolpaths[layer][segment][vertex].y+0.5)/float(cad.ny)
+im.xy_draw.line([x,y,xnew,ynew],fill="black")
+x = xnew
+y = ynew
+images.xy = ImageTk.PhotoImage(im.xy)
+canvas_xy.create_image(cad.nplot/2,cad.nplot/2,image=images.xy)
+string_msg.set("wrote %s"%filename)
+root.update()
+def distance(x1, y1, x2, y2):
+return sqrt((x1-x2)**2+(y1-y2)**2)
+def write_G():
+#
+# G code output
+#
+units = cad.inches_per_unit
+zup = units*cad.zmax
+feed_rate = float(string_g_feed_rate.get())
+spindle_speed = float(string_g_spindle_speed.get())
+coolant = integer_g_cool.get()
+tool = int(string_g_tool.get())
+if (cad.nz == 1):
+cad.zwrite = [cad.zmin]
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("""(---------------------------------------------------------------)
+(---------------------------------------------------------------)
+(Start of sheet header)
+G21 (metric ftw)
+G90 (absolute mode)
+G92 X0 Y0 Z0 (zero all axes)
+G92 Z0.00 F150.00 (go up to printing level)
+M106 (pen down)
+G4 P120 (wait 120ms)
+M300 S50 (pen up)
+G4 P120 (wait 120ms)
+M18 (disengage drives)
+M01 (Was registration test successful?)
+(while drives are disengaged, adjustments can be made to position)
+M17 (engage drives if YES, and continue)
+(End of sheet header)\n""")
+dxy = 0
+dz = 0
+xold = 0
+yold = 0
+for layer in range(len(cad.zwrite)-1,-1,-1):
+zdown = units*cad.zwrite[layer]
+#
+# follow toolpaths CCW, for CW tool motion
+#
+unsorted_segments = cad.toolpaths[layer]
+sorted_segments = []
+if len(unsorted_segments) > 0:
+sorted_segments.append(unsorted_segments.pop(0)) #starts with the first path in the list
+else:
+print "empty path --- strange"
+while len(unsorted_segments) > 0:
+#find closest start to the the last sorted segment start
+min_dist = 99999
+min_dist_index = None
+for i in range(len(unsorted_segments)):
+dist = distance(sorted_segments[-1][0].x, sorted_segments[-1][0].y,
+unsorted_segments[i][0].x, unsorted_segments[i][0].y)
+if dist < min_dist:
+min_dist = dist
+min_dist_index = i
+#print "min_dist: %d index: %d" % (min_dist, min_dist_index)
+sorted_segments.append(unsorted_segments.pop(min_dist_index))
+for segment in range(len(sorted_segments)):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(sorted_segments[segment][0].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-sorted_segments[segment][0].y)+0.5)/float(cad.ny))
+file.write("G1 X%0.4f "%x+"Y%0.4f "%y+"Z%0.4f"%zup+" F2000.00\n") # rapid motion
+file.write("G1 Z%0.4f "%zdown+" F300.00\n") # linear motion
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+dz += zup-zdown
+for vertex in range(1,len(sorted_segments[segment])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(sorted_segments[segment][vertex].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-sorted_segments[segment][vertex].y)+0.5)/float(cad.ny))
+file.write("G1 X%0.4f "%x+"Y%0.4f"%y+" F2000.00\n")
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+file.write("""(Start of sheet footer.)
+M107
+G4 P120 (wait 120ms)
+G0 X0 Y0 Z15 F3500.00 (go to position for retrieving platform -- increase Z to Z25 or similar if you have trouble avoiding tool)
+G4 P300 (wait 300ms)
+M01 (Have you retrieved the print?)
+(machine halts until 'okay')
+G4 P120 (if yes continue, pause 120ms before ... )
+G0 Z0 F3500.00 (return to start position of current sheet)
+G4 P300 (wait 300ms)
+M18 (disengage drives)
+(End of sheet footer)
+M01 (Printing on the next sheet?)
+(yes, if dropping the default .1 mm to next sheet; no, if you will print again on same sheet)
+G0 Z-0.10 F3500.00 (drop 0.1mm to next sheet)
+(Paste in further sheets below)
+(---------------------------------------------------------------)
+(---------------------------------------------------------------)
+""")
+file.close()
+print "Path length: %f" % dxy
+time = (dxy/feed_rate + dz/feed_rate)
+string_send_to_time.set(" estimated time: %.1f minutes"%time)
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_rml():
+#
+# Roland Modela output
+#
+units = 1016*cad.inches_per_unit # 40/mm
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("PA;PA;VS"+string_xy_speed.get()+";!VZ"+string_z_speed.get()+";!MC1;")
+zup = cad.zmax
+izup = int(units*zup)
+if (cad.nz == 1):
+cad.zwrite = [cad.zmin]
+xy_speed = float(string_xy_speed.get()) # mm/s
+z_speed = float(string_z_speed.get()) # mm/s
+dxy = 0
+dz = 0
+xold = 0
+yold = 0
+for layer in range(len(cad.zwrite)-1,-1,-1):
+zdown = cad.zwrite[layer]
+izdown = int(units*zdown)
+file.write("!PZ"+str(izdown)+","+str(izup)+";")
+#
+# follow toolpaths CCW, for CW tool motion
+#
+for segment in range(len(cad.toolpaths[layer])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny)))
+file.write("PU"+str(x)+","+str(y)+";")
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+dz += izup-izdown
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny)))
+file.write("PD"+str(x)+","+str(y)+";")
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+file.write("PU"+str(x)+","+str(y)+";!MC0;")
+#
+# file padding hack for end-of-file buffering problems
+#
+for i in range(1000):
+file.write("!MC0;")
+file.close()
+time = ((dxy/40.0)/xy_speed + (dz/40.0)/z_speed)/60.0
+string_send_to_time.set(" estimated time: %.1f minutes"%time)
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def rml_move(event):
+#
+# move Roland Modela
+#
+units = 1016*cad.inches_per_unit # 40/mm
+x = float(string_rml_x_move.get())
+y = float(string_rml_y_move.get())
+ix = int(units*x)
+iy = int(units*y)
+filename = "move.rml"
+file = open(filename, 'wb')
+file.write("PA;PA;!PZ0,400;VS10;!VZ10;!MC0;PU%d,%d;!MC0;"%(ix,iy))
+file.close()
+send_to_file("move.rml")
+os.remove("move.rml")
+def write_sbp():
+#
+# ShopBot output
+#
+units = cad.inches_per_unit
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("SA\r\n") # set to absolute distances
+file.write("SO,1,1\r\n") # set output number 1 to on
+file.write("pause 2\r\n") # let spindle come up to speed
+xy_speed = units*float(string_xy_speed.get())
+z_speed = units*float(string_z_speed.get())
+file.write("MS %f,%f\r\n"%(xy_speed,z_speed)) # set xy,z speed
+jog_xy_speed = units*float(string_jog_xy_speed.get())
+jog_z_speed = units*float(string_jog_z_speed.get())
+file.write("JS %f,%f\r\n"%(jog_xy_speed,jog_z_speed)) # set jog xy,z speed
+zup = units*float(string_jog_z.get())
+dxy = 0
+dz = 0
+xold = 0
+yold = 0
+for layer in range(len(cad.zwrite)-1,-1,-1):
+zdown = cad.zwrite[layer]
+#
+# follow toolpaths CCW, for CW tool motion
+#
+for segment in range(len(cad.toolpaths[layer])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))
+file.write("JZ %f\r\n"%zup)
+file.write("J2 %f,%f\r\n"%(x,y))
+file.write("MZ %f\r\n"%zdown)
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+dz += zup-zdown
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))
+file.write("M2 %f,%f\r\n"%(x,y))
+dxy += sqrt((xold-x)**2+(yold-y)**2)
+xold = x
+yold = y
+file.write("JZ %f\r\n"%zup)
+file.close()
+time = (dxy/xy_speed + dz/z_speed)/60.0
+string_send_to_time.set(" estimated time: %.1f minutes"%time)
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_oms():
+#
+# Resonetics excimer micromachining center output
+#
+units = 25.4*cad.inches_per_unit
+pulseperiod = float(string_pulse_period.get())
+cutvel = float(string_cut_vel.get())
+cutaccel = float(string_cut_accel.get())
+slewvel = 1
+slewaccel = 5
+settle = 100
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("AA LP0,0,0,0,0\n") # set origin
+file.write("PP%d\n"%pulseperiod) # set pulse period
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))
+file.write("VL%.1f,%.1f\n"%(slewvel,slewvel))
+file.write("AC%.1f,%.1f\n"%(slewaccel,slewaccel))
+file.write("MA%f,%f\n"%(x,y))
+file.write("VL%.1f,%.1f\n"%(cutvel,cutvel))
+file.write("AC%.1f,%.1f\n"%(cutaccel,cutaccel))
+file.write("WT%d\n"%settle) # wait to settle
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx))
+y = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))
+file.write("CutAbs %f,%f\n"%(x,y))
+file.write("END\n")
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_dxf():
+#
+# DXF output
+#
+units = cad.inches_per_unit
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("999\nDXF written by cad.py\n")
+file.write("0\nSECTION\n")
+file.write("2\nHEADER\n")
+file.write("9\n$EXTMIN\n")
+file.write("10\n%f\n"%cad.xmin)
+file.write("20\n%f\n"%cad.ymin)
+file.write("9\n$EXTMAX\n")
+file.write("10\n%f\n"%cad.xmax)
+file.write("20\n%f\n"%cad.ymax)
+file.write("0\nENDSEC\n")
+file.write("0\nSECTION\n")
+file.write("2\nTABLES\n")
+file.write("0\nTABLE\n")
+file.write("2\nLTYPE\n70\n1\n")
+file.write("0\nLTYPE\n")
+file.write("2\nCONTINUOUS\n")
+file.write("70\n64\n3\n")
+file.write("Solid line\n")
+file.write("72\n65\n73\n0\n40\n0.000000\n")
+file.write("0\nENDTAB\n")
+file.write("0\nTABLE\n2\nLAYER\n70\n1\n")
+file.write("0\nLAYER\n2\ndefault\n70\n64\n62\n7\n6\n")
+file.write("CONTINUOUS\n0\nENDTAB\n")
+file.write("0\nENDSEC\n")
+file.write("0\nSECTION\n")
+file.write("2\nBLOCKS\n")
+file.write("0\nENDSEC\n")
+file.write("0\nSECTION\n")
+file.write("2\nENTITIES\n")
+for layer in range(len(cad.toolpaths)):
+for segment in range(len(cad.toolpaths[layer])):
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x0 = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex-1].x+0.5)/float(cad.nx))
+y0 = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex-1].y)+0.5)/float(cad.ny))
+x1 = units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx))
+y1 = units*(cad.ymin + (cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))
+file.write("0\nLINE\n")
+file.write("10\n%f\n"%x0)
+file.write("20\n%f\n"%y0)
+file.write("11\n%f\n"%x1)
+file.write("21\n%f\n"%y1)
+file.write("0\nENDSEC\n")
+file.write("0\nEOF\n")
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_uni():
+#
+# Universal lasercutter output
+#
+units = 1000*cad.inches_per_unit
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write("Z") # initialize
+file.write("t%s~;"%filename) # title
+file.write("IN;DF;PS0;DT~") # initialize
+ppibyte = int(float(string_laser_rate.get())/10)
+file.write("s%c"%ppibyte) # PPI
+speed_hibyte = int(648*float(string_laser_speed.get()))/256
+speed_lobyte = int(648*float(string_laser_speed.get()))%256
+file.write("v%c%c"%(speed_hibyte,speed_lobyte)) # speed
+power = float(string_laser_power.get())
+min_power = float(string_laser_min_power.get())
+max_power = float(string_laser_max_power.get())
+power_hibyte = (320*int(power))/256
+power_lobyte = (320*int(power))%256
+file.write("p%c%c"%(power_hibyte,power_lobyte)) # power
+file.write("a%c"%2) # air assist on high
+for layer in range(len(cad.toolpaths)):
+if ((len(cad.zwrite) > 1) & (len(cad.toolpaths[layer]) > 0)):
+fraction = (cad.zwrite[layer]-cad.zwrite[0])/(cad.zwrite[-1]-cad.zwrite[0])
+layer_power = min_power + fraction*(max_power-min_power)
+power_hibyte = (320*int(layer_power))/256
+power_lobyte = (320*int(layer_power))%256
+file.write("p%c%c"%(power_hibyte,power_lobyte)) # power
+for segment in range(len(cad.toolpaths[layer])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][0].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + ((cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][0].y)+0.5)/float(cad.ny))))
+file.write("PU;PA"+str(x)+","+str(y)+";PD;")
+for vertex in range(1,len(cad.toolpaths[layer][segment])):
+x = int(units*(cad.xmin + (cad.xmax-cad.xmin)*(cad.toolpaths[layer][segment][vertex].x+0.5)/float(cad.nx)))
+y = int(units*(cad.ymin + ((cad.ymax-cad.ymin)*((cad.ny-cad.toolpaths[layer][segment][vertex].y)+0.5)/float(cad.ny))))
+file.write("PA"+str(x)+","+str(y)+";")
+file.write("e") # end of file
+file.close()
+draw_toolpath()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_jpg():
+#
+# JPG image output
+#
+if (cad.views == "xy"):
+filename = string_cam_file.get()
+im.xy = Image.fromarray(im.intensity_xy,mode="RGBX")
+im_rgb_xy = im.xy.convert("RGB")
+dpi = int(cad.nx/float(cad.xmax-cad.xmin))
+im_rgb_xy.save(filename,dpi=(dpi,dpi))
+string_msg.set("wrote %s"%filename)
+elif (cad.views == "xyzr"):
+border = 5
+filename = string_cam_file.get()
+im.xy = Image.fromarray(im.intensity_xy,mode="RGBX")
+im.xz = Image.fromarray(im.intensity_xz,mode="RGBX")
+im.yz = Image.fromarray(im.intensity_yz,mode="RGBX")
+im.yz = im.yz.transpose(Image.FLIP_LEFT_RIGHT)
+im.xyz = Image.fromarray(im.intensity_xyz,mode="RGBX")
+(nx,ny) = im.xy.size
+ny = (nx*cad.nyplot())/cad.nxplot()
+nz = (nx*cad.nzplot())/cad.nxplot()
+im.xy = im.xy.resize((nx,ny))
+im.yz = im.yz.resize((nz,ny))
+im.xz = im.xz.resize((nx,nz))
+im.xyz = im.xyz.resize((nx,ny))
+im_rgb_xy = im.xy.convert("RGB")
+im_rgb_xz = im.xz.convert("RGB")
+im_rgb_yz = im.yz.convert("RGB")
+im_rgb_xyz = im.xyz.convert("RGB")
+img = Image.new("RGB",(nx+border+nx,ny+border+ny),"white")
+img.paste(im_rgb_xy,(0,0))
+img.paste(im_rgb_xz,(0,border+ny))
+img.paste(im_rgb_yz,(border+nx,0))
+img.paste(im_rgb_xyz,(border+nx,border+ny))
+img.save(filename)
+string_msg.set("wrote %s"%filename)
+else:
+string_msg.set("unknown view")
+def write_png():
+#
+# PNG image output
+#
+if (cad.views == "xy"):
+filename = string_cam_file.get()
+im.xy = Image.fromarray(im.intensity_xy,mode="RGBX")
+im_rgb_xy = im.xy.convert("RGB")
+dpi = int(cad.nx/float(cad.xmax-cad.xmin))
+im_rgb_xy.save(filename,dpi=(dpi,dpi))
+string_msg.set("wrote %s"%filename)
+elif (cad.views == "xyzr"):
+border = 5
+filename = string_cam_file.get()
+im.xy = Image.fromarray(im.intensity_xy,mode="RGBX")
+im.xz = Image.fromarray(im.intensity_xz,mode="RGBX")
+im.yz = Image.fromarray(im.intensity_yz,mode="RGBX")
+im.yz = im.yz.transpose(Image.FLIP_LEFT_RIGHT)
+im.xyz = Image.fromarray(im.intensity_xyz,mode="RGBX")
+(nx,ny) = im.xy.size
+ny = (nx*cad.nyplot())/cad.nxplot()
+nz = (nx*cad.nzplot())/cad.nxplot()
+im.xy = im.xy.resize((nx,ny))
+im.yz = im.yz.resize((nz,ny))
+im.xz = im.xz.resize((nx,nz))
+im.xyz = im.xyz.resize((nx,ny))
+im_rgb_xy = im.xy.convert("RGB")
+im_rgb_xz = im.xz.convert("RGB")
+im_rgb_yz = im.yz.convert("RGB")
+im_rgb_xyz = im.xyz.convert("RGB")
+img = Image.new("RGB",(nx+border+nx,ny+border+ny),"white")
+img.paste(im_rgb_xy,(0,0))
+img.paste(im_rgb_xz,(0,border+ny))
+img.paste(im_rgb_yz,(border+nx,0))
+img.paste(im_rgb_xyz,(border+nx,border+ny))
+img.save(filename)
+string_msg.set("wrote %s"%filename)
+else:
+string_msg.set("unknown view")
+def write_stl():
+#
+# STL output
+#
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+units = cad.inches_per_unit
+x = cad.xmin+(cad.xmax-cad.xmin)*(cad.x+0.5)/float(cad.nx)
+y = cad.ymin+(cad.ymax-cad.ymin)*(cad.y+0.5)/float(cad.ny)
+z = cad.zmin+(cad.zmax-cad.zmin)*(cad.z+0.5)/float(cad.nz)
+#
+# header
+#
+file.write('cad.py')
+file.write('a'*74)
+#
+# length
+#
+N = len(cad.x)
+file.write(struct.pack('L',N/3))
+#
+# triangles
+#
+for i in range(0,N,3):
+string_msg.set("write triangle %d/%d"%(i/3,N/3))
+root.update()
+#
+# normals
+#
+file.write(struct.pack('f',0))
+file.write(struct.pack('f',0))
+file.write(struct.pack('f',0))
+#
+# vertices
+#
+file.write(struct.pack('f',x[i]*units))
+file.write(struct.pack('f',y[i]*units))
+file.write(struct.pack('f',z[i]*units))
+file.write(struct.pack('f',x[i+1]*units))
+file.write(struct.pack('f',y[i+1]*units))
+file.write(struct.pack('f',z[i+1]*units))
+file.write(struct.pack('f',x[i+2]*units))
+file.write(struct.pack('f',y[i+2]*units))
+file.write(struct.pack('f',z[i+2]*units))
+#
+# padding
+#
+file.write(struct.pack('xx'))
+file.close()
+string_msg.set("wrote %s"%filename)
+root.update()
+def write_gerber():
+#
+# Gerber (RS-274X) output
+#
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+units = cad.inches_per_unit
+#
+# write parameters
+#
+file.write("%FSLAX24Y24*%\n") # leading zeros omitted, absolute coordinates, 2.4
+file.write("%MOIN*%\n") # inches units
+file.write("%OFA0B0*%\n") # no offset
+#
+# find and write apertures
+#
+ixs = cad.x[::2]
+xs = cad.xmin+(cad.xmax-cad.xmin)*(ixs+0.5)/float(cad.nx)
+ixe = cad.x[1::2]
+xe = cad.xmin+(cad.xmax-cad.xmin)*(ixe+0.5)/float(cad.nx)
+idx = ixe - ixs
+dx = xe - xs
+iys = cad.y[::2]
+ys = cad.ymin+(cad.ymax-cad.ymin)*(iys+0.5)/float(cad.ny)
+iye = cad.y[1::2]
+ye = cad.ymin+(cad.ymax-cad.ymin)*(iye+0.5)/float(cad.ny)
+idy = iye - iys
+dy = ye - ys
+mins = where((idx < idy),idx,idy)
+uniques = unique(mins)
+apertures = (cad.xmax-cad.xmin)*uniques/float(cad.nx)
+index = searchsorted(uniques,mins)
+for i in range(len(uniques)):
+file.write("%%ADD%dR,%.4fX%.4f*%%\n"%(i+10,apertures[i],apertures[i]))
+#
+# write flashes
+#
+coords = arange(len(mins))
+for i in range(len(uniques)):
+file.write("D%d*\n"%(i+10))
+coord = coords[index == i]
+delta = apertures[i]/2.
+ixs = (10000*(xs+delta)).astype(int32)
+ixe = (10000*(xe-delta)).astype(int32)
+iys = (10000*(ys+delta)).astype(int32)
+iye = (10000*(ye-delta)).astype(int32)
+for j in range(len(coord)):
+n = coord[j]
+if (idx[n] == idy[n]):
+#
+# flash
+#
+file.write('X%dY%dD03*\n'%(ixs[n],iys[n]))
+elif (idx[n] > idy[n]):
+#
+# stroke horizontal
+#
+file.write('X%dY%dD02*\n'%(ixs[n],iys[n]))
+file.write('X%dY%dD01*\n'%(ixe[n],iys[n]))
+else:
+#
+# stroke vertical
+#
+file.write('X%dY%dD02*\n'%(ixs[n],iys[n]))
+file.write('X%dY%dD01*\n'%(ixs[n],iye[n]))
+file.write("M02*\n") # end of file
+file.close()
+string_msg.set("wrote %s (RS-274X)"%filename)
+root.update()
+def write_excellon():
+#
+# Excellon (RS-) output
+#
+"""
+%  	Rewind and Stop
+X#Y# 	Move and Drill
+T# 	Tool Selection
+M30 	End of Program
+M00 	End of Program
+R#X#Y# 	Repeat Hole
+G05, G81 	Select Drill Mode
+G90 	Absolute Mode
+G91 	Incremental Mode
+G92 X#Y# 	Set Zero
+G93 X#Y# 	Set Zero
+M48 	Program Header to first "%"
+M72 	English-Imperial Mode
+"""
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+units = cad.inches_per_unit
+#
+# write parameters
+#
+file.write("%FSLAX24Y24*%\n") # leading zeros omitted, absolute coordinates, 2.4
+file.write("%MOIN*%\n") # inches units
+file.write("%OFA0B0*%\n") # no offset
+#
+# find and write apertures
+#
+ixs = cad.x[::2]
+xs = cad.xmin+(cad.xmax-cad.xmin)*(ixs+0.5)/float(cad.nx)
+ixe = cad.x[1::2]
+xe = cad.xmin+(cad.xmax-cad.xmin)*(ixe+0.5)/float(cad.nx)
+idx = ixe - ixs
+dx = xe - xs
+iys = cad.y[::2]
+ys = cad.ymin+(cad.ymax-cad.ymin)*(iys+0.5)/float(cad.ny)
+iye = cad.y[1::2]
+ye = cad.ymin+(cad.ymax-cad.ymin)*(iye+0.5)/float(cad.ny)
+idy = iye - iys
+dy = ye - ys
+mins = where((idx < idy),idx,idy)
+uniques = unique(mins)
+apertures = (cad.xmax-cad.xmin)*uniques/float(cad.nx)
+index = searchsorted(uniques,mins)
+for i in range(len(uniques)):
+file.write("%%ADD%dR,%.4fX%.4f*%%\n"%(i+10,apertures[i],apertures[i]))
+#
+# write flashes
+#
+coords = arange(len(mins))
+for i in range(len(uniques)):
+file.write("D%d*\n"%(i+10))
+coord = coords[index == i]
+delta = apertures[i]/2.
+ixs = (10000*(xs+delta)).astype(int32)
+ixe = (10000*(xe-delta)).astype(int32)
+iys = (10000*(ys+delta)).astype(int32)
+iye = (10000*(ye-delta)).astype(int32)
+for j in range(len(coord)):
+n = coord[j]
+if (idx[n] == idy[n]):
+#
+# flash
+#
+file.write('X%dY%dD03*\n'%(ixs[n],iys[n]))
+elif (idx[n] > idy[n]):
+#
+# stroke horizontal
+#
+file.write('X%dY%dD02*\n'%(ixs[n],iys[n]))
+file.write('X%dY%dD01*\n'%(ixe[n],iys[n]))
+else:
+#
+# stroke vertical
+#
+file.write('X%dY%dD02*\n'%(ixs[n],iys[n]))
+file.write('X%dY%dD01*\n'%(ixs[n],iye[n]))
+file.write("M02*\n") # end of file
+file.close()
+string_msg.set("wrote %s (RS-274X)"%filename)
+root.update()
+def write_ca():
+#
+# CA output
+#
+filename = string_cam_file.get()
+file = open(filename, 'wb')
+file.write(chr(0xB9)) # magic number 0xB9
+file.write(chr(ca.nx/256)) # x size
+file.write(chr(ca.nx%256)) #
+file.write(chr(ca.ny/256)) # y size
+file.write(chr(ca.ny%256)) #
+file.write(chr(4)) # LED sub-array x
+file.write(chr(2)) # LED sub-array y
+for y in range(ca.nx):
+for x in range(ca.nx):
+if (ca.in1[y,x] == ca.E):
+config = 0
+elif (ca.in1[y,x] == ca.NE):
+config = 1
+elif (ca.in1[y,x] == ca.N):
+config = 2
+elif (ca.in1[y,x] == ca.NW):
+config = 3
+elif (ca.in1[y,x] == ca.W):
+config = 4
+elif (ca.in1[y,x] == ca.SW):
+config = 5
+elif (ca.in1[y,x] == ca.S):
+config = 6
+elif (ca.in1[y,x] == ca.SE):
+config = 7
+elif (ca.in1[y,x] == ca.empty): # XOR W W for empty
+config = 4
+if (ca.in2[y,x] == ca.E):
+config += 0
+elif (ca.in2[y,x] == ca.NE):
+config += (1 << 3)
+elif (ca.in2[y,x] == ca.N):
+config += (2 << 3)
+elif (ca.in2[y,x] == ca.NW):
+config += (3 << 3)
+elif (ca.in2[y,x] == ca.W):
+config += (4 << 3)
+elif (ca.in2[y,x] == ca.SW):
+config += (5 << 3)
+elif (ca.in2[y,x] == ca.S):
+config += (6 << 3)
+elif (ca.in2[y,x] == ca.SE):
+config += (7 << 3)
+elif (ca.in2[y,x] == ca.empty): # XOR W W for empty
+config += (4 << 3)
+if (ca.gates[y,x] == ca.AND):
+config += 0
+elif (ca.gates[y,x] == ca.OR):
+config += (1 << 6)
+elif (ca.gates[y,x] == ca.XOR):
+config += (2 << 6)
+elif (ca.gates[y,x] == ca.NAND):
+config += (3 << 6)
+elif (ca.gates[y,x] == ca.empty): # XOR W W for empty
+config += (2 << 6)
+file.write(chr(config))
+for y in range(ca.ny):
+for x in range((ca.nx/8)):
+state = \
+(ca.states[y,8*x+0] << 7) \
++ (ca.states[y,8*x+1] << 6) \
++ (ca.states[y,8*x+2] << 5) \
++ (ca.states[y,8*x+3] << 4) \
++ (ca.states[y,8*x+4] << 3) \
++ (ca.states[y,8*x+5] << 2) \
++ (ca.states[y,8*x+6] << 1) \
++ (ca.states[y,8*x+7] << 0)
+file.write(chr(state))
+if ((ca.nx%8) != 0):
+x = cad.nx/8
+state = 0
+for i in range((ca.nx%8)):
+state += (ca.states[y,8*x+i] << (7-i))
+file.write(chr(state))
+file.close()
+string_msg.set("wrote %s"%filename)
+root.update()
+def msg_xy(event):
+x = (cad.xmin+cad.xmax)/2. + (cad.xmax-cad.xmin)*(1+event.x-cad.nplot/2.)/float(cad.nxplot())
+y = (cad.ymin+cad.ymax)/2. + (cad.ymin-cad.ymax)*(1+event.y-cad.nplot/2.)/float(cad.nyplot())
+string_msg.set("x = %.2f  y = %.2f"%(x,y))
+def msg_yz(event):
+if (cad.nz > 1):
+y = (cad.ymin+cad.ymax)/2. + (cad.ymin-cad.ymax)*(1+event.y-cad.nplot/2.)/float(cad.nyplot())
+z = (cad.zmin+cad.zmax)/2. + (cad.zmin-cad.zmax)*(1+event.x-cad.nplot/2.)/float(cad.nzplot())
+string_msg.set("y = %.2f  z = %.2f"%(y,z))
+else:
+string_msg.set("")
+def msg_xz(event):
+if (cad.nz > 1):
+x = (cad.xmin+cad.xmax)/2. + (cad.xmax-cad.xmin)*(1+event.x-cad.nplot/2.)/float(cad.nxplot())
+z = (cad.zmin+cad.zmax)/2. + (cad.zmin-cad.zmax)*(1+event.y-cad.nplot/2.)/float(cad.nzplot())
+string_msg.set("x = %.2f  z = %.2f"%(x,z))
+else:
+string_msg.set("")
+def msg_nomsg(event):
+string_msg.set("")
+def image_min_x(event):
+cad.xmin = float(string_image_xmin.get())
+xwidth = float(string_image_xwidth.get())
+cad.xmax = cad.xmin + xwidth
+root.update()
+def image_min_y(event):
+cad.ymin = float(string_image_ymin.get())
+yheight = float(string_image_yheight.get())
+cad.ymax = cad.ymin + yheight
+root.update()
+def image_scale_x(event):
+yheight = float(string_image_yheight.get())
+xwidth = yheight*cad.nx/float(cad.ny)
+cad.xmax = cad.xmin + xwidth
+string_image_xwidth.set(str(xwidth))
+root.update()
+def image_scale_y(event):
+xwidth = float(string_image_xwidth.get())
+yheight = xwidth*cad.ny/float(cad.nx)
+cad.ymax = cad.ymin + yheight
+string_image_yheight.set(str(yheight))
+root.update()
+def send_to(event):
+save_cam(0)
+cam_file_name = string_cam_file.get()
+send_to_file(cam_file_name)
+def send_to_file(cam_file_name):
+cad_path = os.path.dirname(sys.argv[0])
+if (sys.argv[0] == "cad.py"):
+cfg_path = "cad.cfg"
+else:
+cfg_path = os.path.dirname(sys.argv[0])+"/cad.cfg"
+try:
+config_file = open(cfg_path, 'r')
+except:
+string_msg.set(cfg_path+" not found")
+root.update()
+return()
+dot = find(cam_file_name,".")
+while 1:
+new_dot = find(cam_file_name,".",dot+1)
+if (new_dot == -1):
+break
+else:
+dot = new_dot
+suffix = cam_file_name[dot+1:]
+while 1:
+line = config_file.readline()
+if (find(line,suffix) == 0):
+string_msg.set("sending "+cam_file_name+" ...")
+root.update()
+quote1 = find(line,"'")
+quote2 = find(line,"'",quote1+1)
+cmd = line[(quote1+1):quote2]
+if (os.name == 'nt'):
+cam_file_name = replace(cam_file_name,'/','\\')
+cmd = replace(cmd,'file','"'+cam_file_name+'"')
+os.system(cmd)
+string_msg.set(cam_file_name+" sent")
+root.update()
+config_file.close()
+root.update()
+return()
+elif (line == ""):
+string_msg.set(suffix+" driver not defined in "+cfg_path)
+config_file.close()
+root.update()
+return()
+def resize_window(event):
+#
+# resize drawing windows
+#
+cad.nplot = int(string_window_size.get())
+cad.view(cad.views)
+render()
+def resize_editor(event):
+#
+# resize editing windows
+#
+cad.editor_height = int(string_editor_height.get())
+widget_cad_text.config(height=cad.editor_height)
+cad.editor_width = int(string_editor_width.get())
+widget_cad_text.config(width=cad.editor_width)
+widget_function_text.config(width=cad.editor_width)
+root.update()
+def reload():
+#
+# reload input file
+#
+filename = string_input_file.get()
+if (find(filename,'.cad') != -1):
+cad_load(0)
+elif ((find(filename,'.jpg') != -1) | (find(filename,'.JPG') != -1) |
+(find(filename,'.png') != -1) | (find(filename,'.PNG') != -1) |
+(find(filename,'.gif') != -1) | (find(filename,'.GIF') != -1)):
+widget_cad_text.delete("1.0",END)
+image_load(0)
+else:
+string_msg.set("unsupported input file format")
+root.update()
+#
+# set up GUI
+#
+root = Tk()
+root.title('cad.py')
+#
+# message frame
+#
+msg_frame = Frame(root)
+string_msg = StringVar()
+widget_msg = Label(msg_frame, textvariable = string_msg)
+widget_msg.pack(side='right')
+Label(msg_frame, text=" ").pack(side='right')
+widget_stop = Button(msg_frame, text='stop', borderwidth=2)
+widget_stop.bind('<Button-1>',render_stop)
+msg_frame.grid(row=0,column=0)
+#
+# size frame
+#
+size_frame = Frame(root)
+Label(size_frame, text="window size: ").pack(side='left')
+string_window_size = StringVar()
+string_window_size.set(str(cad.nplot))
+widget_window_size = Entry(size_frame, width=4, bg='white', textvariable=string_window_size)
+widget_window_size.bind('<Return>',resize_window)
+widget_window_size.pack(side='left')
+Label(size_frame, text="   editor width: ").pack(side='left')
+string_editor_width = StringVar()
+string_editor_width.set(str(cad.editor_width))
+widget_editor_width = Entry(size_frame, width=3, bg='white', textvariable=string_editor_width)
+widget_editor_width.bind('<Return>',resize_editor)
+widget_editor_width.pack(side='left')
+Label(size_frame, text=" height: ").pack(side='left')
+string_editor_height = StringVar()
+string_editor_height.set(str(cad.editor_height))
+widget_editor_height = Entry(size_frame, width=3, bg='white', textvariable=string_editor_height)
+widget_editor_height.bind('<Return>',resize_editor)
+widget_editor_height.pack(side='left')
+size_frame.grid(row=0,column=1)
+#
+# view frame
+#
+view_frame2 = Frame(root)
+view_frame3 = Frame(root)
+canvas_xy = Canvas(view_frame3)
+canvas_xz = Canvas(view_frame3)
+canvas_yz = Canvas(view_frame3)
+canvas_xyz = Canvas(view_frame3)
+cad.view('xyzr')
+#
+# I/O frame
+#
+io_frame = Frame(root)
+io_frame.grid(row=2,column=1,sticky=N)
+#cad_frame.bind('<Motion>',msg_nomsg)
+#
+# input frame
+#
+input_frame = Frame(io_frame)
+input_frame.pack()
+#
+# .cad editor
+#
+editor_frame = Frame(input_frame)
+widget_text_yscrollbar = Scrollbar(editor_frame)
+widget_cad_text = Text(editor_frame, bg='white', bd=5, width=cad.editor_width, height=cad.editor_height, yscrollcommand=widget_text_yscrollbar.set)
+widget_cad_text.grid(row=1,column=1)
+widget_text_yscrollbar.grid(row=1,column=2,sticky=N+S)
+widget_text_yscrollbar.config(command=widget_cad_text.yview)
+widget_cad_text.bind('<Motion>',msg_nomsg)
+editor_frame.pack()
+#
+# input file
+#
+cad_input_frame = Frame(input_frame)
+widget_input_file = Button(cad_input_frame, text="input:",command=input_open)
+widget_input_file.pack(side='left')
+string_input_file = StringVar()
+string_input_file.set('out.cad')
+widget_cad = Entry(cad_input_frame, width=17, bg='white', textvariable=string_input_file)
+widget_cad.pack(side='left')
+Label(cad_input_frame, text=" ").pack(side='left')
+widget_cad_save = Button(cad_input_frame, text="save")
+widget_cad_save.bind('<Button-1>',cad_save)
+widget_cad_save.pack(side='left')
+Label(cad_input_frame, text=" ").pack(side='left')
+widget_reload = Button(cad_input_frame, text="reload",command=reload)
+widget_reload.pack(side='left')
+cad_input_frame.pack()
+#
+# image x
+#
+image_x_frame = Frame(input_frame)
+Label(image_x_frame, text="x min: ").pack(side='left')
+string_image_xmin = StringVar()
+widget_image_xmin = Entry(image_x_frame, width=6, bg='white', textvariable=string_image_xmin)
+widget_image_xmin.bind('<Return>',image_min_x)
+widget_image_xmin.pack(side='left')
+Label(image_x_frame, text="   x width: ").pack(side='left')
+string_image_xwidth = StringVar()
+widget_image_xwidth = Entry(image_x_frame, width=6, bg='white', textvariable=string_image_xwidth)
+widget_image_xwidth.bind('<Return>',image_scale_y)
+widget_image_xwidth.pack(side='left')
+string_image_nx = StringVar()
+Label(image_x_frame, textvariable = string_image_nx).pack(side='left')
+#
+# image y
+#
+image_y_frame = Frame(input_frame)
+Label(image_y_frame, text="y min: ").pack(side='left')
+string_image_ymin = StringVar()
+widget_image_ymin = Entry(image_y_frame, width=6, bg='white', textvariable=string_image_ymin)
+widget_image_ymin.bind('<Return>',image_min_y)
+widget_image_ymin.pack(side='left')
+Label(image_y_frame, text="  y height: ").pack(side='left')
+string_image_yheight = StringVar()
+widget_image_yheight = Entry(image_y_frame, width=6, bg='white', textvariable=string_image_yheight)
+widget_image_yheight.bind('<Return>',image_scale_x)
+widget_image_yheight.pack(side='left')
+string_image_ny = StringVar()
+Label(image_y_frame, textvariable = string_image_ny).pack(side='left')
+#
+# image z
+#
+image_z_frame = Frame(input_frame)
+Label(image_z_frame, text="z min: ").pack(side='left')
+string_image_zmin = StringVar()
+widget_image_zmin = Entry(image_z_frame, width=6, bg='white', textvariable=string_image_zmin)
+widget_image_zmin.pack(side='left')
+Label(image_z_frame, text="   z max: ").pack(side='left')
+string_image_zmax = StringVar()
+widget_image_zmax = Entry(image_z_frame, width=6, bg='white', textvariable=string_image_zmax)
+widget_image_zmax.pack(side='left')
+Label(image_z_frame, text="   nz: ").pack(side='left')
+string_image_nz = StringVar()
+widget_image_nz = Entry(image_z_frame, width=6, bg='white', textvariable=string_image_nz)
+widget_image_nz.pack(side='left')
+#
+# image intensity
+#
+image_intensity_frame = Frame(input_frame)
+Label(image_intensity_frame, text="intensity min: ").pack(side='left')
+string_image_min = StringVar()
+widget_image_min = Entry(image_intensity_frame, width=6, bg='white', textvariable=string_image_min)
+widget_image_min.pack(side='left')
+Label(image_intensity_frame, text="   intensity max: ").pack(side='left')
+string_image_max = StringVar()
+widget_image_max = Entry(image_intensity_frame, width=6, bg='white', textvariable=string_image_max)
+widget_image_max.pack(side='left')
+#
+# image units
+#
+image_units_frame = Frame(input_frame)
+Label(image_units_frame, text="inches per unit: ").pack(side='left')
+string_image_units = StringVar()
+widget_image_units = Entry(image_units_frame, width=6, bg='white', textvariable=string_image_units)
+widget_image_units.pack(side='left')
+#
+# image invert
+#
+image_invert_frame = Frame(input_frame)
+Label(image_invert_frame, text=" ").pack(side='left')
+widget_image_invert = Button(image_invert_frame, text="invert image")
+widget_image_invert.pack(side='left')
+widget_image_invert.bind('<Button-1>',invert_image)
+#
+# output frame
+#
+output_frame = Frame(io_frame)
+output_frame.pack()
+#
+# controls
+#
+control_frame = Frame(output_frame)
+widget_render = Button(control_frame, text="render")
+widget_render.bind('<Button-1>',render_button)
+widget_render.pack(side='left')
+Label(control_frame, text=" ").pack(side='left')
+canvas_logo = Canvas(control_frame, width=26, height=26, background="white")
+canvas_logo.create_oval(2,2,8,8,fill="red",outline="")
+canvas_logo.create_rectangle(11,2,17,8,fill="blue",outline="")
+canvas_logo.create_rectangle(20,2,26,8,fill="blue",outline="")
+canvas_logo.create_rectangle(2,11,8,17,fill="blue",outline="")
+canvas_logo.create_oval(10,10,16,16,fill="red",outline="")
+canvas_logo.create_rectangle(20,11,26,17,fill="blue",outline="")
+canvas_logo.create_rectangle(2,20,8,26,fill="blue",outline="")
+canvas_logo.create_rectangle(11,20,17,26,fill="blue",outline="")
+canvas_logo.create_rectangle(20,20,26,26,fill="blue",outline="")
+canvas_logo.pack(side='left')
+control_text = " cad.py (%s) "%DATE
+Label(control_frame, text=control_text).pack(side='left')
+widget_cam = Button(control_frame, text="cam")
+widget_cam.bind('<Button-1>',cam)
+widget_cam.pack(side='left')
+Label(control_frame, text=" ").pack(side='left')
+widget_quit = Button(control_frame, text="quit", command='exit')
+widget_quit.pack(side='left')
+control_frame.pack()
+#
+# function string
+#
+function_string_frame = Frame(output_frame)
+Label(function_string_frame, text="function:").grid(row=1,column=1)
+widget_function_yscrollbar = Scrollbar(function_string_frame)
+widget_function_text = Text(function_string_frame, bg='white', bd=5, width=cad.editor_width, height=12, yscrollcommand=widget_function_yscrollbar.set, state=DISABLED)
+widget_function_text.grid(row=2,column=1)
+widget_function_yscrollbar.grid(row=2,column=2,sticky=N+S)
+widget_function_yscrollbar.config(command=widget_function_text.yview)
+function_string_frame.pack()
+#
+# CAM file
+#
+cam_file_frame = Frame(output_frame)
+widget_cam_menu_button = Menubutton(cam_file_frame,text="output format", relief=RAISED)
+widget_cam_menu_button.pack(side='left')
+widget_cam_menu = Menu(widget_cam_menu_button)
+widget_cam_menu.add_command(label='.epi (Epilog)',command=select_epi)
+widget_cam_menu.add_command(label='.camm (CAMM)',command=select_camm)
+widget_cam_menu.add_command(label='.rml (Modela)',command=select_rml)
+widget_cam_menu.add_command(label='.sbp (ShopBot)',command=select_sbp)
+widget_cam_menu.add_command(label='.gcode (Gcode)',command=select_g)
+widget_cam_menu.add_command(label='.ps (Postscript)',command=select_ps)
+widget_cam_menu.add_command(label='.ord (OMAX)',command=select_ord)
+widget_cam_menu.add_command(label='.oms (Resonetics)',command=select_oms)
+widget_cam_menu.add_command(label='.grb (Gerber)',command=select_gerber)
+widget_cam_menu.add_command(label='.drl (Excellon)',command=select_excellon)
+widget_cam_menu.add_command(label='.stl (STL)',command=select_stl)
+widget_cam_menu.add_command(label='.dxf (DXF)',command=select_dxf)
+widget_cam_menu.add_command(label='.jpg (JPG)',command=select_jpg)
+widget_cam_menu.add_command(label='.png (PNG)',command=select_png)
+widget_cam_menu.add_command(label='.ca (CA)',command=select_ca)
+widget_cam_menu.add_command(label='.uni (Universal)',command=select_uni)
+widget_cam_menu.add_command(label='.epb (Epilog bitmap)',state=DISABLED)
+widget_cam_menu_button['menu'] = widget_cam_menu
+Label(cam_file_frame, text=" output file: ").pack(side='left')
+string_cam_file = StringVar()
+widget_cam_file = Entry(cam_file_frame, width=12, bg='white', textvariable=string_cam_file)
+widget_cam_file.pack(side='left')
+Label(cam_file_frame, text=" ").pack(side='left')
+widget_cam_save = Button(cam_file_frame, text="save")
+widget_cam_save.bind('<Button-1>',save_cam)
+widget_cam_save.pack(side='left')
+#
+# vectorization
+#
+cam_vector_frame = Frame(output_frame)
+Label(cam_vector_frame, text="maximum vector fit error (lattice units): ").pack(side='left')
+string_vector_error = StringVar()
+string_vector_error.set('.75')
+widget_vector_error = Entry(cam_vector_frame, width=6, bg='white', textvariable=string_vector_error)
+widget_vector_error.pack(side='left')
+#
+# tool
+#
+cam_dia_frame = Frame(output_frame)
+Label(cam_dia_frame, text="tool diameter: ").pack(side='left')
+string_tool_dia = StringVar()
+string_tool_dia.set('0')
+widget_tool_dia = Entry(cam_dia_frame, width=6, bg='white', textvariable=string_tool_dia)
+widget_tool_dia.pack(side='left')
+Label(cam_dia_frame, text=" tool overlap: ").pack(side='left')
+string_tool_overlap = StringVar()
+string_tool_overlap.set('0.5')
+widget_tool_overlap = Entry(cam_dia_frame, width=6, bg='white', textvariable=string_tool_overlap)
+widget_tool_overlap.pack(side='left')
+#
+# contour
+#
+cam_contour_frame = Frame(output_frame)
+Label(cam_contour_frame, text=" # contours (-1 for max): ").pack(side='left')
+string_num_contours = StringVar()
+string_num_contours.set('0')
+widget_num_contours = Entry(cam_contour_frame, width=6, bg='white', textvariable=string_num_contours)
+widget_num_contours.pack(side='left')
+Label(cam_contour_frame, text=" ").pack(side='left')
+widget_cam_contour = Button(cam_contour_frame, text="contour")
+widget_cam_contour.pack(side='left')
+widget_cam_contour.bind('<Button-1>',contour)
+#
+# laser power
+#
+laser_frame1 = Frame(output_frame)
+Label(laser_frame1, text=" power:").pack(side='left')
+string_laser_power = StringVar()
+Entry(laser_frame1, width=6, bg='white', textvariable=string_laser_power).pack(side='left')
+Label(laser_frame1, text=" speed:").pack(side='left')
+string_laser_speed = StringVar()
+Entry(laser_frame1, width=6, bg='white', textvariable=string_laser_speed).pack(side='left')
+Label(laser_frame1, text=" rate: ").pack(side='left')
+string_laser_rate = StringVar()
+Entry(laser_frame1, width=6, bg='white', textvariable=string_laser_rate).pack(side='left')
+#
+# power range
+#
+laser_frame2 = Frame(output_frame)
+Label(laser_frame2, text=" min power:").pack(side='left')
+string_laser_min_power = StringVar()
+Entry(laser_frame2, width=6, bg='white', textvariable=string_laser_min_power).pack(side='left')
+Label(laser_frame2, text="%  max power:").pack(side='left')
+string_laser_max_power = StringVar()
+Entry(laser_frame2, width=6, bg='white', textvariable=string_laser_max_power).pack(side='left')
+Label(laser_frame2, text="%").pack(side='left')
+#
+# autofocus
+#
+laser_frame3 = Frame(output_frame)
+integer_laser_autofocus = IntVar()
+widget_autofocus = Checkbutton(laser_frame3, text="Auto Focus", variable=integer_laser_autofocus).pack(side='left')
+#
+# cutting
+#
+cut_frame = Frame(output_frame)
+Label(cut_frame, text="force: ").pack(side='left')
+string_cut_force = StringVar()
+Entry(cut_frame, width=6, bg='white', textvariable=string_cut_force).pack(side='left')
+Label(cut_frame, text=" velocity:").pack(side='left')
+string_cut_velocity = StringVar()
+Entry(cut_frame, width=6, bg='white', textvariable=string_cut_velocity).pack(side='left')
+#
+# speed
+#
+speed_frame = Frame(output_frame)
+Label(speed_frame, text="xy speed:").pack(side='left')
+string_xy_speed = StringVar()
+Entry(speed_frame, width=4, bg='white', textvariable=string_xy_speed).pack(side='left')
+Label(speed_frame, text=" z speed:").pack(side='left')
+string_z_speed = StringVar()
+Entry(speed_frame, width=4, bg='white', textvariable=string_z_speed).pack(side='left')
+#
+# jog
+#
+jog_frame = Frame(output_frame)
+Label(jog_frame, text="jog xy speed:").pack(side='left')
+string_jog_xy_speed = StringVar()
+Entry(jog_frame, width=4, bg='white', textvariable=string_jog_xy_speed).pack(side='left')
+Label(jog_frame, text=" z speed:").pack(side='left')
+string_jog_z_speed = StringVar()
+Entry(jog_frame, width=4, bg='white', textvariable=string_jog_z_speed).pack(side='left')
+Label(jog_frame, text=" z:").pack(side='left')
+string_jog_z = StringVar()
+Entry(jog_frame, width=4, bg='white', textvariable=string_jog_z).pack(side='left')
+#
+# RML move
+#
+rml_move_frame = Frame(output_frame)
+Label(rml_move_frame, text="x: ").pack(side='left')
+string_rml_x_move = StringVar()
+Entry(rml_move_frame, width=6, bg='white', textvariable=string_rml_x_move).pack(side='left')
+Label(rml_move_frame, text=" y: ").pack(side='left')
+string_rml_y_move = StringVar()
+Entry(rml_move_frame, width=6, bg='white', textvariable=string_rml_y_move).pack(side='left')
+Label(rml_move_frame, text=" ").pack(side='left')
+widget_rml_move = Button(rml_move_frame, text="move")
+widget_rml_move.pack(side='left')
+widget_rml_move.bind('<Button-1>',rml_move)
+#
+# G codes
+#
+g_frame = Frame(output_frame)
+Label(g_frame, text=" feed rate:").pack(side="left")
+string_g_feed_rate = StringVar()
+Entry(g_frame, width=6, textvariable=string_g_feed_rate).pack(side="left")
+Label(g_frame, text=" spindle speed:").pack(side="left")
+string_g_spindle_speed = StringVar()
+Entry(g_frame, width=6, textvariable=string_g_spindle_speed).pack(side="left")
+Label(g_frame, text=" tool:").pack(side="left")
+string_g_tool = StringVar()
+Entry(g_frame, width=3, textvariable=string_g_tool).pack(side="left")
+integer_g_cool = IntVar()
+widget_g_cool = Checkbutton(g_frame, text="coolant", variable=integer_g_cool)
+widget_g_cool.pack(side="left")
+#
+# waterjet
+#
+waterjet_frame = Frame(output_frame)
+Label(waterjet_frame,text="lead-in/out: ").pack(side='left')
+string_lead_in = StringVar()
+widget_lead_in = Entry(waterjet_frame, width=4, bg='white', textvariable=string_lead_in)
+widget_lead_in.pack(side='left')
+Label(waterjet_frame,text="quality: ").pack(side='left')
+string_quality = StringVar()
+widget_quality = Entry(waterjet_frame, width=4, bg='white', textvariable=string_quality)
+widget_quality.pack(side='left')
+#
+# excimer
+#
+excimer_frame = Frame(output_frame)
+Label(excimer_frame,text="period (usec): ").pack(side='left')
+string_pulse_period = StringVar()
+widget_pulse_period = Entry(excimer_frame, width=5, bg='white', textvariable=string_pulse_period)
+widget_pulse_period.pack(side='left')
+Label(excimer_frame,text="velocity: ").pack(side='left')
+string_cut_vel = StringVar()
+widget_cut_vel = Entry(excimer_frame, width=4, bg='white', textvariable=string_cut_vel)
+widget_cut_vel.pack(side='left')
+Label(excimer_frame,text="acceleration: ").pack(side='left')
+string_cut_accel = StringVar()
+widget_cut_accel = Entry(excimer_frame, width=4, bg='white', textvariable=string_cut_accel)
+widget_cut_accel.pack(side='left')
+#
+# STL
+#
+STL_frame = Frame(output_frame)
+widget_STL_triangulate = Button(STL_frame, text="triangulate")
+widget_STL_triangulate.pack(side='left')
+widget_STL_triangulate.bind('<Button-1>',triangulate)
+#
+# Gerber
+#
+Gerber_frame = Frame(output_frame)
+widget_Gerber_convert = Button(Gerber_frame, text="convert")
+widget_Gerber_convert.pack(side='left')
+widget_Gerber_convert.bind('<Button-1>',flash)
+#
+# Excellon
+#
+Excellon_frame = Frame(output_frame)
+widget_Excellon_convert = Button(Excellon_frame, text="convert")
+widget_Excellon_convert.pack(side='left')
+widget_Excellon_convert.bind('<Button-1>',flash)
+#
+# filling
+#
+fill_frame = Frame(output_frame)
+integer_fill = IntVar()
+widget_fill = Checkbutton(fill_frame, text="fill polygons", variable=integer_fill).pack(side='left')
+#
+# send to
+#
+send_to_frame = Frame(output_frame)
+widget_send_to = Button(send_to_frame, text="send to machine")
+widget_send_to.bind('<Button-1>',send_to)
+widget_send_to.pack(side='left')
+string_send_to_time = StringVar()
+string_send_to_time.set("")
+Label(send_to_frame,textvariable=string_send_to_time).pack(side='left')
+#
+# define .cad template
+#
+cad_template = """#
+# .cad template
+#
+#
+# define shapes and transformation
+#
+# circle(x0, y0, r)
+# cylinder(x0, y0, z0, z1, r)
+# cone(x0, y0, z0, z1, r0)
+# sphere(x0, y0, z0, r)
+# torus(x0, y0, z0, r0, r1)
+# rectangle(x0, x1, y0, y1)
+# cube(x0, x1, y0, y1, z0, z1)
+# right_triangle(x0, y0, h)
+# triangle(x0, y0, x1, y1, x2, y2) (points in clockwise order)
+# pyramid(x0, x1, y0, y1, z0, z1)
+# function(Z_of_XY)
+# functions(upper_Z_of_XY,lower_Z_of_XY)
+# add(part1, part2)
+# subtract(part1, part2)
+# intersect(part1, part2)
+# move(part,dx,dy)
+# translate(part,dx,dy,dz)
+# rotate(part, angle)
+# rotate_x(part, angle)
+# rotate_y(part, angle)
+# rotate_z(part, angle)
+# rotate_90(part)
+# rotate_180(part)
+# rotate_270(part)
+# reflect_x(part)
+# reflect_y(part)
+# reflect_z(part)
+# reflect_xy(part)
+# reflect_xz(part)
+# reflect_yz(part)
+# scale_x(part, x0, sx)
+# scale_y(part, y0, sy)
+# scale_z(part, z0, sz)
+# scale_xy(part, x0, y0, sxy)
+# scale_xyz(part, x0, y0, z0, sxyz)
+# coscale_x_y(part, x0, y0, y1, angle0, angle1, amplitude, offset)
+# coscale_x_z(part, x0, z0, z1, angle0, angle1, amplitude, offset)
+# coscale_xy_z(part, x0, y0, z0, z1, angle0, angle1, amplitude, offset)
+# taper_x_y(part, x0, y0, y1, s0, s1)
+# taper_x_z(part, x0, z0, z1, s0, s1)
+# taper_xy_z(part, x0, y0, z0, z1, s0, s1)
+# shear_x_y(part, y0, y1, dx0, dx1)
+# shear_x_z(part, z0, z1, dx0, dx1)
+# (more to come)
+def circle(x0, y0, r):
+part = "(((X-x0)**2 + (Y-y0)**2) <= r**2)"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'r',str(r))
+return part
+def cylinder(x0, y0, z0, z1, r):
+part = "(((X-x0)**2 + (Y-y0)**2 <= r**2) & (Z >= z0) & (Z <= z1))"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'r',str(r))
+return part
+def cone(x0, y0, z0, z1, r0):
+part = cylinder(x0, y0, z0, z1, r0)
+part = taper_xy_z(part, x0, y0, z0, z1, 1.0, 0.0)
+return part
+def sphere(x0, y0, z0, r):
+part = "(((X-x0)**2 + (Y-y0)**2 + (Z-z0)**2) <= r**2)"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'r',str(r))
+return part
+def torus(x0, y0, z0, r0, r1):
+part = "(((r0 - sqrt((X-x0)**2 + (Y-y0)**2))**2 + (Z-z0)**2) <= r1**2)"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'r0',str(r0))
+part = replace(part,'r1',str(r1))
+return part
+def rectangle(x0, x1, y0, y1):
+part = "((X >= x0) & (X <= x1) & (Y >= y0) & (Y <= y1))"
+part = replace(part,'x0',str(x0))
+part = replace(part,'x1',str(x1))
+part = replace(part,'y0',str(y0))
+part = replace(part,'y1',str(y1))
+return part
+def cube(x0, x1, y0, y1, z0, z1):
+part = "((X >= x0) & (X <= x1) & (Y >= y0) & (Y <= y1) & (Z >= z0) & (Z <= z1))"
+part = replace(part,'x0',str(x0))
+part = replace(part,'x1',str(x1))
+part = replace(part,'y0',str(y0))
+part = replace(part,'y1',str(y1))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+return part
+def right_triangle(x0, y0, h):
+part = "((X > x0) & (X < x0 + h - (Y-y0)) & (Y > y0))"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'h',str(h))
+return part
+def triangle(x0, y0, x1, y1, x2, y2): # points in clockwise order
+part = "((((y1-y0)*(X-x0)-(x1-x0)*(Y-y0)) >= 0) & (((y2-y1)*(X-x1)-(x2-x1)*(Y-y1)) >= 0) & (((y0-y2)*(X-x2)-(x0-x2)*(Y-y2)) >= 0))"
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'x1',str(x1))
+part = replace(part,'y1',str(y1))
+part = replace(part,'x2',str(x2))
+part = replace(part,'y2',str(y2))
+return part
+def pyramid(x0, x1, y0, y1, z0, z1):
+part = cube(x0, x1, y0, y1, z0, z1)
+part = taper_xy_z(part, (x0+x1)/2., (y0+y1)/2., z0, z1, 1.0, 0.0)
+return part
+def function(Z_of_XY):
+part = '(Z <= '+Z_of_XY+')'
+return part
+def functions(upper_Z_of_XY,lower_Z_of_XY):
+part = '(Z <= '+upper_Z_of_XY+') & (Z >= '+lower_Z_of_XY+')'
+return part
+def add(part1, part2):
+part = "part1 | part2"
+part = replace(part,'part1',part1)
+part = replace(part,'part2',part2)
+return part
+def subtract(part1, part2):
+part = "(part1) & ~(part2)"
+part = replace(part,'part1',part1)
+part = replace(part,'part2',part2)
+return part
+def intersect(part1, part2):
+part = "(part1) & (part2)"
+part = replace(part,'part1',part1)
+part = replace(part,'part2',part2)
+return part
+def move(part,dx,dy):
+part = replace(part,'X','(X-'+str(dx)+')')
+part = replace(part,'Y','(Y-'+str(dy)+')')
+return part
+def translate(part,dx,dy,dz):
+part = replace(part,'X','(X-'+str(dx)+')')
+part = replace(part,'Y','(Y-'+str(dy)+')')
+part = replace(part,'Z','(Z-'+str(dz)+')')
+return part
+def rotate(part, angle):
+angle = angle*pi/180
+part = replace(part,'X','(cos(angle)*X+sin(angle)*y)')
+part = replace(part,'Y','(-sin(angle)*X+cos(angle)*y)')
+part = replace(part,'y','Y')
+part = replace(part,'angle',str(angle))
+return part
+def rotate_x(part, angle):
+angle = angle*pi/180
+part = replace(part,'Y','(cos(angle)*Y+sin(angle)*z)')
+part = replace(part,'Z','(-sin(angle)*Y+cos(angle)*z)')
+part = replace(part,'z','Z')
+part = replace(part,'angle',str(angle))
+return part
+def rotate_y(part, angle):
+angle = angle*pi/180
+part = replace(part,'X','(cos(angle)*X+sin(angle)*z)')
+part = replace(part,'Z','(-sin(angle)*X+cos(angle)*z)')
+part = replace(part,'z','Z')
+part = replace(part,'angle',str(angle))
+return part
+def rotate_z(part, angle):
+angle = angle*pi/180
+part = replace(part,'X','(cos(angle)*X+sin(angle)*y)')
+part = replace(part,'Y','(-sin(angle)*X+cos(angle)*y)')
+part = replace(part,'y','Y')
+part = replace(part,'angle',str(angle))
+return part
+def rotate_90(part):
+part = reflect_xy(part)
+part = reflect_y(part)
+return part
+def rotate_180(part):
+part = reflect_xy(part)
+part = reflect_y(part)
+part = reflect_xy(part)
+part = reflect_y(part)
+return part
+def rotate_270(part):
+part = reflect_xy(part)
+part = reflect_y(part)
+part = reflect_xy(part)
+part = reflect_y(part)
+part = reflect_xy(part)
+part = reflect_y(part)
+return part
+def reflect_x(part):
+part = replace(part,'X','(-X)')
+return part
+def reflect_y(part):
+part = replace(part,'Y','(-Y)')
+return part
+def reflect_z(part):
+part = replace(part,'Z','(-Z)')
+return part
+def reflect_xy(part):
+part = replace(part,'X','temp')
+part = replace(part,'Y','X')
+part = replace(part,'temp','Y')
+return part
+def reflect_xz(part):
+part = replace(part,'X','temp')
+part = replace(part,'Z','X')
+part = replace(part,'temp','Z')
+return part
+def reflect_yz(part):
+part = replace(part,'Y','temp')
+part = replace(part,'Z','Y')
+part = replace(part,'temp','Z')
+return part
+def scale_x(part, x0, sx):
+part = replace(part,'X','(x0 + (X-x0)/sx)')
+part = replace(part,'x0',str(x0))
+part = replace(part,'sx',str(sx))
+return part
+def scale_y(part, y0, sy):
+part = replace(part,'Y','(y0 + (Y-y0)/sy)')
+part = replace(part,'y0',str(y0))
+part = replace(part,'sy',str(sy))
+return part
+def scale_z(part, z0, sz):
+part = replace(part,'Z','(z0 + (Z-z0)/sz)')
+part = replace(part,'z0',str(z0))
+part = replace(part,'sz',str(sz))
+return part
+def scale_xy(part, x0, y0, sxy):
+part = replace(part,'X','(x0 + (X-x0)/sxy)')
+part = replace(part,'Y','(y0 + (Y-y0)/sxy)')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'sxy',str(sxy))
+return part
+def scale_xyz(part, x0, y0, z0, sxyz):
+part = replace(part,'X','(x0 + (X-x0)/sxyz)')
+part = replace(part,'Y','(y0 + (Y-y0)/sxyz)')
+part = replace(part,'Z','(z0 + (Z-z0)/sxyz)')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'sxyz',str(sxyz))
+return part
+def coscale_x_y(part, x0, y0, y1, angle0, angle1, amplitude, offset):
+phase0 = pi*angle0/180.
+phase1 = pi*angle1/180.
+part = replace(part,'X','(x0 + (X-x0)/(offset + amplitude*cos(phase0 + (phase1-phase0)*(Y-y0)/(y1-y0))))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'y1',str(y1))
+part = replace(part,'phase0',str(phase0))
+part = replace(part,'phase1',str(phase1))
+part = replace(part,'amplitude',str(amplitude))
+part = replace(part,'offset',str(offset))
+return part
+def coscale_x_z(part, x0, z0, z1, angle0, angle1, amplitude, offset):
+phase0 = pi*angle0/180.
+phase1 = pi*angle1/180.
+part = replace(part,'X','(x0 + (X-x0)/(offset + amplitude*cos(phase0 + (phase1-phase0)*(Z-z0)/(z1-z0))))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'phase0',str(phase0))
+part = replace(part,'phase1',str(phase1))
+part = replace(part,'amplitude',str(amplitude))
+part = replace(part,'offset',str(offset))
+return part
+def coscale_xy_z(part, x0, y0, z0, z1, angle0, angle1, amplitude, offset):
+phase0 = pi*angle0/180.
+phase1 = pi*angle1/180.
+part = replace(part,'X','(x0 + (X-x0)/(offset + amplitude*cos(phase0 + (phase1-phase0)*(Z-z0)/(z1-z0))))')
+part = replace(part,'Y','(y0 + (Y-y0)/(offset + amplitude*cos(phase0 + (phase1-phase0)*(Z-z0)/(z1-z0))))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'phase0',str(phase0))
+part = replace(part,'phase1',str(phase1))
+part = replace(part,'amplitude',str(amplitude))
+part = replace(part,'offset',str(offset))
+return part
+def taper_x_y(part, x0, y0, y1, s0, s1):
+part = replace(part,'X','(x0 + (X-x0)*(y1-y0)/(s1*(Y-y0) + s0*(y1-Y)))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'y1',str(y1))
+part = replace(part,'s0',str(s0))
+part = replace(part,'s1',str(s1))
+return part
+def taper_x_z(part, x0, z0, z1, s0, s1):
+part = replace(part,'X','(x0 + (X-x0)*(z1-z0)/(s1*(Z-z0) + s0*(z1-Z)))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'s0',str(s0))
+part = replace(part,'s1',str(s1))
+return part
+def taper_xy_z(part, x0, y0, z0, z1, s0, s1):
+part = replace(part,'X','(x0 + (X-x0)*(z1-z0)/(s1*(Z-z0) + s0*(z1-Z)))')
+part = replace(part,'Y','(y0 + (Y-y0)*(z1-z0)/(s1*(Z-z0) + s0*(z1-Z)))')
+part = replace(part,'x0',str(x0))
+part = replace(part,'y0',str(y0))
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'s0',str(s0))
+part = replace(part,'s1',str(s1))
+return part
+def shear_x_y(part, y0, y1, dx0, dx1):
+part = replace(part,'X','(X - dx0 - (dx1-dx0)*(Y-y0)/(y1-y0))')
+part = replace(part,'y0',str(y0))
+part = replace(part,'y1',str(y1))
+part = replace(part,'dx0',str(dx0))
+part = replace(part,'dx1',str(dx1))
+return part
+def shear_x_z(part, z0, z1, dx0, dx1):
+part = replace(part,'X','(X - dx0 - (dx1-dx0)*(Z-z0)/(z1-z0))')
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'dx0',str(dx0))
+part = replace(part,'dx1',str(dx1))
+return part
+def coshear_x_z(part, z0, z1, angle0, angle1, amplitude, offset):
+phase0 = pi*angle0/180.
+phase1 = pi*angle1/180.
+part = replace(part,'X','(X - offset - amplitude*cos(phase0 + (phase1-phase0)*(Z-z0)/(z1-z0)))')
+part = replace(part,'z0',str(z0))
+part = replace(part,'z1',str(z1))
+part = replace(part,'phase0',str(phase0))
+part = replace(part,'phase1',str(phase1))
+part = replace(part,'amplitude',str(amplitude))
+part = replace(part,'offset',str(offset))
+return part
+#
+# define part
+#
+d = .5
+teapot = cylinder(0,0,-d,d,d)
+teapot = coscale_xy_z(teapot,0,0,-d,d,-90,90,.5,.75)
+handle = torus(0,0,0,3.5*d/5.,d/10.)
+handle = reflect_xz(handle)
+handle = reflect_xy(handle)
+handle = scale_x(handle,0,.75)
+handle = scale_y(handle,0,3)
+handle = translate(handle,-6*d/5.,0,0)
+teapot = add(teapot,handle)
+spout = torus(2.1*d,-.2*d,0,1.1*d,.2*d)
+spout = reflect_yz(spout)
+spout = intersect(spout,cube(-3*d,1.8*d,-3*d,3*d,0,3*d))
+teapot = add(teapot,spout)
+interior = cylinder(0,0,.1-d,.1+d,d-.1)
+interior = coscale_xy_z(interior,0,0,-d,d,-90,90,.5,.75)
+teapot = subtract(teapot,interior)
+spout_interior = torus(2.1*d,-.2*d,0,1.1*d,.15*d)
+spout_interior = reflect_yz(spout_interior)
+spout_interior = intersect(spout_interior,cube(-3*d,1.8*d,-3*d,3*d,0,3*d))
+teapot = subtract(teapot,spout_interior)
+part = teapot
+part = subtract(part,cube(0,3*d,-3*d,0,-3*d,3*d))
+#
+# define limits and parameters
+#
+width = 2.5
+x0 = 0
+y0 = 0
+z0 = 0
+cad.xmin = x0-width/2. # min x to render
+cad.xmax = x0+width/2. # max x to render
+cad.ymin = y0-width/2. # min y to render
+cad.ymax = y0+width/2. # max y to render
+#cad.zmin = z0-width/4. # min z to render
+#cad.zmax = z0+width/4. # max x to render
+cad.zmin = z0-width/4. # min z to render
+cad.zmax = z0+width/4. # max x to render
+cad.rx = 30 # x view rotation (degrees)
+cad.rz = 20 # z view rotation (degrees)
+dpi = 100 # rendering resolution
+cad.nx = int(dpi*(cad.xmax-cad.xmin)) # x points to render
+cad.ny = int(dpi*(cad.ymax-cad.ymin)) # y points to render
+cad.nz = int(dpi*(cad.zmax-cad.zmin)) # z points to render
+cad.inches_per_unit = 1.0 # use inch units
+#
+# assign part to cad.function
+#
+cad.function = part
+"""
+#
+# check config file for window parameters
+#
+cad_path = os.path.dirname(sys.argv[0])
+if (sys.argv[0] == "cad.py"):
+cfg_path = "cad.cfg"
+else:
+cfg_path = os.path.dirname(sys.argv[0])+"/cad.cfg"
+try:
+config_file = open(cfg_path, 'r')
+string_msg.set("found "+cfg_path)
+while 1:
+line = config_file.readline()
+if (find(line,"window size:") == 0):
+string_window_size.set(int(line[12:]))
+elif (find(line,"editor width:") == 0):
+string_editor_width.set(int(line[13:]))
+elif (find(line,"editor height:") == 0):
+string_editor_height.set(int(line[14:]))
+elif (line == ""):
+break
+config_file.close()
+resize_editor(0)
+except:
+string_msg.set(cfg_path+" not found")
+#
+# read input file if on command line, otherwise use template
+#
+if len(sys.argv) == 2:
+filename = sys.argv[1]
+string_input_file.set(filename)
+if (find(filename,'.cad') != -1):
+cad_load(0)
+elif ((find(filename,'.jpg') != -1) | (find(filename,'.JPG') != -1) |
+(find(filename,'.png') != -1) | (find(filename,'.PNG') != -1) |
+(find(filename,'.gif') != -1) | (find(filename,'.GIF') != -1)):
+widget_cad_text.delete("1.0",END)
+image_load(0)
+else:
+string_msg.set("unsupported input file format")
+root.update()
+else:
+widget_cad_text.insert("1.0",cad_template)
+#
+# start GUI
+#
+root.mainloop()

Mercurial > hg-public > lasercut-scripts / file comparison

comparison: stuff/(Cad.py) Plotting with Z axis movement.py

stuff/(Cad.py) Plotting with Z axis movement.py