pyorbbec 1.0.1.25__cp310-cp310-win_amd64.whl

pyorbbec/examples/preset.py

@@ -0,0 +1,67 @@
+# ******************************************************************************
+#  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 pyorbbecsdk as ob
+
+def main():
+    # Create a pipeline with default device
+    pipe = ob.Pipeline()
+
+    # Get the device from the pipeline
+    device = pipe.get_device()
+
+    try:
+        while True:
+            # Get preset list from device
+            preset_list = device.get_available_preset_list()
+            if len(preset_list) == 0:
+                print("The current device does not support preset mode")
+                break
+
+            print("\nAvailable Presets:")
+            for index in range(len(preset_list)):
+                print(f" - {index}. {preset_list[index]}")
+
+            # Print current preset name
+            print(f"\nCurrent PresetName: {device.get_current_preset_name()}")
+
+            # Select preset to load
+            try:
+                input_option = int(input("\nEnter index of preset to load (or -1 to exit): "))
+                if input_option == -1:
+                    break
+                if input_option < 0 or input_option >= len(preset_list):
+                    raise ValueError("Invalid index")
+            except ValueError:
+                print("Invalid input. Please enter a valid index.")
+                continue
+
+            preset_name = preset_list[input_option]
+
+            # Load preset
+            device.load_preset(preset_name)
+
+            # Print current preset name
+            print(f"\nPreset loaded. Current PresetName: {device.get_current_preset_name()}")
+
+    except ob.OBError as e:
+        print(f"Error: {str(e)}")
+    finally:
+        # Stop Pipeline
+        pipe.stop()
+
+if __name__ == "__main__":
+    main()

pyorbbec/examples/quick_start.py

@@ -0,0 +1,90 @@
+# ******************************************************************************
+#  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
+import time
+
+from pyorbbecsdk import *
+from utils import frame_to_bgr_image
+
+ESC_KEY = 27
+MIN_DEPTH = 20  # 20mm
+MAX_DEPTH = 10000  # 10000mm
+
+def main():
+    pipeline = Pipeline()
+
+    pipeline.start()
+    print("Pipeline started successfully. Press 'q' or ESC to exit.")
+
+    # Set window size
+    window_width = 1280
+    window_height = 720
+    cv2.namedWindow("QuickStart Viewer", cv2.WINDOW_NORMAL)
+    cv2.resizeWindow("QuickStart Viewer", window_width, window_height)
+
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if frames is None:
+                continue
+
+            # Get color frame
+            color_frame = frames.get_color_frame()
+            if color_frame is None:
+                continue
+            color_image = frame_to_bgr_image(color_frame)
+
+            # Get depth frame
+            depth_frame = frames.get_depth_frame()
+            if depth_frame is None:
+                continue
+            if depth_frame.get_format() != OBFormat.Y16:
+                print("Depth format is not Y16")
+                continue
+
+            # Process depth data
+            width = depth_frame.get_width()
+            height = depth_frame.get_height()
+            scale = depth_frame.get_depth_scale()
+            
+            depth_data = np.frombuffer(depth_frame.get_data(), dtype=np.uint16).reshape((height, width))
+            depth_data = depth_data.astype(np.float32) * scale
+            depth_data = np.where((depth_data > MIN_DEPTH) & (depth_data < MAX_DEPTH), depth_data, 0).astype(np.uint16)
+
+            # Create depth visualization
+            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)
+
+            # Resize and combine images
+            color_image_resized = cv2.resize(color_image, (window_width // 2, window_height))
+            depth_image_resized = cv2.resize(depth_image, (window_width // 2, window_height))
+            combined_image = np.hstack((color_image_resized, depth_image_resized))
+            
+            cv2.imshow("QuickStart Viewer", combined_image)
+
+            if cv2.waitKey(1) in [ord('q'), ESC_KEY]:
+                break
+        except KeyboardInterrupt:
+            break
+
+    cv2.destroyAllWindows()
+    pipeline.stop()
+    print("Pipeline stopped and all windows closed.")
+
+if __name__ == "__main__":
+    main()

pyorbbec/examples/recorder.py

@@ -0,0 +1,238 @@
+# ******************************************************************************
+#  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
+
+is_paused = False
+# 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 Record Viewer"
+    file_path = input("Enter output filename (.bag) and press Enter to start recording: ")
+
+    DISPLAY_WIDTH = 1280
+    DISPLAY_HEIGHT = 720
+
+    # Initialize camera
+    pipeline = setup_camera()
+    device = pipeline.get_device()
+    #synchronize the timer of the device with the host
+    device.timer_sync_with_host();
+    # initialize recording
+    recorder = RecordDevice(device, file_path)
+    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 == ord('s'):
+            global is_paused
+            if not is_paused:
+                recorder.pause()
+                is_paused = True
+                print("[PAUSED] Recording paused")
+            else:
+                recorder.resume()
+                is_paused = False
+                print("[RESUMED] Recording resumed")
+        if key in (ord('q'), 27):
+            break
+
+    pipeline.stop()
+    recorder = None 
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()

pyorbbec/examples/requirements.txt

@@ -0,0 +1,9 @@
+pybind11==2.11.0
+pybind11-global==2.11.0
+opencv-python
+wheel
+numpy<2.0  # see https://github.com/orbbec/pyorbbecsdk/issues/47
+open3d # for visualization point cloud
+av # for h264 decoding
+pygame # for visualization
+pynput # for keyboard input

pyorbbec/examples/save_image_to_disk.py

@@ -0,0 +1,106 @@
+# ******************************************************************************
+#  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 cv2
+import numpy as np
+
+from pyorbbecsdk import *
+from utils import frame_to_bgr_image
+
+
+def save_depth_frame(frame: DepthFrame, index):
+    if frame is None:
+        return
+    width = frame.get_width()
+    height = frame.get_height()
+    timestamp = frame.get_timestamp()
+    scale = frame.get_depth_scale()
+    depth_format = frame.get_format()
+    if depth_format != OBFormat.Y16:
+        print("depth format is not Y16")
+        return
+    data = np.frombuffer(frame.get_data(), dtype=np.uint16)
+    data = data.reshape((height, width))
+    data = data.astype(np.float32) * scale
+    data = data.astype(np.uint16)
+    save_image_dir = os.path.join(os.getcwd(), "depth_images")
+    if not os.path.exists(save_image_dir):
+        os.mkdir(save_image_dir)
+    raw_filename = save_image_dir + "/depth_{}x{}_{}_{}.raw".format(width, height, index, timestamp)
+    data.tofile(raw_filename)
+
+
+def save_color_frame(frame: ColorFrame, index):
+    if frame is None:
+        return
+    width = frame.get_width()
+    height = frame.get_height()
+    timestamp = frame.get_timestamp()
+    save_image_dir = os.path.join(os.getcwd(), "color_images")
+    if not os.path.exists(save_image_dir):
+        os.mkdir(save_image_dir)
+    filename = save_image_dir + "/color_{}x{}_{}_{}.png".format(width, height, index, timestamp)
+    image = frame_to_bgr_image(frame)
+    if image is None:
+        print("failed to convert frame to image")
+        return
+    cv2.imwrite(filename, image)
+
+
+def main():
+    pipeline = Pipeline()
+    config = Config()
+    saved_color_cnt: int = 0
+    saved_depth_cnt: int = 0
+    has_color_sensor = False
+    try:
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.COLOR_SENSOR)
+        if profile_list is not None:
+            color_profile: VideoStreamProfile = profile_list.get_default_video_stream_profile()
+            config.enable_stream(color_profile)
+            has_color_sensor = True
+    except OBError as e:
+        print(e)
+    depth_profile_list = pipeline.get_stream_profile_list(OBSensorType.DEPTH_SENSOR)
+    if depth_profile_list is not None:
+        depth_profile = depth_profile_list.get_default_video_stream_profile()
+        config.enable_stream(depth_profile)
+    pipeline.start(config)
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if frames is None:
+                continue
+            if has_color_sensor:
+                if saved_color_cnt >= 5 and saved_depth_cnt >= 5:
+                    break
+            elif saved_depth_cnt >= 5:
+                break
+            color_frame = frames.get_color_frame()
+            if color_frame is not None and saved_color_cnt < 5:
+                save_color_frame(color_frame, saved_color_cnt)
+                saved_color_cnt += 1
+            depth_frame = frames.get_depth_frame()
+            if depth_frame is not None and saved_depth_cnt < 5:
+                save_depth_frame(depth_frame, saved_depth_cnt)
+                saved_depth_cnt += 1
+        except KeyboardInterrupt:
+            break
+
+
+if __name__ == "__main__":
+    main()

pyorbbec/examples/sync_align.py

@@ -0,0 +1,109 @@
+# ******************************************************************************
+#  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 argparse
+import sys
+
+import cv2
+import numpy as np
+
+from pyorbbecsdk import *
+from utils import frame_to_bgr_image
+
+ESC_KEY = 27
+
+MIN_DEPTH = 20  # 20mm
+MAX_DEPTH = 10000  # 10000mm
+# Temporal filter for smoothing depth data over time
+
+def main(argv):
+    pipeline = Pipeline()
+    config = Config()
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-s", "--enable_sync", help="enable sync", type=bool, default=True)
+    args = parser.parse_args(argv)
+
+    enable_sync = args.enable_sync
+    try:
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.COLOR_SENSOR)
+        color_profile = profile_list.get_default_video_stream_profile()
+        config.enable_stream(color_profile)
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.DEPTH_SENSOR)
+        depth_profile = profile_list.get_default_video_stream_profile()
+        config.enable_stream(depth_profile)
+    except Exception as e:
+        print(e)
+        return
+
+    if enable_sync:
+        try:
+            pipeline.enable_frame_sync()
+        except Exception as e:
+            print(e)
+
+    try:
+        pipeline.start(config)
+    except Exception as e:
+        print(e)
+        return
+
+    align_filter = AlignFilter(align_to_stream=OBStreamType.COLOR_STREAM)
+
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if not frames:
+                continue
+            color_frame = frames.get_color_frame()
+            depth_frame = frames.get_depth_frame()
+            if not color_frame or not depth_frame:
+                continue
+            frames = align_filter.process(frames)
+            if not frames:
+                continue
+            frames  = frames.as_frame_set()
+            color_frame = frames.get_color_frame()
+            depth_frame = frames.get_depth_frame()
+            if not color_frame or not depth_frame:
+                continue
+
+            color_image = frame_to_bgr_image(color_frame)
+            if color_image is None:
+                print("Failed to convert frame to image")
+                continue
+            try:
+                depth_data = np.frombuffer(depth_frame.get_data(), dtype=np.uint16).reshape(
+                    (depth_frame.get_height(), depth_frame.get_width()))
+            except ValueError:
+                print("Failed to reshape depth data")
+                continue
+            depth_data = depth_data.astype(np.float32) * depth_frame.get_depth_scale()
+            depth_data = np.where((depth_data > MIN_DEPTH) & (depth_data < MAX_DEPTH), depth_data, 0)
+            depth_data = depth_data.astype(np.uint16)
+            depth_image = cv2.normalize(depth_data, None, 0, 255, cv2.NORM_MINMAX)
+            depth_image = cv2.applyColorMap(depth_image.astype(np.uint8), cv2.COLORMAP_JET)
+            depth_image = cv2.addWeighted(color_image, 0.5, depth_image, 0.5, 0)
+
+            cv2.imshow("SyncAlignViewer", depth_image)
+            if cv2.waitKey(1) in [ord('q'), ESC_KEY]:
+                break
+        except KeyboardInterrupt:
+            break
+    cv2.destroyAllWindows()
+    pipeline.stop()
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])