pyorbbec 1.0.1.33__cp311-cp311-win_amd64.whl

pyorbbecsdk/examples/infrared.py

@@ -0,0 +1,148 @@
+# ******************************************************************************
+#  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 cv2
+import numpy as np
+from pyorbbecsdk import *
+
+ESC_KEY = 27
+
+
+def process_ir_frame(ir_frame, is_dual_ir=False):
+    if ir_frame is None:
+        return None
+    ir_frame = ir_frame.as_video_frame()
+    ir_data = np.asanyarray(ir_frame.get_data())
+    width = ir_frame.get_width()
+    height = ir_frame.get_height()
+    ir_format = ir_frame.get_format()
+
+    if ir_format == OBFormat.Y8:
+        ir_data = np.resize(ir_data, (height, width, 1))
+        data_type = np.uint8
+        image_dtype = cv2.CV_8UC1
+        max_data = 255
+    elif ir_format == OBFormat.MJPG:
+        ir_data = cv2.imdecode(ir_data, cv2.IMREAD_UNCHANGED)
+        data_type = np.uint8
+        image_dtype = cv2.CV_8UC1
+        max_data = 255
+        if ir_data is None:
+            print("decode mjpeg failed")
+            return None
+        ir_data = np.resize(ir_data, (height, width, 1))
+    else:
+        ir_data = np.frombuffer(ir_data, dtype=np.uint16)
+        data_type = np.uint16
+        image_dtype = cv2.CV_16UC1
+        max_data = 65535
+        ir_data = np.resize(ir_data, (height, width, 1))
+
+    cv2.normalize(ir_data, ir_data, 0, max_data, cv2.NORM_MINMAX, dtype=image_dtype)
+    ir_data = ir_data.astype(data_type)
+    result = cv2.cvtColor(ir_data, cv2.COLOR_GRAY2RGB)
+    
+    if is_dual_ir:
+        # Scale image to 640x400
+        target_width = 640
+        target_height = 400
+
+        aspect_ratio = width / height
+        target_ratio = target_width / target_height
+        
+        # Determine how to scale based on aspect ratio
+        if aspect_ratio > target_ratio:
+            new_width = target_width
+            new_height = int(target_width / aspect_ratio)
+        else:
+            new_height = target_height
+            new_width = int(target_height * aspect_ratio)
+        
+        # Determine whether to enlarge or reduce, and choose the appropriate interpolation method
+        if width > new_width or height > new_height:
+            interpolation = cv2.INTER_AREA
+        else:
+            interpolation = cv2.INTER_CUBIC
+            
+        # Scale
+        scaled = cv2.resize(result, (new_width, new_height), interpolation=interpolation)
+        
+        # Create a black background, place the scaled image on a black background
+        result = np.zeros((target_height, target_width, 3), dtype=np.uint8)
+        x_offset = (target_width - new_width) // 2
+        y_offset = (target_height - new_height) // 2
+        result[y_offset:y_offset+new_height, x_offset:x_offset+new_width] = scaled
+        
+    return result
+
+
+def main():
+    config = Config()
+    pipeline = Pipeline()
+    device = pipeline.get_device()
+    sensor_list = device.get_sensor_list()
+
+    has_dual_ir = False
+    for sensor in range(len(sensor_list)):
+        if (sensor_list[sensor].get_type() == OBSensorType.LEFT_IR_SENSOR or
+                sensor_list[sensor].get_type() == OBSensorType.RIGHT_IR_SENSOR):
+            has_dual_ir = True
+            break
+
+    if has_dual_ir:
+        config.enable_video_stream(OBSensorType.LEFT_IR_SENSOR)
+        config.enable_video_stream(OBSensorType.RIGHT_IR_SENSOR)
+    else:
+        config.enable_video_stream(OBSensorType.IR_SENSOR)
+
+    pipeline.start(config)
+
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if frames is None:
+                continue
+
+            if has_dual_ir:
+                left_ir_frame = frames.get_frame(OBFrameType.LEFT_IR_FRAME)
+                right_ir_frame = frames.get_frame(OBFrameType.RIGHT_IR_FRAME)
+
+                left_image = process_ir_frame(left_ir_frame, True)
+                right_image = process_ir_frame(right_ir_frame, True)
+
+                if left_image is None or right_image is None:
+                    continue
+
+                combined_ir = np.hstack((left_image, right_image))
+                cv2.imshow("Dual IR", combined_ir)
+            else:
+                ir_frame = frames.get_frame(OBFrameType.IR_FRAME)
+                ir_image = process_ir_frame(ir_frame)
+                if ir_image is not None:
+                    cv2.imshow("IR", ir_image)
+
+            key = cv2.waitKey(1)
+            if key == ord('q') or key == ESC_KEY:
+                break
+
+        except KeyboardInterrupt:
+            break
+
+    pipeline.stop()
+
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/logger.py

@@ -0,0 +1,55 @@
+# ******************************************************************************
+#  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
+from pyorbbecsdk import *
+import time
+
+def main():
+    # Set console logger (INFO level)
+    # if you DO NOT want to see the log message in console, you can set the log level to OBLogLevel.NONE
+    Context.set_logger_to_console(OBLogLevel.INFO)
+
+    # Set file logger (DEBUG level)
+    log_path = "Log/Custom/"
+    os.makedirs(log_path, exist_ok=True)  # Ensure log directory exists
+    Context.set_logger_to_file(OBLogLevel.INFO, log_path)
+
+
+    # Configure streams
+    config = Config()
+    pipeline = Pipeline()
+    # Get and enable depth stream configuration
+    depth_profiles = pipeline.get_stream_profile_list(OBSensorType.DEPTH_SENSOR)
+    depth_profile = depth_profiles.get_default_video_stream_profile()
+    config.enable_stream(depth_profile)
+
+    # Get and enable color stream configuration
+    color_profiles = pipeline.get_stream_profile_list(OBSensorType.COLOR_SENSOR)
+    color_profile = color_profiles.get_default_video_stream_profile()
+    config.enable_stream(color_profile)
+
+    # Start pipeline
+    pipeline.start(config)
+    time.sleep(1)
+    # Stop pipeline
+    pipeline.stop()
+
+    print("\nPress any key to exit.")
+    input()  # Wait for user input to exit
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/metadata.py

@@ -0,0 +1,64 @@
+# ******************************************************************************
+#  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.
+# ******************************************************************************
+
+from pyorbbecsdk import *
+
+ESC_KEY = 27
+
+def main():
+    # Initialize Pipeline
+    pipeline = Pipeline()
+    # Start Pipeline
+    pipeline.start()
+    print("Pipeline started. Press Ctrl+C to exit.")
+
+    frame_counter = 0  # Add frame counter
+    
+    while True:
+        try:
+            # Get frameSet from Pipeline
+            frame_set = pipeline.wait_for_frames(1000)
+            if frame_set is None:
+                continue
+
+            frame_counter += 1  # Increment counter
+            
+            # Only print metadata every 30 frames
+            if frame_counter % 30 == 0:
+                for i in range(len(frame_set)):
+                    frame = frame_set[i]
+
+                    # Print frame metadata
+                    print(f"Frame type: {frame.get_type()}")
+                    metadata_types = [getattr(OBFrameMetadataType, attr) for attr in dir(OBFrameMetadataType) 
+                                    if not attr.startswith('__') and isinstance(getattr(OBFrameMetadataType, attr), OBFrameMetadataType)]
+                    
+                    for metadata_type in metadata_types:
+                        if frame.has_metadata(metadata_type):
+                            metadata_value = frame.get_metadata_value(metadata_type)
+                            print(f"  Metadata type: {metadata_type.name}, value: {metadata_value}")
+
+        except KeyboardInterrupt:
+            break
+        except Exception as e:
+            print("An error occurred:", e)
+            break
+
+    pipeline.stop()
+    print("Pipeline stopped.")
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/multi_device.py

@@ -0,0 +1,169 @@
+# ******************************************************************************
+#  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.
+# ******************************************************************************
+
+from queue import Queue
+from typing import List
+
+import cv2
+import numpy as np
+
+from pyorbbecsdk import *
+from utils import frame_to_bgr_image
+
+MAX_DEVICES = 2
+curr_device_cnt = 0
+
+MAX_QUEUE_SIZE = 5
+ESC_KEY = 27
+
+color_frames_queue: List[Queue] = [Queue() for _ in range(MAX_DEVICES)]
+depth_frames_queue: List[Queue] = [Queue() for _ in range(MAX_DEVICES)]
+has_color_sensor: List[bool] = [False for _ in range(MAX_DEVICES)]
+stop_rendering = False
+
+
+def on_new_frame_callback(frames: FrameSet, index: int):
+    global color_frames_queue, depth_frames_queue
+    global MAX_QUEUE_SIZE
+    assert index < MAX_DEVICES
+    color_frame = frames.get_color_frame()
+    depth_frame = frames.get_depth_frame()
+    if color_frame is not None:
+        if color_frames_queue[index].qsize() >= MAX_QUEUE_SIZE:
+            color_frames_queue[index].get()
+        color_frames_queue[index].put(color_frame)
+    if depth_frame is not None:
+        if depth_frames_queue[index].qsize() >= MAX_QUEUE_SIZE:
+            depth_frames_queue[index].get()
+        depth_frames_queue[index].put(depth_frame)
+
+
+def rendering_frames():
+    global color_frames_queue, depth_frames_queue
+    global curr_device_cnt
+    global stop_rendering
+    while not stop_rendering:
+        for i in range(curr_device_cnt):
+            color_frame = None
+            depth_frame = None
+            if not color_frames_queue[i].empty():
+                color_frame = color_frames_queue[i].get()
+            if not depth_frames_queue[i].empty():
+                depth_frame = depth_frames_queue[i].get()
+            if color_frame is None and depth_frame is None:
+                continue
+            color_image = None
+            depth_image = None
+            color_width, color_height = 0, 0
+            if color_frame is not None:
+                color_width, color_height = color_frame.get_width(), color_frame.get_height()
+                color_image = frame_to_bgr_image(color_frame)
+            if depth_frame is not None:
+                width = depth_frame.get_width()
+                height = depth_frame.get_height()
+                scale = depth_frame.get_depth_scale()
+                depth_format = depth_frame.get_format()
+                if depth_format != OBFormat.Y16:
+                    print("depth format is not Y16")
+                    continue
+
+                try:
+                    depth_data = np.frombuffer(depth_frame.get_data(), dtype=np.uint16)
+                    depth_data = depth_data.reshape((height, width))
+                except ValueError:
+                    print("Failed to reshape depth data")
+                    continue
+
+                depth_data = depth_data.astype(np.float32) * scale
+
+                depth_image = cv2.normalize(depth_data, None, 0, 255, cv2.NORM_MINMAX,
+                                            dtype=cv2.CV_8U)
+                depth_image = cv2.applyColorMap(depth_image, cv2.COLORMAP_JET)
+
+            if color_image is not None and depth_image is not None:
+                window_size = (color_width // 2, color_height // 2)
+                color_image = cv2.resize(color_image, window_size)
+                depth_image = cv2.resize(depth_image, window_size)
+                image = np.hstack((color_image, depth_image))
+            elif depth_image is not None and not has_color_sensor[i]:
+                image = depth_image
+            else:
+                continue
+            cv2.imshow("Device {}".format(i), image)
+            key = cv2.waitKey(1)
+            if key == ord('q') or key == ESC_KEY:
+                stop_rendering = True
+                break
+    cv2.destroyAllWindows()
+
+
+def start_streams(pipelines: List[Pipeline], configs: List[Config]):
+    index = 0
+    for pipeline, config in zip(pipelines, configs):
+        print("Starting device {}".format(index))
+        pipeline.start(config, lambda frame_set, curr_index=index: on_new_frame_callback(frame_set,
+                                                                                         curr_index))
+        index += 1
+
+
+def stop_streams(pipelines: List[Pipeline]):
+    for pipeline in pipelines:
+        pipeline.stop()
+
+
+def main():
+    ctx = Context()
+    device_list = ctx.query_devices()
+    global curr_device_cnt
+    curr_device_cnt = device_list.get_count()
+    if curr_device_cnt == 0:
+        print("No device connected")
+        return
+    if curr_device_cnt > MAX_DEVICES:
+        print("Too many devices connected")
+        return
+    pipelines: List[Pipeline] = []
+    configs: List[Config] = []
+    global has_color_sensor
+    for i in range(device_list.get_count()):
+        device = device_list.get_device_by_index(i)
+        pipeline = Pipeline(device)
+        config = Config()
+        try:
+            profile_list = pipeline.get_stream_profile_list(OBSensorType.COLOR_SENSOR)
+            color_profile: VideoStreamProfile = profile_list.get_default_video_stream_profile()
+            config.enable_stream(color_profile)
+            has_color_sensor[i] = True
+        except OBError as e:
+            print(e)
+            has_color_sensor[i] = False
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.DEPTH_SENSOR)
+        depth_profile = profile_list.get_default_video_stream_profile()
+        config.enable_stream(depth_profile)
+        pipelines.append(pipeline)
+        configs.append(config)
+    global stop_rendering
+    start_streams(pipelines, configs)
+    try:
+        rendering_frames()
+    except KeyboardInterrupt:
+        stop_rendering = True
+    finally:
+        stop_streams(pipelines)
+        cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/multi_streams.py

@@ -0,0 +1,219 @@
+# ******************************************************************************
+#  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 cv2
+import numpy as np
+from pyorbbecsdk import *
+from utils import frame_to_bgr_image
+
+# cached frames for better visualization
+cached_frames = {
+    'color': None,
+    'depth': None,
+    'left_ir': None,
+    'right_ir': None,
+    'ir': None
+}
+
+def setup_camera():
+    """Setup camera and stream configuration"""
+    pipeline = Pipeline()
+    config = Config()
+    device = pipeline.get_device()
+
+    # Try to enable all possible sensors
+    video_sensors = [
+        OBSensorType.COLOR_SENSOR,
+        OBSensorType.DEPTH_SENSOR,
+        OBSensorType.IR_SENSOR,
+        OBSensorType.LEFT_IR_SENSOR,
+        OBSensorType.RIGHT_IR_SENSOR
+    ]
+    sensor_list = device.get_sensor_list()
+    for sensor in range(len(sensor_list)):
+        try:
+            sensor_type = sensor_list[sensor].get_type()
+            if sensor_type in video_sensors:
+                config.enable_stream(sensor_type)
+        except:
+            continue
+
+    pipeline.start(config)
+    return pipeline
+
+def setup_imu():
+    """Setup IMU configuration"""
+    pipeline = Pipeline()   
+    config = Config()
+    config.enable_accel_stream()
+    config.enable_gyro_stream()
+    pipeline.start(config)
+    return pipeline
+
+def process_color(frame):
+    """Process color image"""
+    frame = frame if frame else cached_frames['color']
+    cached_frames['color'] = frame
+    return frame_to_bgr_image(frame) if frame else None
+
+
+def process_depth(frame):
+    """Process depth image"""
+    frame = frame if frame else cached_frames['depth']
+    cached_frames['depth'] = frame
+    if not frame:
+        return None
+    try:
+        depth_data = np.frombuffer(frame.get_data(), dtype=np.uint16)
+        depth_data = depth_data.reshape(frame.get_height(), frame.get_width())
+        depth_image = cv2.normalize(depth_data, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+        return cv2.applyColorMap(depth_image, cv2.COLORMAP_JET)
+    except ValueError:
+        return None
+
+
+def process_ir(ir_frame):
+    """Process IR frame (left or right) to RGB image"""
+    if ir_frame is None:
+        return None
+    ir_frame = ir_frame.as_video_frame()
+    ir_data = np.asanyarray(ir_frame.get_data())
+    width = ir_frame.get_width()
+    height = ir_frame.get_height()
+    ir_format = ir_frame.get_format()
+
+    if ir_format == OBFormat.Y8:
+        ir_data = np.resize(ir_data, (height, width, 1))
+        data_type = np.uint8
+        image_dtype = cv2.CV_8UC1
+        max_data = 255
+    elif ir_format == OBFormat.MJPG:
+        ir_data = cv2.imdecode(ir_data, cv2.IMREAD_UNCHANGED)
+        data_type = np.uint8
+        image_dtype = cv2.CV_8UC1
+        max_data = 255
+        if ir_data is None:
+            print("decode mjpeg failed")
+            return None
+        ir_data = np.resize(ir_data, (height, width, 1))
+    else:
+        ir_data = np.frombuffer(ir_data, dtype=np.uint16)
+        data_type = np.uint16
+        image_dtype = cv2.CV_16UC1
+        max_data = 255
+        ir_data = np.resize(ir_data, (height, width, 1))
+
+    cv2.normalize(ir_data, ir_data, 0, max_data, cv2.NORM_MINMAX, dtype=image_dtype)
+    ir_data = ir_data.astype(data_type)
+    return cv2.cvtColor(ir_data, cv2.COLOR_GRAY2RGB)
+
+def get_imu_text(frame, name):
+    """Format IMU data"""
+    if not frame:
+        return []
+    return [
+        f"{name} x: {frame.get_x():.2f}",
+        f"{name} y: {frame.get_y():.2f}",
+        f"{name} z: {frame.get_z():.2f}"
+    ]
+
+
+def create_display(frames, width=1280, height=720):
+    """Create display window"""
+    display = np.zeros((height, width, 3), dtype=np.uint8)
+    h, w = height // 2, width // 2
+
+    # Process video frames
+    if 'color' in frames and frames['color'] is not None:
+        display[0:h, 0:w] = cv2.resize(frames['color'], (w, h))
+
+    if 'depth' in frames and frames['depth'] is not None:
+        display[0:h, w:] = cv2.resize(frames['depth'], (w, h))
+
+    if 'ir' in frames and frames['ir'] is not None:
+        display[h:, 0:w] = cv2.resize(frames['ir'], (w, h))
+
+    # Display IMU data
+    if 'imu' in frames:
+        y_offset = h + 20
+        for data_type in ['accel', 'gyro']:
+            text_lines = get_imu_text(frames['imu'].get(data_type), data_type.title())
+            for i, line in enumerate(text_lines):
+                cv2.putText(display, line, (w + 10, y_offset + i * 20),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+            y_offset += 80
+
+    return display
+
+
+def main():
+    # Window settings
+    WINDOW_NAME = "MultiStream Viewer"
+    DISPLAY_WIDTH = 1280
+    DISPLAY_HEIGHT = 720
+
+    # Initialize camera
+    pipeline = setup_camera()
+    imu_pipeline = setup_imu()
+    cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
+    cv2.resizeWindow(WINDOW_NAME, DISPLAY_WIDTH, DISPLAY_HEIGHT)
+    while True:
+        # Get all frames
+        frames = pipeline.wait_for_frames(100)
+        if not frames:
+            continue
+        # Process different frame types
+        processed_frames = {'color': process_color(frames.get_color_frame()),
+                            'depth': process_depth(frames.get_depth_frame())}
+
+        # Process IR image: try stereo IR first, fallback to mono if unavailable
+        try:
+            left = process_ir(frames.get_frame(OBFrameType.LEFT_IR_FRAME).as_video_frame())
+            right = process_ir(frames.get_frame(OBFrameType.RIGHT_IR_FRAME).as_video_frame())
+            if left is not None and right is not None:
+                processed_frames['ir'] = np.hstack((left, right))
+        except:
+            ir_frame = frames.get_ir_frame()
+            if ir_frame:
+                processed_frames['ir'] = process_ir(ir_frame.as_video_frame())
+
+        # Process IMU data
+        imu_frames = imu_pipeline.wait_for_frames(100)
+        if not imu_frames:
+            continue
+        accel = imu_frames.get_frame(OBFrameType.ACCEL_FRAME)
+        gyro = imu_frames.get_frame(OBFrameType.GYRO_FRAME)
+        if accel and gyro:
+            processed_frames['imu'] = {
+                'accel': accel.as_accel_frame(),
+                'gyro': gyro.as_gyro_frame()
+            }
+
+        # create display
+        display = create_display(processed_frames, DISPLAY_WIDTH, DISPLAY_HEIGHT)
+        cv2.imshow(WINDOW_NAME, display)
+
+        # check exit key
+        key = cv2.waitKey(1) & 0xFF
+        if key in [ord('q'), 27]:  # q or ESC
+            break
+
+    pipeline.stop()
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()