Repository navigation
Ideas for drawing many triangles #805
Replies: 3 comments 5 replies
|
I squeezed quite a bit more performance with more NumPy 😄 Version 3import itertools
import py5
import numpy as np
colors = []
positions = []
TS = 10 # triangle size
N = 5000 # number of positions
RS = 2 # amplitude of random movemnt
def setup():
py5.size(400, 400, py5.P3D)
py5.no_stroke()
create_positions(N)
py5.profile_draw()
def create_positions(n):
global positions, shp, colors
positions = np.array([
(py5.random_int(py5.width),py5.random_int(py5.height))
for _ in range(N)
])
all_vertices = list(itertools.chain.from_iterable(
((rx, ry), (rx + TS, ry), (rx, ry + TS))
for rx, ry in positions
))
shp = py5.create_shape()
shp.begin_shape(py5.TRIANGLES)
shp.vertices(all_vertices)
shp.end_shape()
colors = [py5.color(py5.random_int(255),
py5.random_int(255),
py5.random_int(255))
for triangle in positions for _ in range(3)]
shp.set_fills(colors)
def draw():
global positions
py5.background(0)
# recreate shape
rnd_offsets = np.random.randint(-RS, RS, size=(N, 2))
positions += rnd_offsets
positions %= 400, 400
all_vertices = np.empty((N * 3, 2), dtype=positions.dtype)
all_vertices[0::3] = positions
all_vertices[1::3] = positions + [TS, 0]
all_vertices[2::3] = positions + [0, TS]
shp = py5.create_shape()
shp.begin_shape(py5.TRIANGLES)
shp.vertices(all_vertices)
shp.end_shape()
shp.set_fills(colors)
# # update shape
# rnd_offsets = np.random.randint(-RS, RS, size=(N, 2))
# positions += rnd_offsets
# positions %= 400, 400
# for i, (nx, ny) in enumerate(positions):
# shp.set_vertex(i * 3, nx, ny)
# shp.set_vertex(i * 3 + 1, nx + TS, ny)
# shp.set_vertex(i * 3 + 2, nx, ny + TS)
# draw shape
py5.shape(shp)
# show frame rate
py5.window_title(f'{py5.get_frame_rate():.1f}')
if py5.frame_count == 1001:
py5.print_line_profiler_stats()
py5.run_sketch() |
|
Great use of py5's profile tool! Performance tuning is a great way to learn.
Each time you access those properties you pull the number from Java which has some extra overhead. It would be faster to write code like For this code: positions = np.array([
(py5.random_int(py5.width),py5.random_int(py5.height))
for _ in range(N)
])you don't need an iterator. You can do something like similarly, all_vertices = list(itertools.chain.from_iterable(
((rx, ry), (rx + TS, ry), (rx, ry + TS))
for rx, ry in positions
))this could be redone without the iterator. I think you'd need |
|
You are right! I left the initializing function behind with no optimizations! Both things are done better in draw, I think the positions could be The all_vertices = np.empty((N * 3, 2), dtype=positions.dtype)
all_vertices[0::3] = positions
all_vertices[1::3] = positions + [TS, 0]
all_vertices[2::3] = positions + [0, TS] |
|
@hx2A, in theory I could use this, but I can't read or explain it easily: offsets = np.array([[0, 0], [TS, 0], [0, TS]])
all_vertices = (positions[:, np.newaxis] + offsets).reshape(-1, 2) |
|
Right that is hard to explain, but it does work, and it is worth the effort you put into figuring this out. I do think there are learning opportunities that are achieved by searching for simpler or more concise ways of coding something. Not necessarily for new coders but a great mental exercise for you. |
|
Trying to improve my naive Object Oriented flocking simulation adding more numpy operations, but without dismantling the OO completely... import numpy as np
import py5
from py5 import Py5Vector as V
N = 50
def setup():
global color_ints
py5.size(500, 500, py5.P3D)
py5.no_stroke()
for _ in range(N):
Boid(250 + py5.random(-100, 100), 250 + py5.random(-100, 100))
py5.color_mode(py5.CMAP, py5.mpl_cmaps.VIRIDIS, 255)
Boid.init_flock_arrays()
def draw():
py5.background('black')
Boid.flock_update()
py5.window_title(str(int(py5.get_frame_rate())))
def key_pressed():
py5.save_frame('####.png')
class Boid:
vel_maxima = 4
forca_maxima = 0.3
alignment_radius = 100
separation_radius = 50
cohesion_radius = 50
flock = []
flock_positions = None # (N, 2)
flock_vels = None # (N, 2)
diff = None # (N, N, 2): diff[i, j] = pos_i - pos_j
sq_dist = None # (N, N)
def __init__(self, x, y):
self.pos = V(x, y)
self.vel = V.random(2) * py5.random(1, 3)
self.acc = V(0, 0)
self.index = len(self.flock)
self.flock.append(self)
@classmethod
def init_flock_arrays(cls):
cls.flock_positions = np.array(
[[b.pos.x, b.pos.y] for b in cls.flock], dtype=float)
cls.flock_vels = np.array(
[[b.vel.x, b.vel.y] for b in cls.flock], dtype=float)
#cls.flock_update()
cls.color_ints = np.array([py5.color(i) for i in range(255)])
@classmethod
def flock_update(cls):
diff = (cls.flock_positions[:, np.newaxis, :]
- cls.flock_positions[np.newaxis, :, :])
cls.diff = diff
cls.sq_dist = np.sum(diff ** 2, axis=-1)
for b in cls.flock:
b.update()
positions = cls.flock_positions
vels = cls.flock_vels
perp = np.stack([-vels[:, 1], vels[:, 0]], axis=1)
#norms = np.linalg.norm(perp, axis=1, keepdims=True)
#norms[norms == 0] = 1 # to avoid division-by-zero
#perp_unit = perp / norms
esquerda = positions - vels * 4 + perp
direita = positions - vels * 4 - perp
all_vertices = np.stack([positions, esquerda, direita], axis=1).reshape(-1, 2)
pc = (positions[:, 0] + positions[:, 1]) / 1000 * 255
colors = cls.color_ints[np.repeat(pc, 3).astype(np.int8)]
shp = py5.create_shape()
shp.begin_shape(py5.TRIANGLES)
shp.no_stroke()
shp.vertices(all_vertices)
shp.end_shape()
shp.set_fills(colors)
py5.shape(shp)
def update(self):
self.acc += self.separation()
self.acc += self.alignment()
self.acc += self.cohesion()
self.vel += self.acc
self.acc.set_mag(0)
self.vel.set_limit(self.vel_maxima)
self.pos += self.vel
self.pos.x = self.pos.x % py5.width
self.pos.y = self.pos.y % py5.height
self.flock_positions[self.index] = (self.pos.x, self.pos.y)
self.flock_vels[self.index] = (self.vel.x, self.vel.y)
def cohesion(self):
steering = V(0, 0)
dist_row = self.sq_dist[self.index]
mask = dist_row < self.cohesion_radius ** 2
mask[self.index] = False # exclui o próprio
if mask.any():
centro_massa = self.flock_positions[mask].mean(axis=0)
direcao_ao_cm = V(*centro_massa) - self.pos
direcao_ao_cm.set_mag(self.vel_maxima)
steering = direcao_ao_cm - self.vel
steering.set_limit(self.forca_maxima)
return steering
def alignment(self):
steering = V(0, 0)
dist_row = self.sq_dist[self.index]
mask = dist_row < self.alignment_radius ** 2
mask[self.index] = False # exclude self
if mask.any():
avg_V = V(*self.flock_vels[mask].mean(axis=0))
avg_V.set_mag(self.vel_maxima)
steering = avg_V - self.vel
return steering
def separation(self):
steering = V(0, 0)
dist_sq = self.sq_dist[self.index]
# exclude boids at zero distance
mask = (dist_sq > 0) & (dist_sq < self.separation_radius ** 2)
if mask.any():
distances = np.sqrt(dist_sq[mask])
diff_vectors = self.diff[self.index][mask] / distances[:, np.newaxis]
avg_V = V(*diff_vectors.mean(axis=0))
if avg_V.mag_sq > 0:
avg_V.set_mag(self.vel_maxima)
steering = avg_V - self.vel
steering.set_limit(self.forca_maxima)
return steering
py5.run_sketch()
|
|
The fastest would be to put all the positions and velocities in the same numpy array. You can create a numpy array that is a "view" into another numpy array. Such a thing might be useful here because each Boid can then only see its own data but all of the data is in the same large array, where you can then do vectorized operations for the cohesion, separation, and alignment in one shot. This would be he fasest |
|
I see... the thing that kind of bothers me is that to make things fast it doesn't make much sense to keep the OO structure, you really don't need it, you can add all accelerations to all velocities and all velocities to all positions and it's all much faster... it becomes the Rougier's example basically. But, trying to keep OO and use the view idea, we could maybe try something like this. I don't know if it would make much sense, but it surely would avoid copying positions and velocities around: def __init__(self, x, y):
self.index = len(self.flock)
self.pos = self.flock_positions[self.index]
self.pos[:] = (x, y)
self.vel = self.flock_velocities[self.index]
self.vel[:] = V.random(2) * py5.random(1, 3)
self.acc = self.flock_accelerations[self.index ] # starts as zeros
self.flock.append(self)But again, initial positions and and velocities could be initialized "en masse"... |
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
Last week we were doing some "flocking" explorations at the community center where I work. Inspired by Shiffman's Nature of Code implementation of the Reynolds' Boids simulation model.
Collecting all the boid's "bodies", with boid.update() that returns the boid's position and two other vertices to make a triangle, I was drawing them like this:
This in turn made me think about strategies for drawing and "updating" many colored triangles, so I made these two minimal examples to test perfomance... using
py5.P2Dfor the vertex based coloring, and thepy5.profiler_draw()feature to check performance of some ideas.The main idea is to create a Py5Shape and color the triangles using
shp.set_fills(color_sequence).I knew calling random for individual values was slow, so I got a all the values from NumPy's random before the loop. 😉
But I was surprised to learn that using
py5.widthandpy5.heightinside my triangle loop (thousands of times for each frame) was very slow! 😮The main difference I wanted to test was to update vertices of the triangles, in lieu of recreating the shape, but the result was kind of disapointing... you can judge by yourself! More tests and ideas are welcome!
Version 1
Draw profiler result for version 1
Version 2
Draw profiler result for version 2
I'm not sure my interpretation is correct, but it looks like drawing the same updated shape is much faster than drawing a freshly created shape each frame, but on the other hand
shp.set_vertex()can be rather slow and it offsets the performance making version 2 slower (even if version 1 has to use time recreating the shape and recoloring it).All reactions