def test_not_equal_exposure_time(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(exposure_time=3333)
settings2 = zivid.Settings(exposure_time=9999)
assert settings1 != settings2
def test_not_equal_bidirectional(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(bidirectional=True)
settings2 = zivid.Settings(bidirectional=False)
assert settings1 != settings2
def test_not_equal_gain(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(gain=0)
settings2 = zivid.Settings(gain=1)
assert settings1 != settings2
def test_not_equal_red_balance(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(red_balance=34)
settings2 = zivid.Settings(red_balance=43)
assert settings1 != settings2
def test_not_equal_iris(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(iris=34)
settings2 = zivid.Settings(iris=43)
assert settings1 != settings2
def test_equal_filters(application): # pylint: disable=unused-argument
import zivid
settings1 = zivid.Settings(filters=zivid.Settings.Filters(
zivid.Settings.Filters.Contrast(enabled=False)))
settings2 = zivid.Settings(filters=zivid.Settings.Filters(
zivid.Settings.Filters.Contrast(enabled=False)))
assert settings1 == settings2
def test_illegal_settings(file_camera):
import zivid
with pytest.raises(TypeError):
file_camera.capture(zivid.Settings())
with pytest.raises(AttributeError):
file_camera.capture([1, 2, 3, 4, 5])
with pytest.raises(AttributeError):
file_camera.capture([zivid.Settings(), zivid.Settings(), 3])
with pytest.raises(TypeError):
file_camera.capture(file_camera.capture())
def random_settings_fixture():
import datetime
from random import randint, choice, uniform
import zivid
heavily_modified_settings = zivid.Settings(
bidirectional=choice([True, False]),
blue_balance=uniform(1, 8),
brightness=uniform(0, 1.8),
exposure_time=datetime.timedelta(microseconds=randint(6500, 100000)),
filters=zivid.Settings.Filters(
contrast=zivid.Settings.Filters.Contrast(
enabled=choice([True, False]), threshold=uniform(0, 100)),
outlier=zivid.Settings.Filters.Outlier(enabled=choice(
[True, False]),
threshold=uniform(0, 100)),
saturated=zivid.Settings.Filters.Saturated(
enabled=choice([True, False])),
reflection=zivid.Settings.Filters.Reflection(
enabled=choice([True, False])),
gaussian=zivid.Settings.Filters.Gaussian(enabled=choice(
[True, False]),
sigma=uniform(0.5, 5)),
),
gain=uniform(1, 16),
iris=randint(0, 72),
red_balance=uniform(1, 8),
)
yield heavily_modified_settings
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 _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 test_init_filters(application): # pylint: disable=unused-argument
import zivid
value = zivid.Settings.Filters()
settings = zivid.Settings(filters=value)
assert settings.filters == value
assert isinstance(settings.filters, zivid.Settings.Filters)
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 test_tuple_one_settings(file_camera):
import zivid
settings_collection = (zivid.Settings(), )
assert isinstance(settings_collection, tuple)
with file_camera.capture(settings_collection) as hdr_frame:
assert hdr_frame
assert isinstance(hdr_frame, zivid.frame.Frame)
def test_capture_settings(file_camera):
import zivid
frame = file_camera.capture(
zivid.Settings(acquisitions=[zivid.Settings.Acquisition()]))
assert frame
assert isinstance(frame, zivid.frame.Frame)
frame.release()
def test_connect_camera_settings(application):
import zivid
settings = zivid.Settings()
with application.connect_camera(settings=settings) as cam:
assert cam
assert isinstance(cam, zivid.camera.Camera)
assert cam.settings == settings
def test_tuple_five_settings(file_camera):
import zivid
settings_collection = tuple([zivid.Settings() for _ in range(5)])
assert isinstance(settings_collection, tuple)
with file_camera.capture(settings_collection) as hdr_frame:
assert hdr_frame
assert isinstance(hdr_frame, zivid.frame.Frame)
def test_init_red_balance(application): # pylint: disable=unused-argument
import numbers
import zivid
value = 38
settings = zivid.Settings(red_balance=value)
assert settings.red_balance == value
assert isinstance(settings.red_balance, numbers.Real)
def test_init_gain(application): # pylint: disable=unused-argument
import numbers
import zivid
value = 36
settings = zivid.Settings(gain=value)
assert settings.gain == value
assert isinstance(settings.gain, numbers.Real)
def test_init_iris(application): # pylint: disable=unused-argument
import numbers
import zivid
value = 37
settings = zivid.Settings(iris=value)
assert settings.iris == value
assert isinstance(settings.iris, numbers.Real)
def test_list_one_settings(file_camera):
import zivid
settings_collection = [zivid.Settings()]
assert isinstance(settings_collection, list)
with file_camera.capture(settings_collection) as hdr_frame:
assert hdr_frame
assert isinstance(hdr_frame, zivid.frame.Frame)
def test_init_exposure_time(application): # pylint: disable=unused-argument
import datetime
import zivid
value = datetime.timedelta(microseconds=10000)
settings = zivid.Settings(exposure_time=value)
assert settings.exposure_time == value
assert isinstance(settings.exposure_time, datetime.timedelta)
def test_init_bidirectional(application): # pylint: disable=unused-argument
import numbers
import zivid
value = True
settings = zivid.Settings(bidirectional=value)
assert settings.bidirectional == value
assert isinstance(settings.bidirectional, numbers.Real)
def to_settings(internal_settings):
return zivid.Settings(
processing=to_settings_processing(internal_settings.processing),
acquisitions=[
to_settings_acquisition(element)
for element in internal_settings.acquisitions.value
],
)
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 test_one_acquisition_in_tuple(file_camera):
import zivid
acquisitions = (zivid.Settings.Acquisition(), )
settings = zivid.Settings(acquisitions=acquisitions)
assert isinstance(acquisitions, tuple)
with file_camera.capture(settings) as frame:
assert frame
assert isinstance(frame, zivid.frame.Frame)
def _apply_color_balance(rgb, red_balance, blue_balance):
"""Apply color balance to RGB image.
Args:
rgb: Input RGB image
red_balance: Red balance
blue_balance: Blue balance
Returns:
corrected_image: RGB image after color balance
"""
default_red_balance = zivid.Settings().red_balance
default_blue_balance = zivid.Settings().blue_balance
corrected_rgb = np.copy(rgb)
corrected_rgb[:, :, 0] = rgb[:, :, 0] * red_balance / default_red_balance
corrected_rgb[:, :, 2] = rgb[:, :, 2] * blue_balance / default_blue_balance
return corrected_rgb
def test_set_settings(file_camera):
import zivid
settings = zivid.Settings(
iris=
21 # Must be 21. File camera's default settings are almost similar to
# the default settings, apart from iris, which is for some reason 21
)
file_camera.settings = settings
assert file_camera.settings == settings
assert isinstance(file_camera.settings, zivid.Settings)
def test_connect_camera_serial_number_and_settings(application):
import zivid
with application.connect_camera() as cam:
serial_number = cam.serial_number
settings = zivid.Settings()
with application.connect_camera(serial_number=serial_number,
settings=settings) as cam:
assert cam
assert isinstance(cam, zivid.camera.Camera)
assert cam.settings == settings
def test_five_acquisitions_in_list(file_camera):
import zivid
acquisitions = [
zivid.Settings.Acquisition(),
zivid.Settings.Acquisition(),
zivid.Settings.Acquisition(),
zivid.Settings.Acquisition(),
zivid.Settings.Acquisition(),
]
settings = zivid.Settings(acquisitions=acquisitions)
assert isinstance(acquisitions, list)
with file_camera.capture(settings) as frame:
assert frame
assert isinstance(frame, zivid.frame.Frame)
