pyorbbec 1.0.1.25__cp310-cp310-win_amd64.whl

pyorbbecsdk/examples/two_devices_sync.py

@@ -0,0 +1,233 @@
+# ******************************************************************************
+#  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 json
+import os
+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)]
+serial_number_list: List[str] = ["" for _ in range(MAX_DEVICES)]
+has_color_sensor: List[bool] = [False for _ in range(MAX_DEVICES)]
+stop_rendering = False
+multi_device_sync_config = {}
+# config_file_path current file path
+config_file_path = os.path.join(
+    os.path.abspath(os.path.dirname(__file__)),
+    "../config/multi_device_sync_config.json",
+)
+
+
+def sync_mode_from_str(sync_mode_str: str) -> OBMultiDeviceSyncMode:
+    # to lower case
+    sync_mode_str = sync_mode_str.upper()
+    if sync_mode_str == "FREE_RUN":
+        return OBMultiDeviceSyncMode.FREE_RUN
+    elif sync_mode_str == "STANDALONE":
+        return OBMultiDeviceSyncMode.STANDALONE
+    elif sync_mode_str == "PRIMARY":
+        return OBMultiDeviceSyncMode.PRIMARY
+    elif sync_mode_str == "SECONDARY":
+        return OBMultiDeviceSyncMode.SECONDARY
+    elif sync_mode_str == "SECONDARY_SYNCED":
+        return OBMultiDeviceSyncMode.SECONDARY_SYNCED
+    elif sync_mode_str == "SOFTWARE_TRIGGERING":
+        return OBMultiDeviceSyncMode.SOFTWARE_TRIGGERING
+    elif sync_mode_str == "HARDWARE_TRIGGERING":
+        return OBMultiDeviceSyncMode.HARDWARE_TRIGGERING
+    else:
+        raise ValueError(f"Invalid sync mode: {sync_mode_str}")
+
+
+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
+    global serial_number_list
+    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
+
+            # print serial number, color timestamp, depth timestamp, break line
+            if color_frame is not None:
+                print(f"device#{i}, color frame timestamp: {color_frame.get_timestamp_us()} us , system timestamp: {color_frame.get_system_timestamp_us()} us")
+            if depth_frame is not None:
+                print(f"device#{i}, depth frame timestamp: {depth_frame.get_timestamp_us()} us , system timestamp: {depth_frame.get_system_timestamp_us()} us")
+            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
+                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_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:
+                return
+
+
+def start_streams(pipelines: List[Pipeline], configs: List[Config]):
+    index = 0
+    for pipeline, config in zip(pipelines, configs):
+        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 read_config(config_file: str):
+    global multi_device_sync_config
+    with open(config_file, "r") as f:
+        config = json.load(f)
+    for device in config["devices"]:
+        multi_device_sync_config[device["serial_number"]] = device
+        print(f"Device {device['serial_number']}: {device['config']['mode']}")
+
+
+def main():
+    global config_file_path
+    read_config(config_file_path)
+    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()
+        serial_number = device.get_device_info().get_serial_number()
+        serial_number_list[i] = serial_number
+        sync_config_json = multi_device_sync_config[serial_number]
+        sync_config = device.get_multi_device_sync_config()
+        sync_config.mode = sync_mode_from_str(sync_config_json["config"]["mode"])
+        sync_config.color_delay_us = sync_config_json["config"]["color_delay_us"]
+        sync_config.depth_delay_us = sync_config_json["config"]["depth_delay_us"]
+        sync_config.trigger_out_enable = sync_config_json["config"]["trigger_out_enable"]
+        sync_config.trigger_out_delay_us = sync_config_json["config"]["trigger_out_delay_us"]
+        sync_config.frames_per_trigger = sync_config_json["config"]["frames_per_trigger"]
+        print(f"Device {serial_number} sync config: {sync_config}")
+        device.set_multi_device_sync_config(sync_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)
+        config.enable_stream(depth_profile)
+        pipelines.append(pipeline)
+        configs.append(config)
+    global stop_rendering
+    start_streams(pipelines, configs)
+    ctx.enable_multi_device_sync(60000)
+    try:
+        rendering_frames()
+        stop_streams(pipelines)
+    except KeyboardInterrupt:
+        stop_rendering = True
+        stop_streams(pipelines)
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()

pyorbbecsdk/examples/utils.py

@@ -0,0 +1,127 @@
+# ******************************************************************************
+#  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 typing import Union, Any, Optional
+
+import cv2
+import numpy as np
+
+from pyorbbecsdk import FormatConvertFilter, VideoFrame
+from pyorbbecsdk import OBFormat, OBConvertFormat
+
+
+def yuyv_to_bgr(frame: np.ndarray, width: int, height: int) -> np.ndarray:
+    yuyv = frame.reshape((height, width, 2))
+    bgr_image = cv2.cvtColor(yuyv, cv2.COLOR_YUV2BGR_YUY2)
+    return bgr_image
+
+
+def uyvy_to_bgr(frame: np.ndarray, width: int, height: int) -> np.ndarray:
+    uyvy = frame.reshape((height, width, 2))
+    bgr_image = cv2.cvtColor(uyvy, cv2.COLOR_YUV2BGR_UYVY)
+    return bgr_image
+
+
+def i420_to_bgr(frame: np.ndarray, width: int, height: int) -> np.ndarray:
+    y = frame[0:height, :]
+    u = frame[height:height + height // 4].reshape(height // 2, width // 2)
+    v = frame[height + height // 4:].reshape(height // 2, width // 2)
+    yuv_image = cv2.merge([y, u, v])
+    bgr_image = cv2.cvtColor(yuv_image, cv2.COLOR_YUV2BGR_I420)
+    return bgr_image
+
+
+def nv21_to_bgr(frame: np.ndarray, width: int, height: int) -> np.ndarray:
+    y = frame[0:height, :]
+    uv = frame[height:height + height // 2].reshape(height // 2, width)
+    yuv_image = cv2.merge([y, uv])
+    bgr_image = cv2.cvtColor(yuv_image, cv2.COLOR_YUV2BGR_NV21)
+    return bgr_image
+
+
+def nv12_to_bgr(frame: np.ndarray, width: int, height: int) -> np.ndarray:
+    y = frame[0:height, :]
+    uv = frame[height:height + height // 2].reshape(height // 2, width)
+    yuv_image = cv2.merge([y, uv])
+    bgr_image = cv2.cvtColor(yuv_image, cv2.COLOR_YUV2BGR_NV12)
+    return bgr_image
+
+
+def determine_convert_format(frame: VideoFrame):
+    if frame.get_format() == OBFormat.I420:
+        return OBConvertFormat.I420_TO_RGB888
+    elif frame.get_format() == OBFormat.MJPG:
+        return OBConvertFormat.MJPG_TO_RGB888
+    elif frame.get_format() == OBFormat.YUYV:
+        return OBConvertFormat.YUYV_TO_RGB888
+    elif frame.get_format() == OBFormat.NV21:
+        return OBConvertFormat.NV21_TO_RGB888
+    elif frame.get_format() == OBFormat.NV12:
+        return OBConvertFormat.NV12_TO_RGB888
+    elif frame.get_format() == OBFormat.UYVY:
+        return OBConvertFormat.UYVY_TO_RGB888
+    else:
+        return None
+
+
+def frame_to_rgb_frame(frame: VideoFrame) -> Union[Optional[VideoFrame], Any]:
+    if frame.get_format() == OBFormat.RGB:
+        return frame
+    convert_format = determine_convert_format(frame)
+    if convert_format is None:
+        print("Unsupported format")
+        return None
+    print("covert format: {}".format(convert_format))
+    convert_filter = FormatConvertFilter()
+    convert_filter.set_format_convert_format(convert_format)
+    rgb_frame = convert_filter.process(frame)
+    if rgb_frame is None:
+        print("Convert {} to RGB failed".format(frame.get_format()))
+    return rgb_frame
+
+
+def frame_to_bgr_image(frame: VideoFrame) -> Union[Optional[np.array], Any]:
+    width = frame.get_width()
+    height = frame.get_height()
+    color_format = frame.get_format()
+    data = np.asanyarray(frame.get_data())
+    image = np.zeros((height, width, 3), dtype=np.uint8)
+    if color_format == OBFormat.RGB:
+        image = np.resize(data, (height, width, 3))
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    elif color_format == OBFormat.BGR:
+        image = np.resize(data, (height, width, 3))
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    elif color_format == OBFormat.YUYV:
+        image = np.resize(data, (height, width, 2))
+        image = cv2.cvtColor(image, cv2.COLOR_YUV2BGR_YUYV)
+    elif color_format == OBFormat.MJPG:
+        image = cv2.imdecode(data, cv2.IMREAD_COLOR)
+    elif color_format == OBFormat.I420:
+        image = i420_to_bgr(data, width, height)
+        return image
+    elif color_format == OBFormat.NV12:
+        image = nv12_to_bgr(data, width, height)
+        return image
+    elif color_format == OBFormat.NV21:
+        image = nv21_to_bgr(data, width, height)
+        return image
+    elif color_format == OBFormat.UYVY:
+        image = np.resize(data, (height, width, 2))
+        image = cv2.cvtColor(image, cv2.COLOR_YUV2BGR_UYVY)
+    else:
+        print("Unsupported color format: {}".format(color_format))
+        return None
+    return image

pyorbbecsdk/pyorbbecsdk/__init__.py

@@ -0,0 +1 @@
+

pyorbbecsdk/pyorbbecsdk/__version__.py

@@ -0,0 +1,10 @@
+__title__ = "pyorbbecsdk"
+__description__ = "Python interface to the Orbbec SDK."
+__url__ = "https://orbbec.com.cn/"
+__version__ = "1.0.0"
+__build__ = 0x023203
+__author__ = "orbbec"
+__author_email__ = "lijie@orbbec.com"
+__license__ = "Apache License"
+__copyright__ = "Copyright Orbbec"
+__cake__ = "\u2728 \U0001f370 \u2728"

pyorbbecsdk/pyorbbecsdk/config/OrbbecSDKConfig.md

@@ -0,0 +1,222 @@
+# Orbbec SDK Configuration File Introduction (OrbbecSDKConfig_v1.0.xml)
+
+The Orbbec SDK configuration file is an XML file that defines the global configuration of the Orbbec SDK.
+
+Upon initialization, the SDK Context will load a configuration file and apply as global configurations. If you have your own configuration file, you can specify it by entering the file path when calling the Context constructor. If you don't provide a path (or input an empty string), the SDK will look for a file named `OrbbecSDKConfig.xml` in the working directory. If neither the specified file nor the default file is found, the SDK will revert to using the built-in default configuration file.
+
+## Log Configuration
+
+Log configuration mainly sets the Log level, the Log level output to the console, the Log level output to a file, configures the path for saving Log files, sets the size of each Log file, and sets the number of Log files.
+
+```cpp
+    <Log>
+        <!--Log output level, int type, optional values: 0-DEBUG, 1-INFO, 2-WARN, 3-ERROR, 4-FATAL, 5-OFF-->
+        <!--Log level configuration execution priority: 0. Application code configuration > 1. Detailed configuration of configuration file (file & console configuration) > 2. Global configuration of configuration file > 3. SDK code default configuration (file: 0, terminal: 1)-->
+        <!--Global log output level-->
+        <LogLevel>0</LogLevel>
+        <!--File log output level-->
+        <FileLogLevel>0</FileLogLevel>
+        <!--Console log output level-->
+        <ConsoleLogLevel>1</ConsoleLogLevel>
+        <!--Default log output file path, string type. If this item is not configured, the default path will be used: Win/Linux: "./Log"; Android: "/sdcard/Orbbec/Log"-->
+        <!--<OutputDir>./log</OutputDir>-->
+        <!--Default log output file size, int type, unit: MB-->
+        <MaxFileSize>100</MaxFileSize>
+        <!--Default log output file number (circular overwrite), int type-->
+        <MaxFileNum>3</MaxFileNum>
+        <!--Log asynchronous output, changing to asynchronous output can reduce the blocking time of printing logs, but some logs may be lost when the program exits abnormally; true-enable, false-disable (default)-->
+        <Async>false</Async>
+    </Log>
+```
+
+## Memory Configuration
+
+```cpp
+    <Memory>
+        <!--Enable memory pool to reuse frame memory, avoid frequent memory allocation and release. true-enable, false-disable)-->
+        <EnableMemoryPool> true </EnableMemoryPool>
+        <!--Maximum memory size of all data frames, int type, unit: MB, minimum 100MB-->
+        <MaxFrameBufferSize> 2048 </MaxFrameBufferSize>
+        <!--Frame buffer queue size in pipeline-->
+        <PipelineFrameQueueSize>10</PipelineFrameQueueSize>
+        <!--Frame buffer queue size in internal processing unit-->
+        <FrameProcessingBlockQueueSize>10</FrameProcessingBlockQueueSize>
+    </Memory>
+```
+
+**Notes**
+
+1. The default size of the memory pool is 2GB (2048MB).
+```cpp
+        <MaxFrameBufferSize> 2048 </MaxFrameBufferSize>
+```
+2. The default number of frame buffere queue in the Pipeline is 10. If the host machine processes slowly, the SDK will buffer up to 10 frames internally, which may affect the delay time in retrieving frames by the user. If the delay is significant, you can reduce the number of buffers.
+```cpp
+        <PipelineFrameQueueSize>10</PipelineFrameQueueSize>
+```
+
+3. The default number of queues in the internal processing unit (Processing unit) is 10. If the host machine processes slowly, the SDK will buffer up to 10 frames internally, which may affect the delay time in retrieving frames by the user. If the delay is significant, you can reduce the number of queues.
+```cpp
+        <FrameProcessingBlockQueueSize>10</FrameProcessingBlockQueueSize>
+```
+
+## Global Timestamp
+
+Based on the device's timestamp and considering data transmission delays, the timestamp is converted to the system timestamp dimension through linear regression. It can be used to synchronize timestamps of multiple different devices. The implementation plan is as follows:
+
+1. Global timestamp fitter: Regularly obtain the device timestamp and the current system timestamp, and calculate the fitting equation parameters using a linear regression method.
+2. Global timestamp converter: Convert the data frame timestamp unit to the same unit as the device timestamp, then calculate the overflow times according to the device timestamp to convert to a 64-bit timestamp, and then convert to a global timestamp according to the fitting parameters output by the global timestamp fitter.
+
+```cpp
+    <Misc>
+        <GlobalTimestampFitterEnable>true</GlobalTimestampFitterEnable>
+        <!--Global timestamp fitter refresh interval, unit: milliseconds, default value: 1000, minimum value: 100, it is recommended not to be greater than 1000 -->
+        <GlobalTimestampFitterInterval>1000</GlobalTimestampFitterInterval>
+        <!--Global timestamp fitter queue size, default value: 100, minimum value: 20 -->
+        <GlobalTimestampFitterQueueSize>100</GlobalTimestampFitterQueueSize>
+    </Misc>
+```
+
+1. By default, the device time is obtained every eight seconds to update the global timestamp fitter.
+```cpp
+        <GlobalTimestampFitterInterval>1000</GlobalTimestampFitterInterval>
+```
+
+2. The default queue size of the global timestamp fitter is 10.
+```cpp
+        <GlobalTimestampFitterQueueSize>100</GlobalTimestampFitterQueueSize>
+```
+
+**Notes**
+
+1. The global timestamp mainly supports the Gemini 330 series. Gemini 2, Gemini 2L, Femto Mega, and Femto Bolt are also supported but not thoroughly tested. If there are stability issues with these devices, the global timestamp function can be turned off.
+```cpp
+        <GlobalTimestampFitterEnable>false</GlobalTimestampFitterEnable>
+```
+
+## Pipeline Configuration
+
+```cpp
+    <!--Default working configuration of pipeline-->
+    <Pipeline>
+        <Stream>
+            <Depth>
+                <!--Use default stream profile, bool type, true: use default stream profile, false: use specified stream profile in the configuration file-->
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </Depth>
+            <Color>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </Color>
+            <!--If you need to open other streams, you can refer to the above format to add configuration-->
+        </Stream>
+        <!--Image alignment, int type, optional values: 0 disable, 1 hardware d2c alignment, 2 software d2c alignment-->
+        <AlignMode>0</AlignMode>
+        <!--Frame synchronization output between different data streams, bool type, true-enable frame synchronization, false-disable frame synchronization-->
+        <FrameSync>false</FrameSync>
+    </Pipeline>
+```
+
+1. Pipeline primarily sets which video streams to enable. By default, only Depth and Color streams are enabled. You can add to enable IR streams, left IR, and right IR as follows.
+```cpp
+<!--If you need to open other streams, you can refer to the above format to add configuration-->
+            <IR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </IR>
+            <LeftIR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </LeftIR>
+            <RightIR>
+                <UseDefaultStreamProfile>true</UseDefaultStreamProfile>
+            </RightIR>
+```
+2. Pipeline can set D2C, such as hardware D2C and software D2C. Some devices do not support hardware D2C, such as Femto Bolt. If you need to use various different types of devices, it is recommended to set this in the user code based on the device type.
+```cpp
+  <AlignMode>0</AlignMode>
+```
+3. Pipeline can set frame synchronization. Enabling frame synchronization will match Depth, Color, and other video frames based on the timestamp and output them as FrameSet within the Pipeline.
+```cpp
+        <FrameSync>false</FrameSync>
+```
+
+## Device Configuration
+
+```cpp
+    <!--Default configuration of data streams for different types of devices-->
+    <Device>
+        <EnumerateNetDevice>false</EnumerateNetDevice>
+        <!--UVC Backend select on Linux; optional values: Auto, V4L2, LibUVC; Auto is the default value-->
+        <LinuxUVCBackend>LibUVC</LinuxUVCBackend>
+
+            <!--Gemini 335 config-->
+        <Gemini335>
+	        <!--Whether to enable heartbeat by default-->
+	        <DefaultHeartBeat>0</DefaultHeartBeat>
+
+			<Depth>
+			    <!--Number of retries for open stream failures, 0 means no retries-->
+				<StreamFailedRetry>0</StreamFailedRetry>
+				<!--Open flow waits for the timeout period of the first frame of data, after which the open flow will fail-->
+				<MaxStartStreamDelayMs>5000</MaxStartStreamDelayMs>
+				<!--The number of data stream restarts due to abnormal interruption, 0 means no restart-->
+				<StreamInterruptedRestart>0</StreamInterruptedRestart>
+				<!--The maximum frame interval time, if this value is exceeded, it will be judged that the stream is interrupted-->
+				<MaxFrameIntervalMs>2000</MaxFrameIntervalMs>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y16</Format>
+            </Depth>
+            <Color>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>1280</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>720</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>MJPG</Format>
+            </Color>
+            <IR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </IR>
+			<LeftIR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </LeftIR>
+			<RightIR>
+                <!--The resolution width is enabled by default, int type-->
+                <Width>848</Width>
+                <!--High resolution is enabled by default, int type-->
+                <Height>480</Height>
+                <!--The frame rate of the resolution enabled by default, int type-->
+                <FPS>30</FPS>
+                <Format>Y8</Format>
+            </RightIR>
+        </Gemini335>
+    </Device>
+```
+
+1. Set whether to enumerate network devices. Femto Mega and Gemini 2 XL support network functions. If you need to use the network functions of these two devices, you can set this to true.
+```cpp
+        <EnumerateNetDevice>false</EnumerateNetDevice>
+```
+
+2. Set whether to use LibUVC or V4L2 to receive data on Linux or ARM. V4L2 is not supported by all devices, and we recommend using LibUVC. The Gemini 330 series devices support V4L2, but kernel patches are needed to obtain Metadata data.
+```cpp
+        <LinuxUVCBackend>LibUVC</LinuxUVCBackend>
+```
+
+3. Set the resolution, frame rate, and data format.