def btn_submit_click(self, **event_args):
if len(self.newvalues) > 0:
draw.clear_canvas(self.canvas, "#fff")
if self.check_blur.checked:
self.newvalues = self.gauss_blur(self.newvalues)
mark = self.check() * 100
self.lbl_mark.text = str(repr(mark)) + "%"
colour = "#198dbf"
if mark > self.pass_mark:
self.lbl_mark.text += "\nWell done!"
else:
colour = "#fff"
self.lbl_mark.text += "\nScore over {0}% to pass".format(
self.pass_mark)
self.graph.plot(xmarker=self.graph.xmarker / self.graph.xu,
ymarker=self.graph.ymarker / self.graph.yu,
colour=colour)
self.graph2 = draw.graph_plot(self.canvas, self.newvalues)
self.graph2.axes_enabled = False
self.graph2.xlabel = self.xlabel
self.graph2.ylabel = self.ylabel
self.graph2.xrange = self.graph.xrange
self.graph2.yrange = self.graph.yrange
self.graph2.plot(colour="rgb(214, 106, 72)",
xmarker=self.graph.xmarker / self.graph.xu,
ymarker=self.graph.ymarker / self.graph.yu)
def timer_tick (self, **event_args):
# This method is called Every [interval] seconds
dt = self.dt
canvas = self.canvas
self.cw = canvas.get_width()
self.ch = canvas.get_height()
cw= self.cw
ch = self.ch
xu = self.xu
draw.clear_canvas(canvas, "#fff")
if self.running:
angmom = self.earth.radius**2*self.earth.ang_vel+self.moon.orbit**2*self.moon.ang_vel
self.earth.move(self.dt)
self.marker.move(self.dt)
self.moon.move(self.dt)
self.tides.move(self.dt)
veldif = (self.earth.ang_vel - self.moon.ang_vel)
self.moon.orbit += veldif*self.ladj*math.pow(self.moon.orbit, 1.5)*dt
self.moon.ang_vel = (angmom- self.earth.radius**2*self.earth.ang_vel)/(self.moon.orbit**2)
self.earth.ang_vel = (angmom - self.moon.orbit**2*self.moon.ang_vel)/(self.earth.radius**2)
self.tides.ang_vel = self.moon.ang_vel
if self.moon.orbit - self.moon.radius <= self.earth.radius or self.moon.orbit > math.sqrt((cw/xu)**2 + (ch/xu)**2)/2:
self.running = False
self.btn_run.text = "Run"
self.draw_all()
def btn_clear_click(self, **event_args):
draw.reset2(self.canvas, 1)
draw.clear_canvas(self.canvas, "#fff")
self.graph.plot(xmarker=self.graph.xmarker / self.graph.xu,
ymarker=self.graph.ymarker / self.graph.yu,
colour="#fff")
self.newvalues = []
def draw_all(self):
canvas = self.canvas
self.cw = canvas.get_width()
self.ch = canvas.get_height()
cw = self.cw
ch = self.ch
xu = self.xu
ball = self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#fff")
canvas.fill_style = "#000"
canvas.fill_rect(0, 0, cw, self.floor_height)
draw.circle(canvas, ball.radius, ball.pos.x, ball.pos.y)
canvas.fill_style = "#3683f3"
canvas.fill()
#arrow
if not self.running:
ball = self.ball
#velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
canvas.rotate(ball.vel.phi())
draw.arrow(canvas,
ball.vel.mag() * self.arrow_scale, 4 * self.linewidth)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
#dashes
if not self.running:
draw.paths(canvas, self.paths, self.linewidth, "#000")
def draw_all(self):
canvas = self.canvas
cw = self.cw
ch = self.ch
xu = self.xu
ball = self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#7ec0ee")
#floor
canvas.fill_style = "#1f8107"
canvas.fill_rect(0, 0, cw / self.xu, self.floor_height)
#pole
canvas.fill_style = "rgb(111, 62, 55)"
canvas.fill_rect(self.L + self.ball.radius, self.floor_height, self.D,
3)
canvas.translate(self.L + self.ball.radius - 0.05,
3 + self.floor_height)
canvas.rotate(-math.pi / 2)
draw.polygon(canvas, 3, self.D * 6)
canvas.fill_style = "rgb(227, 81, 61)"
canvas.fill()
draw.reset2(canvas, xu)
#ball
draw.circle(canvas, ball.radius, ball.pos.x, ball.pos.y)
canvas.fill_style = "#fff"
canvas.fill()
#arrow
if not self.running:
ball = self.ball
#velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
if ball.vel.y > 0:
canvas.rotate(ball.vel.phi())
else:
canvas.rotate(-ball.vel.phi())
draw.arrow(canvas,
ball.vel.mag() * self.arrow_scale, 4 * self.line_width)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
#dashes
canvas.begin_path()
if not self.running:
for path in self.paths:
if len(path) > 2:
for i in range(len(path) - 1):
canvas.move_to(path[i].x, path[i].y)
diff = path[i + 1] - path[i]
new = path[i] + diff * 0.8
canvas.line_to(new.x, new.y)
canvas.line_width = self.line_width
canvas.stroke()
def cleanup(self):
"""Cleanup the GUI (restore default state)."""
GD.debug('GUI cleanup')
self.drawlock.release()
GD.canvas.cancel_selection()
draw.clear_canvas()
self.setBusy(False)
def draw_frame(self, canvas, balls):
#draws border, arrows and balls on to canvas
cw = self.cw
ch = self.ch
xu = self.xu
#reset canvas
draw.reset2(canvas, xu)
#clear canvas
draw.clear_canvas(canvas, "#fff")
#balls
for i in range(0, 2):
if i % 2 == 0:
canvas.fill_style = "#4c7fbe"
else:
canvas.fill_style = "#bb2828"
draw.circle(canvas, balls[i].radius, balls[i].pos.x,
balls[i].pos.y)
canvas.fill()
#borders
canvas.stroke_style = "#000"
canvas.line_width = self.border / xu
canvas.stroke_rect(0, 0, cw / (1.0 * xu), ch / (1.0 * xu))
#arrows
if not self.running and self.check_vel.checked:
for ball in balls:
draw.vel_arrows(canvas, ball, self.linewidth, self.arrow_scale)
draw.reset2(canvas, xu)
def draw_frame(self, canvas, balls):
#draws border, arrows and balls on to canvas
cw = self.cw
ch = self.ch
xu= self.xu
#reset canvas
draw.reset2(canvas,xu)
#clear canvas
draw.clear_canvas(canvas, "#fff")
#balls
for i in range(0,2):
if i%2 == 0:
canvas.fill_style = "#4c7fbe"
else:
canvas.fill_style ="#bb2828"
draw.circle(canvas, balls[i].radius,balls[i].pos.x, balls[i].pos.y)
canvas.fill()
#borders
canvas.stroke_style = "#000"
canvas.line_width = self.border/xu
canvas.stroke_rect(0,0, cw/(1.0*xu),ch/(1.0*xu))
#arrows
if not self.running and self.check_vel.checked:
for ball in balls:
draw.vel_arrows(canvas, ball, self.linewidth, self.arrow_scale)
draw.reset2(canvas, xu)
def initial(self, canvas):
draw.reset2(canvas, self.xu)
draw.clear_canvas(canvas, "#fff")
self.draw_polygon(canvas, self.N, self.L)
self.bug.pos = physics.vector3(-self.L/2, self.d, 0)
draw.reset2(canvas, self.xu)
self.draw_bugs(canvas, self.bug.pos, "#2a2ac7")
draw.reset2(canvas, self.xu)
def initial(self, canvas):
draw.reset2(canvas, self.xu)
draw.clear_canvas(canvas, "#fff")
self.draw_polygon(canvas, self.N, self.L)
self.bug.pos = physics.vector3(-self.L / 2, self.d, 0)
draw.reset2(canvas, self.xu)
self.draw_bugs(canvas, self.bug.pos, "#2a2ac7")
draw.reset2(canvas, self.xu)
def btn_submit_click(self, **event_args):
self.grid_stat.clear()
self.grid_x_int.clear()
self.grid_y_int.clear()
self.lbl_mark.background = "#fff"
if len(self.all) > 0:
draw.clear_canvas(self.canvas, "#fff")
self.newvalues = self.gauss_blur(self.all)
mark = self.check()*100
#self.lbl_mark.text = str(repr(mark)) + "%"
# colour = "#198dbf"
# if mark >self.pass_mark:
# self.lbl_mark.text += "\nWell done!"
# else:
# colour = "#fff"
# self.lbl_mark.text += "\nScore over {0}% to pass".format(self.pass_mark)
#self.graph.plot()
self.graph2 = draw.graph_plot(self.canvas, self.newvalues)
self.graph2.axes_enabled = True
self.graph2.markers_enabled = False
self.graph2.xlabel = self.xlabel
self.graph2.ylabel = self.ylabel
self.graph2.xrange = self.graph.xrange
self.graph2.yrange = self.graph.yrange
self.graph2.plot(colour = "rgb(214, 106, 72)", xmarker = self.xmarker, ymarker = self.ymarker)
# diffd = self.gauss_blur([diffd],10)
# self.graph3 = draw.graph_plot(self.canvas, diffd)
# self.graph3.axes_enabled = False
# self.graph3.xlabel = self.graph2.xlabel
# self.graph3.ylabel = self.graph2.ylabel
# self.graph3.xrange = self.graph2.xrange
# self.graph3.yrange = self.graph2.yrange
# #self.graph3.plot()
#
# diffd2 = physics.diff_5(diffd)
# diffd2 = self.gauss_blur([diffd2],10)
# self.graph4 = draw.graph_plot(self.canvas, diffd2)
# self.graph4.axes_enabled = False
# self.graph4.xlabel = self.graph2.xlabel
# self.graph4.ylabel = self.graph2.ylabel
# self.graph4.xrange = self.graph2.xrange
# self.graph4.yrange = self.graph2.yrange
#self.graph4.plot(colour = "rgb(52, 195, 96)")
self.graph2.circle_points(zip(self.test_x_ints, [0]*len(self.test_x_ints)), "#336888")
self.graph2.circle_points(zip([0]*len(self.test_y_ints), self.test_y_ints), "#D69648", pointoffset = len(self.test_x_ints))
self.graph2.circle_points(self.teststats, "#339664", pointoffset = len(self.test_x_ints) + len(self.test_y_ints))
def draw_all(self):
canvas = self.canvas
cw= self.cw
ch = self.ch
xu = self.xu
ball= self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#7ec0ee")
#floor
canvas.fill_style = "#1f8107"
canvas.fill_rect(0, 0,cw/self.xu , self.floor_height)
#pole
canvas.fill_style = "rgb(111, 62, 55)"
canvas.fill_rect(self.L+self.ball.radius, self.floor_height, self.D, 3)
canvas.translate(self.L+self.ball.radius-0.05, 3+self.floor_height)
canvas.rotate(-math.pi/2)
draw.polygon(canvas,3, self.D*6)
canvas.fill_style = "rgb(227, 81, 61)"
canvas.fill()
draw.reset2(canvas, xu)
#ball
draw.circle(canvas, ball.radius, ball.pos.x, ball.pos.y)
canvas.fill_style= "#fff"
canvas.fill()
#arrow
if not self.running:
ball = self.ball
#velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
if ball.vel.y>0:
canvas.rotate(ball.vel.phi())
else:
canvas.rotate(-ball.vel.phi())
draw.arrow(canvas, ball.vel.mag()*self.arrow_scale, 4*self.line_width)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
#dashes
canvas.begin_path()
if not self.running:
for path in self.paths:
if len(path)>2:
for i in range(len(path)-1):
canvas.move_to(path[i].x, path[i].y)
diff = path[i+1] - path[i]
new = path[i] + diff*0.8
canvas.line_to(new.x, new.y)
canvas.line_width = self.line_width
canvas.stroke()
def draw_frame(self, canvas, balls):
#draws border, arrows and balls on to canvas
cw = self.cw
ch = self.ch
xu = self.xu
#reset canvas
draw.reset2(canvas, xu)
#clear canvas
draw.clear_canvas(canvas, "#fff")
#balls
for i in range(0, 2):
if i % 2 == 0:
canvas.fill_style = "#4c7fbe"
else:
canvas.fill_style = "#bb2828"
draw.circle(canvas, balls[i].radius, balls[i].pos.x,
balls[i].pos.y)
canvas.fill()
#borders
canvas.stroke_style = "#000"
canvas.line_width = self.border / xu
canvas.stroke_rect(0, 0, cw / (1.0 * xu), ch / (1.0 * xu))
#arrows
if not self.running and self.check_vel.checked:
for ball in balls:
#x component
draw.arrow(canvas, ball.vel.x * self.arrow_scale,
2 * self.linewidth, ball.pos.x, ball.pos.y)
canvas.fill_style = "#333333"
canvas.fill()
#y component
canvas.translate(ball.pos.x, ball.pos.y)
canvas.rotate(math.pi / 2)
draw.arrow(canvas, ball.vel.y * self.arrow_scale,
2 * self.linewidth)
canvas.fill()
draw.reset2(canvas, xu)
#velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
if ball.vel.y > 0:
canvas.rotate(ball.vel.phi())
else:
canvas.rotate(-ball.vel.phi())
draw.arrow(canvas,
ball.vel.mag() * self.arrow_scale,
4 * self.linewidth)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
def cleanup(self):
"""Cleanup the GUI (restore default state)."""
pf.debug('GUI cleanup',pf.DEBUG.GUI)
self.drawlock.release()
pf.canvas.cancel_selection()
pf.canvas.cancel_draw()
draw.clear_canvas()
#draw.wakeup()
self.setBusy(False)
def btn_clear_click (self, **event_args):
draw.reset2(self.canvas, 1)
draw.clear_canvas(self.canvas, "#fff")
self.newvalues = []
self.all = []
self.graph.func(self.startvals)
self.lbl_mark.text = ""
self.lbl_mark.background = "#fff"
self.graph.plot(colour = "#fff", xmarker = self.xmarker, ymarker = self.ymarker)
def btn_clear_click (self, **event_args):
draw.reset2(self.canvas, 1)
draw.clear_canvas(self.canvas, "#fff")
self.graph2.plot(colour = "#fff", xmarker = self.xmarker, ymarker = self.ymarker)
self.newvalues = []
self.all = []
self.grid_stat.clear()
self.grid_x_int.clear()
self.grid_y_int.clear()
self.lbl_mark.text = ""
self.lbl_mark.background = "#fff"
self.started = False
def draw_frame(self, canvas, balls):
# draws border, arrows and balls on to canvas
cw = self.cw
ch = self.ch
xu = self.xu
# reset canvas
draw.reset2(canvas, xu)
# clear canvas
draw.clear_canvas(canvas, "#fff")
# balls
for i in range(0, 2):
if i % 2 == 0:
canvas.fill_style = "#4c7fbe"
else:
canvas.fill_style = "#bb2828"
draw.circle(canvas, balls[i].radius, balls[i].pos.x, balls[i].pos.y)
canvas.fill()
# borders
canvas.stroke_style = "#000"
canvas.line_width = self.border / xu
canvas.stroke_rect(0, 0, cw / (1.0 * xu), ch / (1.0 * xu))
# arrows
if not self.running and self.check_vel.checked:
for ball in balls:
# x component
draw.arrow(canvas, ball.vel.x * self.arrow_scale, 2 * self.linewidth, ball.pos.x, ball.pos.y)
canvas.fill_style = "#333333"
canvas.fill()
# y component
canvas.translate(ball.pos.x, ball.pos.y)
canvas.rotate(math.pi / 2)
draw.arrow(canvas, ball.vel.y * self.arrow_scale, 2 * self.linewidth)
canvas.fill()
draw.reset2(canvas, xu)
# velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
if ball.vel.y > 0:
canvas.rotate(ball.vel.phi())
else:
canvas.rotate(-ball.vel.phi())
draw.arrow(canvas, ball.vel.mag() * self.arrow_scale, 4 * self.linewidth)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
def draw_all(self):
canvas = self.canvas
xu = self.xu
canvas.xu = xu
ball = self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#fff")
#ball
drawrad = ball.radius*(1/(1+ball.pos.z/3))
if 0.01>drawrad or drawrad>10:
self.running = False
self.btn_run.text = "Run"
else:
draw.circle(canvas, drawrad, ball.pos.x, ball.pos.y)
canvas.fill_style = "rgb(30, 96, 139)"
canvas.fill()
if self.running and self.check_trail.checked:
b = len(self.trail)
canvas.begin_path()
canvas.move_to(self.trail[0].x, self.trail[0].y)
canvas.quadratic_curve_to(self.trail[int(b/2)].x, self.trail[int(b/2)].y, self.trail[-1].x, self.trail[-1].y)
canvas.line_width = 0.03
canvas.stroke()
#paths
if not self.running and self.check_paths.checked:
draw.paths(canvas,self.paths, self.line_width, "#000")
#arrows
if not self.running:
draw.vel_arrows(canvas, self.ball, self.line_width, self.arrow_scale)
draw.reset2(canvas, xu)
#field arrows
canvas.scale(1.0/self.xu, 1.0/self.xu)
draw.cart_arrows(canvas, self.E, 3, 100/((self.E.mag()+1)), x = 30, y = 50)
B2 = self.B*10e3
draw.cart_arrows(canvas, B2, 3, 100/((B2.mag()+1)), x = (self.cw - 80), y = 50)
canvas.scale(1,-1)
canvas.font= "20px sans-serif"
canvas.fill_text("E",50, -30 )
canvas.fill_text("B",(self.cw - 60), -30 )
canvas.scale(self.xu, -self.xu)
#frame
draw.border(canvas,5, "#000", xu)
def draw_all(self):
canvas = self.canvas
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
big = math.sqrt((self.cw / self.xu * 1.0)**2 +
(self.ch / self.xu * 1.0)**2)
for point in self.points:
point.vel.x = self.spd_slider.value * 0.1
self.draw_source(point, self.canvas)
for point in self.pulses:
if point.wavefront > big:
self.pulses.remove(point)
else:
self.draw_source(point, self.canvas, colour="#fff")
def draw_all(self):
canvas = self.canvas
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
self.wav = self.slid_wav.value
# div = self.cw/(self.xu*10.0)
# canvas.begin_path()
# for i in range(10):
# canvas.move_to(i*div, 0)
# canvas.line_to(i*div, self.ch/(self.xu*1.0))
#
# canvas.line_width = 0.003
# canvas.stroke()
for point in self.points:
self.draw_source(point, self.canvas)
def draw_all(self):
canvas = self.canvas
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
big = math.sqrt((self.cw/self.xu*1.0)**2 + (self.ch/self.xu*1.0)**2)
for point in self.points:
point.vel.x = self.spd_slider.value*0.1
self.draw_source(point, self.canvas)
for point in self.pulses:
if point.wavefront >big:
self.pulses.remove(point)
else:
self.draw_source(point, self.canvas, colour = "#fff")
def draw_all(self):
canvas = self.canvas
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
self.wav = self.slid_wav.value
# div = self.cw/(self.xu*10.0)
# canvas.begin_path()
# for i in range(10):
# canvas.move_to(i*div, 0)
# canvas.line_to(i*div, self.ch/(self.xu*1.0))
#
# canvas.line_width = 0.003
# canvas.stroke()
for point in self.points:
self.draw_source(point, self.canvas)
def initial(self, canvas):
draw.reset2(canvas, self.xu)
draw.clear_canvas(canvas, "#fff")
self.N = self.slid_N.value
self.L = self.slid_L.value
self.v = self.slid_v.value
self.draw_polygon(canvas, self.N, self.L)
if self.reset:
self.bug.pos = physics.vector3(-self.L/2, self.d, 0)
self.path = [self.bug.pos, self.bug.pos]
draw.reset2(canvas, self.xu)
self.draw_bugs(canvas, self.bug.pos, "#2a2ac7")
# for i in range(len(self.path)-1):
# canvas.begin_path()
# canvas.move_to(self.path[i].x, self.path[i].y)
# canvas.line_to(self.path[i+1].x, self.path[i+1].y)
# canvas.stroke()
draw.reset2(canvas, self.xu)
def draw_all(self):
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
N = int(self.slits.N_slider.value)
d = float(self.slits.d_slider.value)
a = float(self.single.a_slider.value)
n = float(self.grating.n_slider.value)
if self.aperture == "slits":
if self.rad_int.selected:
self.draw_slit_int(N,d,a, self.wav)
elif self.rad_pat.selected:
self.draw_slit_pat(N,d,a, self.wav)
elif self.aperture == "single":
if self.rad_int.selected:
self.draw_slit_int(N,d,a, self.wav, "single")
elif self.rad_pat.selected:
self.draw_slit_pat(N,d,a, self.wav, "single")
elif self.aperture == "grating":
self.draw_grating(n, self.wav)
def draw_all(self):
draw.reset2(self.canvas, self.xu)
draw.clear_canvas(self.canvas, "#fff")
N = int(self.slits.N_slider.value)
d = float(self.slits.d_slider.value)
a = float(self.single.a_slider.value)
n = float(self.grating.n_slider.value)
if self.aperture == "slits":
if self.rad_int.selected:
self.draw_slit_int(N, d, a, self.wav)
elif self.rad_pat.selected:
self.draw_slit_pat(N, d, a, self.wav)
elif self.aperture == "single":
if self.rad_int.selected:
self.draw_slit_int(N, d, a, self.wav, "single")
elif self.rad_pat.selected:
self.draw_slit_pat(N, d, a, self.wav, "single")
elif self.aperture == "grating":
self.draw_grating(n, self.wav)
def btn_check_click(self, **event_args):
tol = 100
corr_x_ints = self.corr_x_ints
corr_y_ints = self.corr_y_ints
corr_x_stat = zip(*self.corrstats)[0]
corr_y_stat = zip(*self.corrstats)[1]
ent_x_ints = graphs.extract_vals(self.x_int_box)
ent_y_ints = graphs.extract_vals(self.y_int_box)
ent_x_stat = graphs.extract_vals(self.x_stat_box)
ent_y_stat = graphs.extract_vals(self.y_stat_box)
score = graphs.val_compare(ent_x_ints, corr_x_ints) + graphs.val_compare(ent_y_ints, corr_y_ints)
score += graphs.val_compare(ent_x_stat, corr_x_stat) + graphs.val_compare(ent_y_stat, corr_y_stat)
score *= 100/4
self.lbl_mark.text = "{0}%".format(round(score))
self.lbl_mark.background = "#fff"
#TODO pass mark checking
if score >self.pass_mark:
self.lbl_mark.text += "\nWell done!"
else:
self.lbl_mark.text += "\nScore over {0}% to pass".format(self.pass_mark)
draw.reset2(self.canvas, 1)
draw.clear_canvas(self.canvas)
self.graph.plot(colour = "rgb(214, 106, 72)", xmarker = self.xmarker, ymarker = self.ymarker)
xlabs = [x.text for x in self.x_int_box]
ylabs = [x.text for x in self.y_int_box]
statlabs = ["({0}, {1})".format(self.x_stat_box[i].text, self.y_stat_box[i].text) for i in range(len(self.x_stat_box))]
self.graph.circle_points(zip(self.test_x_ints, [0]*len(self.test_x_ints)), self.x_circle, pointlabels = xlabs)
self.graph.circle_points(zip([0]*len(self.test_y_ints), self.test_y_ints), self.y_circle, pointlabels = ylabs, pointoffset = len(xlabs))
self.graph.circle_points(self.teststats, self.stat_circle, pointlabels = statlabs, pointoffset = len(xlabs) + len(ylabs))
def btn_submit_click(self, **event_args):
self.grid_stat.clear()
self.grid_x_int.clear()
self.grid_y_int.clear()
self.lbl_mark.background = "#fff"
if len(self.all) > 0:
draw.clear_canvas(self.canvas, "#fff")
self.newvalues = graphs.gauss_blur(self.all)
self.graph.func(self.newvalues)
self.drawn_process()
self.graph.plot(colour = "rgb(214, 106, 72)", xmarker = self.xmarker, ymarker = self.ymarker)
self.graph.circle_points(zip(self.test_x_ints, [0]*len(self.test_x_ints)), self.x_circle)
self.graph.circle_points(zip([0]*len(self.test_y_ints), self.test_y_ints), self.y_circle, pointoffset = len(self.test_x_ints))
self.graph.circle_points(self.teststats, self.stat_circle, pointoffset = len(self.test_x_ints) + len(self.test_y_ints))
def draw_all(self):
canvas = self.canvas
self.cw = canvas.get_width()
self.ch = canvas.get_height()
cw= self.cw
ch = self.ch
xu = self.xu
ball= self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#fff")
canvas.fill_style = "#000"
canvas.fill_rect(0, 0, cw, self.floor_height)
draw.circle(canvas, ball.radius, ball.pos.x, ball.pos.y)
canvas.fill_style= "#3683f3"
canvas.fill()
#arrow
if not self.running:
ball = self.ball
#velocity vector
canvas.translate(ball.pos.x, ball.pos.y)
if ball.vel.y>0:
canvas.rotate(ball.vel.phi())
else:
canvas.rotate(-ball.vel.phi())
draw.arrow(canvas, ball.vel.mag()*self.arrow_scale, 4*self.linewidth)
canvas.fill_style = "#49902a"
canvas.fill()
draw.reset2(canvas, xu)
#dashes
if not self.running:
draw.paths(canvas,self.paths, self.linewidth, "#000")
def btn_submit_click(self, **event_args):
if len(self.newvalues) > 0:
draw.clear_canvas(self.canvas, "#fff")
if self.check_blur.checked:
self.newvalues = self.gauss_blur(self.newvalues)
mark = self.check()*100
self.lbl_mark.text = str(repr(mark)) + "%"
colour = "#198dbf"
if mark >self.pass_mark:
self.lbl_mark.text += "\nWell done!"
else:
colour = "#fff"
self.lbl_mark.text += "\nScore over {0}% to pass".format(self.pass_mark)
self.graph.plot( xmarker = self.graph.xmarker/self.graph.xu, ymarker = self.graph.ymarker/self.graph.yu, colour = colour)
self.graph2 = draw.graph_plot(self.canvas, self.newvalues)
self.graph2.axes_enabled = False
self.graph2.xlabel = self.xlabel
self.graph2.ylabel = self.ylabel
self.graph2.xrange = self.graph.xrange
self.graph2.yrange = self.graph.yrange
self.graph2.plot(colour = "rgb(214, 106, 72)", xmarker = self.graph.xmarker/self.graph.xu, ymarker = self.graph.ymarker/self.graph.yu)
def draw(self):
canvas = self.canvas
draw.clear_canvas(canvas)
for comp in self.components:
comp.draw()
canvas.line_join = "round"
start = comp.outpos
if comp.output == None:
raise "Component not connected to anything {0}".format(comp.name)
end = comp.output.inpos
if start != None and end != None:
canvas.begin_path()
canvas.move_to(start[0], start[1])
if start[0] <= end[0]:
canvas.line_to(end[0], start[1])
else:
canvas.line_to(start[0], end[1])
canvas.line_to(end[0], end[1])
comp.draw_end()
def draw_all(self):
canvas = self.canvas
xu = self.xu
canvas.xu = xu
ball = self.ball
draw.reset2(canvas, xu)
draw.clear_canvas(canvas, "#fff")
#ball
drawrad = ball.radius * (1 / (1 + ball.pos.z / 3))
if 0.01 > drawrad or drawrad > 10:
self.running = False
self.btn_run.text = "Run"
else:
draw.circle(canvas, drawrad, ball.pos.x, ball.pos.y)
canvas.fill_style = "rgb(30, 96, 139)"
canvas.fill()
if self.running and self.check_trail.checked:
b = len(self.trail)
canvas.begin_path()
canvas.move_to(self.trail[0].x, self.trail[0].y)
canvas.quadratic_curve_to(self.trail[int(b / 2)].x,
self.trail[int(b / 2)].y,
self.trail[-1].x, self.trail[-1].y)
canvas.line_width = 0.03
canvas.stroke()
#paths
if not self.running and self.check_paths.checked:
draw.paths(canvas, self.paths, self.line_width, "#000")
#arrows
if not self.running:
draw.vel_arrows(canvas, self.ball, self.line_width,
self.arrow_scale)
draw.reset2(canvas, xu)
#field arrows
canvas.scale(1.0 / self.xu, 1.0 / self.xu)
draw.cart_arrows(canvas,
self.E,
3,
100 / ((self.E.mag() + 1)),
x=30,
y=50)
B2 = self.B * 10e3
draw.cart_arrows(canvas,
B2,
3,
100 / ((B2.mag() + 1)),
x=(self.cw - 80),
y=50)
canvas.scale(1, -1)
canvas.font = "20px sans-serif"
canvas.fill_text("E", 50, -30)
canvas.fill_text("B", (self.cw - 60), -30)
canvas.scale(self.xu, -self.xu)
#frame
draw.border(canvas, 5, "#000", xu)
def btn_check_click(self, **event_args):
score = 0
tol = 100
corr_x_ints = self.corr_x_ints
corr_y_ints = self.corr_y_ints
corrstats = self.corrstats
x_int_entries = self.x_int_entries
y_int_entries = self.y_int_entries
stat_entries = self.stat_entries
for i in range(len(corr_x_ints)):
if i< len(x_int_entries):
try:
test = float(x_int_entries[i].text)
except :
test = 0
gap = corr_x_ints[i] - test
add = 1 - math.sqrt(abs(gap/corr_x_ints[i]))
score += add if add>0 else 0
for i in range(len(corr_y_ints)):
if i< len(y_int_entries):
try:
test = float(y_int_entries[i].text)
except :
test = 0
gap = corr_y_ints[i] - test
add = 1-math.sqrt(abs(gap/corr_y_ints[i]))
score += add if add>0 else 0
for i in range(len(corrstats)):
if i< len(stat_entries):
try:
test = (float(stat_entries[i][0].text), float(stat_entries[i][1].text))
except:
test = 0
gapx = corrstats[i][0] - test[0]
gapy = corrstats[i][1] - test[1]
add = 1- math.sqrt(abs(gapx/(corrstats[i][0]))) - math.sqrt(abs(gapy/(corrstats[i][1])))
score += add if add>0 else 0
score *= 100/(len(corrstats) + len(corr_y_ints) + len(corr_x_ints))
self.lbl_mark.text = "{0}%".format(round(score))
colour = "#198dbf"
self.lbl_mark.background = "#fff"
if score >self.pass_mark:
self.lbl_mark.text += "\nWell done!"
else:
colour = "#fff"
self.lbl_mark.text += "\nScore over {0}% to pass".format(self.pass_mark)
draw.clear_canvas(self.canvas)
self.graph2.axes_enabled = True
self.graph2.plot(colour = "rgb(214, 106, 72)", xmarker = self.xmarker, ymarker = self.ymarker)
xlabs = [x.text for x in self.x_int_entries]
ylabs = [x.text for x in self.y_int_entries]
statlabs = ["({0}, {1})".format(x[0].text, x[1].text) for x in self.stat_entries]
self.graph.circle_points(zip(self.test_x_ints, [0]*len(self.test_x_ints)), "#336888", pointlabels = xlabs)
self.graph.circle_points(zip([0]*len(self.test_y_ints), self.test_y_ints), "D69648", pointlabels = ylabs, pointoffset = len(xlabs))
self.graph.circle_points(self.teststats, "#339664", pointlabels = statlabs, pointoffset = len(xlabs) + len(ylabs))
settings.change_size(index + 1)
return True
settings = Settings()
draw.draw_canvas(screen, settings.colors)
while True:
for event in pygame.event.get():
# Red X is clicked
if event.type == pygame.QUIT:
pygame.quit()
break
# Mouse down could be an attempt to draw or change colors
elif event.type == pygame.MOUSEBUTTONDOWN:
# Left click only
if event.button == 1:
if on_canvas(event.pos):
drawing(settings.current_color)
elif on_color_selector(event.pos):
settings.current_color = settings.colors[get_color_index(
event.pos)]
elif on_clear(event.pos):
draw.clear_canvas(screen)
elif on_size(event.pos):
print(f'New size is {settings.size}')
pygame.display.update()
def btn_clear_click (self, **event_args):
draw.reset2(self.canvas, 1)
draw.clear_canvas(self.canvas, "#fff")
self.graph.plot(xmarker = self.graph.xmarker/self.graph.xu, ymarker = self.graph.ymarker/self.graph.yu, colour = "#fff")
self.newvalues = []
def btn_submit_click(self, **event_args):
if len(self.all) > 0:
draw.clear_canvas(self.canvas, "#fff")
self.newvalues = graphs.gauss_blur(self.all)
tolx = 100/self.graph.xu
toly = 100/self.graph.yu
self.teststats = find_stationary(self.newvalues, tol = toly)
self.test_x_ints = find_intersecs(self.newvalues, tol = toly, x = True)
self.test_y_ints = find_intersecs(self.newvalues, tol = tolx, y = True)
self.lbl_mark.text = ""
numbers = True
if len(self.corrstats) != len(self.teststats):
self.lbl_mark.text += "Wrong number of stationary points"
self.lbl_mark.background = self.error_red
numbers = False
if len(self.corr_x_ints) != len(self.test_x_ints):
self.lbl_mark.text += "\nWrong number of x intersections"
self.lbl_mark.background = self.error_red
numbers = False
if len(self.corr_y_ints) != len(self.test_y_ints):
self.lbl_mark.text += "\nWrong number of y intersections"
self.lbl_mark.background = self.error_red
numbers = False
if numbers:
xquads = False
yquads = False
statquads = False
for i in range(len(self.test_x_ints)):
test = self.test_x_ints[i]
corr = self.corr_x_ints[i]
if test*corr<=0:
xquads = True
for i in range(len(self.test_y_ints)):
test = self.test_y_ints[i]
corr = self.corr_y_ints[i]
if test*corr<=0:
yquads = True
for i in range(len(self.teststats)):
test = self.teststats[i]
corr = self.corrstats[i]
if test[0]*corr[0]<=0 or test[1]*corr[1]<=0:
statquads = True
if xquads or yquads or statquads:
self.lbl_mark.background = self.error_red
if xquads:
self.lbl_mark.text += "\nWrong sign for x Intersection(s)"
if yquads:
self.lbl_mark.text += "\nWrong sign for y Intersection(s)"
if statquads:
self.lbl_mark.text += "\nStationary point(s) in wrong quadrant"
else:
mark = self.check()*100
self.lbl_mark.text = "{0}%".format(round(score))
self.lbl_mark.background = "#fff"
#TODO pass mark checking
if score >self.pass_mark:
self.lbl_mark.text += "\nWell done!"
else:
self.lbl_mark.text += "\nScore over {0}% to pass".format(self.pass_mark)
self.graph2 = draw.graph_plot(self.canvas, self.newvalues)
self.graph2.axes_enabled = True
self.graph2.xlabel = self.xlabel
self.graph2.ylabel = self.ylabel
self.graph2.xrange = self.graph.xrange
self.graph2.yrange = self.graph.yrange
self.graph2.plot(colour = self.draw_colour, xmarker = self.xmarker, ymarker = self.ymarker)
