def _main(): user_options = _options() file_path = Path(user_options.filename) if not file_path.exists(): raise FileNotFoundError(f"{user_options.filename} does not exist") with zivid.Application(): print(f"Reading point cloud from file: {user_options.filename}") frame = zivid.Frame(user_options.filename) point_cloud = frame.point_cloud() if user_options.ply: _convert_2_ply(frame, file_path.stem) elif user_options.csv: _convert_2_csv(point_cloud, file_path.stem + ".csv") elif user_options.txt: _convert_2_csv(point_cloud, file_path.stem + ".txt") elif user_options.png: _convert_2_2d(point_cloud, file_path.stem + ".png") elif user_options.jpg: _convert_2_2d(point_cloud, file_path.stem + ".jpg") elif user_options.bmp: _convert_2_2d(point_cloud, file_path.stem + ".bmp") elif user_options.tiff: _convert_2_2d(point_cloud, file_path.stem + ".tiff")
def _main(): with zivid.Application(): data_file = Path() / get_sample_data_path( ) / "CalibrationBoardInCameraOrigin.zdf" print(f"Reading ZDF frame from file: {data_file}") frame = zivid.Frame(data_file) point_cloud = frame.point_cloud() print("Detecting checkerboard and estimating its pose in camera frame") transform_camera_to_checkerboard = ( zivid.calibration.detect_feature_points( point_cloud).pose().to_matrix()) # pylint: disable=no-member print( f"Camera pose in checkerboard frame:\n{transform_camera_to_checkerboard}" ) transform_file = "CameraToCheckerboardTransform.yaml" print( f"Saving detected checkerboard pose to YAML file: {transform_file}" ) _write_transform(transform_camera_to_checkerboard, transform_file) print("Visualizing checkerboard with coordinate system") checkerboard_point_cloud = _create_open3d_point_cloud(point_cloud) _visualize_checkerboard_point_cloud_with_coordinate_system( checkerboard_point_cloud, transform_camera_to_checkerboard)
def _main(): try: args = _args() mode = args.mode app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() _check_user_data_support(camera) if mode == "read": print("Reading user data from camera") print(f"Done. User data: '{_read(camera)}'") if mode == "write": print(f"Writing '{args.user_data}' to the camera") _write(camera, args.user_data) print( "Done. Note! Camera must be rebooted to allow another write operation" ) if mode == "clear": print("Clearing user data from camera") _clear(camera) print( "Done. Note! Camera must be rebooted to allow another clear operation" ) except ValueError as ex: print(f"Error: {ex}")
def _main(): app = zivid.Application() print("Connecting to the camera") camera = app.connect_camera() print("Configuring the camera settings") iris_setting = [17, 27, 27] exposure_setting = [10000, 10000, 40000] gain_setting = [1.0, 1.0, 2.0] settings_collection = [camera.settings for _ in range(3)] for i in range(len(settings_collection)): settings_collection[i].iris = iris_setting[i] settings_collection[i].exposure_time = datetime.timedelta( microseconds=exposure_setting[i] ) settings_collection[i].brightness = 1 settings_collection[i].gain = gain_setting[i] settings_collection[i].bidirectional = 0 settings_collection[i].filters.contrast.enabled = True settings_collection[i].filters.Contrast.threshold = 0.5 settings_collection[i].filters.gaussian.enabled = True settings_collection[i].filters.gaussian.sigma = 1.5 settings_collection[i].filters.outlier.enabled = True settings_collection[i].filters.outlier.threshold = 5 settings_collection[i].filters.reflection.enabled = True settings_collection[i].filters.saturated.enabled = True settings_collection[i].blue_balance = 1 settings_collection[i].red_balance = 1 print("Capturing an HDR frame") with camera.capture(settings_collection) as hdr_frame: print("Saving the HDR frame") hdr_frame.save("HDR.zdf")
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() suggest_settings_parameters = zivid.capture_assistant.SuggestSettingsParameters( max_capture_time=datetime.timedelta(milliseconds=1200), ambient_light_frequency=zivid.capture_assistant. SuggestSettingsParameters.AmbientLightFrequency.none, ) print( f"Running Capture Assistant with parameters: {suggest_settings_parameters}" ) settings = zivid.capture_assistant.suggest_settings( camera, suggest_settings_parameters) print("Settings suggested by Capture Assistant:") for acquisition in settings.acquisitions: print(acquisition) print( "Manually configuring processing settings (Capture Assistant only suggests acquisition settings)" ) settings.processing.filters.reflection.removal.enabled = True settings.processing.filters.reflection.removal.experimental.mode = "global" settings.processing.filters.smoothing.gaussian.enabled = True settings.processing.filters.smoothing.gaussian.sigma = 1.5 print("Capturing frame") with camera.capture(settings) as frame: data_file = "Frame.zdf" print(f"Saving frame to file: {data_file}") frame.save(data_file)
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print("Configuring 2D settings") # Note: The Zivid SDK supports 2D captures with a single acquisition only settings_2d = zivid.Settings2D() settings_2d.acquisitions.append(zivid.Settings2D.Acquisition()) settings_2d.acquisitions[0].exposure_time = datetime.timedelta(microseconds=30000) settings_2d.acquisitions[0].aperture = 11.31 settings_2d.acquisitions[0].brightness = 1.80 settings_2d.acquisitions[0].gain = 2.0 settings_2d.processing.color.balance.red = 1.0 settings_2d.processing.color.balance.green = 1.0 settings_2d.processing.color.balance.blue = 1.0 settings_2d.processing.color.gamma = 1.0 print("Capturing 2D frame") with camera.capture(settings_2d) as frame_2d: print("Getting RGBA image") image = frame_2d.image_rgba() rgba = image.copy_data() pixel_row = 100 pixel_col = 50 pixel = rgba[pixel_row, pixel_col] print(f"Color at pixel ({pixel_row},{pixel_col}): R:{pixel[0]} G:{pixel[1]} B:{pixel[2]} A:{pixel[3]}") image_file = "Image.png" print(f"Saving 2D color image to file: {image_file}") image.save(image_file)
def __init__(self, nx: int, ny: int, sqrSize: float, eye_in_hand: bool = True): self.app = zivid.Application() self.nx = nx self.ny = ny self.square_size = sqrSize self.images = [] self.num_imgs = 0 self.point_clouds = [] self.XYZs = [] self.chessboard_poses = [] self.camera_poses = [] self.robot_poses = [] self.rgbs = [] self.camera_matrix = None self.dist_coeffs = None self.image_files = [] self.pose_files = [] self.corners = [] self.center_points = [] self.object_planes = [] self.board_points = [] self.rvecs = [] self.tvecs = [] self.HE_calib = None self.method = '' self.eye_in_hand = eye_in_hand
def _main(): app = zivid.Application() camera = app.create_file_camera( str(zivid.environment.data_path()) + "/MiscObjects.zdf") with camera.capture() as frame: frame.save("Result.zdf")
def __init__(self): self.image = [] self.depth = [] self.point = [] app = zivid.Application() self.camera = app.connect_camera() self.t = 0.0 self.t_prev = 0.0 self.interval = 0.0 self.fps = 0.0 # 2D image setting self.settings_2d = zivid.Settings2D() self.settings_2d.iris = 26 self.settings_2d.exposure_time = datetime.timedelta(microseconds=8333) # 3D capture setting with self.camera.update_settings() as updater: updater.settings.iris = 26 updater.settings.exposure_time = datetime.timedelta( microseconds=8333) updater.settings.filters.reflection.enabled = True # img cropping self.ycr = 430 self.hcr = 400 self.xcr = 680 self.wcr = 520
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print("Configuring settings") settings = zivid.Settings(acquisitions=[ zivid.Settings.Acquisition(aperture=fnum) for fnum in (11.31, 5.66, 2.83) ]) print("Capturing frame (HDR)") with camera.capture(settings) as frame: point_cloud = frame.point_cloud() rgba = point_cloud.copy_data("rgba") normals = point_cloud.copy_data("normals") normals_colormap = 0.5 * (1 - normals) print("Visualizing normals in 2D") display_rgb(rgb=rgba[:, :, :3], title="RGB image") display_rgb(rgb=normals_colormap, title="Colormapped normals") input("Press any key to continue...") print("Visualizing normals in 3D") display_pointcloud_with_downsampled_normals( point_cloud, zivid.PointCloud.Downsampling.by4x4) input("Press Enter to close...")
def _main(): app = zivid.Application() # The file_camera file is in Zivid Sample Data. See instructions in README.md file_camera = Path() / get_sample_data_path() / "FileCameraZividOne.zfc" print(f"Creating virtual camera using file: {file_camera}") camera = app.create_file_camera(file_camera) print("Configuring settings") settings = zivid.Settings() settings.acquisitions.append(zivid.Settings.Acquisition()) settings.processing.filters.smoothing.gaussian.enabled = True settings.processing.filters.smoothing.gaussian.sigma = 1.5 settings.processing.filters.reflection.removal.enabled = True settings.processing.filters.reflection.removal.experimental.mode = "global" settings.processing.color.balance.red = 1.0 settings.processing.color.balance.green = 1.0 settings.processing.color.balance.blue = 1.0 print("Capturing frame") with camera.capture(settings) as frame: data_file = "Frame.zdf" print(f"Saving frame to file: {data_file}") frame.save(data_file)
def _main(): app = zivid.Application() filename_zdf = Path() / f"{str(zivid.environment.data_path())}/Zivid3D.zdf" print(f"Reading {filename_zdf} point cloud") frame = zivid.Frame(filename_zdf) # Extracting point cloud from the frame point_cloud = frame.get_point_cloud().to_array() xyz = np.dstack([point_cloud["x"], point_cloud["y"], point_cloud["z"]]) rgb = np.dstack([point_cloud["r"], point_cloud["g"], point_cloud["b"]]) contrast = np.dstack([point_cloud["contrast"]]) height = frame.get_point_cloud().height width = frame.get_point_cloud().width print("Point cloud information:") print(f"Number of points: {point_cloud.size}") print(f"Height: {height}, Width: {width}") # Iterating over the point cloud and displaying X, Y, Z, R, G, B, and Contrast # for central 10 x 10 pixels pixels_to_display = 10 for i in range(int((height - pixels_to_display) / 2), int((height + pixels_to_display) / 2)): for j in range(int((width - pixels_to_display) / 2), int((width + pixels_to_display) / 2)): print( f"Values at pixel ({i} , {j}): X:{xyz[i,j,0]:.1f} Y:{xyz[i,j,1]:.1f}" f"Z:{xyz[i,j,2]:.1f} R:{rgb[i,j,0]} G:{rgb[i,j,1]} B:{rgb[i,j,2]}" f"Contrast:{contrast[i,j,0]:.1f}")
def _main(): app = zivid.Application() data_file = Path() / get_sample_data_path() / "Zivid3D.zdf" print(f"Reading point cloud from file: {data_file}") frame = zivid.Frame(data_file) print("Getting point cloud from frame") point_cloud = frame.point_cloud() xyz = point_cloud.copy_data("xyz") rgba = point_cloud.copy_data("rgba") snr = frame.point_cloud().copy_data("snr") height = frame.point_cloud().height width = frame.point_cloud().width print("Point cloud information:") print(f"Number of points: {height * width}") print(f"Height: {height}, Width: {width}") pixels_to_display = 10 print( "Iterating over point cloud and extracting X, Y, Z, R, G, B, and SNR " f"for central {pixels_to_display} x {pixels_to_display} pixels") for i in range(int((height - pixels_to_display) / 2), int((height + pixels_to_display) / 2)): for j in range(int((width - pixels_to_display) / 2), int((width + pixels_to_display) / 2)): print( f"Values at pixel ({i} , {j}): X:{xyz[i,j,0]:.1f} Y:{xyz[i,j,1]:.1f}" f" Z:{xyz[i,j,2]:.1f} R:{rgba[i,j,0]} G:{rgba[i,j,1]} B:{rgba[i,j,2]}" f" SNR:{snr[i,j]:.1f}")
def _main(): app = zivid.Application() data_file = Path() / get_sample_data_path() / "Zivid3D.zdf" print(f"Reading ZDF frame from file: {data_file}") frame = zivid.Frame(data_file) point_cloud = frame.point_cloud() xyz = point_cloud.copy_data("xyz") rgba = point_cloud.copy_data("rgba") print( f"Before downsampling: {point_cloud.width * point_cloud.height} point cloud" ) _display_pointcloud(xyz, rgba[:, :, 0:3]) print("Downsampling point cloud") point_cloud.downsample(zivid.PointCloud.Downsampling.by2x2) xyz_donwsampled = point_cloud.copy_data("xyz") rgba_downsampled = point_cloud.copy_data("rgba") print( f"After downsampling: {point_cloud.width * point_cloud.height} point cloud" ) _display_pointcloud(xyz_donwsampled, rgba_downsampled[:, :, 0:3]) input("Press Enter to close...")
def _main(): app = zivid.Application() print("Connecting to the camera") camera = app.connect_camera() # Initialize settings list number_of_frames_per_hdr = 3 for hdr_index in range(3): print(f"Capturing an HDR image, alternative settings #{hdr_index+1}") settingslist = [] for frame_index in range(number_of_frames_per_hdr): settings = _read_settings_from_file( Path(__file__).parents[2] / f"settings/set{hdr_index+1}/frame_0{frame_index+1}.yml" ) print( f"\tFrame {frame_index + 1}:" f" Iris: {settings.iris}" f" Exposure: {settings.exposure_time.microseconds / 1000}ms" f" Gain: {settings.gain}" ) settingslist.append(settings) with zivid.hdr.capture(camera, settingslist) as hdr_frame: out_file_name = f"HDR_Settings_{hdr_index+1}.zdf" print(f"Saving the HDR frame to: {out_file_name}") hdr_frame.save(out_file_name)
def _main() -> None: app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() # Gather data dataset = collect_dataset(camera) # Calculate infield correciton print(f"Collected {len(dataset)} valid measurements.") print("Computing new camera correction...") correction = calibration.compute_camera_correction(dataset) accuracy_estimate = correction.accuracy_estimate() print( "If written to the camera, this correction can be expected to yield a dimension accuracy of ", f"{accuracy_estimate.dimension_accuracy()*100:.3f} or better in the range of z=[{accuracy_estimate.z_min():.3f}, {accuracy_estimate.z_max():.3f}] across the full FOV.", "Accuracy close to where the correction data was collected is likely better.", ) # Optionally save to camera if yes_no_prompt("Save to camera? "): print("Writing correction to camera") calibration.write_camera_correction(camera, correction) print("Success")
def _main(): app = zivid.Application() print("Connecting to the camera") camera = app.connect_camera() print("Configuring the camera settings") settings_collection = [camera.settings for _ in range(3)] settings_collection[0].exposure_time = datetime.timedelta( microseconds=10000) settings_collection[0].iris = 17 settings_collection[1].exposure_time = datetime.timedelta( microseconds=20000) settings_collection[1].iris = 27 settings_collection[2].exposure_time = datetime.timedelta( microseconds=30000) settings_collection[2].iris = 35 print("Capturing separate frames") frame1 = capture(camera, settings_collection[0]) frame2 = capture(camera, settings_collection[1]) frame3 = capture(camera, settings_collection[2]) print("Combining separate frames into an HDR frame") hdr = zivid.hdr.combine_frames([frame1, frame2, frame3]) print("Saving the frames") frame1.save("frame1.zdf") frame2.save("frame2.zdf") frame3.save("frame3.zdf") print("Saving the HDR frame") hdr.save("HDR.zdf")
def _main() -> None: app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() # For convenience, print the timestamp of the latest correction if calibration.has_camera_correction(camera): timestamp = calibration.camera_correction_timestamp(camera) print( f"Timestamp of current camera correction: {timestamp.strftime(r'%Y-%m-%d %H:%M:%S')}" ) else: print("This camera has no in-field correction written to it.") # Gather data print("Capturing calibration board") detection_result = calibration.detect_feature_points(camera) # Prepare data and check that it is appropriate for in-field verification infield_input = calibration.InfieldCorrectionInput(detection_result) if not infield_input.valid(): raise RuntimeError( f"Capture not valid for in-field verification! Feedback: {infield_input.status_description()}" ) # Show results print(f"Successful measurement at {detection_result.centroid()}") camera_verification = calibration.verify_camera(infield_input) print( f"Estimated dimension trueness at measured position: {camera_verification.local_dimension_trueness()*100:.3f}%" )
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print("Getting camera intrinsics") intrinsics = calibration.intrinsics(camera) print(intrinsics) print("Separated camera intrinsic parameters:") print(f" CX: {intrinsics.camera_matrix.cx}") print(f" CY: {intrinsics.camera_matrix.cy}") print(f" FX: {intrinsics.camera_matrix.fx}") print(f" FY: {intrinsics.camera_matrix.fy}") print(f" K1: {intrinsics.distortion.k1}") print(f" K2: {intrinsics.distortion.k2}") print(f" K3: {intrinsics.distortion.k3}") print(f" P1: {intrinsics.distortion.p1}") print(f" P2: {intrinsics.distortion.p2}") output_file = "Intrinsics.yml" print(f"Saving camera intrinsics to file: {output_file}") intrinsics.save(output_file)
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print("Configuring processing settings for capture:") settings = zivid.Settings() settings.experimental.engine = "phase" filters = settings.processing.filters filters.smoothing.gaussian.enabled = True filters.smoothing.gaussian.sigma = 1.5 filters.noise.removal.enabled = True filters.noise.removal.threshold = 7.0 filters.outlier.removal.enabled = True filters.outlier.removal.threshold = 5.0 filters.reflection.removal.enabled = True filters.reflection.removal.experimental.mode = "global" filters.experimental.contrast_distortion.correction.enabled = True filters.experimental.contrast_distortion.correction.strength = 0.4 filters.experimental.contrast_distortion.removal.enabled = False filters.experimental.contrast_distortion.removal.threshold = 0.5 color = settings.processing.color color.balance.red = 1.0 color.balance.blue = 1.0 color.balance.green = 1.0 color.gamma = 1.0 settings.processing.color.experimental.mode = "automatic" print(settings.processing) print( "Configuring acquisition settings different for all HDR acquisitions") exposure_values = _get_exposure_values(camera) for (aperture, gain, exposure_time) in exposure_values: settings.acquisitions.append( zivid.Settings.Acquisition( aperture=aperture, exposure_time=datetime.timedelta(microseconds=exposure_time), brightness=1.8, gain=gain, )) for acquisition in settings.acquisitions: print(acquisition) print("Capturing frame (HDR)") with camera.capture(settings) as frame: print("Complete settings used:") print(frame.settings) data_file = "Frame.zdf" print(f"Saving frame to file: {data_file}") frame.save(data_file) settings_file = "Settings.yml" print(f"Saving settings to file: {settings_file}") settings.save(settings_file) print(f"Loading settings from file: {settings_file}") settings_from_file = zivid.Settings.load(settings_file) print(settings_from_file)
def _generate_dataset(con: rtde, input_data): """ Generate dataset based on predefined robot poses Args: con: Connection between computer and robot input_data: Input package containing the specific input data registers Returns: Directory to where dataset is saved """ with zivid.Application() as app: with app.connect_camera() as cam: _set_camera_settings(cam) save_dir = _generate_folder() # Signal robot that camera is ready ready_to_capture = True _write_robot_state( con, input_data, finish_capture=False, camera_ready=ready_to_capture ) robot_state = _read_robot_state(con) print( "Initial output robot_states: \n" f"Image count: {_image_count(robot_state)} \n" f"Ready for capture: {_ready_for_capture(robot_state)}\n" ) images_captured = 1 while _image_count(robot_state) != -1: robot_state = _read_robot_state(con) if _ready_for_capture(robot_state) and images_captured == _image_count( robot_state ): print(f"Capture image {_image_count(robot_state)}") _capture_one_frame_and_robot_pose( con, cam, save_dir, input_data, images_captured, ready_to_capture, ) images_captured += 1 time.sleep(0.1) _write_robot_state(con, input_data, finish_capture=False, camera_ready=False) time.sleep(1.0) con.send_pause() con.disconnect() print(f"\n Data saved to: {save_dir}") return save_dir
def _main(): app = zivid.Application() print(f"Python: {platform.python_version()}") print(f"zivid-python: {zivid.__version__}") print(f"Zivid SDK: {zivid.SDKVersion.full}") cameras = app.cameras() for camera in cameras: print(f"Camera Info: {camera}")
def _main() -> None: app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print("Reset in-field correction on the camera") calibration.reset_camera_correction(camera)
def _main() -> None: # Connect to camera app = zivid.Application() cam = app.connect_camera() # Capture manual_capture_loop("manual_test", cam, 1.2)
def _main(): app = zivid.Application() print("Connecting to camera") camera = app.connect_camera() print( "Configuring acquisition settings different for all HDR acquisitions") settings = zivid.Settings(acquisitions=[ zivid.Settings.Acquisition( aperture=8.0, exposure_time=datetime.timedelta(microseconds=10000), brightness=1.8, gain=1.0, ), zivid.Settings.Acquisition( aperture=4.0, exposure_time=datetime.timedelta(microseconds=10000), brightness=1.8, gain=1.0, ), zivid.Settings.Acquisition( aperture=4.0, exposure_time=datetime.timedelta(microseconds=40000), brightness=1.8, gain=2.0, ), ], ) for acquisition in settings.acquisitions: print(acquisition) print("Configuring global processing settings") filters = settings.processing.filters filters.smoothing.gaussian.enabled = True filters.smoothing.gaussian.sigma = 1.5 filters.noise.removal.enabled = True filters.noise.removal.threshold = 7.0 filters.outlier.removal.enabled = True filters.outlier.removal.threshold = 5.0 filters.reflection.removal.enabled = True filters.experimental.contrast_distortion.correction.enabled = True filters.experimental.contrast_distortion.correction.strength = 0.4 filters.experimental.contrast_distortion.removal.enabled = False filters.experimental.contrast_distortion.removal.threshold = 0.5 color = settings.processing.color color.balance.red = 1.0 color.balance.blue = 1.0 color.balance.green = 1.0 color.gamma = 1.0 print(settings.processing) print("Capturing frame (HDR)") with camera.capture(settings) as frame: print("Complete settings used:") print(frame.settings) data_file = "Frame.zdf" print(f"Saving frame to file: {data_file}") frame.save(data_file)
def _main(): app = zivid.Application() print("Connecting to the camera") camera = app.connect_camera() print("Configuring the camera settings") settings_collection = [camera.settings for _ in range(3)] settings_collection[0].brightness = 1.8 settings_collection[0].gain = 1 settings_collection[0].filters.gaussian.enabled = True settings_collection[0].filters.gaussian.sigma = 1.5 settings_collection[0].filters.reflection.enabled = True settings_collection[1].brightness = 1.8 settings_collection[1].gain = 1 settings_collection[1].filters.gaussian.enabled = True settings_collection[1].filters.gaussian.sigma = 1.5 settings_collection[1].filters.reflection.enabled = True settings_collection[2].brightness = 1.8 settings_collection[2].gain = 1 settings_collection[2].filters.gaussian.enabled = True settings_collection[2].filters.gaussian.sigma = 1.5 settings_collection[2].filters.reflection.enabled = True exposure_time_frame_1 = [ datetime.timedelta(microseconds=10000), datetime.timedelta(microseconds=90000), datetime.timedelta(microseconds=40000), ] exposure_time_frame_2 = [ datetime.timedelta(microseconds=40000), datetime.timedelta(microseconds=10000), datetime.timedelta(microseconds=90000), ] exposure_time_frame_3 = [ datetime.timedelta(microseconds=90000), datetime.timedelta(microseconds=40000), datetime.timedelta(microseconds=10000), ] iris_frames = [10, 20, 30] for i in range(len(iris_frames)): settings_collection[0].exposure_time = exposure_time_frame_1[i] settings_collection[1].exposure_time = exposure_time_frame_2[i] settings_collection[2].exposure_time = exposure_time_frame_3[i] settings_collection[0].iris = iris_frames[i] settings_collection[1].iris = iris_frames[i] settings_collection[2].iris = iris_frames[i] print("Capturing an HDR frame") with camera.capture(settings_collection) as hdr_frame: print("Saving the HDR frame") hdr_frame.save("HDR.zdf")
def _main(): print("heyyooo") print(zivid.environment.data_path()) app = zivid.Application() camera = app.create_file_camera( str(zivid.environment.data_path()) + "/MiscObjects.zdf") # Dpes not allow you to save anywhere else...(EB NOTE) with camera.capture() as frame: frame.save("results.zdf")
def _main(): app = zivid.Application() print("Connecting to the camera") serial_number = "12345678" camera = app.connect_camera(serial_number) print( f"Connected to the camera with the following serial number: {camera.serial_number}" )
def _main(): app = zivid.Application() # The Zivid3D.zdf file has to be in the same folder as this sample script. filename_zdf = "Zivid3D.zdf" print(f"Reading {filename_zdf} point cloud") frame = zivid.Frame(filename_zdf) # Getting the point cloud point_cloud = frame.get_point_cloud().to_array() depth_map = np.dstack([point_cloud["z"]]) depth_map_uint8 = ( (depth_map - np.nanmin(depth_map)) / (np.nanmax(depth_map) - np.nanmin(depth_map)) * 255 ).astype(np.uint8) # Applying color map depth_map_color_map = cv2.applyColorMap(depth_map_uint8, cv2.COLORMAP_JET) # Setting nans to black depth_map_color_map[np.isnan(depth_map)[:, :, 0]] = 0 rgb = np.dstack([point_cloud["b"], point_cloud["g"], point_cloud["r"]]) # Displaying the RGB image rgb_window = "RGB image" cv2.namedWindow(rgb_window, cv2.WINDOW_NORMAL) cv2.imshow(rgb_window, rgb) # Waiting for the window to be closed print("Close the RGB image to continue") while cv2.getWindowProperty(rgb_window, 0) >= 0: cv2.waitKey(50) cv2.destroyWindow(rgb_window) # Saving the RGB image cv2.imwrite(f"{rgb_window}.png", rgb) # Displaying the Depth map depth_window = "Depth map" cv2.namedWindow(depth_window, cv2.WINDOW_NORMAL) cv2.imshow(depth_window, depth_map_color_map) # Waiting for the window to be closed print("Close the Depth map image to continue") while cv2.getWindowProperty(depth_window, 0) >= 0: cv2.waitKey(50) cv2.destroyWindow(depth_window) # Saving the Depth map cv2.imwrite(f"{depth_window}.png", depth_map_color_map)
def _main(): app = zivid.Application() camera = app.connect_camera() settings_list = [camera.settings for _ in range(3)] settings_list[0].iris = 14 settings_list[1].iris = 21 settings_list[2].iris = 35 with camera.capture(settings_list) as hdr_frame: hdr_frame.save("Result.zdf")