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