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