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()