Refactor capture and transformation handles

example/bench.py → example/benchmark.py

@@ -62,7 +62,7 @@ def __call__(self, parser, namespace, values, option_string=None):
 
 def parse_args() -> Namespace:
     parser = ArgumentParser(
-        description="Bench camera captures transfer speed. \n"
+        description="Camera captures transfer speed benchmark. \n"
         "You can check if you USB controller/cable has enough performance."
     )
     parser.add_argument("--device-id", type=int, default=0, help="Device ID, from zero. Default: 0")
@@ -74,7 +74,7 @@ def parse_args() -> Namespace:
         help="Color sensor resoultion. Default: 720P",
     )
     parser.add_argument(
-        "--color-color_format",
+        "--color-format",
         type=ImageFormat,
         action=EnumActionTuned,
         default=ImageFormat.COLOR_BGRA32,
@@ -115,7 +115,7 @@ def parse_args() -> Namespace:
 
 def bench(config: Config, device_id: int):
     device = PyK4A(config=config, device_id=device_id)
-    device.connect()
+    device.start()
     depth = color = depth_period = color_period = 0
     print("Press CTRL-C top stop benchmark")
     started_at = started_at_period = monotonic()
@@ -138,7 +138,7 @@ def bench(config: Config, device_id: int):
         except KeyboardInterrupt:
             break
     elapsed = monotonic() - started_at
-    device.disconnect()
+    device.stop()
     print()
     print(f"Result: Color: {color / elapsed:0.2f} FPS, Depth: {depth / elapsed: 0.2f} FPS")
 

example/color_formats.py

@@ -2,44 +2,28 @@
 import numpy as np
 
 import pyk4a
+from helpers import convert_to_bgra_if_required
 from pyk4a import Config, PyK4A
 
 
 def get_color_image_size(config, imshow=True):
     if imshow:
         cv2.namedWindow("k4a")
     k4a = PyK4A(config)
-    k4a.connect()
+    k4a.start()
     count = 0
     while count < 60:
         capture = k4a.get_capture()
         if np.any(capture.color):
             count += 1
             if imshow:
-                cv2.imshow("k4a", convert_to_bgra_if_required(k4a, capture.color))
+                cv2.imshow("k4a", convert_to_bgra_if_required(config.color_format, capture.color))
                 cv2.waitKey(10)
     cv2.destroyAllWindows()
-    k4a.disconnect()
+    k4a.stop()
     return capture.color.nbytes
 
 
-def convert_to_bgra_if_required(k4a, img_color):
-    # examples for all possible pyk4a.ColorFormats
-    if k4a._config.color_format == pyk4a.ImageFormat.COLOR_MJPG:
-        img_color = cv2.imdecode(img_color, cv2.IMREAD_COLOR)
-    elif k4a._config.color_format == pyk4a.ImageFormat.COLOR_NV12:
-        img_color = cv2.cvtColor(img_color, cv2.COLOR_YUV2BGRA_NV12)
-        # this also works and it explains how the COLOR_NV12 color color_format is stored in memory
-        # h, w = color_image.shape[0:2]
-        # h = h // 3 * 2
-        # luminance = color_image[:h]
-        # chroma = color_image[h:, :w//2]
-        # color_image = cv2.cvtColorTwoPlane(luminance, chroma, cv2.COLOR_YUV2BGRA_NV12)
-    elif k4a._config.color_format == pyk4a.ImageFormat.COLOR_YUY2:
-        img_color = cv2.cvtColor(img_color, cv2.COLOR_YUV2BGRA_YUY2)
-    return img_color
-
-
 if __name__ == "__main__":
     imshow = True
     config_BGRA32 = Config(color_format=pyk4a.ImageFormat.COLOR_BGRA32)
@@ -52,8 +36,8 @@ def convert_to_bgra_if_required(k4a, img_color):
     nbytes_NV12 = get_color_image_size(config_NV12, imshow=imshow)
     nbytes_YUY2 = get_color_image_size(config_YUY2, imshow=imshow)
 
-    print(f"{nbytes_BGRA32} {nbytes_MJPG}")
-    print(f"BGRA32 is {nbytes_BGRA32/nbytes_MJPG} larger")
+    print(f"BGRA32: {nbytes_BGRA32},  MJPG: {nbytes_MJPG}, NV12: {nbytes_NV12}, YUY2: {nbytes_YUY2}")
+    print(f"BGRA32 is {nbytes_BGRA32/nbytes_MJPG:0.2f} larger than MJPG")
 
     # output:
     # nbytes_BGRA32=3686400 nbytes_MJPG=229693

example/helpers.py

@@ -0,0 +1,37 @@
+from typing import Optional, Tuple
+
+import cv2
+import numpy as np
+
+from pyk4a import ImageFormat
+
+
+def convert_to_bgra_if_required(color_format: ImageFormat, color_image):
+    # examples for all possible pyk4a.ColorFormats
+    if color_format == ImageFormat.COLOR_MJPG:
+        color_image = cv2.imdecode(color_image, cv2.IMREAD_COLOR)
+    elif color_format == ImageFormat.COLOR_NV12:
+        color_image = cv2.cvtColor(color_image, cv2.COLOR_YUV2BGRA_NV12)
+        # this also works and it explains how the COLOR_NV12 color color_format is stored in memory
+        # h, w = color_image.shape[0:2]
+        # h = h // 3 * 2
+        # luminance = color_image[:h]
+        # chroma = color_image[h:, :w//2]
+        # color_image = cv2.cvtColorTwoPlane(luminance, chroma, cv2.COLOR_YUV2BGRA_NV12)
+    elif color_format == ImageFormat.COLOR_YUY2:
+        color_image = cv2.cvtColor(color_image, cv2.COLOR_YUV2BGRA_YUY2)
+    return color_image
+
+
+def colorize(
+    image: np.ndarray,
+    clipping_range: Tuple[Optional[int], Optional[int]] = (None, None),
+    colormap: int = cv2.COLORMAP_HSV,
+) -> np.ndarray:
+    if clipping_range[0] or clipping_range[1]:
+        img = image.clip(clipping_range[0], clipping_range[1])
+    else:
+        img = image.copy()
+    img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+    img = cv2.applyColorMap(img, colormap)
+    return img

example/imu.py

@@ -25,7 +25,7 @@ def main():
             synchronized_images_only=True,
         )
     )
-    k4a.connect()
+    k4a.start()
     k4a._start_imu()
 
     plt.ion()
@@ -75,7 +75,7 @@ def main():
         fig.canvas.flush_events()
 
     k4a._stop_imu()
-    k4a.disconnect()
+    k4a.stop()
 
 
 if __name__ == "__main__":

example/playback.py

@@ -1,41 +1,9 @@
 from argparse import ArgumentParser
-from typing import Optional, Tuple
 
 import cv2
-import numpy as np
 
-from pyk4a import ImageFormat, PyK4APlayback
-
-
-def colorize(
-    image: np.ndarray,
-    clipping_range: Tuple[Optional[int], Optional[int]] = (None, None),
-    colormap: int = cv2.COLORMAP_HSV,
-) -> np.ndarray:
-    if clipping_range[0] or clipping_range[1]:
-        img = image.clip(clipping_range[0], clipping_range[1])
-    else:
-        img = image.copy()
-    img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
-    img = cv2.applyColorMap(img, colormap)
-    return img
-
-
-def convert_to_bgra_if_required(color_format, color_image):
-    # examples for all possible pyk4a.ColorFormats
-    if color_format == ImageFormat.COLOR_MJPG:
-        color_image = cv2.imdecode(color_image, cv2.IMREAD_COLOR)
-    elif color_format == ImageFormat.COLOR_NV12:
-        color_image = cv2.cvtColor(color_image, cv2.COLOR_YUV2BGRA_NV12)
-        # this also works and it explains how the COLOR_NV12 color color_format is stored in memory
-        # h, w = color_image.shape[0:2]
-        # h = h // 3 * 2
-        # luminance = color_image[:h]
-        # chroma = color_image[h:, :w//2]
-        # color_image = cv2.cvtColorTwoPlane(luminance, chroma, cv2.COLOR_YUV2BGRA_NV12)
-    elif color_format == ImageFormat.COLOR_YUY2:
-        color_image = cv2.cvtColor(color_image, cv2.COLOR_YUV2BGRA_YUY2)
-    return color_image
+from helpers import colorize, convert_to_bgra_if_required
+from pyk4a import PyK4APlayback
 
 
 def info(playback: PyK4APlayback):

example/threads.py

@@ -36,13 +36,13 @@ def __init__(self, device_id=0, thread_safe: bool = True):
     def run(self) -> None:
         print("Start run")
         camera = PyK4A(device_id=self._device_id, thread_safe=self.thread_safe)
-        camera.connect()
+        camera.start()
         while not self._halt:
             capture = camera.get_capture()
             assert capture.depth is not None
             self._count += 1
         sleep(0.1)
-        camera.disconnect()
+        camera.stop()
         del camera
         print("Stop run")
 

example/viewer.py

@@ -13,7 +13,7 @@ def main():
             synchronized_images_only=True,
         )
     )
-    k4a.connect()
+    k4a.start()
 
     # getters and setters directly get and set on device
     k4a.whitebalance = 4500
@@ -29,7 +29,7 @@ def main():
             if key != -1:
                 cv2.destroyAllWindows()
                 break
-    k4a.disconnect()
+    k4a.stop()
 
 
 if __name__ == "__main__":

example/viewer_depth.py

@@ -2,6 +2,7 @@
 import numpy as np
 
 import pyk4a
+from helpers import colorize
 from pyk4a import Config, PyK4A
 
 
@@ -13,7 +14,7 @@ def main():
             synchronized_images_only=False,
         )
     )
-    k4a.connect()
+    k4a.start()
 
     # getters and setters directly get and set on device
     k4a.whitebalance = 4500
@@ -24,18 +25,12 @@ def main():
     while True:
         capture = k4a.get_capture()
         if np.any(capture.depth):
-            # Clip 5000 mm(5 meters)
-            clipped_depth = capture.depth.clip(None, 5000)
-            # normalize and convert to 8bit
-            normalized_depth = cv2.normalize(clipped_depth, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
-            # coloring image by choosed color map
-            colored_depth = cv2.applyColorMap(normalized_depth, cv2.COLORMAP_HSV)
-            cv2.imshow("k4a", colored_depth)
+            cv2.imshow("k4a", colorize(capture.depth, (None, 5000), cv2.COLORMAP_HSV))
             key = cv2.waitKey(10)
             if key != -1:
                 cv2.destroyAllWindows()
                 break
-    k4a.disconnect()
+    k4a.stop()
 
 
 if __name__ == "__main__":

example/viewer_point_cloud.py

@@ -15,7 +15,7 @@ def main():
             synchronized_images_only=True,
         )
     )
-    k4a.connect()
+    k4a.start()
 
     # getters and setters directly get and set on device
     k4a.whitebalance = 4500
@@ -47,7 +47,7 @@ def main():
     ax.view_init(elev=-90, azim=-90)
     plt.show()
 
-    k4a.disconnect()
+    k4a.stop()
 
 
 if __name__ == "__main__":

example/viewer_transformation.py

@@ -1,29 +1,13 @@
-from typing import Optional, Tuple
-
 import cv2
-import numpy as np
 
 import pyk4a
+from helpers import colorize
 from pyk4a import Config, PyK4A
 
 
-def colorize(
-    image: np.ndarray,
-    clipping_range: Tuple[Optional[int], Optional[int]] = (None, None),
-    colormap: int = cv2.COLORMAP_HSV,
-) -> np.ndarray:
-    if clipping_range[0] or clipping_range[1]:
-        img = image.clip(clipping_range[0], clipping_range[1])
-    else:
-        img = image.copy()
-    img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
-    img = cv2.applyColorMap(img, colormap)
-    return img
-
-
 def main():
     k4a = PyK4A(Config(color_resolution=pyk4a.ColorResolution.RES_720P, depth_mode=pyk4a.DepthMode.NFOV_UNBINNED,))
-    k4a.connect()
+    k4a.start()
 
     while True:
         capture = k4a.get_capture()
@@ -43,7 +27,7 @@ def main():
             cv2.destroyAllWindows()
             break
 
-    k4a.disconnect()
+    k4a.stop()
 
 
 if __name__ == "__main__":

pyk4a/calibration.py

@@ -20,7 +20,7 @@ class Calibration:
     def __init__(
         self, handle: object, depth_mode: DepthMode, color_resolution: ColorResolution, thread_safe: bool = True
     ):
-        self._handle = handle
+        self._calibration_handle = handle
         self._transformation_handle: Optional[object] = None
         self.thread_safe = thread_safe
         self._depth_mode = depth_mode
@@ -59,9 +59,8 @@ def _convert_3d_to_3d(
             :param target_camera    The target camera.
             :return                 The 3D coordinates in millimeters representing a point in target camera.
         """
-        # Device needs to be running for the functions to work
         res, target_point_3d = k4a_module.calibration_3d_to_3d(
-            self._handle, self.thread_safe, source_point_3d, source_camera, target_camera,
+            self._calibration_handle, self.thread_safe, source_point_3d, source_camera, target_camera,
         )
 
         _verify_error(res)
@@ -89,9 +88,8 @@ def _convert_2d_to_3d(
             :param target_camera      The target camera.
             :return                   The 3D coordinates in mm representing a point in target camera.
         """
-        # Device needs to be running for the functions to work
         res, valid, target_point_3d = k4a_module.calibration_2d_to_3d(
-            self._handle, self.thread_safe, source_pixel_2d, source_depth, source_camera, target_camera,
+            self._calibration_handle, self.thread_safe, source_pixel_2d, source_depth, source_camera, target_camera,
         )
 
         _verify_error(res)
@@ -117,7 +115,7 @@ def convert_2d_to_3d(
     @property
     def transformation_handle(self) -> object:
         if not self._transformation_handle:
-            handle = k4a_module.transformation_create(self._handle, self.thread_safe)
+            handle = k4a_module.transformation_create(self._calibration_handle, self.thread_safe)
             if not handle:
                 raise K4AException("Cannot create transformation handle")
             self._transformation_handle = handle

pyk4a/errors.py

@@ -1,4 +1,4 @@
-from .result import Result
+from .results import Result
 
 
 class K4AException(Exception):

pyk4a/playback.py

@@ -15,21 +15,7 @@
 from .capture import PyK4ACapture
 from .config import FPS, ColorResolution, DepthMode, ImageFormat, WiredSyncMode
 from .errors import K4AException, _verify_error
-from .result import Result
-
-
-# k4a_buffer_result_t
-class BufferResult(IntEnum):
-    Success = 0
-    Failed = 1
-    TooSmall = 2
-
-
-# k4a_stream_result_t
-class StreamResult(IntEnum):
-    Success = 0
-    Failed = 1
-    EOF = 2
+from .results import Result, StreamResult
 
 
 class SeekOrigin(IntEnum):