upload from mac

Author: tdamdouni

_2018/Image Effects.py

@@ -0,0 +1,66 @@
+# Image Effects
+# Demonstrates some effects using different modules
+# from the Python Imaging Library (PIL).
+#
+# Tip: You can touch and hold an image in the output
+#      to copy it to the clipboard or save it to your
+#      camera roll.
+
+import Image, ImageOps, ImageFilter
+from Image import BILINEAR
+from math import sqrt, sin, cos, atan2
+
+def sketch(img):
+	edge_img = img.filter(ImageFilter.CONTOUR)
+	return ImageOps.grayscale(edge_img)
+	
+def color_tiles(img):
+	size = img.size
+	small_img = img.resize((size[0]/2, size[1]/2), BILINEAR)
+	bw_img = small_img.convert('1', dither=False)
+	gray_img = bw_img.convert('L')
+	result = Image.new('RGB', size)
+	tile1 = ImageOps.colorize(gray_img, 'green', 'red') 
+	tile2 = ImageOps.colorize(gray_img, 'purple', 'yellow')
+	tile3 = ImageOps.colorize(gray_img, 'yellow', 'brown')
+	tile4 = ImageOps.colorize(gray_img, 'red', 'cyan')
+	result.paste(tile1, (0, 0))
+	result.paste(tile2, (size[0]/2, 0))
+	result.paste(tile3, (0, size[1]/2))
+	result.paste(tile4, (size[0]/2, size[1]/2))
+	return result
+
+def twisted(img, strength):
+	mesh = []
+	m = 16
+	w, h = img.size
+	for x in xrange(w / m):
+		for y in xrange(h / m):
+			target_rect = (x * m, y * m, x * m + m, y * m + m)
+			quad_points = ((x * m, y * m), (x * m, y * m + m),
+		                 (x * m + m, y * m + m), (x * m + m, y * m))
+			quad_list = []
+			for qx, qy in quad_points:
+				dx = w/2 - qx
+				dy = h/2 - qy
+				d = sqrt(dx**2 + dy**2)
+				angle = atan2(dx, dy)
+				angle += max((w/2 - d), 0) * strength
+				qx = w/2 - sin(angle) * d
+				qy = h/2 - cos(angle) * d
+				quad_list.append(qx)
+				quad_list.append(qy)
+			mesh.append((target_rect, quad_list))
+	return img.transform(img.size, Image.MESH, mesh, BILINEAR)
+
+def main():
+	img = Image.open('Test_Lenna')
+	img = img.resize((256, 256), Image.BILINEAR)
+	img.show()
+	
+	sketch(img).show()
+	color_tiles(img).show()
+	twisted(img, 0.02).show()
+
+if __name__ == '__main__':
+	main()

_2018/Image Warp.py

@@ -0,0 +1,96 @@
+# Image Warp
+# 
+# Demonstrates an interesting use of the image_quad function
+# to distort an image based on touch.
+
+from scene import *
+from math import sqrt, sin, pi, floor
+import Image
+
+M = 16 # number of vert. and horiz. quads in the mesh (16*16=256)
+
+class ImageWarp (Scene):
+	def setup(self):
+		self.offsets = [[(0.0, 0.0) for x in xrange(M+1)] for y in xrange(M+1)]
+		if self.size.w >= 700:
+			# Use the original image on iPad:
+			self.img = 'Test_Lenna'
+			s = 512
+		else:
+			# Resize the image for small screens:
+			s = 256
+			img_name = 'Test_Lenna'
+			img = Image.open(img_name).convert('RGBA')
+			img = img.resize((s, s), Image.BILINEAR)
+			self.img = load_pil_image(img)
+		self.img_size = s
+		self.m = s / M
+	
+	def draw_warped_image(self):
+		m = self.m
+		for x in xrange(M):
+			for y in xrange(M):
+				d = self.offsets
+				# distances of the 4 corner points from their original position:
+				d1 = d[x][y]; d2 = d[x + 1][y]
+				d3 = d[x][y + 1]; d4 = d[x + 1][y + 1]
+				image_quad(self.img,
+				       # distorted quad:
+		           x * m + d1[0], y * m + d1[1],
+		           x * m + m + d2[0], y * m + d2[1],
+		           x * m + d3[0], y * m + m + d3[1],
+		           x * m + m + d4[0], y * m + m + d4[1],
+		           # source quad in image:
+		           x * m, y * m, x * m + m, y * m,
+		           x * m, y * m + m, x * m + m, y * m + m)
+	
+	def bulge(self, touch_x, touch_y):
+		# push mesh vertices away from touch location:
+		m = self.m
+		r = self.img_size / 5
+		for x in xrange(0, M + 1):
+			for y in xrange(0, M + 1):
+				offset = self.offsets[x][y]
+				dist = sqrt((x*m-touch_x + offset[0])**2.0 +
+				            (y*m-touch_y + offset[1])**2.0)
+				dx = x*m - touch_x
+				dy = y*m - touch_y
+				unit_x = dx / dist if dist > 0 else 0.0
+				unit_y = dy / dist if dist > 0 else 0.0
+				b = self.dt * 50
+				if dist < r:
+					falloff = max(sin(dist/r*pi), 0)
+					offset_x = unit_x * b * falloff + offset[0]
+					offset_y = unit_y * b * falloff + offset[1]
+					self.offsets[x][y] = (offset_x, offset_y)
+	
+	def revert(self):
+		for x in xrange(0, M + 1):
+			for y in xrange(0, M + 1):
+				offset = self.offsets[x][y]
+				offset_x = floor(offset[0] - cmp(offset[0], 0))
+				offset_y = floor(offset[1] - cmp(offset[1], 0))
+				self.offsets[x][y] = (offset_x, offset_y)
+	
+	def draw(self):
+		background(0, 0, 0)
+		push_matrix()
+		tx = self.size.w/2 - self.img_size/2
+		ty = self.size.h/2 - self.img_size/2
+		translate(tx, ty)
+		text('Touch the image to deform it.', 'Helvetica-Bold',
+		     18, self.img_size/2, -30, alignment=5)
+		text('Use two fingers to revert.', 'Helvetica-Bold',
+		     18, self.img_size/2, -60, alignment=5)
+		self.draw_warped_image()
+		pop_matrix()
+		if len(self.touches) ==0:
+			return
+		if len(self.touches) > 1:
+			self.revert()
+		else:
+			loc = self.touches.values()[0].location
+			touch_x, touch_y = loc.x - tx, loc.y - ty
+			self.bulge(touch_x, touch_y)
+
+run(ImageWarp(), frame_interval=1)

_2018/Piano.py

@@ -0,0 +1,82 @@
+# Piano
+# 
+# A simple multi-touch piano.
+
+from scene import *
+import sound
+from itertools import chain
+
+class Key (object):
+	def __init__(self, frame):
+		self.frame = frame
+		self.name = None
+		self.touch = None
+		self.color = Color(1, 1, 1)
+		self.highlight_color = Color(0.9, 0.9, 0.9)
+		
+	def hit_test(self, touch):
+		return touch.location in self.frame
+
+class Piano (Scene):
+	def setup(self):
+		self.white_keys = []
+		self.black_keys = []
+		white_key_names = ['Piano_C3', 'Piano_D3', 'Piano_E3',
+		                   'Piano_F3', 'Piano_G3', 'Piano_A3', 
+		                   'Piano_B3', 'Piano_C4']
+		black_key_names = ['Piano_C3#', 'Piano_D3#', 'Piano_F3#', 
+		                   'Piano_G3#', 'Piano_A3#']
+		for key_name in chain(white_key_names, black_key_names):
+			sound.load_effect(key_name)
+		white_positions = range(8)
+		black_positions = [0.5, 1.5, 3.5, 4.5, 5.5]
+		key_w = self.size.w
+		key_h = self.size.h / 8
+		for i in range(len(white_key_names)):
+			pos = white_positions[i]
+			key = Key(Rect(0, pos * key_h, key_w, key_h))
+			key.name = white_key_names[i]
+			self.white_keys.append(key)
+		for i in range(len(black_key_names)):
+			pos = black_positions[i]
+			key = Key(Rect(0, pos * key_h + 10, key_w * 0.6, key_h - 20))
+			key.name = black_key_names[i]
+			key.color = Color(0, 0, 0)
+			key.highlight_color = Color(0.2, 0.2, 0.2)
+			self.black_keys.append(key)
+		
+	def draw(self):
+		stroke_weight(1)
+		stroke(0.5, 0.5, 0.5)
+		for key in chain(self.white_keys, self.black_keys):
+			if key.touch is not None:
+				fill(*key.highlight_color.as_tuple())
+			else:
+				fill(*key.color.as_tuple())
+			rect(*key.frame.as_tuple())
+	
+	def touch_began(self, touch):
+		for key in chain(self.black_keys, self.white_keys):
+			if key.hit_test(touch):
+				key.touch = touch
+				sound.play_effect(key.name)
+				return
+	
+	def touch_moved(self, touch):
+		hit_key = None
+		for key in chain(self.black_keys, self.white_keys):
+			hit = key.hit_test(touch)
+			if hit and hit_key is None:
+				hit_key = key
+				if key.touch is None:
+					key.touch = touch
+					sound.play_effect(key.name)
+			if key.touch == touch and key is not hit_key:
+				key.touch = None
+				
+	def touch_ended(self, touch):
+		for key in chain(self.black_keys, self.white_keys):
+			if key.touch == touch:
+				key.touch = None
+
+run(Piano(), PORTRAIT)

_2018/Plotter.py

@@ -0,0 +1,66 @@
+# Function Plotter
+
+import canvas
+import console
+from math import sin, cos, pi
+
+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 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()
+
+#Set up the canvas size and clear any text output:
+console.clear()
+canvas.set_size(688, 688)
+#Draw the grid:
+area = (-pi, pi, -pi, pi)
+draw_grid(*area)
+#Draw 4 different graphs (sin(x), cos(x), x^2, x^3):
+plot_function(sin, (1, 0, 0), *area)
+plot_function(cos, (0, 0, 1), *area)
+plot_function(lambda x: x ** 2, (0, 1, 1), *area)
+plot_function(lambda x: x ** 3, (1.0, 0.5, 0), *area)