def draw_triangle(x, y, size, num_remaining):
if num_remaining > 0:
canvas.set_fill_color(*shade_of(random.choice(palette.colors)))
canvas.set_stroke_color(*shade_of(random.choice(palette.colors)))
canvas.set_line_width(random.random() * 0.5 + 0.5)
step = math.sqrt(size**2 - (size / 2.0)**2)
canvas.move_to(x - step, y - (size / 2.0))
canvas.add_line(x, y + size)
canvas.add_line(x + step, y - (size / 2.0))
canvas.add_line(x - step, y - (size / 2.0))
canvas.fill_path()
canvas.draw_line(x - step, y - (size / 2.0), x, y + size)
canvas.draw_line(x, y + size, x + step, y - (size / 2.0))
canvas.draw_line(x + step, y - (size / 2.0), x - step,
y - (size / 2.0))
canvas.draw_line(x, y, x - (step / 2.0), y + (size / 4.0))
canvas.draw_line(x, y, x + (step / 2.0), y + (size / 4.0))
canvas.draw_line(x, y, x, y - (size / 2.0))
canvas.draw_line(x - (step / 2.0), y + (size / 4.0), x + (step / 2.0),
y + (size / 4.0))
canvas.draw_line(x + (step / 2.0), y + (size / 4.0), x,
y - (size / 2.0))
canvas.draw_line(x, y - (size / 2.0), x - (step / 2.0),
y + (size / 4.0))
draw_triangle(random.random() * width,
random.random() * height,
random.random() * triangle_side, num_remaining - 1)
def hexacircle(start_x, start_y):
r, g, b = random.choice(palette)
canvas.set_fill_color(r, g, b, random.random() * 0.75 + 0.25)
canvas.set_stroke_color(1.0, 1.0, 1.0, random.random() * 0.50 + 0.50)
canvas.set_line_width(random.random() * 0.75 + 0.25)
circle = (start_x - (0.5 * circle_size), start_y - (0.5 * circle_size),
circle_size, circle_size)
canvas.draw_ellipse(*circle)
canvas.fill_ellipse(*circle)
# draw lines
rstrokedline(start_x, start_y - circle_size, start_x,
start_y + circle_size)
rstrokedline(start_x - step, start_y, start_x + step, start_y)
rstrokedline(start_x - step, start_y - (0.5 * circle_size), start_x + step,
start_y + (0.5 * circle_size))
rstrokedline(start_x - step, start_y + (0.5 * circle_size), start_x + step,
start_y - (0.5 * circle_size))
rstrokedline(start_x - step, start_y + (1.5 * circle_size), start_x + step,
start_y - (1.5 * circle_size))
rstrokedline(start_x - step, start_y - (1.5 * circle_size), start_x + step,
start_y + (1.5 * circle_size))
rstrokedline(start_x - step, start_y + (2.5 * circle_size), start_x + step,
start_y - (2.5 * circle_size))
rstrokedline(start_x - step, start_y - (2.5 * circle_size), start_x + step,
start_y + (2.5 * circle_size))
rstrokedline(start_x - (3.0 * step), start_y + (0.5 * circle_size),
start_x + (3.0 * step), start_y - (0.5 * circle_size))
rstrokedline(start_x - (3.0 * step), start_y - (0.5 * circle_size),
start_x + (3.0 * step), start_y + (0.5 * circle_size))
def rstrokedline(start_x, start_y, end_x, end_y):
line_width = random.random() * 0.25 + 0.25
canvas.set_line_width(line_width)
r, g, b = palette.lightest
a = random.random() * 0.25 + 0.05
canvas.set_stroke_color(r, g, b, a)
canvas.draw_line(start_x, start_y, end_x, end_y)
def rstrokedline(start_x, start_y, end_x, end_y): line_width = random.random() * 0.25 + 0.25 canvas.set_line_width(line_width) r, g, b = palette.lightest a = random.random() * 0.25 + 0.05 canvas.set_stroke_color(r, g, b, a) canvas.draw_line(start_x, start_y, end_x, end_y)
def hexacircle(start_x, start_y):
r, g, b = random.choice(palette)
canvas.set_fill_color(r, g, b, random.random() * 0.75 + 0.25)
canvas.set_stroke_color(1.0, 1.0, 1.0, random.random() * 0.50 + 0.50)
canvas.set_line_width(random.random() * 0.75 + 0.25)
circle = (start_x - (0.5 * circle_size),
start_y - (0.5 * circle_size),
circle_size, circle_size)
canvas.draw_ellipse(*circle)
canvas.fill_ellipse(*circle)
# draw lines
rstrokedline(start_x, start_y - circle_size, start_x, start_y + circle_size)
rstrokedline(start_x - step, start_y, start_x + step, start_y)
rstrokedline(start_x - step, start_y - (0.5 * circle_size), start_x + step, start_y + (0.5 * circle_size))
rstrokedline(start_x - step, start_y + (0.5 * circle_size), start_x + step, start_y - (0.5 * circle_size))
rstrokedline(start_x - step, start_y + (1.5 * circle_size), start_x + step, start_y - (1.5 * circle_size))
rstrokedline(start_x - step, start_y - (1.5 * circle_size), start_x + step, start_y + (1.5 * circle_size))
rstrokedline(start_x - step, start_y + (2.5 * circle_size), start_x + step, start_y - (2.5 * circle_size))
rstrokedline(start_x - step, start_y - (2.5 * circle_size), start_x + step, start_y + (2.5 * circle_size))
rstrokedline(start_x - (3.0 * step), start_y + (0.5 * circle_size), start_x + (3.0 * step), start_y - (0.5 * circle_size))
rstrokedline(start_x - (3.0 * step), start_y - (0.5 * circle_size), start_x + (3.0 * step), start_y + (0.5 * circle_size))
def plot_spectra(self):
# calculate scale and axis label steps:
scale_x = (688.0 - 2 * self.x_offset) / (self.x_max - self.x_min)
scale_y = (688.0 - 2 * self.y_offset) / (self.y_max - self.y_min)
step_x = scale_x * (self.x_max - self.x_min) / 10
step_y = scale_y * (self.y_max - self.y_min) / 10
# Draw x and y axix:
canvas.set_stroke_color(0, 0, 0)
# x-axis
canvas.draw_line(self.x_offset, self.y_offset, 688, self.y_offset)
# y-axis
canvas.draw_line(self.x_offset, self.y_offset, self.x_offset, 688)
# label and mark the axes..
for i in range(11):
canvas.set_fill_color(0, 0, 0)
# x-axis...
label = self.x_axis_format.format(self.x_min + i *
(self.x_max - self.x_min) / 10)
canvas.draw_text(label,
self.x_offset + step_x * i,
0,
font_name='Helvetica',
font_size=16)
canvas.draw_line(self.x_offset + step_x * i, self.y_offset - 5,
self.x_offset + step_x * i, self.y_offset)
# y-axis...
label = self.y_axis_format.format(self.y_min + i *
(self.y_max - self.y_min) / 10)
canvas.draw_text(label,
0,
self.y_offset + step_y * i,
font_name='Helvetica',
font_size=16)
canvas.draw_line(self.x_offset - 5, self.y_offset + step_y * i,
self.x_offset, self.y_offset + step_y * i)
# draw each dataset...
for j in range(len(self.x_set)):
temp_x = []
temp_y = []
temp_colour = []
temp_x = self.x_set[j]
temp_y = self.y_set[j]
canvas.set_stroke_color(*self.spectrum_colour[j])
canvas.set_line_width(2)
canvas.move_to(self.x_offset + scale_x * (temp_x[0] - self.x_min),
self.y_offset + scale_y * (temp_y[0] - self.y_min))
for i in range(len(temp_x)):
draw_x = self.x_offset + scale_x * (temp_x[i] - self.x_min)
draw_y = self.y_offset + scale_y * (temp_y[i] - self.y_min)
if (self.style[j] == '-'):
canvas.add_line(draw_x, draw_y)
if (self.style[j] == 'o'):
canvas.add_ellipse(draw_x - 3, draw_y - 3, 6, 6)
canvas.draw_path()
def draw_grid(min_x, max_x, min_y, max_y): w, h = canvas.get_size() scale_x = w / (max_x - min_x) scale_y = h / (max_y - min_y) min_x, max_x = round(min_x), round(max_x) min_y, max_y = round(min_y), round(max_y) canvas.begin_updates() canvas.set_line_width(1) canvas.set_stroke_color(0.7, 0.7, 0.7) #Draw vertical grid lines: x = min_x while x <= max_x: if x != 0: draw_x = round(w / 2 + x * scale_x) + 0.5 canvas.draw_line(draw_x, 0, draw_x, h) x += 0.5 #Draw horizontal grid lines: y = min_y while y <= max_y: if y != 0: draw_y = round(h/2 + y * scale_y) + 0.5 canvas.draw_line(0, draw_y, w, draw_y) y += 0.5 #Draw x and y axis: canvas.set_stroke_color(0, 0, 0) canvas.draw_line(0, h/2, w, h/2) canvas.draw_line(w/2, 0, w/2, h) canvas.end_updates()
def draw_heart(outline = False): first = True for t in xrange(int(2*pi * detail)): t = t * detail # heart equation x = 16*(sin(t) ** 3) y = 13*cos(t) - 5*cos(2*t) - 2*cos(3*t) - cos(4*t) # scale result x = origin + x * scale y = origin + y * scale + scale*2 # hide first line if first: canvas.move_to(x, y) first = False else: canvas.add_line(x, y) # set color canvas.set_fill_color(1,0.5,0.5) canvas.set_stroke_color(0.5,0,0) canvas.set_line_width(detail/2) # draw heart if outline: canvas.draw_path() else: canvas.close_path() canvas.fill_path()
def createSpiral(arm1, arm2, color): """arm1 and arm2 are pairs of (length, velocity)""" canvas.begin_path() canvas.move_to(512, 684) x, y = 0, 0 len1, step1 = arm1 len2, step2 = arm2 global lines lines = [] previousPositions = [] while step1 > 10 or step2 > 10: step1 /= 2 step2 /= 2 global run run = 1 iteration = 1 inarow = 0 while run: iteration += 10 point1 = rotate((0,len1), x) point2 = map(sum,zip(rotate((0, len2), y), point1)) p2 = map(sum, zip(point2, (512, 384))) #Detection of whether pattern is repeating itself if point2 not in previousPositions: previousPositions.append(point2) inarow = 0 else: inarow += 1 if inarow >= 5: print "Pattern is detected to be repeating itself" run = 0 if x == 0: oldpoint2 = point2 else: canvas.add_line(p2[0], p2[1]) #lines.append( canvas.add_line(point1[0], point1[1]) ) #lines.append( canvas.add_line(point2[0], point2[1]) ) oldpoint2 = point2 x += step1 if x > 360: x -= 360 y += step2 if y > 360: y -= 360 #for line in lines: # canvas.delete(line) lines = [] time.sleep(0.005) canvas.close_path() canvas.set_line_width(1) canvas.draw_path()
def createSpiral(arm1, arm2, color):
"""arm1 and arm2 are pairs of (length, velocity)"""
canvas.begin_path()
canvas.move_to(512, 684)
x, y = 0, 0
len1, step1 = arm1
len2, step2 = arm2
global lines
lines = []
previousPositions = []
while step1 > 10 or step2 > 10:
step1 /= 2
step2 /= 2
global run
run = 1
iteration = 1
inarow = 0
while run:
iteration += 10
point1 = rotate((0,len1), x)
point2 = map(sum,zip(rotate((0, len2), y), point1))
p2 = map(sum, zip(point2, (512, 384)))
#Detection of whether pattern is repeating itself
if point2 not in previousPositions:
previousPositions.append(point2)
inarow = 0
else:
inarow += 1
if inarow >= 5:
print("Pattern is detected to be repeating itself")
run = 0
if x == 0:
oldpoint2 = point2
else:
canvas.add_line(p2[0], p2[1])
#lines.append( canvas.add_line(point1[0], point1[1]) )
#lines.append( canvas.add_line(point2[0], point2[1]) )
oldpoint2 = point2
x += step1
if x > 360: x -= 360
y += step2
if y > 360: y -= 360
#for line in lines:
# canvas.delete(line)
lines = []
time.sleep(0.005)
canvas.close_path()
canvas.set_line_width(1)
canvas.draw_path()
def backward(self, distance): sleep(DELAY) to = (self.pos[0] - sin(self.heading) * distance, self.pos[1] - cos(self.heading) * distance) if self.pen_is_down: set_line_width(self.pen_width) set_stroke_color(self.r_color, self.g_color, self.b_color) draw_line(self.pos[0], self.pos[1], to[0], to[1]) self.pos = to
def reset(): set_size(512, 512) set_line_width(3) set_stroke_color(0,0,0) draw_rect(0, 0, 512, 512) set_line_width(1) set_stroke_color(0, 0, 1) return True
def drawHand(width, length, angle): rads = radians(angle) endX = int(cos(angle) * length) + centerX endY = int(sin(angle) * length) + centerY canvas.save_gstate() canvas.set_stroke_color(0.0, 0.0, 0.0, 0.6) canvas.set_line_width(width) canvas.draw_line(centerX, centerY, endX, endY) canvas.restore_gstate()
def drawMinorTickmarks(): for i in range(60): canvas.save_gstate() canvas.translate(centerX, centerY) canvas.rotate(-2 * pi / 60.0 * i) canvas.set_fill_color(0.4, 0.4, 0.4, 0.6) width = 1 height = 5 canvas.set_line_width(1) canvas.draw_rect(-width/2, clockWidth * 0.505, width, height) canvas.restore_gstate()
def draw_tree(x, y, trunk_thickness, leaf_h, tree_w, trunk_h):
canvas.begin_path()
canvas.move_to(x - tree_w / 2, y + trunk_h)
canvas.add_line(x + tree_w / 2, y + trunk_h)
canvas.add_line(x, y + trunk_h + leaf_h)
canvas.close_path()
canvas.set_fill_color(0.25, 0.50, 0.00)
canvas.fill_path()
canvas.set_stroke_color(0.50, 0.25, 0.00)
canvas.set_line_width(trunk_thickness)
canvas.draw_line(x, y + trunk_h, x, y)
def plot_function(func, color, min_x, max_x, min_y, max_y): #Calculate scale, set line width and color: w, h = canvas.get_size() origin_x, origin_y = w * 0.5, h * 0.5 scale_x = w / (max_x - min_x) scale_y = h / (max_y - min_y) canvas.set_stroke_color(*color) canvas.set_line_width(2) canvas.move_to(origin_x + scale_x * min_x, origin_y + func(min_x) * scale_y) #Draw the graph line: x = min_x while x <= max_x: x += 0.05 draw_x = origin_x + scale_x * x draw_y = origin_y + func(x) * scale_y canvas.add_line(draw_x, draw_y) canvas.set_fill_color(*color) canvas.draw_path()
def draw_triangle(x, y, size, num_remaining): if num_remaining > 0: canvas.set_fill_color(*shade_of(random.choice(palette.colors))) canvas.set_stroke_color(*shade_of(random.choice(palette.colors))) canvas.set_line_width(random.random() * 0.5 + 0.5) step = math.sqrt(size**2 - (size / 2.0)**2) canvas.move_to(x - step, y - (size / 2.0)) canvas.add_line(x, y + size) canvas.add_line(x + step, y - (size / 2.0)) canvas.add_line(x - step, y - (size / 2.0)) canvas.fill_path() canvas.draw_line(x - step, y - (size / 2.0), x, y + size) canvas.draw_line(x, y + size, x + step, y - (size / 2.0)) canvas.draw_line(x + step, y - (size / 2.0), x - step, y - (size / 2.0)) canvas.draw_line(x, y, x - (step / 2.0), y + (size / 4.0)) canvas.draw_line(x, y, x + (step / 2.0), y + (size / 4.0)) canvas.draw_line(x, y, x, y - (size / 2.0)) canvas.draw_line(x - (step / 2.0), y + (size / 4.0), x + (step / 2.0), y + (size / 4.0)) canvas.draw_line(x + (step / 2.0), y + (size / 4.0), x, y - (size / 2.0)) canvas.draw_line(x, y - (size / 2.0), x - (step / 2.0), y + (size / 4.0)) draw_triangle(random.random() * width, random.random() * height, random.random() * triangle_side, num_remaining - 1)
def draw_heart(scale = 18): # 18 = full canvas
#print(scale) # useful for debugging
first_time = True
(xorigin, yorigin) = canvas.get_size()
xorigin *= 0.5 # in the center
yorigin *= 0.588 # north of center
detail = 100
canvas.begin_path()
for t in range(int(2 * math.pi * detail)):
t *= detail
x = scale * (16 * math.sin(t) ** 3)
y = scale * (13 * math.cos(t) - 5*math.cos(2*t) - 2*math.cos(3*t) - math.cos(4 * t))
if first_time: # hide the seams
canvas.move_to(x + xorigin, y + yorigin)
first_time = False
canvas.add_line(x + xorigin, y + yorigin)
canvas.set_line_width(1)
canvas.close_path()
canvas.draw_path() # try commenting out this line...
canvas.set_fill_color(1, 0, 0)
canvas.fill_path() # how do I fill just the inner part?
def draw_triangle(x, y, size, num_remaining): r, g, b = random.choice(palette) canvas.set_fill_color(r, g, b, random.random() * 0.75 + 0.25) r, g, b = random.choice(palette) canvas.set_stroke_color(r, g, b, random.random() * 0.5 + 0.5) canvas.set_line_width(random.random() * 2.5 + 0.5) step = math.sqrt(size**2 - (size / 2.0)**2) canvas.move_to(x - step, y - (size / 2.0)) canvas.add_line(x, y + size) canvas.add_line(x + step, y - (size / 2.0)) canvas.add_line(x - step, y - (size / 2.0)) canvas.fill_path() canvas.draw_line(x - step, y - (size / 2.0), x, y + size) canvas.draw_line(x, y + size, x + step, y - (size / 2.0)) canvas.draw_line(x + step, y - (size / 2.0), x - step, y - (size / 2.0)) canvas.draw_line(x, y, x - (step / 2.0), y + (size / 4.0)) canvas.draw_line(x, y, x + (step / 2.0), y + (size / 4.0)) canvas.draw_line(x, y, x, y - (size / 2.0)) canvas.draw_line(x - (step / 2.0), y + (size / 4.0), x + (step / 2.0), y + (size / 4.0)) canvas.draw_line(x + (step / 2.0), y + (size / 4.0), x, y - (size / 2.0)) canvas.draw_line(x, y - (size / 2.0), x - (step / 2.0), y + (size / 4.0))
def draw_heart(scale = 18): # 18 = full canvas
#print(scale) # useful for debugging
first_time = True
(xorigin, yorigin) = canvas.get_size()
xorigin *= 0.5 # in the center
yorigin *= 0.588 # north of center
detail = 100
canvas.begin_path()
for t in xrange(int(2 * math.pi * detail)):
t *= detail
x = scale * (16 * math.sin(t) ** 3)
y = scale * (13 * math.cos(t) - 5*math.cos(2*t) - 2*math.cos(3*t) - math.cos(4 * t))
if first_time: # hide the seams
canvas.move_to(x + xorigin, y + yorigin)
first_time = False
canvas.add_line(x + xorigin, y + yorigin)
canvas.set_line_width(1)
canvas.close_path()
canvas.draw_path() # try commenting out this line...
canvas.set_fill_color(1, 0, 0)
canvas.fill_path() # how do I fill just the inner part?
def draw_grid():
console.clear()
canvas.set_size(size_x, size_y)
canvas.begin_updates()
canvas.set_line_width(1)
canvas.set_stroke_color(0.7, 0.7, 0.7)
#Draw vertical grid lines:
x = grid
while x <= max(abs(min_x), abs(max_x)):
cx = t_c_x(x)
if cx > 0 and cx < size_x:
canvas.draw_line(cx, 0, cx, size_y)
cx = t_c_x(-x)
if cx > 0 and cx < size_x:
canvas.draw_line(cx, 0, cx, size_y)
x += grid
y = grid
while y <= max(abs(min_y), abs(max_y)):
cy = t_c_y(y)
if cy > 0 and cy < size_y:
canvas.draw_line(0, cy, size_x, cy)
cy = t_c_y(-y)
if cy > 0 and cy < size_y:
canvas.draw_line(0, cy, size_x, cy)
y += grid
canvas.set_stroke_color(0, 0, 0)
cx = t_c_x(0)
if cx > 0 and cx < size_x:
canvas.draw_line(cx, 0, cx, size_y)
cy = t_c_y(0)
if cy > 0 and cy < size_y:
canvas.draw_line(0, cy, size_x, cy)
canvas.end_updates()
def draw_triangle(x, y, size, num_remaining):
r, g, b = random.choice(palette)
canvas.set_fill_color(r, g, b, random.random() * 0.75 + 0.25)
r, g, b = random.choice(palette)
canvas.set_stroke_color(r, g, b, random.random() * 0.5 + 0.5)
canvas.set_line_width(random.random() * 2.5 + 0.5)
step = math.sqrt(size**2 - (size / 2.0)**2)
canvas.move_to(x - step, y - (size / 2.0))
canvas.add_line(x, y + size)
canvas.add_line(x + step, y - (size / 2.0))
canvas.add_line(x - step, y - (size / 2.0))
canvas.fill_path()
canvas.draw_line(x - step, y - (size / 2.0), x, y + size)
canvas.draw_line(x, y + size, x + step, y - (size / 2.0))
canvas.draw_line(x + step, y - (size / 2.0), x - step, y - (size / 2.0))
canvas.draw_line(x, y, x - (step / 2.0), y + (size / 4.0))
canvas.draw_line(x, y, x + (step / 2.0), y + (size / 4.0))
canvas.draw_line(x, y, x, y - (size / 2.0))
canvas.draw_line(x - (step / 2.0), y + (size / 4.0), x + (step / 2.0),
y + (size / 4.0))
canvas.draw_line(x + (step / 2.0), y + (size / 4.0), x, y - (size / 2.0))
canvas.draw_line(x, y - (size / 2.0), x - (step / 2.0), y + (size / 4.0))
def plot_function(t_, color, min_x,max_x,min_y,max_y):
#Calculate scale, set line width and color:
w, h = canvas.get_size()
scale_x = w / (max_x - min_x)
scale_y = h / (max_y - min_y)
scale_x = min(scale_x,scale_y)
scale_y=scale_x
origin_x, origin_y = -scale_x*min_x,-scale_y*min_y
canvas.set_stroke_color(*color)
canvas.set_line_width(2)
#Draw the graph line:
x = t_[0][0]
y = t_[0][1]
canvas.move_to(origin_x + scale_x * x,
origin_y + scale_y * y)
for p in t_[1:]:
x=p[0]
y=p[1]
draw_x = origin_x + scale_x * x
draw_y = origin_y + scale_y * y
canvas.add_line(*(draw_x, draw_y))
canvas.set_fill_color(*color)
canvas.draw_path()
canvas.begin_updates() canvas.set_size(width, height) canvas.set_fill_color(*palette['darkest']) canvas.fill_rect(0, 0, width, height) canvas.set_fill_color(*random.choice(palette['palette'])) canvas.set_stroke_color(*palette['lightest']) start_x, start_y = (width / 2.0, height / 2.0) lollipop_points = [] for x in xrange(64): end_x, end_y = (random.random() * (width * 0.8) + (width * 0.1), random.random() * (height * 0.8) + (height * 0.1)) lollipop_points.append((end_x, end_y)) canvas.set_line_width(random.random() * 0.75 + 0.25) canvas.draw_line(start_x, start_y, end_x, end_y) for x in xrange(64): end_x, end_y = lollipop_points[x] size = random.random() * 128.0 + 32.0 canvas.fill_ellipse(end_x - (size / 2.0), end_y - (size / 2.0), size, size) canvas.set_line_width(1.25) canvas.draw_ellipse(end_x - (size / 2.0), end_y - (size / 2.0), size, size) size = random.random() * 128.0 + 32.0 canvas.fill_ellipse(start_x - (size / 2.0), start_y - (size / 2.0), size, size) canvas.set_line_width(1.25) canvas.draw_ellipse(start_x - (size / 2.0), start_y - (size / 2.0), size, size) canvas.end_updates()
def draw_line(x1, y1, x2, y2): canvas.set_line_width(3) canvas.draw_line(x1, y1, x2, y2)
def rstrokedline(start_x, start_y, end_x, end_y): line_width = random.random() * 0.75 + 0.25 canvas.set_line_width(line_width) a = random.random() * 0.25 + 0.05 canvas.set_stroke_color(1.0, 1.0, 1.0, a) canvas.draw_line(start_x, start_y, end_x, end_y)
canvas.set_size(width, height)
canvas.set_fill_color(*palette.darkest)
canvas.fill_rect(0, 0, width, height)
canvas.set_fill_color(*random.choice(palette.colors))
canvas.set_stroke_color(*palette.lightest)
start_x, start_y = (width / 2.0, height / 2.0)
lollipop_points = []
for x in xrange(64):
end_x, end_y = (random.random() * (width * 0.8) + (width * 0.1),
random.random() * (height * 0.8) + (height * 0.1))
lollipop_points.append((end_x, end_y))
canvas.set_line_width(random.random() * 0.75 + 0.25)
canvas.draw_line(start_x, start_y, end_x, end_y)
size = random.random() * (width * 0.10)
canvas.fill_ellipse(start_x - (size / 2.0), start_y - (size / 2.0), size, size)
canvas.set_line_width(1.25)
canvas.draw_ellipse(start_x - (size / 2.0), start_y - (size / 2.0), size, size)
for x in xrange(64):
end_x, end_y = lollipop_points[x]
size = random.random() * (width * 0.10)
canvas.fill_ellipse(end_x - (size / 2.0), end_y - (size / 2.0), size, size)
canvas.set_line_width(1.25)
canvas.draw_ellipse(end_x - (size / 2.0), end_y - (size / 2.0), size, size)
canvas.end_updates()
def rstrokedline(start_x, start_y, end_x, end_y):
line_width = random.random() * 0.75 + 0.25
canvas.set_line_width(line_width)
a = random.random() * 0.25 + 0.05
canvas.set_stroke_color(1.0, 1.0, 1.0, a)
canvas.draw_line(start_x, start_y, end_x, end_y)
def draw_circle(x, y, r): canvas.set_line_width(3) canvas.set_stroke_color(0, 0, 0) canvas.set_fill_color(255,255,255) canvas.fill_ellipse(x - r, y - r, 2 * r, 2 * r) canvas.draw_ellipse(x - r, y - r, 2 * r, 2 * r)
def setstyle(w, gray=0):
canvas.set_line_width(w)
canvas.set_stroke_color(gray, gray, gray)
import canvas w = h = 512 canvas.set_size(w, h) canvas.move_to(w * 0.45, h * 0.1) canvas.add_line(w * 0.8, h * 0.55) canvas.add_line(w * 0.55, h * 0.65) canvas.add_line(w * 0.65, h * 0.85) canvas.add_line(w * 0.3, h * 0.55) canvas.add_line(w * 0.55, h * 0.45) canvas.close_path() canvas.set_line_width(3) canvas.draw_path() canvas.fill_path()
import canvas w = h = 512 canvas.set_size(w, h) canvas.move_to(w*0.45, h*0.1) canvas.add_line(w*0.8, h*0.55) canvas.add_line(w*0.55, h*0.65) canvas.add_line(w*0.65, h*0.85) canvas.add_line(w*0.3, h*0.55) canvas.add_line(w*0.55, h*0.45) canvas.close_path() canvas.set_line_width(3) canvas.draw_path() canvas.fill_path()
import canvas canvas.set_size(512, 512) from_point = (10, 10) cp1 = (40, 200) #control point 1 cp2 = (350, 50) #control point 2 to_point = (300, 300) # Draw the actual curve: canvas.begin_path() canvas.move_to(from_point[0], from_point[1]) canvas.add_curve(cp1[0], cp1[1], cp2[0], cp2[1], to_point[0], to_point[1]) canvas.set_line_width(2) canvas.draw_path() # Draw the red dots and lines to illustrate what's happening: canvas.set_stroke_color(1, 0, 0) canvas.set_fill_color(1, 0, 0) # Draw straight lines between the control points and the end points: canvas.draw_line(from_point[0], from_point[1], cp1[0], cp1[1]) canvas.draw_line(to_point[0], to_point[1], cp2[0], cp2[1]) # Draw red squares on all the points: canvas.fill_rect(from_point[0] - 4, from_point[1] - 4, 8, 8) canvas.fill_rect(to_point[0] - 4, to_point[1] - 4, 8, 8) canvas.fill_rect(cp1[0] - 4, cp1[1] - 4, 8, 8) canvas.fill_rect(cp2[0] - 4, cp2[1] - 4, 8, 8)
def main():
draw_grid()
canvas.set_stroke_color(0.7, 0.3, 0.3)
canvas.set_line_width(5)
x = 5.0
y = -3.0
path = []
last_a = 0
for l, delta_a in [(10, 30), (10, 20), (10, 150), (10, -90), (10, 20), (10, 45), (10, 160)]:
last_a += delta_a
a1 = last_a / 180.0 * pi
dx = l * cos(a1)
dy = l * sin(a1)
dt = l / speed
#print dx,dy, sin(a1), cos(a1)
line(x, y, x + dx, y + dy)
path.append([x, y, x + dx, y + dy, dt, 'i'])
x += dx
y += dy
path.append([x, y, x, y, 1, 'l'])
path[0][5] = 'f'
print path
x, y = path[0][:2]
vx = 0.0
vy = 0.0
need_slow = 1
k_slow = 1.0
while need_slow:
need_slow = 0
points = []
last_dt = 0
for (x1, y1, x2, y2, dt, fli) in path:
dt = dt * k_slow
nvx = (x2 - x1) / dt
nvy = (y2 - y1) / dt
dvx = nvx - vx
dvy = nvy - vy
dta = max(abs(dvx / ax_max), abs(dvy / ay_max))
if fli == "i":
dta = dta / 2
ka = dta / dt
else:
ka = dta / dt / 2
#print fli, dvx, dvy, dt, dta, dta/dt
last_ka = dta / (last_dt or 1)
if fli == "f":
points.append((x1, y1, 0, 0, 0))
points.append((x1 + (x2 - x1) * ka, y1 + (y2 - y1) * ka, nvx, nvy, dta))
dta = dta / 2
elif fli == "i":
points.append((last_x2 - (last_x2 - last_x1) * last_ka,
last_y2 - (last_y2 - last_y1) * last_ka,
vx, vy, last_dt - last_dta - dta))
points.append((x1 + (x2 - x1) * ka,
y1 + (y2 - y1) * ka,
nvx, nvy, dta * 2))
elif fli == "l":
points.append((last_x2 - (last_x2 - last_x1) * last_ka / 2,
last_y2 - (last_y2 - last_y1) * last_ka / 2,
vx, vy, last_dt - last_dta - dta / 2))
points.append((x2, y2,
0, 0, dta))
if fli == "i":
if ka > part_max:
need_slow = 1
if last_dt and last_ka > part_max:
need_slow = 1
x0, y0, vx0, vy0, _ = points[-2]
xn, yn, vxn, vyn, sdt = points[-1]
coefs_x = cubic_coeff(x0, vx0, xn, vxn, sdt)
coefs_y = cubic_coeff(y0, vy0, yn, vyn, sdt)
xm = cubic_x(coefs_x, sdt / 2)
ym = cubic_x(coefs_y, sdt / 2)
delta = sqrt((xm - x1) * (xm - x1) + (ym - y1) * (ym - y1))
print delta
if delta > delta_max:
need_slow = 1
else:
if ka > 0.5:
need_slow = 1
if last_dt and last_ka > 0.5:
need_slow = 1
last_x1 = x1
last_y1 = y1
last_x2 = x2
last_y2 = y2
last_dt = dt
last_dta = dta
vx = nvx
vy = nvy
#need_slow = 0
if need_slow:
k_slow = k_slow * 1.1
print "need slowdown, new k =", k_slow, "speed = ", speed / k_slow
print points
last_p = points[0]
for p in points[1:]:
x0, y0, vx0, vy0, _ = last_p
x1, y1, vx1, vy1, dt = p
canvas.set_stroke_color(0.3, 0.7, 0.3)
canvas.set_line_width(3)
line(x0, y0, x1, y1)
circle(x1, y1)
coefs_x = cubic_coeff(x0, vx0, x1, vx1, dt)
coefs_y = cubic_coeff(y0, vy0, y1, vy1, dt)
print "x:", coefs_x, cubic_a(coefs_x, 0), cubic_a(coefs_x, dt)
print "y:", coefs_y, cubic_a(coefs_y, 0), cubic_a(coefs_y, dt)
t = 0.0
step = dt / 10
canvas.set_stroke_color(0, 0, 0)
canvas.set_line_width(3)
while 1:
x = cubic_x(coefs_x, t)
y = cubic_x(coefs_y, t)
vx = cubic_v(coefs_x, t)
vy = cubic_v(coefs_y, t)
print sqrt(vx * vx + vy * vy)
circle(x, y, 2)
t += step
if t > dt:
break
last_p = p
# coding: utf-8 # https://forum.omz-software.com/topic/3191/can-t-fill-path # use the canvas to draw a trapezoid import canvas b = 10 canvas.set_size(500, 500 + b) canvas.draw_rect(0, 0 + b, 500, 500) canvas.set_fill_color(1, 0.1, 0.1) canvas.set_stroke_color(1, 0, 0) canvas.set_line_width(4) canvas.begin_path() canvas.add_line(150, 100 + b) canvas.add_line(350, 100 + b) canvas.add_line(400, 200 + b) canvas.add_line(100, 200 + b) canvas.add_line(150, 100 + b) canvas.draw_path() canvas.fill_path() canvas.close_path()
# https://gist.github.com/omz/5087533 import canvas canvas.set_size(512, 512) from_point = (10, 10) cp1 = (40, 200) #control point 1 cp2 = (350, 50) #control point 2 to_point = (300, 300) # Draw the actual curve: canvas.begin_path() canvas.move_to(from_point[0], from_point[1]) canvas.add_curve(cp1[0], cp1[1], cp2[0], cp2[1], to_point[0], to_point[1]) canvas.set_line_width(2) canvas.draw_path() # Draw the red dots and lines to illustrate what's happening: canvas.set_stroke_color(1, 0, 0) canvas.set_fill_color(1, 0, 0) # Draw straight lines between the control points and the end points: canvas.draw_line(from_point[0], from_point[1], cp1[0], cp1[1]) canvas.draw_line(to_point[0], to_point[1], cp2[0], cp2[1]) # Draw red squares on all the points: canvas.fill_rect(from_point[0]-4, from_point[1]-4, 8, 8) canvas.fill_rect(to_point[0]-4, to_point[1]-4, 8, 8) canvas.fill_rect(cp1[0]-4, cp1[1]-4, 8, 8) canvas.fill_rect(cp2[0]-4, cp2[1]-4, 8, 8)
