def draw(): p.background(50) # grey scale p.fill(255, 150) # grey scale + alpha size = p.mouse.y / 2 p.rect(p.mouse.x, 200, size + 10, size + 10) p.rect(400 - p.mouse.x, 200, 210 - size, 210 - size)
def draw(): global y background(0) y = y - 1 if y < 0: y = height line(0, y, width, y)
def draw(): p.background(0) for e in elements: p.ellipse(e.x, e.y, e.size, e.size) p.line(e.x, e.y, e.x + e.velocity[0] * e.size / 2, e.y + e.velocity[1] * e.size / 2) # find all elements touching another element lines = [] for a, b in itertools.combinations(elements, 2): distance = math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2) if distance < 0.5 * (a.size + b.size): a.touching.append(b) b.touching.append(a) lines.append((a.x, a.y, b.x, b.y, distance)) if lines: # draw lines between elements for line in lines: p.line(line[0], line[1], line[2], line[3]) # move all elements for e in elements: if e.touching: e.rotate() e.move_away() else: e.move()
def setup(): size(100, 100) background(255) fill(0) stroke(0) stroke_weight(10) frame_rate(60)
def draw(): p.background(0) for i in range(20): angle = i * 0.2 x = i * 20 y = (math.sin(angle) + 1) * 200 p.ellipse(x, y, 16, 16)
def setup(): p.size(800,200) p.smooth() p.background(255) global location, velocity location = p.PVector(100,100) velocity = p.PVector(2.5,5)
def draw(): p.background(0) for i in range(width / 20 + 1): for j in range(height / 20 + 1): size = p.dist(p.mouse.x, p.mouse.y, i * 20, j * 20) size = size / MAX_DISTANCE * 66 p.ellipse(i * 20, j * 20, size, size)
def draw(): p5.colorMode(p5.RGB) p5.background(0) if len(projection): p5.pushMatrix() p5.colorMode(p5.HSB) p5.translate(width/4, height/4) p5.scale(width/2, height/2) for point, label in zip(projection, labels): p5.stroke(p5.color(label * 26., 255, 255)) p5.point(point[0], point[1]) p5.popMatrix() #send osc to MaxPatch probability_lda = model.predict_proba([getAmplitude(recent)]) send_osc_message("/lda",probability_lda) probability_svc = clf.predict_proba([getAmplitude(recent)]) send_osc_message("/svm",probability_svc) cur = model.transform([getAmplitude(recent)]) cur = cur[0] cur = (cur - p_min) / (p_max - p_min) global predicted if predicted == None: predicted = cur else: predicted = predicted * .9 + cur * .1 p5.stroke(p5.color(0, 0, 255)) p5.ellipse(width/4 + predicted[0] * width/2, height/4 + predicted[1] * height/2, 10, 10) elif len(recent): # draw time-amplitude p5.pushMatrix() p5.translate(0, height/2) p5.scale(width / N, height/2) p5.stroke(255) p5.noFill() p5.beginShape() for x, y in enumerate(recent): p5.vertex(x, y) p5.endShape() p5.popMatrix() # draw frequency-amplitude amp = getAmplitude(recent) p5.pushMatrix() p5.translate(0, height) p5.scale(width, -height) p5.stroke(255) p5.noFill() p5.beginShape() for x, y in enumerate(amp): p5.vertex(math.log(1+x, len(amp)), pow(y, .5)) p5.endShape() p5.popMatrix()
def draw(): p.background(0) # draw tree trunk and move to its top p.translate(200, 400) p.line(0, 0, 0, -120) p.translate(0, -120) # draw the branches branches(120)
def draw(): p.background(255) wind = p.PVector(0.01,0) gravity = p.PVector(0,0.1) m.applyForce(wind) m.applyForce(gravity) m.update() m.checkEdges() m.display()
def draw(): p.background(255) mouse = np.array([p.mouse.x, p.mouse.y]) center = np.array([width/2, height/2]) mouse = mouse - center p.translate(width/2, height/2) p.strokeWeight(2) p.stroke(0) p.line(0, 0, mouse[0], mouse[1])
def draw(): background(200) bindings = { 'H': clear, 'G': show_grid, 'L': pretty_lines } if key.pressed and key.char in bindings.keys(): bindings[key.char]() map(lambda obj: obj.draw(), actors)
def draw(): p.background(255) force = a.attract(m) m.applyForce(force) m.update() a.drag() a.hover(p.mouse.x, p.mouse.y) a.display() m.display()
def draw(): p.background(0) # draw tree trunk and move to its top p.translate(200, 400) p.line(0, 0, 0, -120) p.translate(0, -120) angle = math.pi * p.mouse.x / 800 # draw the branches branches(120, angle)
def draw(): """ Required for pyprocessing.run() """ global screen_size global camera_pos global spawner global frame_count global swarm global back_col global img_dir pyp.camera(camera_pos.x, camera_pos.y, camera_pos.z, 0, 0, 0, 1, 0, 0) s = max(screen_size) pyp.pointLight(255, 255, 255, 10 * s, 0, 0) pyp.pointLight(255, 255, 255, 0, 10 * s, 0) pyp.pointLight(255, 255, 255, 0, 0, 10 * s) pyp.background(back_col) #calculate spawner angle animation_angle = 2.0 * pi * (frame_count % frame_cycles) / frame_cycles spawner.angle = 65 * animation_angle # print 'spawner', pformat({ # 'angle':spawner.angle, # 'position':spawner.spawn_position # }) seed(animation_angle) swarm.spawn(orientation=PVector(s / 50, 0, 0), position=spawner.spawn_position, velocity=PVector((sin(animation_angle)) * s / 100, (cos(animation_angle)) * s / 100, (1 - random() * 2) * s / 100), active=True) for particle in swarm: # print 'particle', pformat({ # 'position': particle.position, # 'velocity': particle.velocity, # 'orientation': particle.orientation # }) particle.draw() particle.step() frame_count += 1 if frame_count in range(360, 720): img = pyp.get() # print type(img) pyp.save(os.path.join(img_dir, 'image_%s.jpg' % (frame_count)))
def draw(): pp.background(0x000000) pp.translate(width/2.0, height/2.0, -height/4.0 + 500) # +500 is a kludge to make big defineLights() update() pp.lights() try: data = queue.get_nowait() if data: set_values(data) except: pass drawLEDs(network)
def draw(): p.background(255) wind = p.PVector(0.01,0) gravity = p.PVector(0,0.1) for mover in movers: mover.applyForce(wind) mover.applyForce(gravity) mover.update() mover.checkEdges() mover.display()
def draw(): z.step() angle = (2*np.pi-z.state[0]-np.pi/2) pyp.background(200,50) pyp.line(xcenter,ycenter,xcenter+ pendulum_length*np.cos(angle),ycenter+ pendulum_length*np.sin(angle)); pyp.fill(255) pyp.ellipse(xcenter+ pendulum_length*np.cos(angle),ycenter+ pendulum_length*np.sin(angle),100,100) action_taken = z.action_taken for i in range(len(indicators)): #print action_taken if i == action_taken: indicators[i].fill() else: indicators[i].empty()
def draw(self, millis): background(51) items = self.ring.get() (x,self.y) = (0, self.y_step * len(items)) self.update(millis) for item in items: try: if item is not None: fill(item.color) text(item.text, x, self.y) else: text("Something bad happened", x, self.y) except UnicodeDecodeError: text("Unsupported Language Tweeted", x, self.y) self.y-= self.y_step
def draw(): p.background(255) # rather than a double-nested loop, taking advantage of itertools' combination # method to give all possible pairs with no repeats for (m1,m2) in combinations(movers,2): force = m1.attract(m2) m2.applyForce(force) # flip the force and apply it back (avoids duplicate calculations) force.mult(-1.) m1.applyForce(force) for m in movers: m.update() m.display()
def draw(): global x,y,xspeed,yspeed p.background(255) x += xspeed y += yspeed if x > width or x < 0: xspeed *= -1 if y > height or y < 0: yspeed *= -1 p.stroke(0) p.strokeWeight(2) p.fill(127) p.ellipse(x, y, 48, 48)
def draw(): p.background(255) mouse = np.array([p.mouse.x, p.mouse.y]) center = np.array([width/2, height/2]) mouse -= center m = np.linalg.norm(mouse) p.fill(0) p.noStroke() p.rect(0,0,m,10) p.translate(width/2, height/2) p.strokeWeight(2) p.stroke(0) p.line(0, 0, mouse[0], mouse[1])
def draw(): p.background(255) # pick a random number and increase the count index = randint(0,len(randomCounts)-1) randomCounts[index] += 1 # draw a rectangle to graph results p.stroke(0); p.strokeWeight(2); p.fill(127); w = width/len(randomCounts) for x in range(0,len(randomCounts)): p.rect(x*w, height-randomCounts[x], w-1, randomCounts[x])
def rings(): p.background(292, 40, 30) for i in range(30): x = random.randint(0, 600) y = random.randint(0, 200) n = random.randint(3, 30) radius = random.randint(10, 100) size = random.randint(3, 15) colour = random.choice(COLOURS) p.fill(*colour) for i in range(n): angle = i * 2*math.pi / n new_x = x + math.cos(angle) * radius new_y = y + math.sin(angle) * radius p.ellipse(new_x, new_y, size, size)
def draw(): p.background(255) liquid.display() for mover in movers: if liquid.contains(mover): dragForce = liquid.drag(mover) mover.applyForce(dragForce) gravity = p.PVector(0, 0.1 * mover.mass) mover.applyForce(gravity) mover.update() mover.checkEdges() mover.display() p.fill(0) p.text("click mouse to reset", 10, 30)
def draw(): p.background(0) for e in elements: p.ellipse(e.x, e.y, e.size, e.size) p.line(e.x, e.y, e.x + e.velocity[0] * e.size / 2, e.y + e.velocity[1] * e.size / 2) # find all elements touching another element touching = {} for a, b in itertools.combinations(elements, 2): distance = math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2) if distance < 0.5 * (a.size + b.size): touching[a] = True touching[b] = True # rotate and move all elements for e in elements: if e in touching: e.rotate() e.move()
def dimming(): global lights_activated source, text = animation_q.get_nowait() # non-blocking check for items in animation_q. # If queue is empty a Queue.Empty exception is raised. if source == 'dim' and lights_activated: d = int(float(text)) if d < 200: r = d g = d else: r = 255 g = 255 b = d - 20 p.background(200) p.fill(r,g,b) p.rect(0,0,600,600) elif text == 'LIGHTS': lights_activated = True else: pass
def draw(): p.background(255) # vector that points to the mouse location mouse = np.array([p.mouse.x, p.mouse.y], dtype=float) # vector that points to the center of the window center = np.array([width/2, height/2]) # subtract center from mouse, gives vector pointing from center to mouse mouse -= center # normalize the vector mouse /= np.linalg.norm(mouse) # multiply length mouse *= 150 # draw the resulting vector p.translate(width/2, height/2) p.strokeWeight(2) p.stroke(0) p.line(0, 0, mouse[0], mouse[1])
def draw(): global m, learn, z pyp.background(200,50) learn.collect_data() m = learn.get_mean() pyp.loadPixels() m = np.atleast_2d(m) norm = normalize(vmin=min(min(m)), vmax=max(max(m))) cmap = get_cmap('jet') m_normed = norm(m) rgba_data=cmap(m_normed)*255 r = rgba_data[0,:,0].astype('uint32') g = rgba_data[0,:,1].astype('uint32') b = rgba_data[0,:,2].astype('uint32') a = rgba_data[0,:,3].astype('uint32') pyp.screen.pixels = a << 24 | r << 16 | g << 8 | b pyp.updatePixels()
def draw(): p.background(255) c = 0.05 for mover in movers: wind = p.PVector(0.01,0) gravity = p.PVector(0,0.1*mover.mass) friction = mover.velocity.get() friction.mult(-1) if friction.mag() > 0: friction.normalize() friction.mult(c) mover.applyForce(wind) mover.applyForce(gravity) mover.applyForce(friction) mover.update() mover.checkEdges() mover.display()
def draw(): p.background(255) mover.update() mover.checkEdges() mover.display()
def draw_screen(points, slopes, line_segments, arc_segments): # Setup processing import pyprocessing as proc proc.size(VIEW_WIDTH, VIEW_HEIGHT) proc.smooth() proc.background(255, 255, 255) proc.ellipseMode(proc.RADIUS) # Prepare camera bbox = BoundingBox(points) eye_x = bbox.min_x + bbox.width / 2.0 eye_y = bbox.min_y + bbox.height / 2.0 eye_z = (1.5 * max(bbox.width, bbox.height) / 2.0) / sin(radians(50)) center_x = bbox.min_x + bbox.width / 2.0 center_y = bbox.min_y + bbox.height / 2.0 proc.camera( eye_x, eye_y, eye_z, center_x, center_y, 0, 0, 1, 0) if RENDER_CIRCLES: proc.noFill() proc.stroke(232, 232, 232) for arc in arc_segments: proc.ellipse(arc.c[0], arc.c[1], arc.r, arc.r) if RENDER_SLOPES: proc.stroke(127, 127, 127) for k in range(len(points)): if slopes[k]: p = points[k] s = slopes[k].vector / norm(slopes[k].vector) # normalize x0 = p.x() - s[0] * SLOPE_LENGTH y0 = p.y() - s[1] * SLOPE_LENGTH x1 = p.x() + s[0] * SLOPE_LENGTH y1 = p.y() + s[1] * SLOPE_LENGTH proc.line(x0, y0, x1, y1) # line_segments proc.stroke(0, 0, 0, 255) for line in line_segments: proc.line(line.a.x(), line.a.y(), line.b.x(), line.b.y()) # arc_segments proc.noFill() proc.stroke(255, 0, 0, 255) for arc in arc_segments: proc.arc(arc.c[0], arc.c[1], arc.r, arc.r, arc.alfa, arc.beta) # Points proc.fill(255, 0, 0) proc.stroke(0, 0, 0) for p in points: proc.rect(p.x() - BOX_WIDTH / 2.0, p.y() - BOX_WIDTH / 2.0, BOX_WIDTH, BOX_WIDTH) # Execute! :-) proc.run()
def setup(): p.size(800,200) p.background(255) p.smooth()
def clear(): background(200)
def setup(): size(640, 360) stroke(255) frame_rate(60) background(0)
def draw(): p.background(292, 40, 30) for ring in rings: ring.draw()
def setup(): p.size(SIZE, SIZE) p.background(0) p.colorMode(p.HSB, 360, 100, 100)
#!/usr/bin/evn python # coding=utf-8 """ Composition. Square Limit. """ import math import pyprocessing as p p.size(800, 800) p.background(255) p.translate(300, 300) img = p.loadImage("fish.png") def fish(): p.image(img, -80, -80) def transform(t, *args): def wrapper(*args): def wrapped_f(): p.pushMatrix() t(*args) # perform transformation t args[-1]() # call function f p.popMatrix() return wrapped_f return wrapper @transform def rotate(f): p.translate(0, 240)