Intel RealSense SDK 2.0 là thư viện phát triển đa nền tảng dành cho camera độ sâu, cung cấp khả năng thu thập luồng dữ liệu chiều sâu và màu, truy xuất thông số hiệu chuẩn trong – ngoài máy ảnh, cùng nhiều tính năng xử lý nâng cao. Bài viết này trình bày toàn diện cách xây dựng ứng dụng thị giác sâu chuyên nghiệp dựa trên librealsense, từ kiến trúc hệ thống, thiết lập môi trường, triển khai chức năng cốt lõi đến tối ưu hiệu năng.

Kiến trúc Hệ thống và Nguyên lý Hoạt động

SDK được thiết kế theo mô hình phân lớp: lớp thấp thực hiện trừu tượng hóa phần cứng để hỗ trợ nhiều dòng thiết bị RealSense; lớp trung giao diện API thống nhất; lớp trên tích hợp các thuật toán hậu xử lý như làm mịn, điền lỗ và tái tạo bề mặt.

Cơ chế thu thập và biểu diễn dữ liệu chiều sâu

Dữ liệu chiều sâu được tạo ra qua công nghệ ánh sáng hồng ngoại cấu trúc hoặc thị giác nổi hai mắt. SDK chuyển đổi dữ liệu thô thành khung (frame) chuẩn hóa với định dạng Z16 — mỗi pixel lưu giá trị khoảng cách (đơn vị mm) từ cảm biến đến điểm tương ứng trong không gian:

rs2::config config;
config.enable_stream(RS2_STREAM_DEPTH, 848, 480, RS2_FORMAT_Z16, 60);
config.enable_stream(RS2_STREAM_COLOR, 848, 480, RS2_FORMAT_BGR8, 30);

Các ma trận hiệu chuẩn nội – ngoại được tự động tính toán và áp dụng để bù sai méo quang học, đảm bảo độ chính xác vị trí không gian.

Đồng bộ hóa đa cảm biến

Các thiết bị RealSense thường tích hợp đồng thời cảm biến chiều sâu, RGB, hồng ngoại và IMU. SDK sử dụng cả đánh dấu thời gian phần cứng và cơ chế đồng bộ mềm để đảm bảo tính nhất quán về thời điểm giữa các luồng dữ liệu:

rs2::pipeline pipeline;
rs2::config cfg;

cfg.enable_stream(RS2_STREAM_DEPTH);
cfg.enable_stream(RS2_STREAM_COLOR);
cfg.enable_stream(RS2_STREAM_INFRARED, 1);
cfg.enable_stream(RS2_STREAM_INFRARED, 2);

auto profile = pipeline.start(cfg);

Cài đặt Môi Trường Phát Triển

Triển khai trên macOS

Các bước thiết lập môi trường trên macOS:

# Cài Homebrew nếu chưa có
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Cài phụ thuộc
brew install cmake pkg-config libusb openssl

# Clone mã nguồn
git clone https://github.com/IntelRealSense/librealsense
cd librealsense

mkdir build && cd build

cmake .. \
  -DBUILD_EXAMPLES=ON \
  -DBUILD_GRAPHICAL_EXAMPLES=ON \
  -DCMAKE_BUILD_TYPE=Release \
  -DOPENSSL_ROOT_DIR=$(brew --prefix openssl)

Tối ưu tùy chọn biên dịch

Các tùy chọn CMake ảnh hưởng trực tiếp đến hiệu năng và khả năng mở rộng của ứng dụng:

Tùy chọn	Mặc định	Gợi ý	Mục đích
BUILD_PYTHON_BINDINGS	OFF	ON	Đóng gói giao diện Python cho phát triển nhanh
BUILD_WITH_CUDA	OFF	ON (nếu có GPU)	Tăng tốc xử lý điểm ảnh và tái tạo lưới tam giác
BUILD_WITH_OPENMP	ON	ON	Hỗ trợ song song hóa các phép toán xử lý ảnh

Kiểm tra và xác minh

Sau khi biên dịch, kiểm tra hoạt động bằng các lệnh sau:

make -j$(sysctl -n hw.ncpu)
sudo make install

# Kiểm tra thiết bị
rs-enumerate-devices

# Khởi chạy công cụ trực quan hóa
realsense-viewer

Các Thành Phần Chức Năng Chính

Thu thập và xử lý luồng dữ liệu

Ví dụ minh họa việc lấy dữ liệu đồng bộ và trích xuất thông tin chiều sâu:

rs2::pipeline pipe;
pipe.start();

while (running) {
    rs2::frameset frames = pipe.wait_for_frames();
    rs2::depth_frame depth = frames.get_depth_frame();
    
    // Truy cập dữ liệu thô
    const uint16_t* raw = reinterpret_cast<const uint16_t*>(depth.get_data());
    int w = depth.get_width(), h = depth.get_height();
    
    // Xử lý tại đây: phân đoạn, đo khoảng cách, v.v.
}

Áp dụng bộ lọc hậu xử lý

Các bộ lọc tích hợp giúp cải thiện chất lượng bản đồ chiều sâu:

• Bộ lọc không gian: giảm nhiễu cục bộ, phù hợp cho tái tạo bề mặt tĩnh.
• Bộ lọc thời gian: ổn định giá trị theo chuỗi khung, cần bộ đệm lịch sử.
• Bộ điền lỗ: suy đoán giá trị thiếu tại viền vật thể hoặc vùng che khuất.

rs2::spatial_filter spatial;
rs2::temporal_filter temporal;
rs2::hole_filling_filter fill;

spatial.set_option(RS2_OPTION_FILTER_SMOOTH_ALPHA, 0.45f);
temporal.set_option(RS2_OPTION_FILTER_SMOOTH_DELTA, 15);
fill.set_option(RS2_OPTION_HOLE_FILLING, 2); // Mode 2: interpolation + edge-aware

// Áp dụng tuần tự
auto filtered = fill.process(temporal.process(spatial.process(depth)));

Tạo và hiển thị điểm ảnh 3D

Chuyển đổi dữ liệu chiều sâu sang không gian 3D bằng lớp rs2::pointcloud:

rs2::pointcloud pc;
pc.map_to(color_frame); // Gắn texture từ khung màu

while (true) {
    auto frames = pipe.wait_for_frames();
    auto points = pc.calculate(frames.get_depth_frame());

    // Truy xuất tọa độ đỉnh và UV
    const rs2::vertex* verts = points.get_vertices();
    const rs2::texture_coordinate* texs = points.get_texture_coordinates();

    // Truyền vào engine render hoặc phân tích hình học
}

Tối ưu Hiệu Năng và Cấu Hình Nâng Cao

Điều chỉnh tham số thuật toán chiều sâu

Chế độ nâng cao (Advanced Mode) cho phép tinh chỉnh sâu các tham số xử lý stereo:

if (dev.is<rs400::advanced_mode>()) {
    auto adv = dev.as<rs400::advanced_mode>();
    auto table = adv.get_depth_table();
    
    table.disparityShift = 132;
    table.secondPeakThreshold = 750;
    table.textureCountThreshold = 0;
    
    adv.set_depth_table(table);
}

Tối ưu tài nguyên hệ thống

Để duy trì hiệu năng ở độ phân giải cao hoặc tốc độ khung hình lớn:

• Giới hạn số khung đệm trong pipeline bằng set_frames_queue_size().
• Sử dụng luồng riêng biệt cho thu thập và xử lý để tránh nghẽn.
• Áp dụng rs2::frame_queue để quản lý luồng khung không chặn.

Hỗ trợ đa thiết bị

Kết nối đồng thời nhiều camera với đồng bộ hóa phần cứng:

std::vector<rs2::pipeline> pipes;
for (const auto& serial : device_serials) {
    rs2::config cfg;
    cfg.enable_device(serial);
    cfg.enable_stream(RS2_STREAM_DEPTH);
    
    rs2::pipeline p;
    p.start(cfg);
    pipes.push_back(p);
}

// Đồng bộ đọc khung từ tất cả thiết bị
while (true) {
    std::vector<rs2::frameset> all_frames;
    for (auto& p : pipes) {
        all_frames.push_back(p.wait_for_frames());
    }
    // Xử lý dữ liệu đa góc nhìn...
}

Chẩn đoán Sự Cố và Kiểm Định Chất Lượng

Phân tích dữ liệu chiều sâu

Đo lường độ phủ và độ chính xác bằng Python:

import pyrealsense2 as rs
import numpy as np

pipeline = rs.pipeline()
config = rs.config()
config.enable_stream(rs.stream.depth, 640, 480)

pipeline.start(config)
depth_sensor = pipeline.get_active_profile().get_device().first_depth_sensor()
scale = depth_sensor.get_depth_scale()

frames = pipeline.wait_for_frames()
depth = np.array(frames.get_depth_frame().get_data(), dtype=np.uint16)

valid_ratio = np.count_nonzero(depth) / depth.size * 100
print(f"Valid pixels: {valid_ratio:.1f}% | Scale: {scale:.6f}")

Ghi nhật ký chi tiết

Kích hoạt logging mức độ debug để chẩn đoán lỗi kết nối hoặc xử lý:

rs2::log_to_console(RS2_LOG_SEVERITY_DEBUG);
// hoặc đăng ký callback tùy chỉnh
rs2::log_to_callback(RS2_LOG_SEVERITY_WARN, [](rs2_log_severity s, const char* m) {
    std::cerr << "[RS] " << m << "\n";
});

Ứng Dụng Thực Tế

Hệ thống ghi – phát lại dữ liệu

Sử dụng định dạng .bag để lưu trữ và tái hiện luồng dữ liệu:

rs2::config rec_cfg;
rec_cfg.enable_record_to_file("session.bag");
rec_cfg.enable_stream(RS2_STREAM_DEPTH);
rec_cfg.enable_stream(RS2_STREAM_COLOR);

rs2::pipeline recorder;
recorder.start(rec_cfg);

std::this_thread::sleep_for(15s);
recorder.stop();

// Phát lại
rs2::config play_cfg;
play_cfg.enable_device_from_file("session.bag");
rs2::pipeline player;
player.start(play_cfg);

Phát hiện vật thể dựa trên thông tin chiều sâu

Kết hợp OpenCV để phân đoạn vùng gần trong không gian 3D:

import cv2
import numpy as np

# Sau khi lấy depth_image và color_image...
mask = cv2.inRange(depth_image, 700, 1200)  # mm
kernel = np.ones((3,3), np.uint8)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
    if cv2.contourArea(cnt) > 500:
        x,y,w,h = cv2.boundingRect(cnt)
        cv2.rectangle(color_image, (x,y), (x+w,y+h), (0,0,255), 2)