Python API: Adding more tests to test the Device, Capture, Image, and…

… Calibration classes. Fixing shallow copy and deep copy of Image objects.

src/python/k4a/src/k4a/_bindings/calibration.py

@@ -14,8 +14,10 @@
 
 class Calibration:
 
-    def __init__(self, _calibration:_Calibration):
+    def __init__(self, _calibration:_Calibration=None):
         self._calibration = _calibration
+        if self._calibration is None:
+            self._calibration = _Calibration()
 
     # Allow "with" syntax.
     def __enter__(self):

src/python/k4a/src/k4a/_bindings/capture.py

@@ -114,8 +114,10 @@ def __str__(self):
     # Define properties and get/set functions. ############### 
     @property
     def color(self):
-        image_handle = k4a_capture_get_color_image(self._capture_handle)
-        self._color = Image._create_from_existing_image_handle(image_handle)
+        if self._color is None:
+            image_handle = k4a_capture_get_color_image(self._capture_handle)
+            self._color = Image._create_from_existing_image_handle(image_handle)
+
         return self._color
 
     @color.setter
@@ -135,8 +137,10 @@ def color(self):
 
     @property
     def depth(self):
-        image_handle = k4a_capture_get_depth_image(self._capture_handle)
-        self._depth = Image._create_from_existing_image_handle(image_handle)
+        if self._depth is None:
+            image_handle = k4a_capture_get_depth_image(self._capture_handle)
+            self._depth = Image._create_from_existing_image_handle(image_handle)
+
         return self._depth
 
     @depth.setter
@@ -156,8 +160,10 @@ def depth(self):
 
     @property
     def ir(self):
-        image_handle = k4a_capture_get_ir_image(self._capture_handle)
-        self._ir = Image._create_from_existing_image_handle(image_handle)
+        if self._ir is None:
+            image_handle = k4a_capture_get_ir_image(self._capture_handle)
+            self._ir = Image._create_from_existing_image_handle(image_handle)
+
         return self._ir
 
     @ir.setter

src/python/k4a/src/k4a/_bindings/device.py

@@ -20,7 +20,7 @@
     k4a_device_get_imu_sample, k4a_device_get_color_control, \
     k4a_device_start_cameras, k4a_device_stop_cameras, \
     k4a_device_start_imu, k4a_device_stop_imu, \
-    k4a_device_get_color_control, k4a_device_get_raw_calibration, \
+    k4a_device_set_color_control, k4a_device_get_raw_calibration, \
     k4a_device_get_sync_jack, k4a_device_get_capture, k4a_device_get_calibration
 
 from .capture import Capture
@@ -106,15 +106,15 @@ def open(device_index:int=0):
 
             # Create a dictionary of color control capabilities.
             color_control_commands = [
-                ('backlight_comp', EColorControlCommand.BACKLIGHT_COMPENSATION),
-                ('brightness', EColorControlCommand.BRIGHTNESS),
-                ('contrast', EColorControlCommand.CONTRAST),
-                ('exposure_time', EColorControlCommand.EXPOSURE_TIME_ABSOLUTE),
-                ('gain', EColorControlCommand.GAIN),
-                ('powerline_freq', EColorControlCommand.POWERLINE_FREQUENCY),
-                ('saturation', EColorControlCommand.SATURATION),
-                ('sharpness', EColorControlCommand.SHARPNESS),
-                ('whitebalance', EColorControlCommand.WHITEBALANCE)
+                EColorControlCommand.BACKLIGHT_COMPENSATION,
+                EColorControlCommand.BRIGHTNESS,
+                EColorControlCommand.CONTRAST,
+                EColorControlCommand.EXPOSURE_TIME_ABSOLUTE,
+                EColorControlCommand.GAIN,
+                EColorControlCommand.POWERLINE_FREQUENCY,
+                EColorControlCommand.SATURATION,
+                EColorControlCommand.SHARPNESS,
+                EColorControlCommand.WHITEBALANCE
             ]
 
             supports_auto = _ctypes.c_bool(False)
@@ -128,7 +128,7 @@ def open(device_index:int=0):
 
                 status = k4a_device_get_color_control_capabilities(
                     device.__device_handle,
-                    command[1],
+                    command,
                     _ctypes.byref(supports_auto),
                     _ctypes.byref(min_value),
                     _ctypes.byref(max_value),
@@ -137,17 +137,17 @@ def open(device_index:int=0):
                     _ctypes.byref(color_control_mode))
 
                 if (status == EStatus.SUCCEEDED):
-                    device._color_ctrl_cap.__dict__[command[0]] = _EmptyClass()
-                    device._color_ctrl_cap.__dict__[command[0]].supports_auto = bool(supports_auto.value)
-                    device._color_ctrl_cap.__dict__[command[0]].min_value = int(min_value.value)
-                    device._color_ctrl_cap.__dict__[command[0]].max_value = int(max_value.value)
-                    device._color_ctrl_cap.__dict__[command[0]].step_value = int(step_value.value)
-                    device._color_ctrl_cap.__dict__[command[0]].default_value = int(default_value.value)
-                    device._color_ctrl_cap.__dict__[command[0]].default_mode = EColorControlMode(color_control_mode.value)
+                    device._color_ctrl_cap.__dict__[command] = _EmptyClass()
+                    device._color_ctrl_cap.__dict__[command].supports_auto = bool(supports_auto.value)
+                    device._color_ctrl_cap.__dict__[command].min_value = int(min_value.value)
+                    device._color_ctrl_cap.__dict__[command].max_value = int(max_value.value)
+                    device._color_ctrl_cap.__dict__[command].step_value = int(step_value.value)
+                    device._color_ctrl_cap.__dict__[command].default_value = int(default_value.value)
+                    device._color_ctrl_cap.__dict__[command].default_mode = EColorControlMode(color_control_mode.value)
 
-        # Read the sync jack.
-        (device._sync_in_connected, device._sync_out_connected) = \
-            _read_sync_jack_helper(device.__device_handle)
+            # Read the sync jack.
+            (device._sync_in_connected, device._sync_out_connected) = \
+                _read_sync_jack_helper(device.__device_handle)
 
         return device
 
@@ -233,16 +233,16 @@ def start_imu(self)->EStatus:
     def stop_imu(self):
         k4a_device_stop_imu(self.__device_handle)
 
-    def get_color_control(
-        color_ctrl_command:EColorControlCommand,
-        color_ctrl_mode:EColorControlMode)->int:
+    def get_color_control(self, 
+        color_ctrl_command:EColorControlCommand)->(int, EColorControlMode):
 
         retval = None
+        retmode = None
 
         color_ctrl_value = _ctypes.c_int32(0)
         command = _ctypes.c_int(color_ctrl_command.value)
-        mode = _ctypes.c_int(color_ctrl_mode.value)
-
+        mode = _ctypes.c_int32(EColorControlMode.MANUAL.value)
+        
         status = k4a_device_get_color_control(
             self.__device_handle,
             color_ctrl_command,
@@ -251,10 +251,12 @@ def get_color_control(
 
         if status == EStatus.SUCCEEDED:
             retval = color_ctrl_value.value
+            retmode = EColorControlMode(mode.value)
 
-        return retval
+        return (retval, retmode)
 
     def set_color_control(
+        self,
         color_ctrl_command:EColorControlCommand,
         color_ctrl_mode:EColorControlMode,
         color_ctrl_value:int)->EStatus:

src/python/k4a/src/k4a/_bindings/image.py

@@ -206,17 +206,17 @@ def __copy__(self):
 
         # Create a shallow copy.
         new_image = Image(self._image_handle)
-        new_image._data = _copy.copy(self._data)
-        new_image._image_format = _copy.copy(self._image_format)
-        new_image._size_bytes = _copy.copy(self._size_bytes)
-        new_image._width_pixels = _copy.copy(self._width_pixels)
-        new_image._height_pixels = _copy.copy(self._height_pixels)
-        new_image._stride_bytes = _copy.copy(self._stride_bytes)
-        new_image._device_timestamp_usec = _copy.copy(self._device_timestamp_usec)
-        new_image._system_timestamp_nsec = _copy.copy(self._system_timestamp_nsec)
-        new_image._exposure_usec = _copy.copy(self._exposure_usec)
-        new_image._white_balance = _copy.copy(self._white_balance)
-        new_image._iso_speed = _copy.copy(self._iso_speed)
+        new_image._data = self._data.view()
+        new_image._image_format = self._image_format
+        new_image._size_bytes = self._size_bytes
+        new_image._width_pixels = self._width_pixels
+        new_image._height_pixels = self._height_pixels
+        new_image._stride_bytes = self._stride_bytes
+        new_image._device_timestamp_usec = self._device_timestamp_usec
+        new_image._system_timestamp_nsec = self._system_timestamp_nsec
+        new_image._exposure_usec =self._exposure_usec
+        new_image._white_balance = self._white_balance
+        new_image._iso_speed = self._iso_speed
 
         # Update reference count.
         new_image._reference()

src/python/k4a/src/k4a/_bindings/k4atypes.py

@@ -264,7 +264,7 @@ class ETransformInterpolationType(_IntEnum):
 
 
 @_unique
-class EFramePerSecond(_IntEnum):
+class EFramesPerSecond(_IntEnum):
     """
     Color and depth sensor frame rate.
 
@@ -437,7 +437,7 @@ class ECalibrationType(_IntEnum):
     NUM_TYPES                        Number of types excluding unknown type.
     ================================ ==========================================
     """
-    UNKNOWN = 0
+    UNKNOWN = -1
     DEPTH = _auto()
     COLOR = _auto()
     GYRO = _auto()
@@ -587,15 +587,15 @@ class DeviceConfiguration(_ctypes.Structure):
     ]
 
     def __init__(self, 
-        color_format:EImageFormat,
-        color_resolution:EColorResolution,
-        depth_mode:EDepthMode,
-        camera_fps:EFramePerSecond,
-        synchronized_images_only:bool,
-        depth_delay_off_color_usec:int,
-        wired_sync_mode:EWiredSyncMode,
-        subordinate_delay_off_master_usec:int,
-        disable_streaming_indicator:bool):
+        color_format:EImageFormat=EImageFormat.CUSTOM,
+        color_resolution:EColorResolution=EColorResolution.RES_720P,
+        depth_mode:EDepthMode=EDepthMode.OFF,
+        camera_fps:EFramesPerSecond=EFramesPerSecond.FPS_5,
+        synchronized_images_only:bool=True,
+        depth_delay_off_color_usec:int=0,
+        wired_sync_mode:EWiredSyncMode=EWiredSyncMode.STANDALONE,
+        subordinate_delay_off_master_usec:int=0,
+        disable_streaming_indicator:bool=False):
 
         self.color_format = color_format
         self.color_resolution = color_resolution
@@ -885,7 +885,7 @@ def __str__(self):
     color_format = EImageFormat.COLOR_MJPG,
     color_resolution = EColorResolution.OFF,
     depth_mode = EDepthMode.OFF,
-    camera_fps = EFramePerSecond.FPS_30,
+    camera_fps = EFramesPerSecond.FPS_30,
     synchronized_images_only = False,
     depth_delay_off_color_usec = 0,
     wired_sync_mode = EWiredSyncMode.STANDALONE,
@@ -896,7 +896,7 @@ def __str__(self):
     color_format = EImageFormat.COLOR_BGRA32,
     color_resolution = EColorResolution.RES_2160P,
     depth_mode = EDepthMode.WFOV_2X2BINNED,
-    camera_fps = EFramePerSecond.FPS_15,
+    camera_fps = EFramesPerSecond.FPS_15,
     synchronized_images_only = True,
     depth_delay_off_color_usec = 0,
     wired_sync_mode = EWiredSyncMode.STANDALONE,
@@ -913,7 +913,7 @@ def __str__(self):
 
         if len(keys) > 0:
             for n in range(len(keys)-1):
-                tempstr = tempstr + keys[n] + "=" + str(self.__dict__[keys[n]]) + ", "
-            tempstr = tempstr + keys[len(keys)-1] + "=" + str(self.__dict__[keys[len(keys)-1]])
+                tempstr = tempstr + str(keys[n]) + "=" + str(self.__dict__[keys[n]]) + ", "
+            tempstr = tempstr + str(keys[len(keys)-1]) + "=" + str(self.__dict__[keys[len(keys)-1]])
 
         return tempstr