def test_not_equal_exposure_time(application): # pylint: disable=unused-argument
import zivid
settings_2d_1 = zivid.Settings2D(exposure_time=3333)
settings_2d_2 = zivid.Settings2D(exposure_time=9999)
assert settings_2d_1 != settings_2d_2
def test_not_equal_brightness(application): # pylint: disable=unused-argument
import zivid
settings_2d_1 = zivid.Settings2D(brightness=34)
settings_2d_2 = zivid.Settings2D(brightness=43)
assert settings_2d_1 != settings_2d_2
def test_not_equal_gain(application): # pylint: disable=unused-argument
import zivid
settings_2d_1 = zivid.Settings2D(gain=0)
settings_2d_2 = zivid.Settings2D(gain=1)
assert settings_2d_1 != settings_2d_2
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):
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 _set_settings(dimension, iris, exposure_time, brightness, gain):
"""Set settings for capture (3D or 2D).
Args:
dimension: '3d' or '2d'
iris: Iris
exposure_time: Exposure time
brightness: Projector brightness
gain: Gain
Returns:
settings: Capture settings (3D or 2D)
Raises:
ValueError: If dimension is not '3d' or '2d'
"""
if dimension == "3d":
settings = zivid.Settings()
settings.iris = iris
settings.exposure_time = datetime.timedelta(microseconds=exposure_time)
settings.brightness = brightness
settings.gain = gain
elif dimension == "2d":
settings = zivid.Settings2D()
settings.iris = iris
settings.exposure_time = datetime.timedelta(microseconds=exposure_time)
settings.brightness = brightness
settings.gain = gain
else:
raise ValueError(
f"The dimension value should be '3d' or '2d', got: '{dimension}'"
)
return settings
def to_settings2_d(internal_settings2_d):
return zivid.Settings2D(
processing=to_settings2_d_processing(internal_settings2_d.processing),
acquisitions=[
to_settings2_d_acquisition(element)
for element in internal_settings2_d.acquisitions.value
],
)
def test_capture_settings_2d(file_camera):
import zivid
frame_2d = file_camera.capture(
zivid.Settings2D(acquisitions=[zivid.Settings2D.Acquisition()]))
assert frame_2d
assert isinstance(frame_2d, zivid.frame_2d.Frame2D)
frame_2d.release()
def test_capture_2d(physical_camera):
import zivid
settings_2d = zivid.Settings2D()
frame_2d = physical_camera.capture_2d(settings_2d)
assert frame_2d is not None
assert isinstance(frame_2d, zivid.Frame2D)
def test_init_exposure_time(application): # pylint: disable=unused-argument
import datetime
import zivid
value = datetime.timedelta(microseconds=10000)
settings_2d = zivid.Settings2D(exposure_time=value)
assert settings_2d.exposure_time == value
assert isinstance(settings_2d.exposure_time, datetime.timedelta)
def test_init_iris(application): # pylint: disable=unused-argument
import numbers
import zivid
value = 37
settings_2d = zivid.Settings2D(iris=value)
assert settings_2d.iris == value
assert isinstance(settings_2d.iris, numbers.Real)
def test_init_gain(application): # pylint: disable=unused-argument
import numbers
import zivid
value = 36
settings_2d = zivid.Settings2D(gain=value)
assert settings_2d.gain == value
assert isinstance(settings_2d.gain, numbers.Real)
def test_context_manager(physical_camera): # pylint: disable=unused-argument
import zivid
settings_2d = zivid.Settings2D()
with physical_camera.capture_2d(settings_2d) as frame_2d:
frame_2d.image()
with pytest.raises(RuntimeError):
frame_2d.image()
def test_context_manager(physical_camera):
import zivid
settings_2d = zivid.Settings2D(
acquisitions=[zivid.Settings2D.Acquisition()])
with physical_camera.capture(settings_2d) as frame_2d:
frame_2d.image_rgba()
with pytest.raises(RuntimeError):
frame_2d.image_rgba()
def _main():
app = zivid.Application()
camera = app.connect_camera()
settings_2d = zivid.Settings2D()
settings_2d.iris = 50
settings_2d.exposure_time = datetime.timedelta(microseconds=50000)
with camera.capture_2d(settings_2d) as frame_2d:
image = frame_2d.image()
image.save("result.png")
def test_default_init_settings_2d(application): # pylint: disable=unused-argument
import numbers
import datetime
import zivid
settings_2d = zivid.Settings2D()
assert settings_2d.brightness is not None
assert settings_2d.exposure_time is not None
assert settings_2d.gain is not None
assert settings_2d.iris is not None
assert isinstance(settings_2d.brightness, numbers.Real)
assert isinstance(settings_2d.exposure_time, datetime.timedelta)
assert isinstance(settings_2d.gain, numbers.Real)
assert isinstance(settings_2d.iris, numbers.Real)
def _capture_2d_image(camera):
"""Capture and extract 2D image, then convert from RGBA and return BGR.
Args:
camera: Zivid Camera handle
Returns:
OpenCV BGR image
"""
settings_2d = zivid.Settings2D()
with camera.capture_2d(settings_2d) as frame_2d:
image = frame_2d.image()
image_array = image.to_array()
return np.dstack([image_array["b"], image_array["g"], image_array["r"]])
def test_init_default_settings(application):
import zivid
settings_2d = zivid.Settings2D()
assert isinstance(settings_2d.acquisitions, list)
assert isinstance(settings_2d.processing, zivid.Settings2D.Processing)
assert isinstance(settings_2d.processing.color,
zivid.Settings2D.Processing.Color)
assert isinstance(settings_2d.processing.color.balance,
zivid.Settings2D.Processing.Color.Balance)
assert settings_2d.processing.color.gamma is None
assert settings_2d.processing.color.balance.red is None
assert settings_2d.processing.color.balance.green is None
assert settings_2d.processing.color.balance.blue is None
def test_settings_processing(application):
import zivid
pytest.helpers.set_attribute_tester(
settings_instance=zivid.Settings2D(),
member="processing",
value=zivid.Settings2D.Processing(),
expected_data_type=zivid.Settings2D.Processing,
)
pytest.helpers.equality_tester(
zivid.Settings2D.Processing,
[
zivid.Settings2D.Processing.Color(
0.9, zivid.Settings2D.Processing.Color.Balance(blue=1.1))
],
[
zivid.Settings2D.Processing.Color(
1.1, zivid.Settings2D.Processing.Color.Balance(blue=1.2))
],
)
def test_default_acquisition(application):
import zivid
import datetime
settings_2d = zivid.Settings2D(
acquisitions=[zivid.Settings2D.Acquisition()])
assert isinstance(settings_2d.acquisitions, list)
acquisition = settings_2d.acquisitions[0]
assert isinstance(acquisition, zivid.Settings2D.Acquisition)
assert acquisition.aperture is None
assert acquisition.brightness is None
assert acquisition.exposure_time is None
assert acquisition.gain is None
pytest.helpers.equality_tester(
zivid.Settings2D.Acquisition,
[5, 0.5, datetime.timedelta(microseconds=11000), 14],
[5, 0.5, datetime.timedelta(microseconds=11001), 14],
)
def configure_setting(self):
# 2D image setting
self.settings_2d = zivid.Settings2D()
self.settings_2d.acquisitions.append(zivid.Settings2D.Acquisition())
self.settings_2d.acquisitions[0].aperture = 4.76
self.settings_2d.acquisitions[0].exposure_time = datetime.timedelta(
microseconds=10000)
self.settings_2d.brightness = 1.3
# 3D capture setting
self.settings = zivid.Settings()
self.settings.acquisitions.append(zivid.Settings.Acquisition())
self.settings.acquisitions[0].aperture = 4.76
self.settings.acquisitions[0].exposure_time = datetime.timedelta(
microseconds=10000)
self.settings.brightness = 1.3
self.settings.processing.filters.outlier.removal.enabled = True
self.settings.processing.filters.outlier.removal.threshold = 5.0
self.settings.processing.filters.noise.removal.enabled = False
self.settings.processing.filters.outlier.removal.enabled = True
self.settings.processing.Filters.Smoothing.Gaussian.enabled = True
self.settings.processing.Filters.Smoothing.Gaussian.sigma = 1.5
def _capture_bgr_image(camera, gamma):
"""Capture and extract 2D image, then convert from RGBA and return BGR.
Args:
camera: Zivid Camera handle
gamma: Gamma correction value
Returns:
BGR image (HxWx3 darray)
"""
print("Configuring Settings")
settings_2d = zivid.Settings2D(
acquisitions=[zivid.Settings2D.Acquisition()], )
settings_2d.processing.color.gamma = gamma
print("Capturing 2D frame")
with camera.capture(settings_2d) as frame_2d:
image = frame_2d.image_rgba()
rgba = image.copy_data()
bgr = cv2.cvtColor(rgba, cv2.COLOR_RGBA2BGR)
return bgr
def physical_camera_frame_2d_fixture(physical_camera):
import zivid
settings_2d = zivid.Settings2D()
with physical_camera.capture_2d(settings_2d) as frame_2d:
yield frame_2d
def _auto_settings_configuration(camera):
"""Automatically configure 2D capture settings by taking images in a loop while tunning gain, exposure time, and
aperture. The goal is that the maximum of mean RGB values reaches the value within defined limits.
Args:
camera: Camera
Returns:
settings_2d: 2D capture settings
"""
print("Starting auto settings configuration")
desired_color_range = [200, 225]
settings_2d = zivid.Settings2D(acquisitions=[
zivid.Settings2D.Acquisition(
aperture=8,
exposure_time=datetime.timedelta(microseconds=20000),
brightness=0.0,
gain=2.0,
)
], )
fnums = [11.31, 8, 5.6, 4, 2.8, 2]
setting_tunning_index = 1
cnt = 0
timeout_cnt = 25
timeout_break = False
while True:
rgba = camera.capture(settings_2d).image_rgba().copy_data()
mean_color = _compute_mean_rgb(rgba[:, :, 0:3], 100)
max_mean_color = max(mean_color.red, mean_color.green, mean_color.blue)
print(f"Iteration: {cnt+1}")
print(f" Max mean color: {max_mean_color} ")
print(
f" Desired color range: [{desired_color_range[0]},{desired_color_range[1]}]"
)
# Breaking on timeout the first time 2D image is not saturated
if timeout_break is True and max_mean_color < 255:
break
if max_mean_color <= desired_color_range[
0] or max_mean_color >= desired_color_range[1]:
color_ratio = np.mean(desired_color_range) / max_mean_color
if setting_tunning_index == 1:
settings_2d.acquisitions[0].gain = np.clip(
settings_2d.acquisitions[0].gain * color_ratio, 1, 16)
print(f" New gain: {settings_2d.acquisitions[0].gain}")
setting_tunning_index = 2
elif setting_tunning_index == 2:
new_exp = settings_2d.acquisitions[
0].exposure_time.microseconds * color_ratio
settings_2d.acquisitions[0].exposure_time = datetime.timedelta(
microseconds=np.clip(new_exp, 6500, 100000))
print(
f" New exposure time: {settings_2d.acquisitions[0].exposure_time.microseconds}"
)
setting_tunning_index = 3
elif setting_tunning_index == 3:
fnum_index = fnums.index(settings_2d.acquisitions[0].aperture)
if color_ratio > 1:
settings_2d.acquisitions[0].aperture = np.clip(
fnums[fnum_index + 1], fnums[-1], fnums[0])
if color_ratio < 1:
settings_2d.acquisitions[0].aperture = np.clip(
fnums[fnum_index - 1], fnums[-1], fnums[0])
setting_tunning_index = 1
print(f" New aperture: {settings_2d.acquisitions[0].aperture}")
cnt = cnt + 1
else:
print("Auto settings configuration sucessful")
break
if cnt >= timeout_cnt:
timeout_break = True
print("Settings:")
print(settings_2d.acquisitions[0])
return settings_2d
def physical_camera_frame_2d_fixture(physical_camera):
settings_2d = zivid.Settings2D(
acquisitions=[zivid.Settings2D.Acquisition()])
with physical_camera.capture(settings_2d) as frame_2d:
yield frame_2d
def test_equal_iris(application): # pylint: disable=unused-argument
import zivid
settings_2d_1 = zivid.Settings2D(iris=34)
settings_2d_2 = zivid.Settings2D(iris=34)
assert settings_2d_1 == settings_2d_2
