def showCrossover(self):
self.GenerCanvas = [
Canvas.Canvas(self.population, 1),
Canvas.Canvas(self.population, 1)
]
self.vboxc[0].addWidget(self.GenerCanvas[0])
self.vboxc[1].addWidget(self.GenerCanvas[1])
self.GenerCanvas[0].drawImage()
self.GenerCanvas[1].drawImage()
def __init__(self, parent):
QtGui.QMainWindow.__init__(self)
UI_DrawingWindow.__init__(self)
self.setupUi(self)
self.parent = parent
self.canvas = Canvas.Canvas(self.drawing_panel)
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.INFO)
self.register_buttons()
# set max counts in progresss bar
self.count_progress_bar.setMaximum(
config.Settings.SAMPLE_COUNT_PER_DIGIT)
self.count_progress_bar.setValue(
config.Settings.SAMPLE_COUNT_PER_DIGIT)
# Attach this window to the Server
globals.device_server.attach_active_drawing_window(self)
# Panel Updater timer
self.timer = QtCore.QTimer(self)
self.timer.setInterval(config.Settings.REFRESH_INTERVAL)
self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.update_panel)
self.timer.start()
def showSelection(self):
self.GenerCanvas = [Canvas.Canvas(self.population, 1)]
self.warning1.setText(
"<div style='color: rgb(255, 255, 255); text-align: center;'>Расставьте уникальное значение для каждого изображения, где 1 - наименее подходящее изображение, "
+ str(self.population.size) + " - наиболее подходящее.</div>")
self.hboxs.addWidget(self.GenerCanvas[0])
self.GenerCanvas[0].drawImage()
def show(self):
self.tk.wm_title(self.title)
self.board = Canvas(self.tk,relief=SUNKEN, bd=2, width=self.ww, height=self.wh)
self.board.pack(fill=BOTH)
Rectangle(self.board, (0,0), (self.ww,self.wh), fill="white", width=1)
b = Button(self.tk, text="Close", font=self.font, command = self.close )
b.pack()
def main():
canvas = Canvas(300, 300)
canvas.putpixel(0, 0, (255, 0, 0))
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
canvas.repaint()
def load_painter(self):
# Загружаем холст
self.paint_page.setLayout(self.paint_page_lay)
# Текущий цвет - черный, ширина кисти - 10
self.now_col = QColor(0, 0, 0)
self.now_width = 10
self.point_width.setValue(10)
# Подвязываем кнопку с изменением ширины кисти к соответсвующему слоту
self.point_width.valueChanged.connect(self.change_width)
# Создаем холст как экземпляр класса Canvas из доп.модуля Canvas
self.canvas = Canvas.Canvas(self.main_paint_widg)
self.canvas.move(1, 1)
self.canvas.resize(self.main_paint_widg.width() - 1,
self.main_paint_widg.height() - 1)
print(self.main_paint_widg.size(), self.canvas.size(),
self.border_lab.size())
# Устанавливаем границы рамки
self.border_lab.setStyleSheet(
'border-style: solid; border-width: 2px; border-color: black;')
self.canvas.setStyleSheet('background-color: white;')
# Устанавливаем сильный фокус для перехвата всех событий
# клавиатуры и мыши
self.setFocusPolicy(Qt.StrongFocus)
# Подвязываем действия из меню к слотам
self.actionSave.triggered.connect(self.save_file)
self.actionSave_as.triggered.connect(self.save_as_file)
self.actionOpen.triggered.connect(self.open_file)
self.actionReference.triggered.connect(self.open_reference)
# и кнопку очистки холста, а также задания цвета кисти
self.bt_clear.clicked.connect(self.clear_canvas)
self.bt_set_color.clicked.connect(self.set_color_with_bt)
# Имя файла изначально не задано, файл не сохранен
self.file_name = ''
self.saved = False
self.resizeEvent(QResizeEvent(self.size(), self.size()))
def make1DPlot(queue,
lumi,
var,
name,
nbinx,
xmin,
xmax,
xlabel,
tree,
cuts,
ylog=False,
outtag='',
split=False,
normed=False):
if queue:
launchToQueue('make1DPlot', queue, name, outtag)
else:
h = tree.getTH1F(lumi, name, var, nbinx, xmin, xmax, cuts, '', xlabel)
h.SetFillColor(r.kAzure)
h.SetLineColor(r.kBlack)
plot = Canvas.Canvas('hist_' + name, 'png', 0.34, 0.68, 0.9, 0.9, 2)
plot.addHisto(h, 'hist', '', 'f', '', 1, 0)
outdir = os.path.dirname(os.path.abspath(
__main__.__file__)) + '/1DPlots_' + outtag + '/'
plot.save(0, 1, ylog, lumi, '', outputDir=outdir)
def init(gui = 0, mode=1, pause_time=0, call_from_gui=0, size=None, backend="vtk"):
'''
Function: init # Initialize, Construct a VCS Canvas Object
Description of Function:
Construct the VCS Canas object. There can only be at most 8 VCS
Canvases open at any given time.
Graphics User Interface Mode:
gui = 0|1 if ==1, create the canvas with GUI controls
(Default setting is *not* to display GUI controls)
Example of Use:
import vcs,cu
file=cu.open('filename.nc')
slab=file.getslab('variable')
a=vcs.init() # This examples constructs 4 VCS Canvas
a.plot(slab) # Plot slab using default settings
b=vcs.init() # Construct VCS object
template=b.gettemplate('AMIP') # Get 'example' template object
b.plot(slab,template) # Plot slab using template 'AMIP'
c=vcs.init() # Construct new VCS object
isofill=c.getisofill('quick') # Get 'quick' isofill graphics method
c.plot(slab,template,isofill) # Plot slab using template and isofill objects
d=vcs.init() # Construct new VCS object
isoline=c.getisoline('quick') # Get 'quick' isoline graphics method
c.plot(isoline,slab,template) # Plot slab using isoline and template objects
'''
canvas = Canvas.Canvas(gui=gui, mode=mode, pause_time=pause_time, call_from_gui=call_from_gui, size=size, backend=backend)
global canvaslist
canvaslist.append(canvas)
return canvas
def drawPictINCurrLay(self, canvacount, n):
if self.layout == 1:
self.vboxs.removeWidget(self.GenerCanvas[canvacount])
self.GenerCanvas[canvacount] = Canvas.Canvas(self.population, n)
self.hboxs.addWidget(self.GenerCanvas[canvacount])
self.setPictRang.setText(
str(self.GenerCanvas[0].population.individs[
self.GenerCanvas[0].pictNum - 1].rang))
elif self.layout == 2:
self.vboxc[canvacount].removeWidget(self.GenerCanvas[canvacount])
self.GenerCanvas[canvacount] = Canvas.Canvas(self.population, n)
self.vboxc[canvacount].addWidget(self.GenerCanvas[canvacount])
elif self.layout == 3:
self.vboxm.removeWidget(self.GenerCanvas[canvacount])
self.GenerCanvas[canvacount] = Canvas.Canvas(
self.population.subPopulation, n)
self.hboxm.addWidget(self.GenerCanvas[canvacount])
self.GenerCanvas[canvacount].drawImage()
def cut(W, H, N, RECTANGLES, CANVAS, ORDER):
def divide(canvas, rectangles):
if (len(rectangles) < 1):
canvasnotused.append(canvas)
return
for j in range(len(rectangles)):
flag, rectangles[j] = uc.fitin(canvas, rectangles[j])
if (flag):
rectangles[j].x = canvas.x
rectangles[j].y = canvas.y
rectangles[j].xx = rectangles[j].x + rectangles[j].w
rectangles[j].yy = rectangles[j].y + rectangles[j].h
rectangles[j].sheet = canvas.order
#Corte inferior
c1 = c.Canvas(rectangles[j].xx, rectangles[j].y,
canvas.w - rectangles[j].w, canvas.h, ORDER)
c2 = c.Canvas(rectangles[j].x, rectangles[j].yy,
rectangles[j].w, canvas.h - rectangles[j].h,
ORDER)
"""
#Corte lateral
c1 = c.Canvas(rectangles[j].xx, rectangles[j].y,
canvas.w-rectangles[j].w, rectangles[j].h, ORDER)
c2 = c.Canvas(rectangles[j].x, rectangles[j].yy,
canvas.w, canvas.h-rectangles[j].h, ORDER)
"""
if not (rectangles[j] in cutted):
cutted.append(rectangles[j])
rectangles.remove(rectangles[j])
divide(c1, rectangles)
divide(c2, rectangles)
return
canvasnotused.append(canvas)
divide(CANVAS, RECTANGLES)
if RECTANGLES:
#tienen que ser de ese canvas
uc.extra(W, H, canvasnotused, RECTANGLES, cutted, ORDER)
if RECTANGLES:
ORDER += 1
newcanvas = c.Canvas(0, 0, W, H, ORDER)
cut(W, H, len(RECTANGLES), RECTANGLES, newcanvas, ORDER)
return
waste, area = uc.waste(W, H, canvasnotused, ORDER)
do.results(ORDER, waste, area, cuts, cutted)
g.set_draws(ORDER, W, H, cutted)
g.draw()
def repaintImage(self):
if self.population.canvaSize[0] != 0 and self.population.canvaSize[
1] != 0:
if self.population.size != 0:
self.population.genetatePopulation()
if self.GenerCanvas[0] != 0:
self.vboxg.removeWidget(self.GenerCanvas[0])
self.GenerCanvas = [Canvas.Canvas(self.population, 1)]
self.hboxg.addWidget(self.GenerCanvas[0])
self.show()
def __init__(self,
canvas=None,
template_name='',
gui_parent=None,
gm='isofill',
gm_name='default'):
self.gm = gm
self.gm_name = gm_name #these are used for sample plots
if canvas is None:
canvas = Canvas.Canvas()
self.canvas = canvas
canvas.canvas_template_editor = self
self.dialog = gui_support.VcsDialog(command=self.button_dispatch,
defaultbutton='Apply',
buttons=('Apply', 'Apply & Exit',
'Save Session', 'Revert'))
gui_support.balloon.bind(self.dialog.component('buttonbox'),
TemplateEditor.command_summary)
self.dialog.dialog.withdraw()
self.gui_parent = gui_parent
self.template_name = ''
gui_support.balloon.bind(self.dialog.interior(),
TemplateEditor.balloon_text)
# create the templateeditor menus
main_menu = Pmw.MenuBar(self.dialog.interior(),
hull_relief='raised',
hull_borderwidth=2,
balloon=gui_support.balloon)
main_menu.pack(side='top', fill='both')
self.create_filemenu(main_menu, canvas)
self.create_help_menu(main_menu)
self.create_dialogs()
self.editors = []
self._create_data() #sample variable
# Create the notebook, with 'lazy' page creation.
self.notebook = Pmw.NoteBook(self.dialog.interior(),
createcommand=self.makepages)
self.notebook.pack(side='top', fill='both', expand=1, padx=3, pady=3)
# Decide where to put it on the screen
if gui_parent is None:
d = [
int(self.dialog.dialog.winfo_screenwidth() / 6),
int(self.dialog.dialog.winfo_screenheight() / 6)
]
self.dialog.geometry("+%s+%s" % (d[0], d[1]))
else:
self.dialog.position_over(gui_parent)
self.dialog.dialog.deiconify()
if template_name == '':
self.open()
else:
self._open_template(template_name)
self.dialog.dialog.lift()
def __init__(self, mastr, sq, *a, **k):
self.highlight = 0
Frame.__init__(self, mastr, border=0, *a, **k)
self.ca = Canvas(master=self, border=0, width=48, height=48)
self.ca.pack(expand=1, fill=BOTH)
self.l = ImageItem(self.ca, 0, 16, anchor=NW)
self.t = ImageItem(self.ca, 16, 0, anchor=NW)
self.c = ImageItem(self.ca, 16, 16, anchor=NW)
self.b = ImageItem(self.ca, 16, 32, anchor=NW)
self.r = ImageItem(self.ca, 32, 16, anchor=NW)
self.seq = sq
def main():
pygame.init()
#make screen
size = (1074, 818)
screen = pygame.display.set_mode(size)
screen.fill(WHITE)
pygame.display.update()
canvas = Canvas.Canvas(screen, WHITE, (25, 25), 1024, 768)
menu = Menu(canvas)
mainloop()
def init(mode=1,
pause_time=0,
call_from_gui=0,
size=None,
backend="vtk",
geometry=None,
bg=None):
"""
Initialize and construct a VCS Canvas object.
:Example:
::
import vcs
# Portrait orientation of 1 width per 2 height
portrait = vcs.init(size=.5)
# also accepts "usletter"
letter = vcs.init(size="letter")
a4 = vcs.init(size="a4")
import vtk
# Useful for embedding VCS inside another application
my_win = vtk.vtkRenderWindow()
embedded = vcs.init(backend=my_win)
dict_init = vcs.init(geometry={"width": 1200, "height": 600})
tuple_init = vcs.init(geometry=(1200, 600))
bg_canvas = vcs.init(bg=True)
:param size: Aspect ratio for canvas (width / height)
:param backend: Which VCS backend to use
:param geometry: Size (in pixels) you want the canvas to be.
:param bg: Initialize a canvas to render in "background" mode (without displaying a window)
:type size: float or case-insensitive str
:type backend: str, `vtk.vtkRenderWindow`
:type geometry: dict or tuple
:type bg: bool
:return: an initialized canvas
:rtype: vcs.Canvas.Canvas
"""
canvas = Canvas.Canvas(mode=mode,
pause_time=pause_time,
call_from_gui=call_from_gui,
size=size,
backend=backend,
geometry=geometry,
bg=bg)
global canvaslist
canvaslist.append(canvas)
return canvas
def __init__(self, app):
"""
Create a main window for the given application.
"""
defaultOptions["palette"] = app.palette()
Systray.__init__(self)
self.expansions = 0
self.client = None
self.server = None
self.running = False
self.recovery = False
mainWidgets["main"] = self
mainWidgets["app"] = app
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget = TabWidget(self)
mainWidgets["tab"] = self.tabWidget
self.setCentralWidget(self.tabWidget)
#self.setCentralWidget(self.canvas)
self.createActions()
self.createMenus()
self.createToolBars()
self.createStatusBar()
self.createDockWindows()
self.createConfigWindows()
self.createPopupWindows()
self.createProgressBar()
self.newScene()
self.debugWindow.hide()
self.tm.hide()
self.routes.hide()
self.setVisible(True)
self.center()
self.saveLayout(environ["config"] + "defaultLayout")
self.defaultLayout = True
if options["restore"]:
self.loadLayout()
self.defaultLayout = False
self.loadProject()
atexit.register(self.cleanup)
def divide(canvas, rectangles):
if (len(rectangles) < 1):
canvasnotused.append(canvas)
return
for j in range(len(rectangles)):
flag, rectangles[j] = uc.fitin(canvas, rectangles[j])
if (flag):
rectangles[j].x = canvas.x
rectangles[j].y = canvas.y
rectangles[j].xx = rectangles[j].x + rectangles[j].w
rectangles[j].yy = rectangles[j].y + rectangles[j].h
rectangles[j].sheet = canvas.order
#Corte inferior
c1 = c.Canvas(rectangles[j].xx, rectangles[j].y,
canvas.w - rectangles[j].w, canvas.h, ORDER)
c2 = c.Canvas(rectangles[j].x, rectangles[j].yy,
rectangles[j].w, canvas.h - rectangles[j].h,
ORDER)
"""
#Corte lateral
c1 = c.Canvas(rectangles[j].xx, rectangles[j].y,
canvas.w-rectangles[j].w, rectangles[j].h, ORDER)
c2 = c.Canvas(rectangles[j].x, rectangles[j].yy,
canvas.w, canvas.h-rectangles[j].h, ORDER)
"""
if not (rectangles[j] in cutted):
cutted.append(rectangles[j])
rectangles.remove(rectangles[j])
divide(c1, rectangles)
divide(c2, rectangles)
return
canvasnotused.append(canvas)
def initUI(self):
self.canvas = Canvas()
self.setCentralWidget(self.canvas)
self.initActions()
self.initMenu()
self.setWindowTitle("Draw Pixel")
self.resize(800, 600)
self.toolbar = QToolBar("Size Bar", self)
self.toolbar.addAction("PlaceHolder")
self.sizeSlider = QSlider(self)
self.toolbar.addWidget(self.sizeSlider)
def render_world(self, world, verbose=False):
image = Canvas.Canvas(int(self.hsize), int(self.vsize))
for y in range(0, int(self.vsize)):
for x in range(0, int(self.hsize)):
ray = self.ray_for_pixel(x, y)
colour = world.colour_at(ray)
image.write_pixel(x, y, colour)
if verbose:
sys.stdout.write(".")
sys.stdout.flush()
if verbose:
sys.stdout.write(str(y))
sys.stdout.write("\n")
sys.stdout.flush()
return image
def closeTopology(self):
"""
Close the current topology.
"""
if self.running:
self.log.append(
"You cannot close a topology when one is still running!")
return False
scene = self.canvas.scene()
if scene and scene.items():
reply = QtGui.QMessageBox.warning(
self, self.tr(Core.globals.PROG_NAME),
self.tr("Save before closing?"), QtGui.QMessageBox.Yes
| QtGui.QMessageBox.No | QtGui.QMessageBox.Cancel)
if reply == QtGui.QMessageBox.Yes:
if not self.saveTopology():
return False
elif reply == QtGui.QMessageBox.No:
pass
else:
return False
if isinstance(mainWidgets["canvas"], Tutorial):
self.canvas = Canvas(self)
mainWidgets["canvas"] = self.canvas
self.tabWidget.removeTab(0)
self.tabWidget.addTab(self.canvas, "Default Project")
self.project = ""
self.unlockDocks()
self.filename = ""
scene = Scene(self.canvas)
scene.setItemIndexMethod(QtGui.QGraphicsScene.NoIndex)
self.canvas.setScene(scene)
self.expansions = 0
for nodeType in nodeTypes.keys():
itemTypes = nodeTypes[nodeType]
itemTypes[nodeType] = 0
self.properties.clear()
self.interfaces.clear()
self.routes.clear()
return True
def __init__(self):
pygame.init()
pygame.display.set_caption("Fever Fighter")
self.clock = pygame.time.Clock()
self.game_canvas = Canvas.Canvas(self, 800, 600)
self.input_handler = InputHandler.InputHandler(self)
self.player = Player.Player(100, 100, 30, 30, 100, 100)
#self.enemy = Enemy.Enemy()
self.entities = []
self.entities.append(self.player)
#self.entities.append(enemy)
self.running = True
self.wave = Waves.Waves()
def createWidgets(self):
self.QUIT = Button(self)
self.QUIT["text"] = "QUIT"
self.QUIT["fg"] = "red"
self.QUIT["command"] = self.quit
self.QUIT.pack({"side": "left"})
self.hi_there = Button(self)
self.hi_there["text"] = "Hello",
self.hi_there["command"] = self.say_hi
self.hi_there.pack({"side": "left"})
#c = Tkinter.Canvas()
c = Canvas()
line = Canvas.Line(c, 1, 1, 2, 2)
def initialize_create_canvas(self):
import Canvas
# create a new canvas for each frame
self.create_canvas = Canvas.Canvas()
alen = None
# dims = self.vcs_self.canvasinfo()
dims = self.canvas_info
if dims['height'] < 500:
factor = 2
else:
factor = 1
if dims["width"] < dims["height"]:
self.create_canvas.portrait(width=dims["width"],
height=dims["height"])
self.create_canvas.setbgoutputdimensions(width=dims['width'] * factor,
height=dims['height'] *
factor,
units='pixel')
def openImage(self,
path,
bitDepth=16,
enableAutoWB=False,
brightness=20,
blackLevel=50):
if not path == '':
canvas = Canvas(self, self.config)
self.connectCanvas(canvas)
self.canvasScaleFactorChanged.emit(self.scaleFactor)
img_array = self.loadImage(canvas, path, bitDepth, enableAutoWB,
brightness, blackLevel)
self.photoList.append(img_array)
self.pathList.append(path)
self.mainTab.addTab(canvas, os.path.basename(path))
self.mainTab.setCurrentIndex(self.mainTab.count() - 1)
canvas.fitCanvas()
canvas.toggleMode(self._mode)
self.currentPath = path
self.fileOpened.emit(path)
def __init__(self):
pygame.init()
self.FPS = 40
self.is_running = True
self.sizes = [1280, 720]
self.background_color = pygame.Color("white")
self.display = pygame.display.set_mode(self.sizes)
pygame.display.set_caption("Graph editor")
self.canvas = Canvas.Canvas(position=[200, 0], sizes=[1080, 720])
self.sidebar = Sidebar.Sidebar(position=[0, 0], sizes=[200, 720])
self.is_mouse_dragging = False
self.state = "move_graph"
self.frame_duration = 0.5
self.frame_time = 0
self.run()
def __init__(self, root):
self.root = root
# make a frame and a canvas and some buttons
frame = Frame(self.root)
frame.pack(fill=X)
label = Label(frame, text="Canvas test")
label.pack()
self.canvas = Canvas(frame, bg="grey", width=600, height=600)
self.canvas.pack()
cmd = Button(frame, text="Scale", command=self.scale)
cmd.pack()
self.groups = []
for i in range(self.layers):
self.groups.append(Group(self.canvas))
# time the creation of the rectangles
start = time()
self.makeShapes()
print "Took ", time(
) - start, " seconds to make", self.layers, "layers"
def make2DPlot(queue,
lumi,
var,
name,
nbinx,
xmin,
xmax,
nbiny,
ymin,
ymax,
xlabel,
ylabel,
tree,
cuts,
outtag='',
options='colz',
normed=False):
if queue:
launchToQueue('make2DPlot', queue, name, outtag)
else:
h = tree.getTH2F(lumi, name, var, nbinx, xmin, xmax, nbiny, ymin, ymax,
cuts, options, xlabel, ylabel)
### TH2F tunning
h.GetZaxis().SetLabelSize(0.03)
plot = Canvas.Canvas('hist_' + name, 'png', 0.34, 0.68, 0.9, 0.9, 2)
plot.addHisto(h, options, '', '', False, 1, 0)
outdir = os.path.dirname(os.path.abspath(
__main__.__file__)) + '/2DPlots_' + outtag + '/'
plot.save(0, 0, 0, lumi, '', outputDir=outdir, zlog=True)
bg = "bg.gif"
width = 9
height = 9
from Tkinter import *
from Canvas import * #Not availible on Python 3k: anyone willing to port this program to Tkinter.Canvas methods are welcome
try:
from ImageTk import *
except ImportError:
pass
root = Tk()
rootc = Canvas(root,
width=16 * width + 3 + 7 + 16 + 16 + 16,
height=16 * height + 6 + 13)
rootc.pack(expand=1, fill=BOTH)
for n, v in enumerate(normtiles):
normtiles[n] = PhotoImage(file=v)
wildcard = PhotoImage(file=wildcard)
dunce = PhotoImage(file=dunce)
bg = PhotoImage(file=bg)
canvasf = Frame(rootc, border=1, relief=RAISED)
canvas = Canvas(canvasf, width=16 * width, height=16 * height)
canvas.pack(expand=1, fill=BOTH)
canvasW = Window(rootc, 0, 0, anchor=NW, window=canvasf)
guess_point()
#Detecte le space bar et fait action en conséquence
def appuye_space(d):
entraine_point()
#Detecte enter et fait action en conséquence
def appuye_enter(d):
while 1:
entraine_point()
canvas = Canvas.Canvas(canvas_width, canvas_height, clique_gauche,
clique_molette, clique_droit, appuye_space,
appuye_enter)
#Cree le nombre de pt demandé et les affiches
def cree_point(nb):
for i in range(0, nb):
point_cree = Point.Point(canvas_width, canvas_height)
canvas.cree_cercle(point_cree.coord, 25, "grey", point_cree.label)
points_actif.append(point_cree)
canvas.cree_ligne(canvas_width, canvas_height, 5)
#Le Perceptron fait un guess sur la position des points
def guess_point():
nb_erreur = 0
print ("morph.py firstPolygon secondPolygon")
sys.exit(-1)
# TODOS:
# - read in polygons
# - transform from local into global coordinate system
# - make both polygons contain same number of points
# create main window
mw = Tk()
mw._root().wm_title("Morphing")
# create and position canvas and buttons
cFr = Frame(mw, width=width, height=height, relief="sunken", bd=1)
cFr.pack(side="top")
can = Canvas(cFr, width=width, height=height)
can.pack()
cFr = Frame(mw)
cFr.pack(side="left")
bClear = Button(cFr, text="backward", command=backward)
bClear.pack(side="left")
bClear = Button(cFr, text="forward", command=forward)
bClear.pack(side="left")
eFr = Frame(mw)
eFr.pack(side="right")
bExit = Button(eFr, text="Quit", command=(lambda root=mw: quit(root)))
bExit.pack()
draw()
fileZ = open("polygonZ.dat")
