def flashlight(phi=np.pi/4, direction=(0,0,1), size=None, dtype=np.double):
theta, u = np.random.uniform(0.0, 2*np.pi, size), \
np.random.uniform(np.cos(phi), 1, size)
c = np.sqrt(1-u**2)
if np.equal(direction, (0,0,1)).all():
rotation_axis = (0,0,1)
rotation_angle = 0.0
else:
rotation_axis = np.cross((0,0,1), direction)
rotation_angle = \
-np.arccos(np.dot(direction, (0,0,1))/np.linalg.norm(direction))
if size is None:
return rotate(np.array([c*np.cos(theta), c*np.sin(theta), u]),
rotation_angle, rotation_axis)
points = np.empty((size, 3), dtype)
points[:,0] = c*np.cos(theta)
points[:,1] = c*np.sin(theta)
points[:,2] = u
return rotate(points, rotation_angle, rotation_axis)
def laser(radius, hwhm, direction=(0, 0, 1), size=None, dtype=np.double):
"""
Creates a collimated laser source (positions) with Lorentzian (Cauchy) distribution.
CURRENTLY DEPRECATED
"""
r, theta = lineshape(radius, hwhm, size) #Theta aziumthal
if np.equal(direction, (0, 0, 1)).all():
rotation_axis = (0, 0, 1)
rotation_angle = 0.0
else:
rotation_axis = np.cross((0, 0, 1), direction)
rotation_angle = -np.arccos(
np.dot(direction, (0, 0, 1)) / np.linalg.norm(direction))
if size == None:
raise Exception("laser: size is None!")
points = np.empty((size, 3), dtype)
points[:, 0] = r * np.cos(theta)
points[:, 1] = r * np.sin(theta)
points[:, 2] = np.zeros(size)
return rotate(points, rotation_angle, rotation_axis)
def test_rotate():
n = nthreads_per_block * blocks
a = np.random.rand(n, 3).astype(np.float32)
t = np.random.rand(n).astype(np.float32) * 2 * np.pi
w = normalize(np.random.rand(3))
a_gpu = ga.to_gpu(to_float3(a))
t_gpu = ga.to_gpu(t)
dest_gpu = ga.empty(n, dtype=ga.vec.float3)
t0 = time.time()
rotate_gpu(a_gpu,
t_gpu,
ga.vec.make_float3(*w),
dest_gpu,
block=(nthreads_per_block, 1, 1),
grid=(blocks, 1))
autoinit.context.synchronize()
elapsed = time.time() - t0
print('elapsed %f sec' % elapsed)
r = rotate(a, t, w)
assert np.allclose(r,
dest_gpu.get().view(np.float32).reshape((-1, 3)),
atol=1e-5)
def rotate_around_point(self, phi, n, point, redraw=True):
self.axis1 = rotate(self.axis1, phi, n)
self.axis2 = rotate(self.axis2, phi, n)
if self.display3d:
self.rays1.rotate_around_point(phi, n, point)
self.rays2.rotate_around_point(phi, n, point)
self.scope_rays.rotate_around_point(phi, n, point)
else:
self.rays.rotate_around_point(phi, n, point)
if redraw:
if self.hybrid_render:
self.clear_image()
self.update()
def rotate_around_point(self, phi, n, point, redraw=True):
self.axis1 = rotate(self.axis1, phi, n)
self.axis2 = rotate(self.axis2, phi, n)
if self.display3d:
self.rays1.rotate_around_point(phi, n, point)
self.rays2.rotate_around_point(phi, n, point)
self.scope_rays.rotate_around_point(phi, n, point)
else:
self.rays.rotate_around_point(phi, n, point)
if redraw:
if self.hybrid_render:
self.clear_image()
self.update()
def rotate_extrude(x, y, nsteps=64):
"""
Return the solid mesh formed by extruding the profile defined by the x and
y points `x` and `y` around the y axis.
.. note::
The path traced by the points `x` and `y` should go counter-clockwise,
otherwise the mesh will be inside out.
Example:
>>> # create a bipyramid
>>> m = rotate_extrude([0,1,0], [-1,0,1], nsteps=4)
"""
if len(x) != len(y):
raise Exception('`x` and `y` arrays must have the same length.')
points = np.array([x, y, np.zeros(len(x))]).transpose()
steps = np.linspace(0, 2 * np.pi, nsteps, endpoint=False)
vertices = np.vstack(
[rotate(points, angle, (0, -1, 0)) for angle in steps])
triangles = mesh_grid(
np.arange(len(vertices)).reshape(
(len(steps), len(points))).transpose()[::-1])
return Mesh(vertices, triangles, remove_duplicate_vertices=True)
def rotate(self, phi, n):
if self.display3d:
self.rays1.rotate(phi, n)
self.rays2.rotate(phi, n)
self.scope_rays.rotate(phi, n)
self.point1 = rotate(self.point1, phi, n)
self.point2 = rotate(self.point2, phi, n)
else:
self.rays.rotate(phi, n)
self.point = rotate(self.point, phi, n)
self.axis1 = rotate(self.axis1, phi, n)
self.axis2 = rotate(self.axis2, phi, n)
if self.hybrid_render:
self.clear_image()
self.update()
def rotate(self, phi, n):
if self.display3d:
self.rays1.rotate(phi, n)
self.rays2.rotate(phi, n)
self.scope_rays.rotate(phi, n)
self.point1 = rotate(self.point1, phi, n)
self.point2 = rotate(self.point2, phi, n)
else:
self.rays.rotate(phi, n)
self.point = rotate(self.point, phi, n)
self.axis1 = rotate(self.axis1, phi, n)
self.axis2 = rotate(self.axis2, phi, n)
if self.hybrid_render:
self.clear_image()
self.update()
def rotate_extrude(x, y, nsteps=64):
"""
Return the solid mesh formed by extruding the profile defined by the x and
y points `x` and `y` around the y axis.
.. note::
The path traced by the points `x` and `y` should go counter-clockwise,
otherwise the mesh will be inside out.
Example:
>>> # create a bipyramid
>>> m = rotate_extrude([0,1,0], [-1,0,1], nsteps=4)
"""
if len(x) != len(y):
raise Exception('`x` and `y` arrays must have the same length.')
points = np.array([x,y,np.zeros(len(x))]).transpose()
steps = np.linspace(0, 2*np.pi, nsteps, endpoint=False)
vertices = np.vstack([rotate(points,angle,(0,-1,0)) for angle in steps])
triangles = mesh_grid(np.arange(len(vertices)).reshape((len(steps),len(points))).transpose()[::-1])
return Mesh(vertices, triangles, remove_duplicate_vertices=True)
def process_event(self, event):
if event.type == MOUSEBUTTONDOWN:
if event.button == 4:
v = self.scale * np.cross(self.axis1, self.axis2) / 10.0
self.translate(v)
elif event.button == 5:
v = -self.scale * np.cross(self.axis1, self.axis2) / 10.0
self.translate(v)
elif event.button == 1:
mouse_position = pygame.mouse.get_rel()
self.clicked = True
elif event.type == MOUSEBUTTONUP:
if event.button == 1:
self.clicked = False
elif event.type == MOUSEMOTION and self.clicked:
movement = np.array(pygame.mouse.get_rel())
if (movement == 0).all():
return
length = np.linalg.norm(movement)
mouse_direction = movement[0] * self.axis2 - movement[
1] * self.axis1
mouse_direction /= np.linalg.norm(mouse_direction)
if pygame.key.get_mods() & (KMOD_LSHIFT | KMOD_RSHIFT):
v = -mouse_direction * self.scale * length / float(self.width)
self.translate(v)
else:
phi = np.float32(2 * np.pi * length / float(self.width))
n = rotate(mouse_direction, np.pi / 2,
np.cross(self.axis1, self.axis2))
if pygame.key.get_mods() & KMOD_LCTRL:
self.rotate_around_point(phi, n, self.point)
else:
self.rotate(phi, n)
elif event.type == KEYDOWN:
if event.key == K_LALT or event.key == K_RALT:
if self.motion == 'coarse':
self.scale = self.mesh_diagonal_norm / 20.0
self.motion = 'fine'
elif self.motion == 'fine':
self.scale = self.mesh_diagonal_norm / 400.0
self.motion = 'superfine'
elif self.motion == 'superfine':
self.scale = self.mesh_diagonal_norm
self.motion = 'coarse'
elif event.key == K_F6:
self.clear_xyz_lookup()
self.clear_image()
self.source_position = self.point
elif event.key == K_F7:
for i in range(100):
self.update_xyz_lookup(self.point)
self.source_position = self.point
elif event.key == K_F11:
pygame.display.toggle_fullscreen()
elif event.key == K_ESCAPE:
self.done = True
return
elif event.key == K_EQUALS:
if self.alpha_depth < self.max_alpha_depth:
self.alpha_depth += 1
self.update()
elif event.key == K_MINUS:
if self.alpha_depth > 1:
self.alpha_depth -= 1
self.update()
elif event.key == K_PAGEDOWN:
if self.currentlayer is None:
self.currentlayer = None
else:
if self.currentlayer > 0:
self.currentlayer -= 1
else:
self.currentlayer = None
self.loadlayer(self.currentlayer)
elif event.key == K_PAGEUP:
if self.currentlayer is None:
self.currentlayer = 0
else:
if self.currentlayer < self.bvh_layer_count:
self.currentlayer += 1
else:
self.currentlayer = None
self.loadlayer(self.currentlayer)
elif event.key == K_3:
if self.display3d:
self.disable3d()
else:
self.enable3d()
self.update()
elif event.key == K_g:
self.green_magenta = not self.green_magenta
self.update()
elif event.key == K_F12:
self.screenshot()
elif event.key == K_F5:
if not hasattr(self, 'rng_states_gpu'):
self.initialize_render()
self.hybrid_render = not self.hybrid_render
self.clear_image()
self.update()
elif event.key == K_m:
if self.movie:
encode_movie(self.movie_dir)
self.movie_dir = None
self.movie = False
else:
self.movie_index = 0
self.movie_dir = tempfile.mkdtemp()
self.movie = True
elif event.type == pygame.SYSWMEVENT and self.spnav:
# Space Navigator controls
spnav_event = self.spnav_module.spnav_x11_event(event.event)
if spnav_event is None:
return
if spnav_event.ev_type == self.spnav_module.SPNAV_EVENT_MOTION:
if pygame.key.get_mods() & (KMOD_LSHIFT | KMOD_RSHIFT):
accelerate_factor = 2.0
else:
accelerate_factor = 1.0
v1 = self.axis1
v2 = self.axis2
v3 = np.cross(self.axis1, self.axis2)
x, y, z = spnav_event.translation
rx, ry, rz = spnav_event.rotation
v = v2 * x + v1 * y + v3 * z
v *= self.scale / 5000.0 * accelerate_factor
self.translate(v, redraw=False)
axis = -v2 * rx - v1 * ry - v3 * rz
if (axis != 0).any():
axis = axis.astype(float)
length = np.linalg.norm(axis)
angle = length * 0.0001 * accelerate_factor
axis /= length
self.rotate_around_point(angle,
axis,
self.point,
redraw=False)
if self.hybrid_render:
self.clear_image()
self.update()
pygame.event.clear(pygame.SYSWMEVENT)
elif spnav_event.ev_type == self.spnav_module.SPNAV_EVENT_BUTTON:
if spnav_event.bnum == 0 and spnav_event.press:
if not hasattr(self, 'rng_states_gpu'):
self.initialize_render()
self.hybrid_render = not self.hybrid_render
self.clear_image()
self.update()
pygame.event.clear(pygame.SYSWMEVENT)
elif event.type == pygame.QUIT:
self.done = True
return
def process_event(self, event):
if event.type == MOUSEBUTTONDOWN:
if event.button == 4:
v = self.scale*np.cross(self.axis1,self.axis2)/10.0
self.translate(v)
elif event.button == 5:
v = -self.scale*np.cross(self.axis1,self.axis2)/10.0
self.translate(v)
elif event.button == 1:
mouse_position = pygame.mouse.get_rel()
self.clicked = True
elif event.type == MOUSEBUTTONUP:
if event.button == 1:
self.clicked = False
elif event.type == MOUSEMOTION and self.clicked:
movement = np.array(pygame.mouse.get_rel())
if (movement == 0).all():
return
length = np.linalg.norm(movement)
mouse_direction = movement[0]*self.axis2 - movement[1]*self.axis1
mouse_direction /= np.linalg.norm(mouse_direction)
if pygame.key.get_mods() & (KMOD_LSHIFT | KMOD_RSHIFT):
v = -mouse_direction*self.scale*length/float(self.width)
self.translate(v)
else:
phi = np.float32(2*np.pi*length/float(self.width))
n = rotate(mouse_direction, np.pi/2,
np.cross(self.axis1,self.axis2))
if pygame.key.get_mods() & KMOD_LCTRL:
self.rotate_around_point(phi, n, self.point)
else:
self.rotate(phi, n)
elif event.type == KEYDOWN:
if event.key == K_LALT or event.key == K_RALT:
if self.motion == 'coarse':
self.scale = self.mesh_diagonal_norm/20.0
self.motion = 'fine'
elif self.motion == 'fine':
self.scale = self.mesh_diagonal_norm/400.0
self.motion = 'superfine'
elif self.motion == 'superfine':
self.scale = self.mesh_diagonal_norm
self.motion = 'coarse'
elif event.key == K_F6:
self.clear_xyz_lookup()
self.clear_image()
self.source_position = self.point
elif event.key == K_F7:
for i in range(100):
self.update_xyz_lookup(self.point)
self.source_position = self.point
elif event.key == K_F11:
pygame.display.toggle_fullscreen()
elif event.key == K_ESCAPE:
self.done = True
return
elif event.key == K_EQUALS:
if self.alpha_depth < self.max_alpha_depth:
self.alpha_depth += 1
self.update()
elif event.key == K_MINUS:
if self.alpha_depth > 1:
self.alpha_depth -= 1
self.update()
elif event.key == K_PAGEDOWN:
if self.currentlayer is None:
self.currentlayer = self.bvh_layer_count - 1
else:
if self.currentlayer > 0:
self.currentlayer -= 1
else:
self.currentlayer = None
self.loadlayer(self.currentlayer)
elif event.key == K_PAGEUP:
if self.currentlayer is None:
self.currentlayer = 0
else:
if self.currentlayer < self.bvh_layer_count:
self.currentlayer += 1
else:
self.currentlayer = None
self.loadlayer(self.currentlayer)
elif event.key == K_3:
if self.display3d:
self.disable3d()
else:
self.enable3d()
self.update()
elif event.key == K_g:
self.green_magenta = not self.green_magenta
self.update()
elif event.key == K_F12:
self.screenshot()
elif event.key == K_F5:
if not hasattr(self, 'rng_states_gpu'):
self.initialize_render()
self.hybrid_render = not self.hybrid_render
self.clear_image()
self.update()
elif event.key == K_m:
if self.movie:
encode_movie(self.movie_dir)
self.movie_dir = None
self.movie = False
else:
self.movie_index = 0
self.movie_dir = tempfile.mkdtemp()
self.movie = True
elif event.type == pygame.SYSWMEVENT and self.spnav:
# Space Navigator controls
spnav_event = self.spnav_module.spnav_x11_event(event.event)
if spnav_event is None:
return
if spnav_event.ev_type == self.spnav_module.SPNAV_EVENT_MOTION:
if pygame.key.get_mods() & (KMOD_LSHIFT | KMOD_RSHIFT):
accelerate_factor = 2.0
else:
accelerate_factor = 1.0
v1 = self.axis1
v2 = self.axis2
v3 = np.cross(self.axis1,self.axis2)
x, y, z = spnav_event.translation
rx, ry, rz = spnav_event.rotation
v = v2*x + v1*y + v3*z
v *= self.scale / 5000.0 * accelerate_factor
self.translate(v, redraw=False)
axis = -v2*rx - v1*ry - v3*rz
if (axis != 0).any():
axis = axis.astype(float)
length = np.linalg.norm(axis)
angle = length * 0.0001 * accelerate_factor
axis /= length
self.rotate_around_point(angle, axis, self.point,
redraw=False)
if self.hybrid_render:
self.clear_image()
self.update()
pygame.event.clear(pygame.SYSWMEVENT)
elif spnav_event.ev_type == self.spnav_module.SPNAV_EVENT_BUTTON:
if spnav_event.bnum == 0 and spnav_event.press:
if not hasattr(self, 'rng_states_gpu'):
self.initialize_render()
self.hybrid_render = not self.hybrid_render
self.clear_image()
self.update()
pygame.event.clear(pygame.SYSWMEVENT)
elif event.type == pygame.QUIT:
self.done = True
return
