pyorbbec 1.0.1.18__tar.gz → 1.0.1.20__tar.gz

pyorbbec-1.0.1.20/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyorbbec
+Version: 1.0.1.20
+Summary: pyorbbecsdk is a python wrapper for the OrbbecSDK
+Author: zhonghong
+Author-email: zhonghong@orbbec.com
+License-File: LICENSE

pyorbbec-1.0.1.20/pyorbbec.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: pyorbbec
+Version: 1.0.1.20
+Summary: pyorbbecsdk is a python wrapper for the OrbbecSDK
+Author: zhonghong
+Author-email: zhonghong@orbbec.com
+License-File: LICENSE

pyorbbec-1.0.1.20/pyorbbec.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+pyorbbec.egg-info/PKG-INFO
+pyorbbec.egg-info/SOURCES.txt
+pyorbbec.egg-info/dependency_links.txt
+pyorbbec.egg-info/not-zip-safe
+pyorbbec.egg-info/top_level.txt
+test/test_context.py
+test/test_device.py
+test/test_pipeline.py
+test/test_sensor_control.py

pyorbbec-1.0.1.20/pyorbbec.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyorbbecsdk

pyorbbec-1.0.1.20/pyproject.toml

@@ -0,0 +1,3 @@
+[tool.cibuildwheel]
+build = "cp39-* cp310-*"
+archs = "AMD64"   # Options: AMD64 ARM64 x86

pyorbbec-1.0.1.20/setup.py

@@ -0,0 +1,77 @@
+# ******************************************************************************
+#  Copyright (c) 2024 Orbbec 3D Technology, Inc
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http:# www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+# ******************************************************************************
+
+import os
+import shutil
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+
+
+class PrebuiltExtension(Extension):
+    def __init__(self, name, lib_dir=''):
+        super().__init__(name, sources=[])  # No sources to compile
+        self.lib_dir = os.path.abspath(lib_dir)
+
+
+class CustomBuildExt(build_ext):
+    def run(self):
+        for ext in self.extensions:
+            self.build_extension(ext)
+
+    def build_extension(self, ext):
+        # Check if the lib directory exists and contains files
+        if not os.path.isdir(ext.lib_dir) or not os.listdir(ext.lib_dir):
+            raise FileNotFoundError(
+                f"Directory '{ext.lib_dir}' is empty or does not exist. "
+                "Please compile the necessary components with CMake as described in the README."
+            )
+
+        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+        os.makedirs(extdir, exist_ok=True)  # Ensure the destination path exists
+        self.copy_all_files(ext.lib_dir, extdir)
+
+    def copy_all_files(self, source_dir, destination_dir):
+        os.makedirs(destination_dir, exist_ok=True)  # Ensure the entire destination directory structure exists
+
+        for item in os.listdir(source_dir):
+            source_path = os.path.join(source_dir, item)
+            destination_path = os.path.join(destination_dir, item)
+
+            if os.path.islink(source_path):
+                link_target = os.readlink(source_path)
+                if os.path.exists(destination_path):
+                    os.remove(destination_path)
+                os.symlink(link_target, destination_path)
+                print(f"Preserved symbolic link {destination_path} -> {link_target}")
+            elif os.path.isdir(source_path):
+                self.copy_all_files(source_path, destination_path)
+            else:
+                shutil.copy2(source_path, destination_path)
+                print(f"Copied {source_path} to {destination_path}")
+
+
+setup(
+    name='pyorbbec',
+    version='1.0.1.20',
+    author='zhonghong',
+    author_email='zhonghong@orbbec.com',
+    description='pyorbbecsdk is a python wrapper for the OrbbecSDK',
+    long_description='',
+    ext_modules=[PrebuiltExtension('pyorbbecsdk', 'install/lib')],
+    cmdclass={'build_ext': CustomBuildExt},
+    zip_safe=False,
+)

pyorbbec-1.0.1.20/test/test_context.py

@@ -0,0 +1,54 @@
+import unittest
+from pyorbbecsdk import *
+
+
+def on_device_connected_callback(_: DeviceList):
+    print("on_device_connected_callback")
+
+
+def on_device_disconnected_callback(_: DeviceList):
+    print("on_device_disconnected_callback")
+
+
+def on_set_device_changed_callback(disconn_list: DeviceList, conn_list: DeviceList):
+    on_device_disconnected_callback(disconn_list)
+    on_device_connected_callback(conn_list)
+
+
+class ContextTest(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.context = Context()
+
+    def tearDown(self) -> None:
+        self.context = None
+
+    def test_get_device_list(self):
+        device_list = self.context.query_devices()
+        self.assertIsNotNone(device_list)
+        self.assertGreater(device_list.get_count(), 0)
+
+    def test_setup_logger_level(self):
+        self.context.set_logger_level(OBLogLevel.DEBUG)
+        self.context.set_logger_level(OBLogLevel.INFO)
+        self.context.set_logger_level(OBLogLevel.WARNING)
+        self.context.set_logger_level(OBLogLevel.ERROR)
+        self.context.set_logger_level(OBLogLevel.FATAL)
+        self.context.set_logger_level(OBLogLevel.NONE)
+
+    def test_set_device_changed_callback(self):
+        self.context.set_device_changed_callback(on_set_device_changed_callback)
+
+    def test_enable_multi_device_sync(self):
+        self.context.enable_multi_device_sync(100)
+
+    def test_set_logger_to_console(self):
+        self.context.set_logger_to_console(OBLogLevel.DEBUG)
+
+    def test_set_logger_to_file(self):
+        self.context.set_logger_to_file(OBLogLevel.DEBUG, "test.log")
+
+
+if __name__ == '__main__':
+    print("Start test Context interface, Please make sure you have connected a device to your computer.")
+    unittest.main()

pyorbbec-1.0.1.20/test/test_device.py

@@ -0,0 +1,84 @@
+import unittest
+from pyorbbecsdk import *
+
+
+class DeviceTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.context = Context()
+        device_list = self.context.query_devices()
+        self.assertIsNotNone(device_list)
+        self.assertGreater(device_list.get_count(), 0)
+        self.device = device_list.get_device_by_index(0)
+        self.assertIsNotNone(self.device)
+
+    def tearDown(self) -> None:
+        self.device = None
+        self.context = None
+
+    def test_get_device_info(self):
+        device_info = self.device.get_device_info()
+        self.assertIsNotNone(device_info)
+        self.assertIsNotNone(device_info.get_name())
+        self.assertIsNotNone(device_info.get_pid())
+        self.assertIsNotNone(device_info.get_vid())
+        self.assertIsNotNone(device_info.get_serial_number())
+        self.assertIsNotNone(device_info.get_firmware_version())
+        self.assertIsNotNone(device_info.get_hardware_version())
+        self.assertIsNotNone(device_info.get_connection_type())
+        self.assertIsNotNone(device_info.get_device_type())
+        print("Device info: ", device_info)
+
+    def test_get_sensor_list(self):
+        sensor_list = self.device.get_sensor_list()
+        self.assertIsNotNone(sensor_list)
+        self.assertGreater(sensor_list.get_count(), 0)
+        for i in range(sensor_list.get_count()):
+            sensor = sensor_list.get_sensor_by_index(i)
+            self.assertIsNotNone(sensor)
+            self.assertIsNotNone(sensor.get_type())
+            print(sensor)
+
+    def test_get_depth_work_mode_list(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_STRUCT_CURRENT_DEPTH_ALG_MODE,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth work mode!")
+            return
+        current_depth_work_mode = self.device.get_depth_work_mode()
+        self.assertIsNotNone(current_depth_work_mode)
+        print("Current depth work mode: ", current_depth_work_mode)
+        depth_work_mode_list = self.device.get_depth_work_mode_list()
+        self.assertIsNotNone(depth_work_mode_list)
+        self.assertGreater(depth_work_mode_list.get_count(), 0)
+        select_depth_work_mode = None
+        for i in range(depth_work_mode_list.get_count()):
+            depth_work_mode = depth_work_mode_list.get_depth_work_mode_by_index(i)
+            self.assertIsNotNone(depth_work_mode)
+            print(depth_work_mode)
+            if depth_work_mode != current_depth_work_mode:
+                select_depth_work_mode = depth_work_mode
+        if select_depth_work_mode is not None:
+            self.device.set_depth_work_mode(select_depth_work_mode)
+            self.assertEqual(select_depth_work_mode, self.device.get_depth_work_mode())
+            self.device.set_depth_work_mode(current_depth_work_mode)
+            self.assertEqual(current_depth_work_mode, self.device.get_depth_work_mode())
+
+        self.device.set_depth_work_mode(current_depth_work_mode)
+
+    def test_get_calib_camera_params(self):
+        calib_camera_params_list = self.device.get_calibration_camera_param_list()
+        self.assertIsNotNone(calib_camera_params_list)
+        self.assertGreater(calib_camera_params_list.get_count(), 0)
+        for i in range(calib_camera_params_list.get_count()):
+            calib_camera_params = calib_camera_params_list.get_camera_param(i)
+            self.assertIsNotNone(calib_camera_params)
+            print(calib_camera_params)
+
+    def test_get_temperature(self):
+        temperature = self.device.get_temperature()
+        self.assertIsNotNone(temperature)
+        print("Device temperature: ", temperature)
+
+
+if __name__ == '__main__':
+    print("Start test Device interface, Please make sure you have connected a device to your computer.")
+    unittest.main()

pyorbbec-1.0.1.20/test/test_pipeline.py

@@ -0,0 +1,47 @@
+import unittest
+from pyorbbecsdk import *
+
+
+class PipelineTest(unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.context = Context()
+        device_list = self.context.query_devices()
+        self.assertIsNotNone(device_list)
+        self.assertGreater(device_list.get_count(), 0)
+        self.device = device_list.get_device_by_index(0)
+        self.assertIsNotNone(self.device)
+        self.pipeline = Pipeline(self.device)
+        self.assertIsNotNone(self.pipeline)
+
+    def tearDown(self) -> None:
+        self.pipeline = None
+        self.device = None
+        self.context = None
+
+    def test_get_device_info(self):
+        device_info = self.device.get_device_info()
+        self.assertIsNotNone(device_info)
+        self.assertIsNotNone(device_info.get_name())
+        self.assertIsNotNone(device_info.get_pid())
+        self.assertIsNotNone(device_info.get_vid())
+        self.assertIsNotNone(device_info.get_serial_number())
+        self.assertIsNotNone(device_info.get_firmware_version())
+        self.assertIsNotNone(device_info.get_hardware_version())
+        self.assertIsNotNone(device_info.get_connection_type())
+        self.assertIsNotNone(device_info.get_device_type())
+        print("Device info: ", device_info)
+
+    def test_get_camera_param(self):
+        camera_param = self.pipeline.get_camera_param()
+        self.assertIsNotNone(camera_param)
+        print(camera_param.depth_intrinsic)
+        print(camera_param.rgb_intrinsic)
+        print(camera_param.depth_distortion)
+        print(camera_param.rgb_distortion)
+        print(camera_param.transform)
+
+
+if __name__ == '__main__':
+    print("Start test Pipeline interface, Please make sure you have connected a device to your computer.")
+    unittest.main()

pyorbbec-1.0.1.20/test/test_sensor_control.py

@@ -0,0 +1,474 @@
+import unittest
+from pyorbbecsdk import *
+
+
+class SensorControlTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.context = Context()
+        device_list = self.context.query_devices()
+        self.assertIsNotNone(device_list)
+        self.assertGreater(device_list.get_count(), 0)
+        self.device = device_list.get_device_by_index(0)
+        self.assertIsNotNone(self.device)
+        self.pipeline = Pipeline(self.device)
+
+    def tearDown(self) -> None:
+        self.pipeline = None
+        self.device = None
+        self.context = None
+
+    def turn_off_depth_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, False)
+
+    def turn_on_depth_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, True)
+
+    def turn_off_ir_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL, False)
+
+    def turn_on_ir_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL, True)
+
+    def turn_off_color_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, False)
+
+    def turn_on_color_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color auto exposure!")
+            return
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, True)
+
+    def test_get_and_set_ir_gain(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_GAIN_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir gain!")
+            return
+        self.turn_off_ir_auto_exposure()
+        curr_ir_gain = self.device.get_int_property(OBPropertyID.OB_PROP_IR_GAIN_INT)
+        self.assertIsNotNone(curr_ir_gain)
+        print("Current ir gain: ", curr_ir_gain)
+        ir_gain = curr_ir_gain + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_IR_GAIN_INT, ir_gain)
+        new_ir_gain = self.device.get_int_property(OBPropertyID.OB_PROP_IR_GAIN_INT)
+        self.assertIsNotNone(new_ir_gain)
+        self.assertEqual(new_ir_gain, ir_gain)
+        self.device.set_int_property(OBPropertyID.OB_PROP_IR_GAIN_INT, curr_ir_gain)
+        self.turn_on_ir_auto_exposure()
+
+    def test_get_and_set_color_gain(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_GAIN_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color gain!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_gain = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_GAIN_INT)
+        self.assertIsNotNone(curr_color_gain)
+        print("Current color gain: ", curr_color_gain)
+        color_gain = curr_color_gain + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_GAIN_INT, color_gain)
+        new_color_gain = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_GAIN_INT)
+        self.assertIsNotNone(new_color_gain)
+        self.assertEqual(new_color_gain, color_gain)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_GAIN_INT, curr_color_gain)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_depth_gain(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_GAIN_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth gain!")
+            return
+        self.turn_off_depth_auto_exposure()
+        curr_depth_gain = self.device.get_int_property(OBPropertyID.OB_PROP_DEPTH_GAIN_INT)
+        self.assertIsNotNone(curr_depth_gain)
+        print("Current depth gain: ", curr_depth_gain)
+        depth_gain = curr_depth_gain + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_DEPTH_GAIN_INT, depth_gain)
+        new_depth_gain = self.device.get_int_property(OBPropertyID.OB_PROP_DEPTH_GAIN_INT)
+        self.assertIsNotNone(new_depth_gain)
+        self.assertEqual(new_depth_gain, depth_gain)
+        self.device.set_int_property(OBPropertyID.OB_PROP_DEPTH_GAIN_INT, curr_depth_gain)
+        self.turn_on_depth_auto_exposure()
+
+    def test_get_and_set_color_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_EXPOSURE_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color exposure!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_exposure = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_EXPOSURE_INT)
+        self.assertIsNotNone(curr_color_exposure)
+        print("Current color exposure: ", curr_color_exposure)
+        color_exposure = curr_color_exposure + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_EXPOSURE_INT, color_exposure)
+        new_color_exposure = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_EXPOSURE_INT)
+        self.assertIsNotNone(new_color_exposure)
+        self.assertEqual(new_color_exposure, color_exposure)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_EXPOSURE_INT, curr_color_exposure)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_ir_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_EXPOSURE_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir exposure!")
+            return
+        self.turn_off_ir_auto_exposure()
+        curr_ir_exposure = self.device.get_int_property(OBPropertyID.OB_PROP_IR_EXPOSURE_INT)
+        self.assertIsNotNone(curr_ir_exposure)
+        print("Current ir exposure: ", curr_ir_exposure)
+        ir_exposure = curr_ir_exposure + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_IR_EXPOSURE_INT, ir_exposure)
+        new_ir_exposure = self.device.get_int_property(OBPropertyID.OB_PROP_IR_EXPOSURE_INT)
+        self.assertIsNotNone(new_ir_exposure)
+        self.assertEqual(new_ir_exposure, ir_exposure)
+        self.device.set_int_property(OBPropertyID.OB_PROP_IR_EXPOSURE_INT, curr_ir_exposure)
+        self.turn_on_ir_auto_exposure()
+
+    def test_get_and_set_color_auto_white_balance(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color auto white balance!")
+            return
+        self.turn_on_color_auto_exposure()
+        curr_color_auto_white_balance = self.device.get_bool_property(
+            OBPropertyID.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL)
+        self.assertIsNotNone(curr_color_auto_white_balance)
+        print("Current color auto white balance: ", curr_color_auto_white_balance)
+        color_auto_white_balance = not curr_color_auto_white_balance
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL,
+                                      color_auto_white_balance)
+        new_color_auto_white_balance = self.device.get_bool_property(
+            OBPropertyID.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL)
+        self.assertIsNotNone(new_color_auto_white_balance)
+        self.assertEqual(new_color_auto_white_balance, color_auto_white_balance)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_WHITE_BALANCE_BOOL,
+                                      curr_color_auto_white_balance)
+        self.turn_off_color_auto_exposure()
+
+    def test_get_and_set_ldp(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_LDP_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support LDP!")
+            return
+        curr_ldp = self.device.get_bool_property(OBPropertyID.OB_PROP_LDP_BOOL)
+        self.assertIsNotNone(curr_ldp)
+        print("Current LDP: ", curr_ldp)
+        ldp = not curr_ldp
+        self.device.set_bool_property(OBPropertyID.OB_PROP_LDP_BOOL, ldp)
+        new_ldp = self.device.get_bool_property(OBPropertyID.OB_PROP_LDP_BOOL)
+        self.assertIsNotNone(new_ldp)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_LDP_BOOL, curr_ldp)
+
+    def test_get_and_set_laser(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_LASER_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support laser!")
+            return
+        curr_laser = self.device.get_bool_property(OBPropertyID.OB_PROP_LASER_BOOL)
+        self.assertIsNotNone(curr_laser)
+        print("Current laser: ", curr_laser)
+        laser = not curr_laser
+        self.device.set_bool_property(OBPropertyID.OB_PROP_LASER_BOOL, laser)
+        new_laser = self.device.get_bool_property(OBPropertyID.OB_PROP_LASER_BOOL)
+        self.assertIsNotNone(new_laser)
+        self.assertEqual(new_laser, laser)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_LASER_BOOL, curr_laser)
+
+    def test_get_and_set_flood(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_FLOOD_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support flood!")
+            return
+        curr_flood = self.device.get_bool_property(OBPropertyID.OB_PROP_FLOOD_BOOL)
+        self.assertIsNotNone(curr_flood)
+        print("Current flood: ", curr_flood)
+        flood = not curr_flood
+        self.device.set_bool_property(OBPropertyID.OB_PROP_FLOOD_BOOL, flood)
+        new_flood = self.device.get_bool_property(OBPropertyID.OB_PROP_FLOOD_BOOL)
+        self.assertIsNotNone(new_flood)
+        self.assertEqual(new_flood, flood)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_FLOOD_BOOL, curr_flood)
+
+    def test_get_and_set_soft_filter(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_SOFT_FILTER_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support soft filter!")
+            return
+        curr_soft_filter = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_SOFT_FILTER_BOOL)
+        self.assertIsNotNone(curr_soft_filter)
+        print("Current soft filter: ", curr_soft_filter)
+        soft_filter = not curr_soft_filter
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_SOFT_FILTER_BOOL, soft_filter)
+        new_soft_filter = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_SOFT_FILTER_BOOL)
+        self.assertIsNotNone(new_soft_filter)
+        self.assertEqual(new_soft_filter, soft_filter)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_SOFT_FILTER_BOOL, curr_soft_filter)
+
+    def test_get_and_set_color_mirror(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_MIRROR_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color mirror!")
+            return
+        curr_color_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_MIRROR_BOOL)
+        self.assertIsNotNone(curr_color_mirror)
+        print("Current color mirror: ", curr_color_mirror)
+        color_mirror = not curr_color_mirror
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_MIRROR_BOOL, color_mirror)
+        new_color_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_MIRROR_BOOL)
+        self.assertIsNotNone(new_color_mirror)
+        self.assertEqual(new_color_mirror, color_mirror)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_MIRROR_BOOL, curr_color_mirror)
+
+    def test_get_and_set_depth_mirror(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_MIRROR_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth mirror!")
+            return
+        curr_depth_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_MIRROR_BOOL)
+        self.assertIsNotNone(curr_depth_mirror)
+        print("Current depth mirror: ", curr_depth_mirror)
+        depth_mirror = not curr_depth_mirror
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_MIRROR_BOOL, depth_mirror)
+        new_depth_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_MIRROR_BOOL)
+        self.assertIsNotNone(new_depth_mirror)
+        self.assertEqual(new_depth_mirror, depth_mirror)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_MIRROR_BOOL, curr_depth_mirror)
+
+    def test_get_and_set_ir_mirror(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_MIRROR_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir mirror!")
+            return
+        curr_ir_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_MIRROR_BOOL)
+        self.assertIsNotNone(curr_ir_mirror)
+        print("Current ir mirror: ", curr_ir_mirror)
+        ir_mirror = not curr_ir_mirror
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_MIRROR_BOOL, ir_mirror)
+        new_ir_mirror = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_MIRROR_BOOL)
+        self.assertIsNotNone(new_ir_mirror)
+        self.assertEqual(new_ir_mirror, ir_mirror)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_MIRROR_BOOL, curr_ir_mirror)
+
+    def test_get_and_set_color_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color auto exposure!")
+            return
+        curr_color_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(curr_color_auto_exposure)
+        print("Current color auto exposure: ", curr_color_auto_exposure)
+        color_auto_exposure = not curr_color_auto_exposure
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, color_auto_exposure)
+        new_color_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(new_color_auto_exposure)
+        self.assertEqual(new_color_auto_exposure, color_auto_exposure)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_AUTO_EXPOSURE_BOOL, curr_color_auto_exposure)
+
+    def test_get_and_set_depth_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth auto exposure!")
+            return
+        curr_depth_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(curr_depth_auto_exposure)
+        print("Current depth auto exposure: ", curr_depth_auto_exposure)
+        depth_auto_exposure = not curr_depth_auto_exposure
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, depth_auto_exposure)
+        new_depth_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(new_depth_auto_exposure)
+        self.assertEqual(new_depth_auto_exposure, depth_auto_exposure)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_AUTO_EXPOSURE_BOOL, curr_depth_auto_exposure)
+
+    def test_get_and_set_ir_auto_exposure(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir auto exposure!")
+            return
+        curr_ir_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(curr_ir_auto_exposure)
+        print("Current ir auto exposure: ", curr_ir_auto_exposure)
+        ir_auto_exposure = not curr_ir_auto_exposure
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL, ir_auto_exposure)
+        new_ir_auto_exposure = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL)
+        self.assertIsNotNone(new_ir_auto_exposure)
+        self.assertEqual(new_ir_auto_exposure, ir_auto_exposure)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_AUTO_EXPOSURE_BOOL, curr_ir_auto_exposure)
+
+    def test_get_and_set_color_flip(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_FLIP_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color flip!")
+            return
+        curr_color_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_FLIP_BOOL)
+        self.assertIsNotNone(curr_color_flip)
+        print("Current color flip: ", curr_color_flip)
+        color_flip = not curr_color_flip
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_FLIP_BOOL, color_flip)
+        new_color_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_COLOR_FLIP_BOOL)
+        self.assertIsNotNone(new_color_flip)
+        self.assertEqual(new_color_flip, color_flip)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_COLOR_FLIP_BOOL, curr_color_flip)
+
+    def test_get_and_set_depth_flip(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_DEPTH_FLIP_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth flip!")
+            return
+        curr_depth_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_FLIP_BOOL)
+        self.assertIsNotNone(curr_depth_flip)
+        print("Current depth flip: ", curr_depth_flip)
+        depth_flip = not curr_depth_flip
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_FLIP_BOOL, depth_flip)
+        new_depth_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_DEPTH_FLIP_BOOL)
+        self.assertIsNotNone(new_depth_flip)
+        self.assertEqual(new_depth_flip, depth_flip)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_DEPTH_FLIP_BOOL, curr_depth_flip)
+
+    def test_get_and_set_ir_flip(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_IR_FLIP_BOOL,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support ir flip!")
+            return
+        curr_ir_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_FLIP_BOOL)
+        self.assertIsNotNone(curr_ir_flip)
+        print("Current ir flip: ", curr_ir_flip)
+        ir_flip = not curr_ir_flip
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_FLIP_BOOL, ir_flip)
+        new_ir_flip = self.device.get_bool_property(OBPropertyID.OB_PROP_IR_FLIP_BOOL)
+        self.assertIsNotNone(new_ir_flip)
+        self.assertEqual(new_ir_flip, ir_flip)
+        self.device.set_bool_property(OBPropertyID.OB_PROP_IR_FLIP_BOOL, curr_ir_flip)
+
+    def test_get_and_set_color_sharpness(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_SHARPNESS_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color sharpness!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_sharpness = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_SHARPNESS_INT)
+        self.assertIsNotNone(curr_color_sharpness)
+        print("Current color sharpness: ", curr_color_sharpness)
+        color_sharpness = curr_color_sharpness + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_SHARPNESS_INT, color_sharpness)
+        new_color_sharpness = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_SHARPNESS_INT)
+        self.assertIsNotNone(new_color_sharpness)
+        self.assertEqual(new_color_sharpness, color_sharpness)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_SHARPNESS_INT, curr_color_sharpness)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_color_hue(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_HUE_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color hue!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_hue = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_HUE_INT)
+        self.assertIsNotNone(curr_color_hue)
+        print("Current color hue: ", curr_color_hue)
+        color_hue = curr_color_hue + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_HUE_INT, color_hue)
+        new_color_hue = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_HUE_INT)
+        self.assertIsNotNone(new_color_hue)
+        self.assertEqual(new_color_hue, color_hue)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_HUE_INT, curr_color_hue)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_color_contrast(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_CONTRAST_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color contrast!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_contrast = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_CONTRAST_INT)
+        self.assertIsNotNone(curr_color_contrast)
+        print("Current color contrast: ", curr_color_contrast)
+        color_contrast = curr_color_contrast + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_CONTRAST_INT, color_contrast)
+        new_color_contrast = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_CONTRAST_INT)
+        self.assertIsNotNone(new_color_contrast)
+        self.assertEqual(new_color_contrast, color_contrast)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_CONTRAST_INT, curr_color_contrast)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_color_brightness(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_COLOR_BRIGHTNESS_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support color brightness!")
+            return
+        self.turn_off_color_auto_exposure()
+        curr_color_brightness = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_BRIGHTNESS_INT)
+        self.assertIsNotNone(curr_color_brightness)
+        print("Current color brightness: ", curr_color_brightness)
+        color_brightness = curr_color_brightness + 1
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_BRIGHTNESS_INT, color_brightness)
+        new_color_brightness = self.device.get_int_property(OBPropertyID.OB_PROP_COLOR_BRIGHTNESS_INT)
+        self.assertIsNotNone(new_color_brightness)
+        self.assertEqual(new_color_brightness, color_brightness)
+        self.device.set_int_property(OBPropertyID.OB_PROP_COLOR_BRIGHTNESS_INT, curr_color_brightness)
+        self.turn_on_color_auto_exposure()
+
+    def test_get_and_set_depth_work_mode(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_STRUCT_CURRENT_DEPTH_ALG_MODE,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support depth work mode!")
+            return
+        curr_depth_work_mode = self.device.get_depth_work_mode()
+        self.assertIsNotNone(curr_depth_work_mode)
+        print("Current depth work mode: ", curr_depth_work_mode)
+        depth_work_mode_list = self.device.get_depth_work_mode_list()
+        self.assertIsNotNone(depth_work_mode_list)
+        select_depth_work_mode = None
+        for i in range(depth_work_mode_list.get_count()):
+            depth_work_mode = depth_work_mode_list.get_depth_work_mode_by_index(i)
+            print("depth_work_mode: ", depth_work_mode)
+            if depth_work_mode != curr_depth_work_mode:
+                select_depth_work_mode = depth_work_mode
+
+        if select_depth_work_mode is None:
+            print("Not found depth work mode!")
+            return
+        self.device.set_depth_work_mode(select_depth_work_mode)
+        new_depth_work_mode = self.device.get_depth_work_mode()
+        self.assertIsNotNone(new_depth_work_mode)
+        self.assertEqual(new_depth_work_mode, select_depth_work_mode)
+        self.device.set_depth_work_mode(curr_depth_work_mode)
+
+    def test_get_and_set_fan_work_mode(self):
+        if not self.device.is_property_supported(OBPropertyID.OB_PROP_FAN_WORK_MODE_INT,
+                                                 OBPermissionType.PERMISSION_READ_WRITE):
+            print("Current device not support fan work mode!")
+            return
+        curr_fan_work_mode = self.device.get_int_property(OBPropertyID.OB_PROP_FAN_WORK_MODE_INT)
+        self.assertIsNotNone(curr_fan_work_mode)
+        print("Current fan work mode: ", curr_fan_work_mode)
+        fan_work_mode = not curr_fan_work_mode
+        self.device.set_int_property(OBPropertyID.OB_PROP_FAN_WORK_MODE_INT, fan_work_mode)
+        new_fan_work_mode = self.device.get_int_property(OBPropertyID.OB_PROP_FAN_WORK_MODE_INT)
+        self.assertIsNotNone(new_fan_work_mode)
+        self.assertEqual(new_fan_work_mode, fan_work_mode)
+        self.device.set_int_property(OBPropertyID.OB_PROP_FAN_WORK_MODE_INT, curr_fan_work_mode)
+
+
+if __name__ == '__main__':
+    print("Start test SensorControl interface, Please make sure you have connected a device to your computer.")
+    unittest.main()

pyorbbec-1.0.1.18/MANIFEST.in

@@ -1,3 +0,0 @@
-include README.md LICENSE NOTICE HISTORY.md requirements-dev.txt
-recursive-include src/pyorbbecsdk/extensions *
-recursive-include src/pyorbbecsdk/examples *

pyorbbec-1.0.1.18/NOTICE

@@ -1,2 +0,0 @@
-pyorbbecsdk
-Copyright 2019 Orbbec

pyorbbec-1.0.1.18/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: pyorbbec
-Version: 1.0.1.18
-Summary: Python interface to the Orbbec SDK.
-Home-page: https://orbbec.com.cn/
-Author: orbbec
-Author-email: lijie@orbbec.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: NOTICE
-Requires-Dist: pybind11==2.11.0
-Requires-Dist: pybind11-global==2.11.0
-Requires-Dist: opencv-python
-Requires-Dist: wheel
-Requires-Dist: numpy<2.0
-Requires-Dist: av
-Requires-Dist: pygame
-Requires-Dist: pynput

pyorbbec-1.0.1.18/pyproject.toml

@@ -1,4 +0,0 @@
-[tool.isort]
-profile = "black"
-src_paths = ["src/pyorbbecsdk"]
-honor_noqa = true

pyorbbec-1.0.1.18/setup.py

@@ -1,91 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2024 Orbbec 3D Technology, Inc
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#      http:# www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-# ******************************************************************************
-
-import os
-import sys
-import platform
-import shutil
-
-from setuptools import setup, find_packages
-
-requires = [
-    'pybind11==2.11.0',
-    'pybind11-global==2.11.0',
-    'opencv-python',
-    'wheel',
-    'numpy<2.0',  # see https://github.com/orbbec/pyorbbecsdk/issues/47
-    'av',         # for h264 decoding
-    'pygame',     # for visualization
-    'pynput',     # for keyboard input
-]
-
-# platform tag
-def get_platform_tag():
-    if sys.platform.startswith('win'):
-        return 'win_amd64'
-    elif sys.platform.startswith('linux'):
-        if sys.maxsize > 2**32 and 'aarch64' in sys.version.lower():
-            return 'linux_aarch64'
-        else:
-            return 'manylinux_2_17_x86_64'
-    else:
-        raise ValueError(f"Unsupported platform: {sys.platform}")
-
-# Platform
-current_platform = platform.system().lower()
-
-# Set package data according to platform
-package_data = {
-    'pyorbbecsdk': [],
-}
-
-# Windows
-if current_platform == 'windows':
-    package_data['pyorbbecsdk'].extend(['win_x64/*.pyd', 'win_x64/*.dll', 'win_x64/*.lib', 'win_x64/*.xml'])
-
-# Linux
-elif current_platform == 'linux':
-    package_data['pyorbbecsdk'].extend(['linux_x64/*.so', 'linux_x64/*.so*', 'linux_x64/*.xml'])
-
-setup(
-    name="pyorbbec",
-    version="1.0.1.18",
-    description="Python interface to the Orbbec SDK.",
-    long_description_content_type="text/markdown",
-    author="orbbec",
-    author_email="lijie@orbbec.com",
-    url="https://orbbec.com.cn/",
-    packages=find_packages(where="src", include=["pyorbbecsdk", "pyorbbecsdk.*"]),
-    package_dir={"": "src"},
-    options={
-        'bdist_wheel': {
-            'python_tag': 'py38',
-            'plat_name': get_platform_tag(),
-            'universal': False,
-        }
-    },
-    python_requires=">=3.8",
-    install_requires=requires,
-    license="Apache-2.0",
-    zip_safe=False,
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: Apache Software License",
-    ],
-    
-    package_data=package_data,
-    include_package_data=True,
-)

pyorbbec-1.0.1.18/src/pyorbbec.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: pyorbbec
-Version: 1.0.1.18
-Summary: Python interface to the Orbbec SDK.
-Home-page: https://orbbec.com.cn/
-Author: orbbec
-Author-email: lijie@orbbec.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: NOTICE
-Requires-Dist: pybind11==2.11.0
-Requires-Dist: pybind11-global==2.11.0
-Requires-Dist: opencv-python
-Requires-Dist: wheel
-Requires-Dist: numpy<2.0
-Requires-Dist: av
-Requires-Dist: pygame
-Requires-Dist: pynput

pyorbbec-1.0.1.18/src/pyorbbec.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-LICENSE
-MANIFEST.in
-NOTICE
-README.md
-pyproject.toml
-setup.py
-src/pyorbbec.egg-info/PKG-INFO
-src/pyorbbec.egg-info/SOURCES.txt
-src/pyorbbec.egg-info/dependency_links.txt
-src/pyorbbec.egg-info/not-zip-safe
-src/pyorbbec.egg-info/requires.txt
-src/pyorbbec.egg-info/top_level.txt

pyorbbec-1.0.1.18/src/pyorbbec.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

pyorbbec-1.0.1.18/src/pyorbbec.egg-info/requires.txt

@@ -1,8 +0,0 @@
-pybind11==2.11.0
-pybind11-global==2.11.0
-opencv-python
-wheel
-numpy<2.0
-av
-pygame
-pynput