def create_random_lf_cameras(num_to_create, look_from_radii, max_look_to_origin=1.0, interspatial_distance=1.0, spatial_rows=8, spatial_cols=8, look_up=vec3(0.0, 1.0, 0.0)): """Create a list of randomnly positioned lf cameras Keyword arguments: num_to_create -- the number of lf cameras to create look_from_radii -- min, max distance from the origin to camera look from max_look_to_origin -- max distance from the origin to camera look to interspatial_distance -- distance between cameras in array (default 1.0) spatial_rows, spatial_cols -- dimensions of camera array (default 8 x 8) """ lf_cameras = [] for _ in range(num_to_create): look_from, look_to, look_up = create_random_camera( look_from_radii, max_look_to_origin, look_up, False) # Centre the light field on the centre image view_direction = look_to - look_from right_vec = normalize(cross_product(view_direction, look_up)) correction_x = -ceil(spatial_cols / 2) * interspatial_distance correction_y = ceil(spatial_rows / 2) * interspatial_distance correction = (normalize(look_up) * correction_y + right_vec * correction_x) look_from = look_from + correction look_to = look_to + correction lf_cam = LightFieldCamera(look_from, look_to, look_up, interspatial_distance, spatial_rows, spatial_cols) lf_cameras.append(lf_cam) return lf_cameras
def create_random_camera(look_from_radii, max_look_to_origin=1.0, look_up=vec3(0, 1, 0), fix_look_up=False, random_look_up=False): """Create a randomly positioned camera""" d = max_look_to_origin look_from = rand_vec_between_spheres(*look_from_radii) look_to = vec3(random_float(), random_float(), random_float()) * d reverse_direction = normalize(look_from - look_to) if random_look_up: look_up = normalize( vec3(random_float(), random_float(), random_float())) if fix_look_up: right = normalize(cross_product(look_up, reverse_direction)) look_up = cross_product(reverse_direction, right) return (look_from, look_to, look_up)
def rand_vec_between_spheres(big_radius, small_radius): """ Generates a vec3 in between the shell of two spheres Input is the radius of the big and small sphere """ radius_diff = big_radius - small_radius point_on_unit_sphere = normalize(rand_vec_in_unit_sphere()) scale_factor = (random() * radius_diff + small_radius) point_in_between = point_on_unit_sphere * scale_factor return point_in_between
def callback(self, pickevent, type): if pickevent.state == ivw.PickingState.Updated: i = pickevent.pickedId points = json.loads(self.pts.value) pos = points["from"][i] if type == 1 else points["to"][i] pickevent.setToolTip(f"{type} {i} {pos}") else: pickevent.setToolTip("") # and ivw.PickingPressItem.Primary in pickevent.pressItems if (pickevent.pressState == ivw.PickingPressState.Move and ivw.PickingPressItem.Primary in pickevent.pressItems): points = json.loads(self.pts.value) delta = pickevent.getWorldSpaceDeltaAtPressDepth( self.camera.camera) print(f"drag {delta}") upPos = glm.dvec3(points["up"][pickevent.pickedId]) if type == 1: points["from"][pickevent.pickedId][0] += delta.x points["from"][pickevent.pickedId][1] += delta.y points["from"][pickevent.pickedId][2] += delta.z elif type == 2: points["to"][pickevent.pickedId][0] += delta.x points["to"][pickevent.pickedId][1] += delta.y points["to"][pickevent.pickedId][2] += delta.z else: upPos += delta / self.scale.value normal = glm.dvec3(points["to"][pickevent.pickedId]) - glm.dvec3( points["from"][pickevent.pickedId]) upPos = upPos - normal * (glm.dot(upPos, normal) / glm.length2(normal)) upPos = glm.normalize(upPos) points["up"][pickevent.pickedId][0] = upPos.x points["up"][pickevent.pickedId][1] = upPos.y points["up"][pickevent.pickedId][2] = upPos.z pickevent.markAsUsed() self.pts.value = json.dumps( points, indent=4, ) self.invalidate(ivw.properties.InvalidationLevel.InvalidOutput)
def updateFrame(self): currentFrame = self.frame.value if currentFrame < len(self.fromTrack): self.outCamera.properties.lookFrom.minValue = glm.vec3(-10000.0) self.outCamera.properties.lookFrom.maxValue = glm.vec3(+10000.0) self.outCamera.properties.lookTo.minValue = glm.vec3(-10000.0) self.outCamera.properties.lookTo.maxValue = glm.vec3(+10000.0) fromVec = glm.vec3(self.fromTrack[currentFrame]) toVec = glm.vec3(self.toTrack[currentFrame]) upVec = glm.vec3(self.upTrack[currentFrame]) normal = toVec - fromVec right = glm.cross(normal, upVec) upVec = glm.normalize(glm.cross(right, normal)) self.outCamera.lookFrom = fromVec self.outCamera.lookTo = toVec self.outCamera.lookUp = upVec
def calculate_camera_array(self): """Returns list of (look_from, look_to) tuples for the camera array""" look_list = [] row_step_vec = normalize(self.look_up) * self.interspatial_distance col_step_vec = self.get_look_right() * self.interspatial_distance #Start at the top left camera position for i in range(self.spatial_rows): row_movement = row_step_vec * (-i) row_look_from = self.look_from + row_movement row_look_to = self.look_to + row_movement for j in range(self.spatial_cols): col_movement = col_step_vec * j cam_look_from = row_look_from + col_movement cam_look_to = row_look_to + col_movement look_list.append((cam_look_from, cam_look_to)) return look_list
def get_look_right(self): """Get the right look vector for the top left camera""" view_direction = self.look_to - self.look_from right_vec = normalize(cross_product(view_direction, self.look_up)) return right_vec