def graphFunction():
x = xmin
while x <= xmax:
p.stroke(255, 0, 0)
p.fill(0)
p.line((x * xscl, f(x) * yscl), ((x + 0.1) * xscl, f(x + 0.1) * yscl))
x += 0.1
def draw():
p5.background(0)
if player.walking:
settings.Maps[settings.currentMap].move(player)
player.walkingAnimation(settings.Maps[settings.currentMap])
if player.walkTimer % player.walkingAnimationTime == 0 and player.stopRequest:
player.walking = False
player.walkTimer = 0
settings.Maps[settings.currentMap].show()
player.show()
settings.Maps[settings.currentMap].drawExtras()
p5.stroke(255)
p5.stroke_weight(1)
if showGrid:
for x in range(settings.Maps[settings.currentMap].gridWidth + 2):
p5.line((settings.Maps[settings.currentMap].GridtoPosX(x),
settings.Maps[settings.currentMap].GridtoPosY(0)),
(settings.Maps[settings.currentMap].GridtoPosX(x),
settings.Maps[settings.currentMap].GridtoPosY(
settings.Maps[settings.currentMap].gridHeight + 1)))
for y in range(settings.Maps[settings.currentMap].gridHeight + 2):
p5.line((settings.Maps[settings.currentMap].GridtoPosX(0),
settings.Maps[settings.currentMap].GridtoPosY(y)),
(settings.Maps[settings.currentMap].GridtoPosX(
settings.Maps[settings.currentMap].gridWidth + 1),
settings.Maps[settings.currentMap].GridtoPosY(y)))
def follow(self, path):
# calculate future location
predicted_location = copy.copy(self.velocity)
predicted_location.normalize()
predicted_location *= 10
predicted_location += self.location
shortest_distance = width # initialise to a large number
# check whether future location is on path
for i in range(len(path.points) - 1):
point_a = path.points[i]
point_b = path.points[i + 1]
norm = sp.scalar_projection(predicted_location, point_a, point_b)
if(norm.x < point_a.x or norm.x > point_b.x):
continue
distance = Vector.distance(norm, predicted_location)
if distance < shortest_distance:
shortest_distance = distance
direction = point_b - point_a
direction.normalize()
direction *= 20
target = norm + direction
if shortest_distance > path.radius:
self.steer(target)
if self.debug:
line(self._tup(self.location), (self._tup(predicted_location)))
fill(255, 0, 0)
ellipse((norm.x, norm.y), 10, 10)
fill(0, 255, 0)
ellipse((target.x, target.y), 10, 10)
def new_doodle(d):
p5.background(240, 238, 225)
n = doodles[d]
query = "SELECT MIN(vertex_x) as 'left', " \
"MAX(vertex_x) as 'right', " \
"MIN(vertex_y) as 'top', " \
"MAX(vertex_y) as 'bottom' " \
"FROM path_verticies " \
"WHERE doodle_id = '%s'" % d
table_rows = db.query(query)
outers = {
k: v
for k, v in zip(['left', 'right', 'top', 'bottom'], table_rows[0])
}
l, r, t, b = outers['left'], outers['right'], outers['top'], outers[
'bottom']
x_interp = interp1d([l, r], [0, res])
y_interp = interp1d([t, b], [0, res])
for i in range(n):
path_chars_columns = [
'doodle_id', 'path_number', 'color_r', 'color_g', 'color_b',
'stroke_weight'
]
path_verts_columns = [
'doodle_id', 'path_number', 'vertex_number', 'vertex_x', 'vertex_y'
]
query = "SELECT * FROM path_characteristics " \
"WHERE doodle_id = '%s' AND path_number = %d" % (d, i)
table_rows = db.query(query)
path_chars = {k: v for k, v in zip(path_chars_columns, table_rows[0])}
query = "SELECT * FROM path_verticies " \
"WHERE doodle_id = '%s' AND path_number = %d" % (d, i)
table_rows = db.query(query)
path_verts = pd.DataFrame(table_rows, columns=path_verts_columns)
p5.stroke(path_chars['color_r'], path_chars['color_g'],
path_chars['color_b'])
for i in range(path_verts.shape[0] - 1):
row = path_verts.iloc[i]
row_next = path_verts.iloc[i + 1]
x = round(float(x_interp(row.vertex_x)), 2)
y = round(float(y_interp(row.vertex_y)), 2)
x_next = round(float(x_interp(row_next.vertex_x)), 2)
y_next = round(float(y_interp(row_next.vertex_y)), 2)
p5.line((x, y), (x_next, y_next))
def draw():
global smallBall, bigBall
p5.background(0)
smallBall.updatePos(bigBall)
smallBall.collision(bigBall)
smallBall.show()
bigBall.show()
p5.stroke(255, 0, 0)
p5.line((smallBall.pos), (bigBall.pos))
def draw():
p5.translate(width / 2, height / 2)
#v=p5.Vector(randint(-100,100),randint(-100,100))
v = p5.Vector.random_2D() #random unit vector in 2d
v *= 100
p5.stroke_weight(4)
p5.stroke(255, 50)
p5.line((0, 0), (v.x, v.y))
def draw():
global smallBall, bigBall
p5.background(0)
MousePos = p5.Vector(mouse_x, mouse_y)
smallBall.pos = MousePos
smallBall.collision(bigBall)
print(abs(smallBall.relativePos(bigBall)))
smallBall.show()
bigBall.show()
p5.stroke(255, 0, 0)
p5.line((smallBall.pos), (bigBall.pos))
def draw():
p5.background(0)
pos = p5.Vector(200, 200)
mouse = p5.Vector(mouse_x, mouse_y)
v = mouse - pos
#m=abs(v)
v = v.normalize() * 100
p5.translate(width / 2, height / 2)
p5.stroke_weight(4)
p5.stroke(255)
p5.line((0, 0), (v.x, v.y))
def display(self):
for row in range(self.number_of_rows):
for column in range(self.number_of_columns):
origin = [column * self.resolution, row * self.resolution]
vector_x = copy.copy(self.field[row][column].x)
vector_y = copy.copy(self.field[row][column].y)
vector_x *= 10
vector_y *= 10
with push_matrix():
translate(self.resolution / 2, self.resolution / 2)
line((origin), (origin[0] + vector_x, origin[1] + vector_y))
reset_matrix()
def draw():
background(250)
global point_a
global point_b
stroke(0)
mouse = Vector(mouse_x, mouse_y)
line(point_a, mouse)
line(point_a, point_b)
norm = scalar_projection(mouse, point_a, point_b)
fill(255, 0, 0)
ellipse((norm.x, norm.y), 10, 10)
def draw():
p.background(255)
p.translate(width/2, height/2)
points = []
t = 0
while t < 1000:
points.append(harmonograph(t))
t += 0.01
for i, s in enumerate(points):
p.stroke_weight(0.01)
p.stroke(255, 0, 0)
if i < len(points)-1:
p.line((s[0], s[1]), (points[i+1][0], points[i+1][1]))
def draw():
p5.background(0)
p5.stroke(255)
p5.stroke_weight(strokeWeight)
if showGrid:
for x in range(int(gridW / gridScl) + 1):
x += gridOffsetX / gridScl
p5.line((x * gridScl, gridOffsetY),
(x * gridScl, gridOffsetY + gridH))
for y in range(int(gridH / gridScl) + 1):
y += gridOffsetY / gridScl
p5.line((gridOffsetX, y * gridScl),
(gridOffsetX + gridW, y * gridScl))
def draw(self):
p5.stroke_weight(0.01)
if self.stage > 0:
p5.rect((self.bottomLeft.x, self.bottomLeft.y), self.linewidth,
-self.height)
if self.stage > 1:
p5.rect((self.bottomLeft.x, self.bottomLeft.y - self.height),
self.width / 2 + self.linewidth / 2, self.linewidth)
if self.stage > 2:
p5.rect((self.bottomLeft.x + self.width / 2 - self.linewidth / 2,
self.bottomLeft.y - self.height), self.linewidth,
self.height / 4)
if self.stage > 3:
p5.no_fill()
p5.circle((self.bottomLeft.x + self.width / 2, self.bottomLeft.y -
self.height + self.height / 4 + (self.linewidth * 2.5)),
self.linewidth * 5,
mode="CENTER")
if self.stage > 4:
p5.fill(255)
p5.rect((self.bottomLeft.x + self.width / 2 - self.linewidth / 4,
self.bottomLeft.y - self.height + self.height / 4 +
(self.linewidth * 5)), self.linewidth / 2,
self.height / 4)
if self.stage > 5:
p5.rect((self.bottomLeft.x + self.width / 2 - self.linewidth / 4,
self.bottomLeft.y - self.height + self.height / 4 +
(self.linewidth * 5) + 10), -self.width / 4,
self.linewidth / 2)
if self.stage > 6:
p5.rect((self.bottomLeft.x + self.width / 2 + self.linewidth / 4,
self.bottomLeft.y - self.height + self.height / 4 +
(self.linewidth * 5) + 10), self.width / 4,
self.linewidth / 2)
if self.stage > 7:
p5.stroke(255)
p5.stroke_weight(4)
p5.line((self.bottomLeft.x + self.width / 2,
self.bottomLeft.y - self.height + self.height / 4 +
(self.linewidth * 5) + self.height / 4),
(self.bottomLeft.x + self.width - self.width / 4,
self.bottomLeft.y - self.height / 12))
if self.stage > 8:
p5.line((self.bottomLeft.x + self.width / 2,
self.bottomLeft.y - self.height + self.height / 4 +
(self.linewidth * 5) + self.height / 4),
(self.bottomLeft.x + self.width - self.width * 3 / 4,
self.bottomLeft.y - self.height / 12))
def grid(xscl, yscl):
p.stroke_weight(1)
p.stroke(0, 255, 255)
for i in range(xmin, xmax + 1):
p.line((i * xscl, ymin * yscl), (i * xscl, ymax * yscl))
for i in range(ymin, ymax + 1):
p.line((xmin * xscl, i * yscl), (xmax * xscl, i * yscl))
p.stroke(0)
p.line((0, ymin * yscl), (0, ymax * yscl))
p.line((xmin * xscl, 0), (xmax * xscl, 0))
def new_doodle():
p5.background(240, 238, 225)
d = doodle_ids[randint(0, len(doodle_ids) - 1)]
n = doodles[d]
for i in range(n):
path_chars_columns =['doodle_id', 'path_number', 'color_r',
'color_g', 'color_b', 'stroke_weight']
path_verts_columns =['doodle_id', 'path_number',
'vertex_number', 'vertex_x', 'vertex_y']
query = "SELECT * FROM path_characteristics " \
"WHERE doodle_id = '%s' AND path_number = %d" % (d, i)
cursor.execute(query)
table_rows = cursor.fetchall()
path_chars = {k:v for k,v in zip(path_chars_columns, table_rows[0])}
query = "SELECT * FROM path_verticies " \
"WHERE doodle_id = '%s' AND path_number = %d" % (d, i)
cursor.execute(query)
table_rows = cursor.fetchall()
path_verts = pd.DataFrame(table_rows, columns=path_verts_columns)
p5.stroke(path_chars['color_r'],
path_chars['color_g'],
path_chars['color_b'])
# p5.stroke_weight(path_chars['stroke_weight'])
for i in range(path_verts.shape[0] - 1):
row = path_verts.iloc[i]
row_next = path_verts.iloc[i + 1]
x = round(row.vertex_x, 2)
y = round(row.vertex_y, 2)
x_next = round(row_next.vertex_x, 2)
y_next = round(row_next.vertex_y, 2)
p5.line((x, y), (x_next, y_next))
def draw():
global t, circleList
p.background(200)
p.translate(width / 4, height / 2)
p.no_fill()
p.stroke(0)
p.ellipse((0, 0), 2 * r1, 2 * r1)
p.fill(255, 0, 0)
y = r1 * p.sin(t)
x = r1 * p.cos(t)
circleList = [y] + circleList[:249]
p.ellipse((x, y), r2, r2)
p.stroke(0, 255, 0)
p.line((x, y), (200, y))
p.fill(0, 255, 0)
p.ellipse((200, y), 10, 10)
for i, c in enumerate(circleList):
p.ellipse((200 + i, c), 15, 15)
t += 0.1
def draw():
global r1, r2, x1, y1, t, prop, points
p.translate(width / 2, height / 2)
p.background(255)
p.no_fill()
p.stroke(0)
p.ellipse((x1, y1), 2 * r1, 2 * r1)
x2 = (r1 - r2) * p.cos(t)
y2 = (r1 - r2) * p.sin(t)
p.ellipse((x2, y2), 2 * r2, 2 * r2)
x3 = x2 + prop * (r2 - r3) * p.cos(-((r1 - r2) / r2) * t)
y3 = y2 + prop * (r2 - r3) * p.sin(-((r1 - r2) / r2) * t)
p.fill(255, 0, 0)
p.ellipse((x3, y3), 2 * r3, 2 * r3)
points = [[x3, y3]] + points[:2000]
for i, d in enumerate(points):
if i < len(points) - 1:
p.stroke(255, 0, 0)
p.line((d[0], d[1]), (points[i + 1][0], points[i + 1][1]))
t += 0.1
def displayWord(self, word):
self.word = word
self.wordLength = len(word)
self.spacing = (self.width / (self.wordLength)) / 2
self.offset = (width / 2 - self.width / 2) + self.spacing / 2
self.txt_size = int(self.spacing * 4 / 3)
self.GuessFont = p5.create_font("arial.ttf", self.txt_size)
p5.text_font(self.GuessFont, self.txt_size)
p5.text_align("CENTER", "BASELINE")
self.txt_width = p5.text_width("A")
for i in range(self.wordLength):
p5.fill(255)
p5.text(word[i],
((i * 2 * self.spacing) + self.spacing / 2 + self.offset,
self.y - (self.txt_width * 4 / 3) - 2))
p5.line((i * 2 * self.spacing + self.offset, self.y),
(((i * 2) + 1) * self.spacing + self.offset, self.y))
def draw():
global ofset, x, y, z,fp,fl
if(flag7=="fsek"):
ofset = sek
if (flag2 == "pus"):
pass
if(flag8=="nxt" or flag9=="pev"):
ofset=sek
fp=fl
else:
signal, sampling_rate = audio2numpy.audio_from_file(fp, offset=ofset, duration=dur, dtype='int')
p.background(250)
signal = abs(signal)
# signal = signal[..., 1]
ofset = ofset + dur
# print(np.size(signal[:250]))
for i in signal:
p.line((x, height - 5), (x, -(200 * i[1] + 50) + height - 5))
x +=1.5
p.line((x, height - 5), (x, -(200 * i[0]+100) + height - 5))
x+=1.5
p.line((x, height - 5), (x, -(200*i[1]+50)+height - 5))
x +=1.5
if (ofset >= final):
pass
time.sleep(dur)
x = 5
def draw_objects(self):
# global simulation
# triangle((0, 0), (0, 200), (350, 100))
background(30, 30, 47)
# don't paint obstacles for free run
if self.free_run:
return
fill(50)
# shaded are upper quadrant
quad((0, 0), (0, 160), (280, 256), (self.shaded_area_x, 0))
quad((0, self.height), (0, 640), (280, 544),
(self.shaded_area_x, self.height))
fill(102)
triangle((0, 160), (0, 640), (700, 400))
# fishes' start box
rect((self.box_left, 335), self.box_width, self.box_width)
# replica line
for rc in self.replicas_coordinates:
line((0, rc[2]), (rc[0], rc[1]))
# line((0, 720), (self.replica_x_start, self.replica_y_start))
# shaded area line
line((self.shaded_area_x, 0), (self.shaded_area_x, self.height))
# 544
# decision line
line((self.decision_x, 0), (self.decision_x, self.height))
def show(self):
# find line showing boid direction
y_angle = math.atan(self.velocity[1] / self.velocity[0])
x_angle = math.atan(self.velocity[0] / self.velocity[1])
larger = x_angle if x_angle > y_angle else y_angle
lsign = -1 if larger < 0 else 1
norm_x = x_angle / (10.0 * lsign)
norm_y = y_angle / (10.0 * lsign)
x_mult = -1 if self.velocity[0] < 0 else 1
y_mult = -1 if self.velocity[1] < 0 else 1
x_point_coord = self.position[0] + (x_mult * norm_x * 100)
y_point_coord = self.position[1] + (y_mult * norm_y * 100)
# show the boid on the grid
stroke(255)
fill(255)
circle(self.position, 9)
stroke("red")
line(self.position, (x_point_coord, y_point_coord))
def draw():
# sayac değikenini düzenlemek için global
global sayac
# Eğer ilk framede isek, arka planı siyah yap
if sayac == 0:
p5.background(p5.Color(0, 0, 0))
# isimlerin sayacinci elemanını al
isim = isimler[sayac]
# 0, 0 noktasını ekranın sol üst köşesine taşı (resetleme)
p5.reset_matrix()
# 0, 0 noktasını ekranın x ekseninnde orta, y ekseninde alt tarafa taşı
p5.translate(1920 / 2, 1080 - 50)
# isim deki her harf için döngü başlat
for harf in isim:
# harfın ascii değerine bak.
if ord(harf) % 2:
# Çift ise pozitif yönde aci kadar dön
p5.rotate(aci)
else:
# Tek ise negatif yönde aci kadar dön
p5.rotate(-aci)
# 0, 0'dan y yönünde uzunluk kadar br çizgi çiz
p5.line(p5.Vector(0, 0), p5.Vector(0, -uzuluk))
# 0, 0 noktasını çizilen çizginin son noktasına taşı
p5.translate(0, -uzuluk)
# Eğer sayac isimlerin uzunluğundan bir eksik ise
if sayac == len(isimler) - 1:
# Bitti yaz ve p5, döngüsünü durdur
print("Bitti")
p5.no_loop()
else:
# değilse, sayac'ı bir arttır
sayac += 1
def draw():
# Arka planı siyah yap
p5.background(0)
# Orijini pencerenin merkezine taşı
p5.translate(width / 2, height / 2)
# clock fonsiyonundan gelen değerleri
# sırasıyla h, m ve s değişkenlerine ata
h, m, s = clock()
# Çevre çizgisi çizme
p5.no_stroke()
# [0, 360) aralığında 6'şar derece aralıklarla değer oluştur
# 0, 6, 12, ..., 342, 348, 354
for i in range(0, 360, 6):
# Kutupsal koordinat sisteminde
# (r_d, i) değerini kartezyen koordinat sistemine dönüştür
d_x, d_y = pol2car(r_d, i)
# i değeri 30'un tam katıysa,
if i % 30 == 0:
# saat değerleri için nokta koyacağız
p5.fill(255, 0, 0)
r = 15
else:
# dakika/saniye değerleri için nokta koyacağız
p5.fill(255)
r = 10
# Belirlenen özelliklerle hesaplanan noktada
# bir daire çiz
p5.circle((d_x, d_y), r)
# Akrep kolunun ucunun konumunu hesala
h_x, h_y = pol2car(r_h, h)
# Akrep kolunun şekil ayarlarını yap
p5.stroke(255)
p5.stroke_weight(5)
# Akrep konu çiz
p5.line((0, 0), (h_x, h_y))
# Yelkovan kolunun ucunun konumunu hesala
m_x, m_y = pol2car(r_m, m)
# Yelkovan kolunun şekil ayarlarını yap
p5.stroke(255)
p5.stroke_weight(3)
# Yelkovan konu çiz
p5.line((0, 0), (m_x, m_y))
# Saniye kolunun ucunun konumunu hesala
s_x, s_y = pol2car(r_s, s)
# Saniye kolunun şekil ayarlarını yap
p5.stroke(255, 0, 0)
p5.stroke_weight(1)
# Saniye konu çiz
p5.line((0, 0), (s_x, s_y))
def show(self, boid_list):
y_angle = math.atan(self.vel[1] / self.vel[0])
x_angle = math.atan(self.vel[0] / self.vel[1])
larger = x_angle if x_angle > y_angle else y_angle
lsign = -1 if larger < 0 else 1
norm_x = x_angle / (10.0 * lsign)
norm_y = y_angle / (10.0 * lsign)
x_mult = -1 if self.vel[0] < 0 else 1
y_mult = -1 if self.vel[1] < 0 else 1
x_point_coord = self.pos[0] + (x_mult * norm_x * 150)
y_point_coord = self.pos[1] + (y_mult * norm_y * 150)
if self.id == 0 and VIEW_DISPLAY_ON:
stroke("gray", alpha=100.5, v2=80)
fill("gray", alpha=100.5, v2=80)
circle((self.pos), radius=2 * VIEWING_DIST)
stroke("blue")
for boid in boid_list:
x_coord_difference = self.pos[0] - boid.pos[0]
y_coord_difference = self.pos[1] - boid.pos[1]
dist = magnitude(x_coord_difference, y_coord_difference)
#if within min distance
if dist <= VIEWING_DIST:
try:
line(self.pos, boid.pos)
except:
pass
#get random color
stroke(255)
fill(255)
circle(self.pos, radius=10)
stroke("red")
line(self.pos, (x_point_coord, y_point_coord))
def follow(self, path):
# calculate future location
predicted_location = copy.copy(self.velocity)
predicted_location.normalize()
predicted_location *= 50
predicted_location += self.location
# check whether future location is on path
norm = sp.scalar_projection(predicted_location, path.point_a,
path.point_b)
distance = Vector.distance(norm, predicted_location)
direction = path.point_b - path.point_a
direction.normalize()
direction *= 20
target = norm + direction
if distance > path.radius:
self.steer(target)
if self.debug:
line(self._tup(self.location), (self._tup(predicted_location)))
fill(255, 0, 0)
ellipse((norm.x, norm.y), 10, 10)
fill(0, 255, 0)
ellipse((target.x, target.y), 10, 10)
def drawProjectionLine(self,line):
p5.stroke(255,0,0)
p5.fill(255,0,0)
if line.p1.x!=line.p2.x:
#not a vertical line
posfromLine=self.pos-line.p1
multiplier=(posfromLine.dot(line.Vector))/(abs(line.Vector)**2)
proj=line.Vector*multiplier
closestPoint=proj+line.p1
if closestPoint.x>line.p1.x and closestPoint.x<line.p2.x:
p5.circle((closestPoint),10)
p5.line((closestPoint),(self.pos))
elif closestPoint.x<line.p1.x:
p5.circle((line.p1),10)
p5.line((line.p1),(self.pos))
elif closestPoint.x>line.p2.x:
p5.circle((line.p2),10)
p5.line((line.p2),(self.pos))
else:
#a vertical line
#print("Vertical")
closestPoint=p5.Vector(line.p1.x,self.pos.y)
if closestPoint.y>line.p1.y and closestPoint.y<line.p2.y:
p5.circle((closestPoint),10)
p5.line((closestPoint),(self.pos))
elif closestPoint.y<line.p1.y:
p5.circle((line.p1),10)
p5.line((line.p1),(self.pos))
elif closestPoint.y>line.p2.y:
p5.circle((line.p2),10)
p5.line((line.p2),(self.pos))
def show(self):
p5.stroke(255)
p5.line(self.p1,self.p2)
def applyForce(self, force):
self.acceleration += force
line(
(self.location.x, self.location.y),
(self.location.x - force.x, self.location.y - force.y),
)
def graphPoints2(pointList, edges):
for e in edges:
p.line((pointList[e[0]][0] * xscl, pointList[e[0]][1] * yscl),
(pointList[e[1]][0] * xscl, pointList[e[1]][1] * yscl))
def draw_lines(self):
for col in range(self.number_of_columns):
line((col * self.resolution, 0), (col * self.resolution, height))
for row in range(self.number_of_rows):
line((0, row * self.resolution), (width, row * self.resolution))
