pyorbbec 1.0.1.6__py3-none-any.whl → 1.0.1.8__py3-none-any.whl

pyorbbecsdk/examples/hdr.py

@@ -0,0 +1,216 @@
+# ******************************************************************************
+#  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 sys
+import cv2
+import numpy as np
+from pyorbbecsdk import *
+
+ESC_KEY = 27
+PRINT_INTERVAL = 1  # seconds
+MIN_DEPTH = 20  # 20mm
+MAX_DEPTH = 10000  # 10000mm
+
+
+def add_text_to_image(image, text, position):
+    """
+    Add text to an image at the specified position
+    Args:
+        image: Input image
+        text: Text to add
+        position: Tuple of (x, y) coordinates
+    Returns:
+        Image with text added
+    """
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 0.8
+    color = (255, 255, 255)  # White color
+    thickness = 2
+
+    # Add black background for better visibility
+    (text_width, text_height), _ = cv2.getTextSize(text, font, font_scale, thickness)
+    cv2.rectangle(image,
+                  (position[0], position[1] - text_height - 5),
+                  (position[0] + text_width, position[1] + 5),
+                  (0, 0, 0),
+                  -1)
+
+    return cv2.putText(image, text, position, font, font_scale, color, thickness)
+
+
+def enhance_contrast(image, clip_limit=3.0, tile_grid_size=(8, 8)):
+    """
+    Enhance image contrast using CLAHE
+    """
+    if len(image.shape) == 3:
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+        l = clahe.apply(l)
+        lab = cv2.merge((l, a, b))
+        return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+    else:
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+        return clahe.apply(image)
+
+
+def main(argv):
+    pipeline = Pipeline()
+    device = pipeline.get_device()
+    is_support_hdr = device.is_property_supported(OBPropertyID.OB_STRUCT_DEPTH_HDR_CONFIG,OBPermissionType.PERMISSION_READ_WRITE)
+    if is_support_hdr == False:
+        print("Current default device does not support HDR merge")
+        return
+    config = Config()
+
+    try:
+        # Enable depth stream
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.DEPTH_SENSOR)
+        depth_profile = profile_list.get_default_video_stream_profile()
+        config.enable_stream(depth_profile)
+
+        # Enable IR streams
+        left_profile_list = pipeline.get_stream_profile_list(OBSensorType.LEFT_IR_SENSOR)
+        right_profile_list = pipeline.get_stream_profile_list(OBSensorType.RIGHT_IR_SENSOR)
+        left_ir_profile = left_profile_list.get_default_video_stream_profile()
+        right_ir_profile = right_profile_list.get_default_video_stream_profile()
+        config.enable_stream(left_ir_profile)
+        config.enable_stream(right_ir_profile)
+        config.set_frame_aggregate_output_mode(OBFrameAggregateOutputMode.FULL_FRAME_REQUIRE)
+    except Exception as e:
+        print(e)
+        return
+
+    try:
+        pipeline.enable_frame_sync()
+    except Exception as e:
+        print(e)
+
+    try:
+        pipeline.start(config)
+    except Exception as e:
+        print(e)
+        return
+
+    device = pipeline.get_device()
+    config = OBHdrConfig()
+    config.enable = True
+    config.exposure_1 = 7500
+    config.gain_1 = 24
+    config.exposure_2 = 50
+    config.gain_2 = 16
+    device.set_hdr_config(config)
+    hdr_filter = HDRMergeFilter()
+
+    # Create window for visualization
+    cv2.namedWindow("HDR Merge Viewer", cv2.WINDOW_NORMAL)
+    cv2.resizeWindow("HDR Merge Viewer", 1280, 960)  # Adjusted for 2x2 layout
+
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if not frames:
+                print("No frames received")
+                continue
+
+            # Get all frames
+            depth_frame = frames.get_depth_frame()
+            left_ir_frame = frames.get_frame(OBFrameType.LEFT_IR_FRAME)
+            right_ir_frame = frames.get_frame(OBFrameType.RIGHT_IR_FRAME)
+
+            if not all([depth_frame, left_ir_frame, right_ir_frame]):
+                print("Not All frames received")
+                continue
+
+            # Process with HDR merge
+            merged_frame = hdr_filter.process(frames)
+            if not merged_frame:
+                continue
+
+            merged_frames = merged_frame.as_frame_set()
+            merged_depth_frame = merged_frames.get_depth_frame()
+
+            # Convert frames to displayable images
+            depth_image = create_depth_image(depth_frame)
+            merged_depth_image = create_depth_image(merged_depth_frame)
+            ir_left_image = create_ir_image(left_ir_frame)
+            ir_right_image = create_ir_image(right_ir_frame)
+
+            # Enhance contrast for all images
+            depth_image = enhance_contrast(depth_image, clip_limit=4.0)
+            ir_left_image = enhance_contrast(ir_left_image, clip_limit=4.0)
+            ir_right_image = enhance_contrast(ir_right_image, clip_limit=4.0)
+            merged_depth_image = enhance_contrast(merged_depth_image, clip_limit=4.0)
+
+            # Ensure all images have the same dimensions for display
+            h, w = depth_image.shape[:2]
+            ir_left_image = cv2.resize(ir_left_image, (w, h))
+            ir_right_image = cv2.resize(ir_right_image, (w, h))
+            merged_depth_image = cv2.resize(merged_depth_image, (w, h))
+
+            # Add text annotations to images
+            ir_left_image = add_text_to_image(ir_left_image, "Left IR (HDR)", (10, 30))
+            ir_right_image = add_text_to_image(ir_right_image, "Right IR (HDR)", (10, 30))
+            depth_image = add_text_to_image(depth_image, "Original Depth (HDR)", (10, 30))
+            merged_depth_image = add_text_to_image(merged_depth_image, "HDR Merged Depth", (10, 30))
+
+            # Create 2x2 layout
+            top_row = np.hstack((ir_left_image, ir_right_image))
+            bottom_row = np.hstack((depth_image, merged_depth_image))
+            display_image = np.vstack((top_row, bottom_row))
+
+            cv2.imshow("HDR Merge Viewer", display_image)
+            key = cv2.waitKey(1)
+            if key == ord('q') or key == ESC_KEY:
+                break
+
+        except KeyboardInterrupt:
+            break
+
+    cv2.destroyAllWindows()
+    pipeline.stop()
+
+
+def create_depth_image(depth_frame):
+    """Convert depth frame to colorized image"""
+    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)
+    depth_data = depth_data.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)
+    depth_data = depth_data.astype(np.uint16)
+
+    depth_image = cv2.normalize(depth_data, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+    return cv2.applyColorMap(depth_image, cv2.COLORMAP_JET)
+
+
+def create_ir_image(ir_frame):
+    """Convert IR frame to displayable image with enhanced contrast"""
+    ir_frame = ir_frame.as_video_frame()
+    width = ir_frame.get_width()
+    height = ir_frame.get_height()
+
+    ir_data = np.frombuffer(ir_frame.get_data(), dtype=np.uint8)
+    ir_data = ir_data.reshape((height, width))
+
+    ir_image = cv2.normalize(ir_data, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
+    return cv2.cvtColor(ir_image, cv2.COLOR_GRAY2BGR)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

pyorbbecsdk/examples/hot_plug.py

@@ -0,0 +1,160 @@
+# ******************************************************************************
+#  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 threading
+import time
+from typing import Optional
+
+from pyorbbecsdk import *
+
+# Global variables
+device: Optional[Device] = None
+pipeline: Optional[Pipeline] = None
+device_lock = threading.Lock()
+
+def start_stream(device: Device):
+    """Starts the stream for both color and depth sensors."""
+    global pipeline
+    if device is None:
+        print("No device connected")
+        return
+   
+    config = Config()
+    print("Try to reset pipeline")
+    pipeline = Pipeline(device)
+    print("Try to enable color stream")
+    # Enable color stream
+    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)
+    except Exception as e:
+        print(f"Failed to enable color stream: {e}")
+    
+    # Enable depth stream
+    try:
+        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(f"Failed to enable depth stream: {e}")
+    
+    print("Starting the stream...")
+    pipeline.start(config)
+
+def stop_stream():
+    """Stops the pipeline if it is running."""
+    global pipeline
+    if pipeline is None:
+        print("Pipeline is not started")
+        return
+    pipeline.stop()
+    pipeline = None
+
+def on_device_connected_callback(device_list: DeviceList):
+    """Callback when a new device is connected."""
+    global device
+    if len(device_list) == 0:
+        return
+    
+    print("Device connected")
+    with device_lock:
+        if device is not None:
+            print("Device is already connected")
+            return
+        
+        # Get the first available device and start the stream
+        print("Try to get device")
+        device = device_list[0]
+        print("Try to start stream")
+        start_stream(device)
+        print("Start stream successfully")
+
+def on_device_disconnected_callback(device_list: DeviceList):
+    """Callback when a device is disconnected."""
+    global device, pipeline
+    if len(device_list) == 0:
+        return
+    
+    print("Device disconnected")
+    try:
+        with device_lock:
+            print("reset device ...")
+            device = None
+            print("reset device successfully")
+    except OBError as e:
+        print(e)
+    print("Device disconnected successfully")
+
+def on_new_frame_callback(frame: Frame):
+    """Handles new frames captured by the sensors."""
+    if frame is None:
+        return
+    print(f"{frame.get_type()} frame, width={frame.get_width()}, height={frame.get_height()}, format={frame.get_format()}, timestamp={frame.get_timestamp_us()}us")
+
+def on_device_changed_callback(disconn_device_list: DeviceList, conn_device_list: DeviceList):
+    """Handles device changes by invoking appropriate connect/disconnect callbacks."""
+    on_device_connected_callback(conn_device_list)
+    on_device_disconnected_callback(disconn_device_list)
+
+def main():
+    """Main program loop to handle device connection and frame processing."""
+    ctx = Context()
+    
+    # Set callback for device changes (connect/disconnect)
+    ctx.set_device_changed_callback(on_device_changed_callback)
+    
+    # Check for currently connected devices
+    device_list = ctx.query_devices()
+    on_device_connected_callback(device_list)
+    
+    global pipeline, device
+
+    while True:
+        try:
+            with device_lock:
+                if pipeline is not None and device is not None:
+                    # Wait for a new set of frames
+                    frames: FrameSet = pipeline.wait_for_frames(100)
+                else:
+                    continue
+            if frames is None:
+                time.sleep(0.001)  # Avoid busy waiting
+                continue
+            
+            # Get color and depth frames
+            color_frame = frames.get_color_frame()
+            depth_frame = frames.get_depth_frame()
+            
+            # Process each frame
+            on_new_frame_callback(color_frame)
+            on_new_frame_callback(depth_frame)
+        except KeyboardInterrupt:
+            break
+        except OBError as e:
+            print(f"Error during frame capture: {e}")
+            continue
+    
+    # Stop the pipeline on exit
+    print("Stopping the pipeline...")
+    try:
+        if pipeline is not None:
+            pipeline.stop()
+    except OBError as e:
+        print(f"Error during pipeline stop: {e}")
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/hw_d2c_align.py

@@ -0,0 +1,135 @@
+# ******************************************************************************
+#  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 *
+import cv2
+import numpy as np
+from utils import frame_to_bgr_image
+
+def get_stream_config(pipeline: Pipeline):
+    """
+    Gets the stream configuration for the pipeline.
+
+    Args:
+        pipeline (Pipeline): The pipeline object.
+
+    Returns:
+        Config: The stream configuration.
+    """
+    config = Config()
+    try:
+        # Get the list of color stream profiles
+        profile_list = pipeline.get_stream_profile_list(OBSensorType.COLOR_SENSOR)
+        assert profile_list is not None
+        
+        # Iterate through the color stream profiles
+        for i in range(len(profile_list)):
+            color_profile = profile_list[i]
+            
+            # Check if the color format is RGB
+            if color_profile.get_format() != OBFormat.RGB:
+                continue
+            
+            # Get the list of hardware aligned depth-to-color profiles
+            hw_d2c_profile_list = pipeline.get_d2c_depth_profile_list(color_profile, OBAlignMode.HW_MODE)
+            if len(hw_d2c_profile_list) == 0:
+                continue
+            
+            # Get the first hardware aligned depth-to-color profile
+            hw_d2c_profile = hw_d2c_profile_list[0]
+            print("hw_d2c_profile: ", hw_d2c_profile)
+            
+            # Enable the depth and color streams
+            config.enable_stream(hw_d2c_profile)
+            config.enable_stream(color_profile)
+            
+            # Set the alignment mode to hardware alignment
+            config.set_align_mode(OBAlignMode.HW_MODE)
+            return config
+    except Exception as e:
+        print(e)
+        return None
+    return None
+
+def main():
+    # Create a pipeline object
+    pipeline = Pipeline()
+    
+    # Get the stream configuration
+    config = get_stream_config(pipeline)
+    if config is None:
+        return
+    
+    # Start the pipeline
+    pipeline.start(config)
+    
+    # Set the depth range
+    min_depth = 20  # Minimum depth value, keep closer depths
+    max_depth = 10000  # Maximum depth value, allow far depths to be lost
+
+    while True:
+        # Wait for frames
+        frames = pipeline.wait_for_frames(100)
+        if frames is None:
+            continue
+        
+        # Get the color and depth frames
+        color_frame = frames.get_color_frame()
+        depth_frame = frames.get_depth_frame()
+        if not color_frame or not depth_frame:
+            continue
+        depth_format = depth_frame.get_format()
+        if depth_format != OBFormat.Y16:
+            print("depth format is not Y16")
+            continue
+
+        # Convert the color frame to a BGR image
+        color_image = frame_to_bgr_image(color_frame)
+        if color_image is None:
+            print("Failed to convert frame to image")
+            continue
+
+        # Get the depth data
+        depth_data = np.frombuffer(depth_frame.get_data(), dtype=np.uint16).reshape(
+            (depth_frame.get_height(), depth_frame.get_width()))
+        
+        # Convert depth data to float32 and apply depth scale
+        depth_data = depth_data.astype(np.float32) * depth_frame.get_depth_scale()
+        
+        # Apply custom depth range, clip depth data
+        depth_data = np.clip(depth_data, min_depth, max_depth)
+        
+        # Normalize depth data for display
+        depth_image = cv2.normalize(depth_data, None, 0, 255, cv2.NORM_MINMAX)
+        depth_image = cv2.applyColorMap(depth_image.astype(np.uint8), cv2.COLORMAP_JET)
+
+        # Blend the depth and color images
+        blended_image = cv2.addWeighted(color_image, 0.5, depth_image, 0.5, 0)
+
+        #resize the window
+        cv2.namedWindow("HW D2C Align Viewer", cv2.WINDOW_NORMAL)
+        cv2.resizeWindow("HW D2C Align Viewer", 640, 480)
+        
+        # Display the result
+        cv2.imshow("HW D2C Align Viewer", blended_image)
+        if cv2.waitKey(1) in [ord('q'), 27]:  # 27 is the ESC key
+            break
+
+    # Stop the pipeline
+    pipeline.stop()
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/imu.py

@@ -0,0 +1,60 @@
+# ******************************************************************************
+#  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 time
+import cv2
+import numpy as np
+from pyorbbecsdk import *
+
+ESC_KEY = 27
+
+def main():
+    config = Config()
+    pipeline = Pipeline()
+    config.enable_accel_stream()
+    config.enable_gyro_stream()
+    config.set_frame_aggregate_output_mode(OBFrameAggregateOutputMode.FULL_FRAME_REQUIRE)
+    pipeline.start(config)
+    while True:
+        try:
+            frames = pipeline.wait_for_frames(100)
+            if frames is None:
+                continue
+            
+            accel_frame = frames.get_frame(OBFrameType.ACCEL_FRAME)
+            accel_frame = accel_frame.as_accel_frame()
+            
+            if accel_frame is not None:
+                accel_index = accel_frame.get_index()
+                if accel_index % 50 == 0:
+                    print("AccelFrame: ts={}".format(accel_frame.get_timestamp()))
+                    print("AccelFrame: x={}, y={}, z={}".format(accel_frame.get_x(), accel_frame.get_y(),accel_frame.get_z()))    
+
+            gyro_frame = frames.get_frame(OBFrameType.GYRO_FRAME)
+            gyro_frame = gyro_frame.as_gyro_frame()
+            if gyro_frame is not None:
+                gyro_index = gyro_frame.get_index()
+                if gyro_index % 50 == 0:
+                    print("GyroFrame: ts={}".format(gyro_frame.get_timestamp()))
+                    print("GyroFrame: x={}, y={}, z={}".format(gyro_frame.get_x(), gyro_frame.get_y(),gyro_frame.get_z()))  
+
+            key = cv2.waitKey(1)
+            if key == ord('q') or key == ESC_KEY:
+                break            
+        except KeyboardInterrupt:
+            break           
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/infrared.py

@@ -0,0 +1,115 @@
+# ******************************************************************************
+#  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):
+    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)
+    return cv2.cvtColor(ir_data, cv2.COLOR_GRAY2RGB)
+
+
+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)
+                right_image = process_ir_frame(right_ir_frame)
+
+                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()