stuff/%28Cad.py%29%20Plotting%20with%20Z%20axis%20movement.py

#!/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()