def main(): # Create a ZED camera object zed = sl.Camera() # Set configuration parameters init = sl.InitParameters() init.camera_resolution = sl.RESOLUTION.HD720 init.depth_mode = sl.DEPTH_MODE.ULTRA init.coordinate_units = sl.UNIT.METER init.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP # Open the camera err = zed.open(init) if err != sl.ERROR_CODE.SUCCESS: print(repr(err)) zed.close() exit(1) res = sl.Resolution() res.width = 720 res.height = 404 point_cloud = sl.Mat(res.width, res.height, sl.MAT_TYPE.F32_C4, sl.MEM.CPU) camera_model = zed.get_camera_information().camera_model # Create OpenGL viewer viewer = gl.GLViewer() viewer.init(len(sys.argv), sys.argv, camera_model, res) while viewer.is_available(): if zed.grab() == sl.ERROR_CODE.SUCCESS: zed.retrieve_measure(point_cloud, sl.MEASURE.XYZRGBA, sl.MEM.CPU, res) viewer.updateData(point_cloud) viewer.exit() zed.close()
if err != sl.ERROR_CODE.SUCCESS: exit(1) # Enable object detection module obj_param = sl.ObjectDetectionParameters() # Defines if the object detection will track objects across images flow. obj_param.enable_tracking = True # if True, enable positional tracking print(obj_param.detection_model) if obj_param.enable_tracking: zed.enable_positional_tracking() zed.enable_object_detection(obj_param) camera_info = zed.get_camera_information() # Create OpenGL viewer viewer = gl.GLViewer() viewer.init(camera_info.calibration_parameters.left_cam) # Configure object detection runtime parameters obj_runtime_param = sl.ObjectDetectionRuntimeParameters() obj_runtime_param.detection_confidence_threshold = 50 obj_runtime_param.object_class_filter = [sl.OBJECT_CLASS.PERSON] # Only detect Persons # Create ZED objects filled in the main loop objects = sl.Objects() image = sl.Mat() while viewer.is_available(): # Grab an image, a RuntimeParameters object must be given to grab() if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS: # Retrieve left image
def main(): print("Running Plane Detection sample ... Press 'q' to quit") # Create a camera object zed = sl.Camera() # Set configuration parameters init = sl.InitParameters() init.coordinate_units = sl.UNIT.METER init.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP # OpenGL coordinate system # If applicable, use the SVO given as parameter # Otherwise use ZED live stream if len(sys.argv) == 2: filepath = sys.argv[1] print("Reading SVO file: {0}".format(filepath)) init.set_from_svo_file(filepath) # Open the camera status = zed.open(init) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit(1) # Get camera info and check if IMU data is available camera_infos = zed.get_camera_information() has_imu = camera_infos.sensors_configuration.gyroscope_parameters.is_available # Initialize OpenGL viewer viewer = gl.GLViewer() viewer.init( camera_infos.camera_configuration.calibration_parameters.left_cam, has_imu) image = sl.Mat() # current left image pose = sl.Pose() # positional tracking data plane = sl.Plane() # detected plane mesh = sl.Mesh() # plane mesh find_plane_status = sl.ERROR_CODE.SUCCESS tracking_state = sl.POSITIONAL_TRACKING_STATE.OFF # Timestamp of the last mesh request last_call = time.time() user_action = gl.UserAction() user_action.clear() # Enable positional tracking before starting spatial mapping zed.enable_positional_tracking() runtime_parameters = sl.RuntimeParameters() runtime_parameters.measure3D_reference_frame = sl.REFERENCE_FRAME.WORLD while viewer.is_available(): if zed.grab(runtime_parameters) == sl.ERROR_CODE.SUCCESS: # Retrieve left image zed.retrieve_image(image, sl.VIEW.LEFT) # Update pose data (used for projection of the mesh over the current image) tracking_state = zed.get_position(pose) if tracking_state == sl.POSITIONAL_TRACKING_STATE.OK: # Compute elapse time since the last call of plane detection duration = time.time() - last_call # Ask for a mesh update on mouse click if user_action.hit: image_click = [ user_action.hit_coord[0] * camera_infos. camera_configuration.camera_resolution.width, user_action.hit_coord[1] * camera_infos. camera_configuration.camera_resolution.height ] find_plane_status = zed.find_plane_at_hit( image_click, plane) # Check if 500 ms have elapsed since last mesh request if duration > .5 and user_action.press_space: # Update pose data (used for projection of the mesh over the current image) reset_tracking_floor_frame = sl.Transform() find_plane_status = zed.find_floor_plane( plane, reset_tracking_floor_frame) last_call = time.time() if find_plane_status == sl.ERROR_CODE.SUCCESS: mesh = plane.extract_mesh() viewer.update_mesh(mesh, plane.type) user_action = viewer.update_view(image, pose.pose_data(), tracking_state) viewer.exit() image.free(sl.MEM.CPU) mesh.clear() # Disable modules and close camera zed.disable_positional_tracking() zed.close()
def main(): print("Running Spatial Mapping sample ... Press 'q' to quit") # Create a Camera object zed = sl.Camera() # Create a InitParameters object and set configuration parameters init_params = sl.InitParameters() init_params.camera_resolution = sl.RESOLUTION.HD720 # Use HD720 video mode init_params.coordinate_units = sl.UNIT.METER # Set coordinate units init_params.coordinate_system = sl.COORDINATE_SYSTEM.RIGHT_HANDED_Y_UP # OpenGL coordinates # If applicable, use the SVO given as parameter # Otherwise use ZED live stream if len(sys.argv) == 2: filepath = sys.argv[1] print("Using SVO file: {0}".format(filepath)) init_params.set_from_svo_file(filepath) # Open the camera status = zed.open(init_params) if status != sl.ERROR_CODE.SUCCESS: print(repr(status)) exit() # Get camera parameters camera_parameters = zed.get_camera_information( ).camera_configuration.calibration_parameters.left_cam pymesh = sl.Mesh() # Current incremental mesh image = sl.Mat() # Left image from camera pose = sl.Pose() # Camera pose tracking data viewer = gl.GLViewer() viewer.init(camera_parameters, pymesh) spatial_mapping_parameters = sl.SpatialMappingParameters() tracking_state = sl.POSITIONAL_TRACKING_STATE.OFF mapping_state = sl.SPATIAL_MAPPING_STATE.NOT_ENABLED mapping_activated = False last_call = time.time() # Timestamp of last mesh request # Enable positional tracking err = zed.enable_positional_tracking() if err != sl.ERROR_CODE.SUCCESS: print(repr(err)) exit() # Set runtime parameters runtime = sl.RuntimeParameters() while viewer.is_available(): # Grab an image, a RuntimeParameters object must be given to grab() if zed.grab(runtime) == sl.ERROR_CODE.SUCCESS: # Retrieve left image zed.retrieve_image(image, sl.VIEW.LEFT) # Update pose data (used for projection of the mesh over the current image) tracking_state = zed.get_position(pose) if mapping_activated: mapping_state = zed.get_spatial_mapping_state() # Compute elapsed time since the last call of Camera.request_spatial_map_async() duration = time.time() - last_call # Ask for a mesh update if 500ms elapsed since last request if (duration > .5 and viewer.chunks_updated()): zed.request_spatial_map_async() last_call = time.time() if zed.get_spatial_map_request_status_async( ) == sl.ERROR_CODE.SUCCESS: zed.retrieve_spatial_map_async(pymesh) viewer.update_chunks() change_state = viewer.update_view(image, pose.pose_data(), tracking_state, mapping_state) if change_state: if not mapping_activated: init_pose = sl.Transform() zed.reset_positional_tracking(init_pose) # Configure spatial mapping parameters spatial_mapping_parameters.resolution_meter = sl.SpatialMappingParameters( ).get_resolution_preset(sl.MAPPING_RESOLUTION.MEDIUM) spatial_mapping_parameters.use_chunk_only = True spatial_mapping_parameters.save_texture = False # Set to True to apply texture over the created mesh spatial_mapping_parameters.map_type = sl.SPATIAL_MAP_TYPE.MESH # Enable spatial mapping zed.enable_spatial_mapping() # Clear previous mesh data pymesh.clear() viewer.clear_current_mesh() # Start timer last_call = time.time() mapping_activated = True else: # Extract whole mesh zed.extract_whole_spatial_map(pymesh) filter_params = sl.MeshFilterParameters() filter_params.set(sl.MESH_FILTER.MEDIUM) # Filter the extracted mesh pymesh.filter(filter_params, True) viewer.clear_current_mesh() # If textures have been saved during spatial mapping, apply them to the mesh if (spatial_mapping_parameters.save_texture): print("Save texture set to : {}".format( spatial_mapping_parameters.save_texture)) pymesh.apply_texture(sl.MESH_TEXTURE_FORMAT.RGBA) # Save mesh as an obj file filepath = "mesh_gen.obj" status = pymesh.save(filepath) if status: print("Mesh saved under " + filepath) else: print("Failed to save the mesh under " + filepath) mapping_state = sl.SPATIAL_MAPPING_STATE.NOT_ENABLED mapping_activated = False image.free(memory_type=sl.MEM.CPU) pymesh.clear() # Disable modules and close camera zed.disable_spatial_mapping() zed.disable_positional_tracking() zed.close()