feat: 添加点云去噪及其参数调整

update: readme
fix: 修改日志生成位置
2026-03-04 15:59:39 +08:00 · 2026-03-03 17:15:43 +08:00 · 2026-03-03 11:51:05 +08:00 · 2026-02-06 14:47:42 +08:00 · 2026-02-02 14:26:45 +08:00 · 2026-02-02 14:08:30 +08:00
22 changed files with 3060 additions and 457 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(D330Viewer VERSION 1.0.0 LANGUAGES CXX C)
+project(Viewer VERSION 1.0.0 LANGUAGES CXX C)

 # 设置C++标准
 set(CMAKE_CXX_STANDARD 17)
@@ -34,7 +34,7 @@ find_package(Qt6 REQUIRED COMPONENTS
 )

 # 查找PCL
-find_package(PCL REQUIRED COMPONENTS common io visualization)
+find_package(PCL REQUIRED COMPONENTS common io visualization filters)
 if(PCL_FOUND)
    include_directories(${PCL_INCLUDE_DIRS})
    link_directories(${PCL_LIBRARY_DIRS})
@@ -101,6 +101,52 @@ add_executable(${PROJECT_NAME} WIN32
    ${RESOURCES}
 )

+# ==================== 标定文件(cmos0)检查 ====================
+set(VIEWER_CALIBRATION_DIR "${CMAKE_SOURCE_DIR}/cmos0")
+set(VIEWER_REQUIRED_CALIB_FILES
+    "coe.txt"
+    "kc.txt"
+    "KK.txt"
+)
+
+set(VIEWER_MISSING_CALIB_FILES "")
+foreach(_calib_file IN LISTS VIEWER_REQUIRED_CALIB_FILES)
+    if(NOT EXISTS "${VIEWER_CALIBRATION_DIR}/${_calib_file}")
+        list(APPEND VIEWER_MISSING_CALIB_FILES "${_calib_file}")
+    endif()
+endforeach()
+
+option(VIEWER_REQUIRE_CALIB_FILES "Fail configure when required cmos0 calibration files are missing" ON)
+
+if(VIEWER_MISSING_CALIB_FILES)
+    if(VIEWER_REQUIRE_CALIB_FILES)
+        message(FATAL_ERROR
+            "Missing calibration file(s) in ${VIEWER_CALIBRATION_DIR}: ${VIEWER_MISSING_CALIB_FILES}\n"
+            "Please ensure cmos0 contains: ${VIEWER_REQUIRED_CALIB_FILES}"
+        )
+    else()
+        message(WARNING
+            "Missing calibration file(s) in ${VIEWER_CALIBRATION_DIR}: ${VIEWER_MISSING_CALIB_FILES}\n"
+            "Build continues, but runtime or MSI may be incomplete."
+        )
+    endif()
+else()
+    message(STATUS "Calibration files found: ${VIEWER_REQUIRED_CALIB_FILES}")
+endif()
+
+# 复制标定文件到运行目录（bin/cmos0）
+if(EXISTS "${VIEWER_CALIBRATION_DIR}" AND NOT VIEWER_MISSING_CALIB_FILES)
+    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:${PROJECT_NAME}>/cmos0"
+        COMMAND ${CMAKE_COMMAND} -E copy_directory
+                "${VIEWER_CALIBRATION_DIR}"
+                "$<TARGET_FILE_DIR:${PROJECT_NAME}>/cmos0"
+        COMMENT "Copy cmos0 calibration files to runtime directory"
+    )
+else()
+    message(WARNING "Skip copying cmos0 because required calibration files are missing.")
+endif()
+
 # 链接库
 target_link_libraries(${PROJECT_NAME}
    Qt6::Core
@@ -141,25 +187,34 @@ install(DIRECTORY ${CMAKE_SOURCE_DIR}/bin/platforms/
    FILES_MATCHING PATTERN "*.dll"
 )

+# 安装标定文件目录（用于MSI）
+if(EXISTS "${VIEWER_CALIBRATION_DIR}" AND NOT VIEWER_MISSING_CALIB_FILES)
+    install(DIRECTORY ${VIEWER_CALIBRATION_DIR}/
+        DESTINATION cmos0
+        FILES_MATCHING
+        PATTERN "*.txt"
+    )
+endif()
+
 # ==================== CPack配置 - MSI安装程序 ====================
-set(CPACK_PACKAGE_NAME "D330Viewer")
+set(CPACK_PACKAGE_NAME "Viewer")
 set(CPACK_PACKAGE_VENDOR "Lorenzo Zhao")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "D330M Depth Camera Control System")
-set(CPACK_PACKAGE_VERSION "0.2.0")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Depth Camera Control System")
+set(CPACK_PACKAGE_VERSION "0.3.3")
 set(CPACK_PACKAGE_VERSION_MAJOR "0")
-set(CPACK_PACKAGE_VERSION_MINOR "2")
-set(CPACK_PACKAGE_VERSION_PATCH "0")
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "D330Viewer")
+set(CPACK_PACKAGE_VERSION_MINOR "3")
+set(CPACK_PACKAGE_VERSION_PATCH "3")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "Viewer")

 # WiX生成器配置（用于MSI）
 set(CPACK_GENERATOR "WIX")
 set(CPACK_WIX_UPGRADE_GUID "42365CB0-5840-487F-A2C8-56F9699A9022")
-set(CPACK_WIX_PROGRAM_MENU_FOLDER "D330Viewer")
+set(CPACK_WIX_PROGRAM_MENU_FOLDER "Viewer")
 set(CPACK_WIX_LICENSE_RTF "${CMAKE_SOURCE_DIR}/LICENSE.rtf")

 # 创建开始菜单和桌面快捷方式
-set(CPACK_PACKAGE_EXECUTABLES "D330Viewer" "D330Viewer")
-set(CPACK_CREATE_DESKTOP_LINKS "D330Viewer")
+set(CPACK_PACKAGE_EXECUTABLES "Viewer" "Viewer")
+set(CPACK_CREATE_DESKTOP_LINKS "Viewer")

 # 包含CPack模块
 include(CPack)
--- a/README.md
+++ b/README.md
@@ -149,6 +149,7 @@ C:\Program Files\D330Viewer\
 - ✅ 自动设备扫描和发现
 - ✅ 相机连接管理（连接/断开）
 - ✅ 命令发送（START/STOP）
+- ✅ 下位机动态切换IP，可随时切换上位机

 #### 可视化
 - ✅ 实时左红外、右红外相机图像显示
@@ -167,19 +168,64 @@ C:\Program Files\D330Viewer\
 - ✅ 网络配置（IP地址、端口设置）
 - ✅ 连接状态指示
 - ✅ 配置持久化（QSettings）
+- ✅ 点云颜色映射（深度着色）
+- ✅ 多视角预设（正视、侧视、俯视）

 ### 🚧 当前开发计划

 根据需求文档和用户反馈，后续待添加功能如下：

 - 录制功能（连续保存多帧）
- 点云颜色映射（深度着色）
 - 点云滤波选项（降噪、平滑）
 - 测量工具（距离、角度测量）
- 多视角预设（正视、侧视、俯视）
 - 性能监控（CPU/GPU使用率、内存使用）
 - 其他相机参数调节（增益、白平衡等）

+## 点云去噪原理与参数说明
+
+### 去噪处理流程（当前版本）
+
+当前点云去噪不是单一滤波器，而是多阶段组合策略，目标是在保留主体结构的同时抑制放射状无效点和外围杂点。
+
+1. 有效点预筛：去掉非有限值和 `z<=0` 的点，得到基础有效掩码。
+2. 中心ROI深度门控：基于中心区域中位深度自适应裁剪深度窗口，先去掉明显离群深度。
+3. 邻域一致性筛选：统计每个点在局部窗口内“深度相近邻居”的数量，邻域支持不足的点剔除。
+4. 形态学轻清理：移除局部孤立残点，减少毛刺。
+5. 近距离尾部裁剪：对低深度尾部进行比例裁剪，抑制中心放射状噪点。
+6. 连通簇筛选：按面积、深度一致性和中心重叠等条件保留主簇及相关簇，抑制周边散簇。
+7. 最终细枝清理：对近距离且邻居不足的细枝点做额外抑制。
+8. 时序稳定：对关键阈值做帧间平滑和限跳，减少块状点云“时有时无”的闪烁。
+
+### 三个参数的作用与范围
+
+参数都在“曝光与拍照 -> 拍照参数 -> 点云去噪参数”中，实时生效。
+
+1. 邻域支持阈值
+- 范围：`3 ~ 12`
+- 含义：一个点要保留，局部邻域内至少需要多少个深度相近邻居。
+- 调大：噪点更少，但边缘和细小结构更容易被吃掉。
+- 调小：细节更多，但散点噪声会增加。
+
+2. 射线裁剪强度 (‰)
+- 范围：`5 ~ 50`
+- 含义：近距离低深度尾部的裁剪比例（千分比）。
+- 调大：中心放射状噪点减少更明显，但近距离真实细节可能减少。
+- 调小：近距离细节保留更多，但放射状点可能增多。
+
+3. 周边抑制带宽 (‰)
+- 范围：`40 ~ 180`
+- 含义：控制连通簇保留深度带宽、回补范围和近距离毛刺门限。
+- 调小：抑制更激进，周边杂点更少，但主体可能偏“硬”、易丢块。
+- 调大：主体与细节更完整，但外围杂点回升概率更高。
+
+### 推荐起始参数
+
+用于室内桌椅等常见场景，可先从以下值起步，再按效果微调：
+
+- 邻域支持阈值：`8 ~ 10`
+- 射线裁剪强度：`12 ~ 18`
+- 周边抑制带宽：`90 ~ 130`
+
 ## 项目结构

 ```
@@ -283,4 +329,4 @@ d330viewer/
 - 使用Qt6信号槽机制进行模块间通信
 - OpenCL kernel代码内联在C++源文件中
 - 配置使用QSettings持久化
- 日志输出到 `bin/d330viewer.log`
+- 日志输出到 `%LOCALAPPDATA%/Viewer/Viewer/viewer.log`（例如 `C:/Users/<用户名>/AppData/Local/Viewer/Viewer/viewer.log`）
--- a/cmos0/KK.txt
+++ b/cmos0/KK.txt
@@ -0,0 +1,3 @@
+   1.4328957e+03   0.0000000e+00   6.3751170e+02
+   0.0000000e+00   1.4326590e+03   5.2187200e+02
+   0.0000000e+00   0.0000000e+00   1.0000000e+00
--- a/cmos0/coe.txt
+++ b/cmos0/coe.txt
--- a/cmos0/kc.txt
+++ b/cmos0/kc.txt
@@ -0,0 +1,5 @@
+  -1.2009005e-01
+   1.1928703e-01
+   9.6197371e-05
+  -1.4896083e-04
+   0.0000000e+00
--- a/configure.bat
+++ b/configure.bat
@@ -4,7 +4,7 @@ REM CMake配置脚本 - Windows版本
 REM 请根据实际安装路径修改以下变量

 echo ========================================
-echo D330Viewer CMake配置脚本
+echo Viewer CMake配置脚本
 echo ========================================
 echo.

@@ -47,7 +47,7 @@ if %ERRORLEVEL% EQU 0 (
    echo ========================================
    echo.
    echo 下一步：
-    echo 1. 打开 build\D330Viewer.sln 使用Visual Studio编译
+    echo 1. 打开 build\Viewer.sln 使用Visual Studio编译
    echo 2. 或运行: cmake --build build --config Release
    echo.
 ) else (
--- a/include/core/GVSPParser.h
+++ b/include/core/GVSPParser.h
@@ -22,11 +22,15 @@
 #define PIXEL_FORMAT_MONO16      0x01100005  // Mono16 format (legacy)
 #define PIXEL_FORMAT_MONO16_LEFT 0x01100006  // Mono16 format for left IR camera
 #define PIXEL_FORMAT_MONO16_RIGHT 0x01100007 // Mono16 format for right IR camera
+#define PIXEL_FORMAT_MONO8_LEFT  0x01080006  // Mono8 format for left IR camera (downsampled)
+#define PIXEL_FORMAT_MONO8_RIGHT 0x01080007  // Mono8 format for right IR camera (downsampled)
 #define PIXEL_FORMAT_MJPEG       0x02180001  // MJPEG format for RGB camera

 // Image dimensions
 #define IMAGE_WIDTH  1224
 #define IMAGE_HEIGHT 1024
+#define IR_DISPLAY_WIDTH  612   // Downsampled IR display width
+#define IR_DISPLAY_HEIGHT 512   // Downsampled IR display height
 #define RGB_WIDTH    1920
 #define RGB_HEIGHT   1080

--- a/include/core/PointCloudProcessor.h
+++ b/include/core/PointCloudProcessor.h
@@ -1,8 +1,10 @@
-#ifndef POINTCLOUDPROCESSOR_H
+#ifndef POINTCLOUDPROCESSOR_H
 #define POINTCLOUDPROCESSOR_H

 #include <QObject>
 #include <QByteArray>
+#include <atomic>
+#include <mutex>
 #include <pcl/point_cloud.h>
 #include <pcl/point_types.h>
 #include <CL/cl.h>
@@ -15,44 +17,38 @@ public:
    explicit PointCloudProcessor(QObject *parent = nullptr);
    ~PointCloudProcessor();

-    // 初始化OpenCL
    bool initializeOpenCL();
-
-    // 设置相机内参
    void setCameraIntrinsics(float fx, float fy, float cx, float cy);
-
-    // 设置Z缩放因子
    void setZScaleFactor(float scale);

-    // 将深度数据转换为点云（使用OpenCL GPU加速）
    void processDepthData(const QByteArray &depthData, uint32_t blockId);
-
-    // 处理已经计算好的点云数据（x,y,z格式）
    void processPointCloudData(const QByteArray &cloudData, uint32_t blockId);

+    void setDenoiseEnabled(bool enabled);
+    void setDenoiseNeighborSupport(int minNeighbors);
+    void setDenoiseLowTailPermille(int permille);
+    void setDenoiseDepthBandPermille(int permille);
+
 signals:
    void pointCloudReady(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, uint32_t blockId);
    void errorOccurred(const QString &error);

 private:
-    // 清理OpenCL资源
+    pcl::PointCloud<pcl::PointXYZ>::Ptr applyDenoise(const pcl::PointCloud<pcl::PointXYZ>::Ptr &input);
+    void loadLowerCalibration();
    void cleanupOpenCL();

-    // 相机内参
    float m_fx;
    float m_fy;
    float m_cx;
    float m_cy;

-    // Z缩放因子
    float m_zScale;

-    // 图像尺寸
    int m_imageWidth;
    int m_imageHeight;
    int m_totalPoints;

-    // OpenCL资源
    cl_platform_id m_platform;
    cl_device_id m_device;
    cl_context m_context;
@@ -62,6 +58,30 @@ private:
    cl_mem m_depthBuffer;
    cl_mem m_xyzBuffer;
    bool m_clInitialized;
+
+    std::atomic_bool m_denoiseEnabled;
+    float m_voxelLeafSize;
+    std::atomic_int m_denoiseNeighborSupport;
+    std::atomic_int m_denoiseLowTailPermille;
+    std::atomic_int m_denoiseDepthBandPermille;
+
+    // Calibration params aligned with lower-machine model
+    float m_k1;
+    float m_k2;
+    float m_p1;
+    float m_p2;
+    float m_p5;
+    float m_p6;
+    float m_p7;
+    float m_p8;
+    bool m_hasLowerCalibration;
+
+    // Temporal stabilizers for denoise to reduce frame-to-frame flicker.
+    std::mutex m_denoiseStateMutex;
+    bool m_hasAnchorMeanZ;
+    float m_anchorMeanZFiltered;
+    bool m_hasLowCutZ;
+    float m_lowCutZFiltered;
 };

 #endif // POINTCLOUDPROCESSOR_H
--- a/include/gui/PointCloudGLWidget.h
+++ b/include/gui/PointCloudGLWidget.h
@@ -23,6 +23,9 @@ public:
    ~PointCloudGLWidget();

    void updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud);
+    void setColorMode(bool enabled) { m_colorMode = enabled ? 1 : 0; update(); }
+    bool colorMode() const { return m_colorMode != 0; }
+    void resetView();  // 重置视角到初始状态

 protected:
    void initializeGL() override;
@@ -48,25 +51,31 @@ private:
    // 点云数据
    std::vector<float> m_vertices;
    int m_pointCount;
-
-    // 固定的点云中心点（避免抖动）
-    QVector3D m_fixedCenter;
-    bool m_centerInitialized;
+    float m_minZ, m_maxZ;  // 深度范围（用于着色）

    // 相机参数
    QMatrix4x4 m_projection;
    QMatrix4x4 m_view;
    QMatrix4x4 m_model;

-    float m_orthoSize;     // 正交投影视野大小（控制缩放）
+    float m_fov;           // 透视投影视场角
    float m_rotationX;     // X轴旋转角度
    float m_rotationY;     // Y轴旋转角度
-    QVector3D m_translation; // 平移
+    QVector3D m_cloudCenter;  // 点云中心
+    float m_viewDistance;     // 观察距离
+    QVector3D m_panOffset;    // 用户平移偏移
+    float m_zoom;          // 缩放因子

    // 鼠标交互状态
    QPoint m_lastMousePos;
    bool m_leftButtonPressed;
    bool m_rightButtonPressed;
+
+    // 首帧标志（只在首帧时自动居中）
+    bool m_firstFrame;
+
+    // 颜色模式（0=黑白，1=彩色）
+    int m_colorMode;
 };

 #endif // POINTCLOUDGLWIDGET_H
--- a/include/gui/PointCloudWidget.h
+++ b/include/gui/PointCloudWidget.h
@@ -19,6 +19,10 @@ public:
    // 更新点云显示
    void updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud);

+    // 颜色模式控制
+    void setColorMode(bool enabled);
+    bool colorMode() const;
+
 private:
    QLabel *m_statusLabel;
    PointCloudGLWidget *m_glWidget;
--- a/src/config/ConfigManager.cpp
+++ b/src/config/ConfigManager.cpp
@@ -1,7 +1,7 @@
 #include "config/ConfigManager.h"

 ConfigManager::ConfigManager()
-    : m_settings(std::make_unique<QSettings>("D330Viewer", "D330Viewer"))
+    : m_settings(std::make_unique<QSettings>("Viewer", "Viewer"))
 {
    // 构造函数：初始化QSettings
 }
@@ -45,7 +45,7 @@ void ConfigManager::setDataPort(int port)
 // ========== 相机配置 ==========
 int ConfigManager::getExposureTime() const
 {
-    return m_settings->value("Camera/ExposureTime", 10000).toInt();
+    return m_settings->value("Camera/ExposureTime", 5980).toInt();
 }

 void ConfigManager::setExposureTime(int exposure)
--- a/src/core/DeviceScanner.cpp
+++ b/src/core/DeviceScanner.cpp
@@ -1,6 +1,8 @@
 #include "DeviceScanner.h"
 #include <QNetworkDatagram>
 #include <QNetworkInterface>
+#include <QCoreApplication>
+#include <QThread>
 #include <QDebug>

 DeviceScanner::DeviceScanner(QObject *parent)
@@ -8,8 +10,9 @@ DeviceScanner::DeviceScanner(QObject *parent)
    , m_socket(new QUdpSocket(this))
    , m_timeoutTimer(new QTimer(this))
    , m_scanTimer(new QTimer(this))
-    , m_currentHost(HOST_START)
-    , m_totalHosts(HOST_END - HOST_START + 1)
+    , m_prefixLength(24)
+    , m_currentHost(0)
+    , m_totalHosts(0)
    , m_isScanning(false)
 {
    connect(m_socket, &QUdpSocket::readyRead, this, &DeviceScanner::onReadyRead);
@@ -33,8 +36,9 @@ void DeviceScanner::startScan(const QString &subnet)
        return;
    }

-    m_subnet = subnet.isEmpty() ? getLocalSubnet() : subnet;
-    m_currentHost = HOST_START;
+    // Get network info (base IP and prefix length)
+    getLocalNetworkInfo(m_baseIp, m_prefixLength);
+
    m_foundDevices.clear();
    m_isScanning = true;

@@ -44,17 +48,62 @@ void DeviceScanner::startScan(const QString &subnet)
        return;
    }

-    qDebug() << "Starting fast device scan on subnet:" << m_subnet;
-
-    // Send DISCOVER to all hosts at once (batch mode)
-    for (int host = HOST_START; host <= HOST_END; host++) {
-        QString ip = m_subnet + "." + QString::number(host);
-        sendDiscoveryPacket(ip);
+    // Calculate IP range based on prefix length
+    QStringList parts = m_baseIp.split('.');
+    if (parts.size() != 4) {
+        emit scanError("Invalid base IP");
+        m_isScanning = false;
+        return;
    }

-    // Wait 3 seconds for all responses
-    m_timeoutTimer->start(3000);
-    qDebug() << "Sent discovery packets to all hosts, waiting for responses...";
+    quint32 baseAddr = (parts[0].toUInt() << 24) | (parts[1].toUInt() << 16) |
+                       (parts[2].toUInt() << 8) | parts[3].toUInt();
+    quint32 mask = (0xFFFFFFFF << (32 - m_prefixLength)) & 0xFFFFFFFF;
+    quint32 networkAddr = baseAddr & mask;
+    quint32 broadcastAddr = networkAddr | (~mask & 0xFFFFFFFF);
+
+    qDebug() << "Starting device scan - Base IP:" << m_baseIp << "Prefix:" << m_prefixLength;
+
+    int packetsSent = 0;
+
+    // For large subnets (/16 or larger), use broadcast + batched unicast
+    if (m_prefixLength <= 16) {
+        // First: send to subnet broadcast address
+        QHostAddress broadcast(broadcastAddr);
+        qDebug() << "Large subnet detected, using broadcast discovery:" << broadcast.toString();
+        sendDiscoveryPacket(broadcast.toString());
+        packetsSent++;
+
+        // Second: scan all /24 subnets with throttling to avoid buffer overflow
+        qDebug() << "Scanning all /24 subnets within /16 range (throttled)...";
+        for (int oct3 = 0; oct3 <= 255; oct3++) {
+            quint32 subNetBase = (networkAddr & 0xFFFF0000) | (oct3 << 8);
+            for (int oct4 = 1; oct4 <= 254; oct4++) {
+                quint32 addr = subNetBase | oct4;
+                sendDiscoveryPacket(QHostAddress(addr).toString());
+                packetsSent++;
+            }
+            // Process events and add small delay every /24 subnet to avoid buffer overflow
+            QCoreApplication::processEvents();
+            QThread::msleep(5);
+        }
+    } else {
+        // For smaller subnets, scan all hosts
+        qDebug() << "Network range:" << QHostAddress(networkAddr + 1).toString()
+                 << "to" << QHostAddress(broadcastAddr - 1).toString();
+
+        for (quint32 addr = networkAddr + 1; addr < broadcastAddr; addr++) {
+            sendDiscoveryPacket(QHostAddress(addr).toString());
+            packetsSent++;
+        }
+    }
+
+    m_totalHosts = packetsSent;
+    qDebug() << "Sent" << packetsSent << "discovery packets, waiting for responses...";
+
+    // Adjust timeout based on network size
+    int timeout = (m_prefixLength >= 24) ? 3000 : 10000;
+    m_timeoutTimer->start(timeout);
 }

 void DeviceScanner::stopScan()
@@ -91,10 +140,17 @@ void DeviceScanner::onReadyRead()

        qDebug() << "Received response from" << senderIp << ":" << response;

-        if (response.contains("D330M_CAMERA")) {
+        if (response.startsWith("EXPOSURE:")) {
+            bool ok;
+            int exposure = response.mid(9).trimmed().toInt(&ok);
+            if (ok && exposure > 0) {
+                qDebug() << "Received exposure from camera:" << exposure << "us";
+                emit exposureReceived(exposure);
+            }
+        } else if (response.contains("D330M_CAMERA")) {
            DeviceInfo device;
            device.ipAddress = senderIp;
-            device.deviceName = "D330M Camera";
+            device.deviceName = "Camera";
            device.port = SCAN_PORT;
            device.responseTime = 0;

@@ -122,7 +178,7 @@ void DeviceScanner::sendDiscoveryPacket(const QString &ip)
    m_socket->writeDatagram(data, QHostAddress(ip), SCAN_PORT);
 }

-QString DeviceScanner::getLocalSubnet()
+void DeviceScanner::getLocalNetworkInfo(QString &baseIp, int &prefixLength)
 {
    // Get all network interfaces
    QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
@@ -144,12 +200,14 @@ QString DeviceScanner::getLocalSubnet()
            for (const QNetworkAddressEntry &entry : entries) {
                QHostAddress addr = entry.ip();
                if (addr.protocol() == QAbstractSocket::IPv4Protocol && !addr.isLoopback()) {
-                    QString ip = addr.toString();
-                    QStringList parts = ip.split('.');
-                    if (parts.size() == 4) {
-                        qDebug() << "Found Ethernet adapter:" << iface.humanReadableName() << "IP:" << ip;
-                        return parts[0] + "." + parts[1] + "." + parts[2];
+                    baseIp = addr.toString();
+                    prefixLength = entry.prefixLength();
+                    if (prefixLength <= 0 || prefixLength > 32) {
+                        prefixLength = 24;  // Default to /24 if invalid
                    }
+                    qDebug() << "Found Ethernet adapter:" << iface.humanReadableName()
+                             << "IP:" << baseIp << "Prefix:" << prefixLength;
+                    return;
                }
            }
        }
@@ -169,15 +227,19 @@ QString DeviceScanner::getLocalSubnet()
        for (const QNetworkAddressEntry &entry : entries) {
            QHostAddress addr = entry.ip();
            if (addr.protocol() == QAbstractSocket::IPv4Protocol && !addr.isLoopback()) {
-                QString ip = addr.toString();
-                QStringList parts = ip.split('.');
-                if (parts.size() == 4) {
-                    qDebug() << "Found adapter:" << iface.humanReadableName() << "IP:" << ip;
-                    return parts[0] + "." + parts[1] + "." + parts[2];
+                baseIp = addr.toString();
+                prefixLength = entry.prefixLength();
+                if (prefixLength <= 0 || prefixLength > 32) {
+                    prefixLength = 24;
                }
+                qDebug() << "Found adapter:" << iface.humanReadableName()
+                         << "IP:" << baseIp << "Prefix:" << prefixLength;
+                return;
            }
        }
    }

-    return "192.168.0";
+    // Default fallback
+    baseIp = "192.168.0.1";
+    prefixLength = 24;
 }
--- a/src/core/DeviceScanner.h
+++ b/src/core/DeviceScanner.h
@@ -29,6 +29,7 @@ public:

 signals:
    void deviceFound(const DeviceInfo &device);
+    void exposureReceived(int exposureUs);
    void scanProgress(int current, int total);
    void scanFinished(int devicesFound);
    void scanError(const QString &error);
@@ -40,13 +41,14 @@ private slots:

 private:
    void sendDiscoveryPacket(const QString &ip);
-    QString getLocalSubnet();
+    void getLocalNetworkInfo(QString &baseIp, int &prefixLength);

    QUdpSocket *m_socket;
    QTimer *m_timeoutTimer;
    QTimer *m_scanTimer;

-    QString m_subnet;
+    QString m_baseIp;
+    int m_prefixLength;
    int m_currentHost;
    int m_totalHosts;
    bool m_isScanning;
@@ -55,8 +57,6 @@ private:

    static constexpr int SCAN_PORT = 6790;  // Control port for device discovery
    static constexpr int SCAN_TIMEOUT = 10;
-    static constexpr int HOST_START = 1;
-    static constexpr int HOST_END = 254;
 };

 #endif // DEVICESCANNER_H
--- a/src/core/GVSPParser.cpp
+++ b/src/core/GVSPParser.cpp
@@ -96,9 +96,9 @@ void GVSPParser::handleLeaderPacket(const uint8_t *data, size_t size)

        // 根据像素格式选择对应的状态
        StreamState *state = nullptr;
-        if (pixelFormat == PIXEL_FORMAT_MONO16_LEFT) {
+        if (pixelFormat == PIXEL_FORMAT_MONO16_LEFT || pixelFormat == PIXEL_FORMAT_MONO8_LEFT) {
            state = &m_leftIRState;
-        } else if (pixelFormat == PIXEL_FORMAT_MONO16_RIGHT) {
+        } else if (pixelFormat == PIXEL_FORMAT_MONO16_RIGHT || pixelFormat == PIXEL_FORMAT_MONO8_RIGHT) {
            state = &m_rightIRState;
        } else if (pixelFormat == PIXEL_FORMAT_MJPEG) {
            state = &m_rgbState;
@@ -118,6 +118,9 @@ void GVSPParser::handleLeaderPacket(const uint8_t *data, size_t size)
            if (pixelFormat == PIXEL_FORMAT_MJPEG) {
                // MJPEG是压缩格式，实际大小未知，设置为0表示动态接收
                state->expectedSize = 0;
+            } else if (pixelFormat == PIXEL_FORMAT_MONO8_LEFT || pixelFormat == PIXEL_FORMAT_MONO8_RIGHT) {
+                // 8-bit灰度格式（下采样）
+                state->expectedSize = imageWidth * imageHeight;
            } else {
                // 16-bit或12-bit灰度等固定格式
                state->expectedSize = imageWidth * imageHeight * 2;
@@ -268,6 +271,29 @@ void GVSPParser::processImageData(GVSPParser::StreamState *state)
        return;
    }

+    // 处理Mono8格式（左右红外相机下采样8位数据）
+    if (state->pixelFormat == PIXEL_FORMAT_MONO8_LEFT) {
+        // 检查数据大小
+        if (state->dataBuffer.size() < state->expectedSize) {
+            return;
+        }
+        // 左红外8位数据
+        emit leftImageReceived(state->dataBuffer, state->blockId);
+        m_imageSequence++;
+        return;
+    }
+
+    if (state->pixelFormat == PIXEL_FORMAT_MONO8_RIGHT) {
+        // 检查数据大小
+        if (state->dataBuffer.size() < state->expectedSize) {
+            return;
+        }
+        // 右红外8位数据
+        emit rightImageReceived(state->dataBuffer, state->blockId);
+        m_imageSequence++;
+        return;
+    }
+
    // 兼容旧版本：使用序号区分（legacy）
    if (state->pixelFormat == PIXEL_FORMAT_MONO16) {
        // 检查数据大小
--- a/src/core/NetworkManager.cpp
+++ b/src/core/NetworkManager.cpp
@@ -16,6 +16,9 @@ NetworkManager::NetworkManager(QObject *parent)
    connect(m_dataSocket, &QUdpSocket::readyRead, this, &NetworkManager::onReadyRead);
    connect(m_dataSocket, &QUdpSocket::errorOccurred, this, &NetworkManager::onError);

+    // 连接控制socket接收信号（用于接收相机回复，如曝光值）
+    connect(m_controlSocket, &QUdpSocket::readyRead, this, &NetworkManager::onControlReadyRead);
+
    // 连接GVSP解析器信号
    connect(m_gvspParser, &GVSPParser::imageReceived, this, &NetworkManager::imageReceived);
    connect(m_gvspParser, &GVSPParser::leftImageReceived, this, &NetworkManager::leftImageReceived);
@@ -38,7 +41,7 @@ bool NetworkManager::connectToCamera(const QString &ip, int controlPort, int dat
    m_dataPort = dataPort;

    // 绑定控制Socket到任意端口（让系统自动分配）
-    if (!m_controlSocket->bind(QHostAddress::Any, 0)) {
+    if(!m_controlSocket->bind(QHostAddress::Any, 0)) {
        QString error = QString("Failed to bind control socket: %1")
                            .arg(m_controlSocket->errorString());
        qDebug() << error;
@@ -48,7 +51,7 @@ bool NetworkManager::connectToCamera(const QString &ip, int controlPort, int dat
    qDebug() << "Successfully bound control socket to port" << m_controlSocket->localPort();

    // 绑定数据接收端口
-    if (!m_dataSocket->bind(QHostAddress::Any, m_dataPort)) {
+    if(!m_dataSocket->bind(QHostAddress::Any, m_dataPort)) {
        QString error = QString("Failed to bind data port %1: %2")
                            .arg(m_dataPort)
                            .arg(m_dataSocket->errorString());
@@ -67,6 +70,10 @@ bool NetworkManager::connectToCamera(const QString &ip, int controlPort, int dat
    m_isConnected = true;
    qDebug() << "Connected to camera:" << m_cameraIp << "Control port:" << m_controlPort << "Data port:" << m_dataPort;

+    // Send DISCOVER to get camera's current exposure value
+    sendCommand("DISCOVER");
+    qDebug() << "Sent DISCOVER to fetch camera exposure";
+
    // Send STOP command to register client IP on camera
    sendStopCommand();
    qDebug() << "Sent STOP command to register client IP";
@@ -77,7 +84,7 @@ bool NetworkManager::connectToCamera(const QString &ip, int controlPort, int dat

 void NetworkManager::disconnectFromCamera()
 {
-    if (m_isConnected) {
+    if(m_isConnected) {
        m_controlSocket->close();
        m_dataSocket->close();
        m_isConnected = false;
@@ -94,7 +101,7 @@ bool NetworkManager::isConnected() const
 // ========== 发送控制命令 ==========
 bool NetworkManager::sendCommand(const QString &command)
 {
-    if (!m_isConnected) {
+    if(!m_isConnected) {
        qDebug() << "Not connected to camera";
        return false;
    }
@@ -109,7 +116,7 @@ bool NetworkManager::sendCommand(const QString &command)
    qint64 sent = m_controlSocket->writeDatagram(data, QHostAddress(m_cameraIp), m_controlPort);

    qDebug() << "writeDatagram returned:" << sent;
-    if (sent == -1) {
+    if(sent == -1) {
        QString error = QString("Failed to send command: %1").arg(m_controlSocket->errorString());
        qDebug() << error;
        qDebug() << "Socket error code:" << m_controlSocket->error();
@@ -134,23 +141,8 @@ bool NetworkManager::sendStopCommand()

 bool NetworkManager::sendExposureCommand(int exposureTime)
 {
-    // 同时发送结构光曝光命令（UART控制激光器，单位μs）
    QString exposureCommand = QString("EXPOSURE:%1").arg(exposureTime);
-    bool success1 = sendCommand(exposureCommand);
-
-    // 同时发送红外相机曝光命令（通过触发脉冲宽度控制，单位μs）
-    // 下位机会将此值用作manual_trigger_pulse()的脉冲宽度参数
-    // 脉冲宽度直接决定相机的实际曝光时间
-    int irExposure = exposureTime;
-
-    // 限制在有效范围内（1000μs ~ 100000μs，避免脉冲太短导致相机无法触发）
-    if (irExposure < 1000) irExposure = 1000;
-    if (irExposure > 100000) irExposure = 100000;
-
-    QString irExposureCommand = QString("IR_EXPOSURE:%1").arg(irExposure);
-    bool success2 = sendCommand(irExposureCommand);
-
-    return success1 && success2;
+    return sendCommand(exposureCommand);
 }

 // ========== 传输开关命令 ==========
@@ -208,7 +200,7 @@ void NetworkManager::onReadyRead()
        m_dataSocket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);

        // 只打印前5个包的详细信息
-        if (packetCount < 5) {
+        if(packetCount < 5) {
    // qDebug() << "[NetworkManager] Packet" << packetCount
    // << "from" << sender.toString() << ":" << senderPort
    // << "size:" << datagram.size() << "bytes";
@@ -223,11 +215,32 @@ void NetworkManager::onReadyRead()
    }

    // 每1000个包打印一次统计（减少日志量）
-    if (packetCount % 1000 == 0) {
+    if(packetCount % 1000 == 0) {
    // qDebug() << "[NetworkManager] Total packets received:" << packetCount;
    }
 }

+void NetworkManager::onControlReadyRead()
+{
+    while (m_controlSocket->hasPendingDatagrams()) {
+        QByteArray datagram;
+        datagram.resize(m_controlSocket->pendingDatagramSize());
+        m_controlSocket->readDatagram(datagram.data(), datagram.size());
+
+        QString response = QString::fromUtf8(datagram);
+        qDebug() << "[NetworkManager] Control response:" << response;
+
+        if (response.startsWith("EXPOSURE:")) {
+            bool ok;
+            int exposure = response.mid(9).trimmed().toInt(&ok);
+            if (ok && exposure > 0) {
+                qDebug() << "[NetworkManager] Camera exposure:" << exposure << "us";
+                emit exposureReceived(exposure);
+            }
+        }
+    }
+}
+
 void NetworkManager::onError(QAbstractSocket::SocketError socketError)
 {
    QString error = QString("Socket error: %1").arg(m_dataSocket->errorString());
--- a/src/core/NetworkManager.h
+++ b/src/core/NetworkManager.h
@@ -43,6 +43,7 @@ public:
 signals:
    void connected();
    void disconnected();
+    void exposureReceived(int exposureUs);
    void errorOccurred(const QString &error);
    void dataReceived(const QByteArray &data);
    void imageReceived(const QImage &image, uint32_t blockId);
@@ -54,6 +55,7 @@ signals:

 private slots:
    void onReadyRead();
+    void onControlReadyRead();
    void onError(QAbstractSocket::SocketError socketError);

 private:
--- a/src/core/PointCloudProcessor.cpp
+++ b/src/core/PointCloudProcessor.cpp
@@ -1,12 +1,93 @@
 #include "core/PointCloudProcessor.h"
 #include <QDebug>
+#include <QCoreApplication>
+#include <QDir>
+#include <QFile>
+#include <QRegularExpression>
+#include <QStringList>
 #include <vector>
 #include <cmath>
+#include <cstdint>
+#include <algorithm>
+#include <unordered_map>
+#include <pcl/common/point_tests.h>

 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif

+namespace {
+struct VoxelKey {
+    int x;
+    int y;
+    int z;
+
+    bool operator==(const VoxelKey &other) const noexcept
+    {
+        return x == other.x && y == other.y && z == other.z;
+    }
+};
+
+struct VoxelKeyHash {
+    size_t operator()(const VoxelKey &k) const noexcept
+    {
+        // FNV-1a hash for 3D integer voxel index.
+        uint64_t h = 1469598103934665603ull;
+        auto mix = [&h](uint64_t v) {
+            h ^= v;
+            h *= 1099511628211ull;
+        };
+        mix(static_cast<uint32_t>(k.x));
+        mix(static_cast<uint32_t>(k.y));
+        mix(static_cast<uint32_t>(k.z));
+        return static_cast<size_t>(h);
+    }
+};
+
+struct VoxelAccum {
+    float sumX = 0.0f;
+    float sumY = 0.0f;
+    float sumZ = 0.0f;
+    uint32_t count = 0;
+};
+
+constexpr int kNeighborOffsets[26][3] = {
+    {-1, -1, -1}, {0, -1, -1}, {1, -1, -1},
+    {-1,  0, -1}, {0,  0, -1}, {1,  0, -1},
+    {-1,  1, -1}, {0,  1, -1}, {1,  1, -1},
+    {-1, -1,  0}, {0, -1,  0}, {1, -1,  0},
+    {-1,  0,  0},               {1,  0,  0},
+    {-1,  1,  0}, {0,  1,  0}, {1,  1,  0},
+    {-1, -1,  1}, {0, -1,  1}, {1, -1,  1},
+    {-1,  0,  1}, {0,  0,  1}, {1,  0,  1},
+    {-1,  1,  1}, {0,  1,  1}, {1,  1,  1}
+};
+
+bool readFloatFile(const QString &path, std::vector<float> &out)
+{
+    QFile file(path);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return false;
+    }
+
+    const QByteArray raw = file.readAll();
+    const QString text = QString::fromUtf8(raw);
+    const QStringList tokens = text.split(QRegularExpression("\\s+"), Qt::SkipEmptyParts);
+    out.clear();
+    out.reserve(tokens.size());
+
+    for (const QString &token : tokens) {
+        bool ok = false;
+        float value = token.toFloat(&ok);
+        if (ok) {
+            out.push_back(value);
+        }
+    }
+
+    return !out.empty();
+}
+} // namespace
+
 PointCloudProcessor::PointCloudProcessor(QObject *parent)
    : QObject(parent)
    , m_fx(1432.8957f)
@@ -26,7 +107,26 @@ PointCloudProcessor::PointCloudProcessor(QObject *parent)
    , m_depthBuffer(nullptr)
    , m_xyzBuffer(nullptr)
    , m_clInitialized(false)
+    , m_denoiseEnabled(false)
+    , m_voxelLeafSize(2.5f)
+    , m_denoiseNeighborSupport(6)
+    , m_denoiseLowTailPermille(15)
+    , m_denoiseDepthBandPermille(80)
+    , m_k1(0.0f)
+    , m_k2(0.0f)
+    , m_p1(0.0f)
+    , m_p2(0.0f)
+    , m_p5(1.0f / 1432.8957f)
+    , m_p6(-637.5117f / 1432.8957f)
+    , m_p7(1.0f / 1432.6590f)
+    , m_p8(-521.8720f / 1432.6590f)
+    , m_hasLowerCalibration(false)
+    , m_hasAnchorMeanZ(false)
+    , m_anchorMeanZFiltered(0.0f)
+    , m_hasLowCutZ(false)
+    , m_lowCutZFiltered(0.0f)
 {
+    loadLowerCalibration();
 }

 PointCloudProcessor::~PointCloudProcessor()
@@ -40,6 +140,14 @@ void PointCloudProcessor::setCameraIntrinsics(float fx, float fy, float cx, floa
    m_fy = fy;
    m_cx = cx;
    m_cy = cy;
+
+    // Keep lower-machine style projection terms in sync when intrinsics are changed at runtime.
+    if (m_fx != 0.0f && m_fy != 0.0f) {
+        m_p5 = 1.0f / m_fx;
+        m_p6 = -m_cx / m_fx;
+        m_p7 = 1.0f / m_fy;
+        m_p8 = -m_cy / m_fy;
+    }
 }

 void PointCloudProcessor::setZScaleFactor(float scale)
@@ -47,6 +155,557 @@ void PointCloudProcessor::setZScaleFactor(float scale)
    m_zScale = scale;
 }

+void PointCloudProcessor::loadLowerCalibration()
+{
+    const QString appDir = QCoreApplication::applicationDirPath();
+    QStringList candidates;
+    candidates
+        << QDir::current().filePath("cmos0")
+        << QDir(appDir).filePath("cmos0")
+        << QDir(appDir).filePath("../cmos0")
+        << QDir(appDir).filePath("../../cmos0");
+
+    for (const QString &dirPath : candidates) {
+        const QString kcPath = QDir(dirPath).filePath("kc.txt");
+        const QString kkPath = QDir(dirPath).filePath("KK.txt");
+        if (!QFile::exists(kcPath) || !QFile::exists(kkPath)) {
+            continue;
+        }
+
+        std::vector<float> kcVals;
+        std::vector<float> kkVals;
+        if (!readFloatFile(kcPath, kcVals) || !readFloatFile(kkPath, kkVals)) {
+            continue;
+        }
+        if (kcVals.size() < 4 || kkVals.size() < 6) {
+            continue;
+        }
+
+        const float fx = kkVals[0];
+        const float cx = kkVals[2];
+        const float fy = kkVals[4];
+        const float cy = kkVals[5];
+        if (fx == 0.0f || fy == 0.0f) {
+            continue;
+        }
+
+        m_k1 = kcVals[0];
+        m_k2 = kcVals[1];
+        m_p1 = kcVals[2];
+        m_p2 = kcVals[3];
+
+        m_fx = fx;
+        m_fy = fy;
+        m_cx = cx;
+        m_cy = cy;
+        m_p5 = 1.0f / fx;
+        m_p6 = -cx / fx;
+        m_p7 = 1.0f / fy;
+        m_p8 = -cy / fy;
+        m_hasLowerCalibration = true;
+
+        qDebug() << "[PointCloud] Loaded lower calibration from" << dirPath
+                 << "kc size:" << static_cast<int>(kcVals.size())
+                 << "KK size:" << static_cast<int>(kkVals.size());
+        return;
+    }
+
+    m_hasLowerCalibration = false;
+    qDebug() << "[PointCloud] lower calibration txt not found, using fallback intrinsics";
+}
+
+void PointCloudProcessor::setDenoiseEnabled(bool enabled)
+{
+    m_denoiseEnabled.store(enabled, std::memory_order_relaxed);
+}
+
+void PointCloudProcessor::setDenoiseNeighborSupport(int minNeighbors)
+{
+    m_denoiseNeighborSupport.store(std::clamp(minNeighbors, 3, 12), std::memory_order_relaxed);
+}
+
+void PointCloudProcessor::setDenoiseLowTailPermille(int permille)
+{
+    m_denoiseLowTailPermille.store(std::clamp(permille, 5, 50), std::memory_order_relaxed);
+}
+
+void PointCloudProcessor::setDenoiseDepthBandPermille(int permille)
+{
+    m_denoiseDepthBandPermille.store(std::clamp(permille, 40, 180), std::memory_order_relaxed);
+}
+
+pcl::PointCloud<pcl::PointXYZ>::Ptr PointCloudProcessor::applyDenoise(
+    const pcl::PointCloud<pcl::PointXYZ>::Ptr &input)
+{
+    if (!input || input->empty()) {
+        return input;
+    }
+
+    const size_t total = input->points.size();
+    const int width = static_cast<int>(input->width);
+    const int height = static_cast<int>(input->height);
+    const int supportMinNeighbors = m_denoiseNeighborSupport.load(std::memory_order_relaxed);
+    const int lowTailPermille = m_denoiseLowTailPermille.load(std::memory_order_relaxed);
+    const int depthBandPermille = m_denoiseDepthBandPermille.load(std::memory_order_relaxed);
+
+    bool hasPrevAnchor = false;
+    float prevAnchorMeanZ = 0.0f;
+    bool hasPrevLowCut = false;
+    float prevLowCutZ = 0.0f;
+    {
+        std::lock_guard<std::mutex> lock(m_denoiseStateMutex);
+        hasPrevAnchor = m_hasAnchorMeanZ;
+        prevAnchorMeanZ = m_anchorMeanZFiltered;
+        hasPrevLowCut = m_hasLowCutZ;
+        prevLowCutZ = m_lowCutZFiltered;
+    }
+    bool anchorUpdated = false;
+    float anchorToStore = 0.0f;
+    bool lowCutUpdated = false;
+    float lowCutToStore = 0.0f;
+
+    // Fallback for unorganized clouds: only remove invalid points.
+    if (width <= 1 || height <= 1 || static_cast<size_t>(width) * static_cast<size_t>(height) != total) {
+        pcl::PointCloud<pcl::PointXYZ>::Ptr validOnly(new pcl::PointCloud<pcl::PointXYZ>());
+        validOnly->points.reserve(total);
+        for (const auto &p : input->points) {
+            if (pcl::isFinite(p) && p.z > 0.0f) {
+                validOnly->points.push_back(p);
+            }
+        }
+        if (validOnly->points.empty()) {
+            return input;
+        }
+        validOnly->width = static_cast<uint32_t>(validOnly->points.size());
+        validOnly->height = 1;
+        validOnly->is_dense = true;
+        return validOnly;
+    }
+
+    const auto idx = [width](int r, int c) -> int { return r * width + c; };
+    std::vector<uint8_t> validMask(total, 0);
+
+    float minZ = std::numeric_limits<float>::max();
+    float maxZ = std::numeric_limits<float>::lowest();
+    int validCount = 0;
+    for (size_t i = 0; i < total; ++i) {
+        const auto &p = input->points[i];
+        if (pcl::isFinite(p) && p.z > 0.0f) {
+            validMask[i] = 1;
+            ++validCount;
+            if (p.z < minZ) minZ = p.z;
+            if (p.z > maxZ) maxZ = p.z;
+        }
+    }
+
+    if (validCount < 1200) {
+        return input;
+    }
+
+    // Pass 0: adaptive conditional depth gate (inspired by ConditionalRemoval/CropBox idea).
+    // Use center ROI median depth as reference, then keep a dynamic depth band.
+    const float spanZ = std::max(0.0f, maxZ - minZ);
+    int gatedCount = validCount;
+    if (spanZ > 1e-3f) {
+        const int r0 = static_cast<int>(height * 0.35f);
+        const int r1 = static_cast<int>(height * 0.75f);
+        const int c0 = static_cast<int>(width * 0.35f);
+        const int c1 = static_cast<int>(width * 0.65f);
+
+        std::vector<float> centerZ;
+        centerZ.reserve(static_cast<size_t>((r1 - r0) * (c1 - c0)));
+        for (int r = r0; r < r1; ++r) {
+            for (int c = c0; c < c1; ++c) {
+                const int i = idx(r, c);
+                if (validMask[i]) {
+                    centerZ.push_back(input->points[i].z);
+                }
+            }
+        }
+
+        if (centerZ.size() > 800) {
+            const size_t mid = centerZ.size() / 2;
+            std::nth_element(centerZ.begin(), centerZ.begin() + mid, centerZ.end());
+            const float zRef = centerZ[mid];
+
+            const float zNear = std::max(minZ, zRef - std::max(80.0f, spanZ * 0.08f));
+            const float zFar = std::min(maxZ, zRef + std::max(250.0f, spanZ * 0.22f));
+
+            gatedCount = 0;
+            for (size_t i = 0; i < total; ++i) {
+                if (!validMask[i]) {
+                    continue;
+                }
+                const float z = input->points[i].z;
+                if (z < zNear || z > zFar) {
+                    validMask[i] = 0;
+                } else {
+                    ++gatedCount;
+                }
+            }
+
+            // If gate is too aggressive, rollback.
+            if (gatedCount < 2000) {
+                std::fill(validMask.begin(), validMask.end(), 0);
+                gatedCount = 0;
+                for (size_t i = 0; i < total; ++i) {
+                    const auto &p = input->points[i];
+                    if (pcl::isFinite(p) && p.z > 0.0f) {
+                        validMask[i] = 1;
+                        ++gatedCount;
+                    }
+                }
+            }
+        }
+    }
+
+    // Pass 1: local depth-consistency support in 3x3 neighborhood.
+    // This suppresses thin ray artifacts while preserving contiguous surfaces.
+    std::vector<uint8_t> supportMask(total, 0);
+    int supportCount = 0;
+
+    for (int r = 2; r < height - 2; ++r) {
+        for (int c = 2; c < width - 2; ++c) {
+            const int center = idx(r, c);
+            if (!validMask[center]) {
+                continue;
+            }
+
+            const float z = input->points[center].z;
+            const float dzThreshold = std::max(12.0f, z * 0.015f);
+
+            int neighbors = 0;
+            for (int rr = -2; rr <= 2; ++rr) {
+                for (int cc = -2; cc <= 2; ++cc) {
+                    if (rr == 0 && cc == 0) {
+                        continue;
+                    }
+                    const int ni = idx(r + rr, c + cc);
+                    if (!validMask[ni]) {
+                        continue;
+                    }
+                    if (std::fabs(input->points[ni].z - z) <= dzThreshold) {
+                        ++neighbors;
+                    }
+                }
+            }
+
+            if (neighbors >= supportMinNeighbors) {
+                supportMask[center] = 1;
+                ++supportCount;
+            }
+        }
+    }
+
+    if (supportCount < 1500) {
+        return input;
+    }
+
+    // Pass 1.5: one morphology-like cleanup to remove sparse remnants.
+    std::vector<uint8_t> cleanMask = supportMask;
+    int cleanCount = 0;
+    for (int r = 1; r < height - 1; ++r) {
+        for (int c = 1; c < width - 1; ++c) {
+            const int center = idx(r, c);
+            if (!supportMask[center]) {
+                continue;
+            }
+            int kept = 0;
+            for (int rr = -1; rr <= 1; ++rr) {
+                for (int cc = -1; cc <= 1; ++cc) {
+                    if (rr == 0 && cc == 0) {
+                        continue;
+                    }
+                    if (supportMask[idx(r + rr, c + cc)]) {
+                        ++kept;
+                    }
+                }
+            }
+            if (kept < 2) {
+                cleanMask[center] = 0;
+            }
+            if (cleanMask[center]) {
+                ++cleanCount;
+            }
+        }
+    }
+    if (cleanCount >= 1500) {
+        supportMask.swap(cleanMask);
+        supportCount = cleanCount;
+    }
+
+    // Pass 2: clip the near-camera low-depth tail to suppress center-radiating streaks.
+    std::vector<uint8_t> finalMask = supportMask;
+    if (spanZ > 1e-3f) {
+        constexpr int kBins = 256;
+        std::vector<int> hist(kBins, 0);
+        for (size_t i = 0; i < total; ++i) {
+            if (!supportMask[i]) {
+                continue;
+            }
+            const float z = input->points[i].z;
+            int b = static_cast<int>((z - minZ) / spanZ * static_cast<float>(kBins - 1));
+            b = std::clamp(b, 0, kBins - 1);
+            ++hist[b];
+        }
+
+        const int lowTailTarget = std::max(120, static_cast<int>(supportCount * (static_cast<float>(lowTailPermille) / 1000.0f)));
+        int accum = 0;
+        int lowBin = 0;
+        for (int b = 0; b < kBins; ++b) {
+            accum += hist[b];
+            if (accum >= lowTailTarget) {
+                lowBin = b;
+                break;
+            }
+        }
+        const float rawLowCut = minZ + spanZ * (static_cast<float>(lowBin) / static_cast<float>(kBins - 1));
+        float zLowCut = rawLowCut;
+        if (hasPrevLowCut) {
+            const float maxJump = std::max(120.0f, spanZ * 0.10f);
+            const float clamped = std::clamp(rawLowCut, prevLowCutZ - maxJump, prevLowCutZ + maxJump);
+            zLowCut = prevLowCutZ * 0.65f + clamped * 0.35f;
+        }
+        lowCutUpdated = true;
+        lowCutToStore = zLowCut;
+
+        int finalCount = 0;
+        for (size_t i = 0; i < total; ++i) {
+            if (finalMask[i] && input->points[i].z < zLowCut) {
+                finalMask[i] = 0;
+            }
+            if (finalMask[i]) {
+                ++finalCount;
+            }
+        }
+
+        if (finalCount < 1200) {
+            finalMask = supportMask;
+        }
+    }
+
+    // Pass 2.5: 2D connected components + foreground-priority keep.
+    // This suppresses surrounding residual blobs while preserving the near main object.
+    struct ComponentStat {
+        std::vector<int> pixels;
+        int area = 0;
+        float zSum = 0.0f;
+        int centerOverlap = 0;
+    };
+
+    const int centerR0 = static_cast<int>(height * 0.35f);
+    const int centerR1 = static_cast<int>(height * 0.75f);
+    const int centerC0 = static_cast<int>(width * 0.35f);
+    const int centerC1 = static_cast<int>(width * 0.65f);
+
+    std::vector<uint8_t> visited(total, 0);
+    std::vector<ComponentStat> comps;
+    comps.reserve(32);
+
+    std::vector<int> queue;
+    queue.reserve(4096);
+    constexpr int cdr[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
+    constexpr int cdc[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
+
+    for (int r = 0; r < height; ++r) {
+        for (int c = 0; c < width; ++c) {
+            const int seed = idx(r, c);
+            if (!finalMask[seed] || visited[seed]) {
+                continue;
+            }
+
+            ComponentStat comp;
+            queue.clear();
+            queue.push_back(seed);
+            visited[seed] = 1;
+
+            for (size_t head = 0; head < queue.size(); ++head) {
+                const int cur = queue[head];
+                const int rr = cur / width;
+                const int cc = cur % width;
+
+                comp.pixels.push_back(cur);
+                comp.area += 1;
+                comp.zSum += input->points[cur].z;
+                if (rr >= centerR0 && rr < centerR1 && cc >= centerC0 && cc < centerC1) {
+                    comp.centerOverlap += 1;
+                }
+
+                for (int k = 0; k < 8; ++k) {
+                    const int nr = rr + cdr[k];
+                    const int nc = cc + cdc[k];
+                    if (nr < 0 || nr >= height || nc < 0 || nc >= width) {
+                        continue;
+                    }
+                    const int ni = idx(nr, nc);
+                    if (!finalMask[ni] || visited[ni]) {
+                        continue;
+                    }
+                    visited[ni] = 1;
+                    queue.push_back(ni);
+                }
+            }
+
+            comps.push_back(std::move(comp));
+        }
+    }
+
+    if (!comps.empty()) {
+        int anchor = -1;
+        float anchorMeanZ = std::numeric_limits<float>::max();
+        int anchorArea = 0;
+        float bestScore = -std::numeric_limits<float>::max();
+        const float temporalBand = std::max(120.0f, spanZ * 0.10f);
+
+        // Stable anchor selection with temporal bias to reduce frame-to-frame jumping.
+        for (int i = 0; i < static_cast<int>(comps.size()); ++i) {
+            const auto &cp = comps[i];
+            if (cp.area < 300) {
+                continue;
+            }
+            const float meanZ = cp.zSum / static_cast<float>(cp.area);
+            float score = static_cast<float>(cp.centerOverlap) * 6.0f
+                        + static_cast<float>(std::min(cp.area, 12000)) * 0.25f;
+            if (hasPrevAnchor) {
+                const float dz = std::fabs(meanZ - prevAnchorMeanZ);
+                score -= dz * 0.35f;
+                if (dz <= temporalBand) {
+                    score += 1200.0f;
+                }
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                anchor = i;
+                anchorMeanZ = meanZ;
+                anchorArea = cp.area;
+            }
+        }
+
+        if (anchor >= 0) {
+            float stableAnchorMeanZ = anchorMeanZ;
+            if (hasPrevAnchor) {
+                const float maxJump = std::max(180.0f, spanZ * 0.15f);
+                const float clamped = std::clamp(anchorMeanZ, prevAnchorMeanZ - maxJump, prevAnchorMeanZ + maxJump);
+                stableAnchorMeanZ = prevAnchorMeanZ * 0.60f + clamped * 0.40f;
+            }
+            anchorUpdated = true;
+            anchorToStore = stableAnchorMeanZ;
+
+            std::vector<uint8_t> ccMask(total, 0);
+            int kept = 0;
+            // Make depth-band slider more perceptible: 40 -> tight (strong suppression), 180 -> loose.
+            const float bandT = std::clamp((static_cast<float>(depthBandPermille) - 40.0f) / 140.0f, 0.0f, 1.0f);
+            const float zKeepBandFloor = 90.0f + 260.0f * bandT;
+            const float zKeepBandSpanFactor = 0.03f + 0.19f * bandT;
+            const float zKeepBandBase = std::max(zKeepBandFloor, spanZ * zKeepBandSpanFactor);
+            const float zKeepBand = hasPrevAnchor
+                ? (zKeepBandBase * (1.15f + 0.35f * bandT))
+                : (zKeepBandBase * (1.00f + 0.25f * bandT));
+            const float minKeepAreaRatio = 0.035f - 0.020f * bandT;
+            const int minKeepArea = std::max(60, static_cast<int>(anchorArea * minKeepAreaRatio));
+
+            for (const auto &cp : comps) {
+                if (cp.area < minKeepArea) {
+                    continue;
+                }
+                const float meanZ = cp.zSum / static_cast<float>(cp.area);
+                const float overlapBonus = (cp.centerOverlap > 0) ? (zKeepBand * 0.45f) : 0.0f;
+                if (meanZ > stableAnchorMeanZ + zKeepBand + overlapBonus) {
+                    continue;
+                }
+                for (int p : cp.pixels) {
+                    ccMask[p] = 1;
+                    ++kept;
+                }
+            }
+
+            // Apply when preserving a reasonable part of support mask to avoid frame jumps.
+            const float minStableRatio = 0.18f - 0.10f * bandT;
+            const int minStableKeep = std::max(1000, static_cast<int>(supportCount * minStableRatio));
+            if (kept >= minStableKeep) {
+                // Soft fallback: keep previously accepted support points that are depth-consistent.
+                const float softKeepFar = stableAnchorMeanZ + zKeepBand * (1.20f + 1.60f * bandT);
+                for (size_t i = 0; i < total; ++i) {
+                    if (finalMask[i] && !ccMask[i] && input->points[i].z <= softKeepFar) {
+                        ccMask[i] = 1;
+                    }
+                }
+                finalMask.swap(ccMask);
+            }
+        }
+    }
+
+    // Pass 2.8: final spur cleanup to reduce radiating thin points.
+    {
+        std::vector<uint8_t> pruned = finalMask;
+        int keptAfterPrune = 0;
+        const float bandT = std::clamp((static_cast<float>(depthBandPermille) - 40.0f) / 140.0f, 0.0f, 1.0f);
+        const float nearRaySpanFactor = 0.10f - 0.06f * bandT;
+        const float nearRayOffset = std::max(70.0f, spanZ * nearRaySpanFactor);
+        const float nearRayGate = lowCutUpdated
+            ? (lowCutToStore + nearRayOffset)
+            : (minZ + spanZ * (0.22f - 0.10f * bandT));
+        for (int r = 1; r < height - 1; ++r) {
+            for (int c = 1; c < width - 1; ++c) {
+                const int center = idx(r, c);
+                if (!finalMask[center]) {
+                    continue;
+                }
+                int n = 0;
+                for (int rr = -1; rr <= 1; ++rr) {
+                    for (int cc = -1; cc <= 1; ++cc) {
+                        if (rr == 0 && cc == 0) {
+                            continue;
+                        }
+                        if (finalMask[idx(r + rr, c + cc)]) {
+                            ++n;
+                        }
+                    }
+                }
+                if (n < 2 && input->points[center].z < nearRayGate) {
+                    pruned[center] = 0;
+                }
+                if (pruned[center]) {
+                    ++keptAfterPrune;
+                }
+            }
+        }
+        if (keptAfterPrune >= 1200) {
+            finalMask.swap(pruned);
+        }
+    }
+
+    pcl::PointCloud<pcl::PointXYZ>::Ptr denoised(new pcl::PointCloud<pcl::PointXYZ>());
+    denoised->points.reserve(static_cast<size_t>(supportCount));
+    for (size_t i = 0; i < total; ++i) {
+        if (finalMask[i]) {
+            denoised->points.push_back(input->points[i]);
+        }
+    }
+
+    if (denoised->points.empty()) {
+        return input;
+    }
+
+    denoised->width = static_cast<uint32_t>(denoised->points.size());
+    denoised->height = 1;
+    denoised->is_dense = true;
+
+    {
+        std::lock_guard<std::mutex> lock(m_denoiseStateMutex);
+        if (anchorUpdated) {
+            m_anchorMeanZFiltered = anchorToStore;
+            m_hasAnchorMeanZ = true;
+        }
+        if (lowCutUpdated) {
+            m_lowCutZFiltered = lowCutToStore;
+            m_hasLowCutZ = true;
+        }
+    }
+
+    return denoised;
+}
+
 bool PointCloudProcessor::initializeOpenCL()
 {
    if (m_clInitialized) {
@@ -106,9 +765,8 @@ bool PointCloudProcessor::initializeOpenCL()
        "int y = idx / width; "
        "int x = idx % width; "
        "float z = depth[idx] * z_scale; "
-        // 完全平面的圆柱投影：X和Y直接使用像素坐标，缩放到合适的范围
-        "xyz[idx*3] = (x - cx) * 2.0f; "  // X坐标，缩放系数2.0
-        "xyz[idx*3+1] = -(y - cy) * 2.0f; "  // Y坐标取反，修正上下颠倒
+        "xyz[idx*3] = (x - cx) * z * inv_fx; "
+        "xyz[idx*3+1] = (y - cy) * z * inv_fy; "
        "xyz[idx*3+2] = z; "
        "}";

@@ -248,6 +906,9 @@ void PointCloudProcessor::processDepthData(const QByteArray &depthData, uint32_t

    // 注释掉频繁的日志输出
    // qDebug() << "[PointCloud] Block" << blockId << "processed successfully";
+    if (m_denoiseEnabled.load(std::memory_order_relaxed)) {
+        cloud = applyDenoise(cloud);
+    }
    emit pointCloudReady(cloud, blockId);
 }

@@ -283,36 +944,65 @@ void PointCloudProcessor::processPointCloudData(const QByteArray &cloudData, uin
    // 从int16_t数组读取点云数据
    const int16_t* cloudShort = reinterpret_cast<const int16_t*>(cloudData.constData());

+    // 与下位机 gpu_calculate_pointcloud.cl 对齐的参数：
+    // u = p5 * (j - 0.5) + p6, v = p7 * (i + 1) + p8
+    // (k1,k2,p1,p2,p5,p6,p7,p8) 由 cmos0/kc.txt 与 cmos0/KK.txt 加载。
+
    if (isZOnly) {
-        // Z-only格式：转换为正交投影（柱形）
+        // Z-only格式：标准针孔模型反投影
        for (size_t i = 0; i < m_totalPoints; i++) {
            int row = i / m_imageWidth;
            int col = i % m_imageWidth;

-            // 读取深度值（单位：毫米）
            float z = static_cast<float>(cloudShort[i]) * m_zScale;

-            // 正交投影：X、Y使用像素坐标（Y轴翻转以修正镜像）
-            cloud->points[i].x = static_cast<float>(col);
-            cloud->points[i].y = static_cast<float>(m_imageHeight - 1 - row);
+            // 旧公式保留，便于快速回退：
+            // cloud->points[i].x = (col - m_cx) * z * inv_fx;
+            // cloud->points[i].y = (row - m_cy) * z * inv_fy;
+
+            // 下位机同款：先求(u,v)并做畸变修正得到(unc,vnc)，再乘z得到(x,y)
+            float u = m_p5 * (static_cast<float>(col) - 0.5f) + m_p6;
+            float v = m_p7 * (static_cast<float>(row) + 1.0f) + m_p8;
+            float r = u * u + v * v;
+            float temp3 = 1.0f / (1.0f + m_k1 * r + m_k2 * r * r);
+            float unc = temp3 * (u - 2.0f * m_p1 * u * v - m_p2 * (r + 2.0f * u * u));
+            float vnc = temp3 * (v - m_p1 * (r + 2.0f * v * v) - 2.0f * m_p2 * u * v);
+
+            cloud->points[i].x = unc * z;
+            cloud->points[i].y = vnc * z;
            cloud->points[i].z = z;
        }
    } else {
-        // XYZ格式：完整的三维坐标
-        // 转换为正交投影（柱形），使用像素坐标作为X、Y
+        // XYZ格式：使用Z值进行针孔模型反投影
        for (size_t i = 0; i < m_totalPoints; i++) {
            int row = i / m_imageWidth;
            int col = i % m_imageWidth;

-            // 正交投影：X、Y使用像素坐标（Y轴翻转以修正镜像），Z使用深度值
-            cloud->points[i].x = static_cast<float>(col);
-            cloud->points[i].y = static_cast<float>(m_imageHeight - 1 - row);
-            cloud->points[i].z = static_cast<float>(cloudShort[i * 3 + 2]) * m_zScale;
+            float z = static_cast<float>(cloudShort[i * 3 + 2]) * m_zScale;
+
+            // 旧公式保留，便于快速回退：
+            // cloud->points[i].x = (col - m_cx) * z * inv_fx;
+            // cloud->points[i].y = (row - m_cy) * z * inv_fy;
+
+            // 下位机同款：先求(u,v)并做畸变修正得到(unc,vnc)，再乘z得到(x,y)
+            float u = m_p5 * (static_cast<float>(col) - 0.5f) + m_p6;
+            float v = m_p7 * (static_cast<float>(row) + 1.0f) + m_p8;
+            float r = u * u + v * v;
+            float temp3 = 1.0f / (1.0f + m_k1 * r + m_k2 * r * r);
+            float unc = temp3 * (u - 2.0f * m_p1 * u * v - m_p2 * (r + 2.0f * u * u));
+            float vnc = temp3 * (v - m_p1 * (r + 2.0f * v * v) - 2.0f * m_p2 * u * v);
+
+            cloud->points[i].x = unc * z;
+            cloud->points[i].y = vnc * z;
+            cloud->points[i].z = z;
        }
    }

    // qDebug() << "[PointCloud] Block" << blockId << "processed successfully,"
    // << m_totalPoints << "points";
+    if (m_denoiseEnabled.load(std::memory_order_relaxed)) {
+        cloud = applyDenoise(cloud);
+    }
    emit pointCloudReady(cloud, blockId);
 }

--- a/src/gui/MainWindow.cpp
+++ b/src/gui/MainWindow.cpp
--- a/src/gui/MainWindow.h
+++ b/src/gui/MainWindow.h
@@ -140,6 +140,8 @@ private:
    QPushButton *m_leftIRToggle;
    QPushButton *m_rightIRToggle;
    QPushButton *m_rgbToggle;
+    QPushButton *m_pointCloudColorToggle;  // 点云颜色开关
+    QPushButton *m_pointCloudDenoiseToggle;  // Point cloud denoise toggle

    // 单目/双目模式切换按钮
    QPushButton *m_monocularBtn;
@@ -156,6 +158,12 @@ private:
    QPushButton *m_browseSavePathBtn;
    class QComboBox *m_depthFormatCombo;
    class QComboBox *m_pointCloudFormatCombo;
+    QSlider *m_denoiseSupportSlider;
+    QSpinBox *m_denoiseSupportSpinBox;
+    QSlider *m_denoiseTailSlider;
+    QSpinBox *m_denoiseTailSpinBox;
+    QSlider *m_denoiseBandSlider;
+    QSpinBox *m_denoiseBandSpinBox;

    // 显示控件
    QLabel *m_statusLabel;
@@ -207,8 +215,18 @@ private:
    int m_totalRgbFrameCount;
    double m_currentRgbFps;

-    // RGB解码处理标志（防止线程积压）
+    // 解码处理标志（防止线程积压导致闪烁）
    QAtomicInt m_rgbProcessing;
+    QAtomicInt m_leftIRProcessing;
+    QAtomicInt m_rightIRProcessing;
+    QAtomicInt m_pointCloudProcessing;
+    QAtomicInt m_pointCloudDropCounter;
+    bool m_leftIrDisplayRangeInited;
+    float m_leftIrDisplayMin;
+    float m_leftIrDisplayMax;
+    bool m_rightIrDisplayRangeInited;
+    float m_rightIrDisplayMin;
+    float m_rightIrDisplayMax;
    int m_rgbSkipCounter;  // RGB帧跳过计数器

    // 相机启用状态标志（防止关闭后闪烁）
--- a/src/gui/PointCloudGLWidget.cpp
+++ b/src/gui/PointCloudGLWidget.cpp
@@ -1,5 +1,6 @@
 #include "gui/PointCloudGLWidget.h"
 #include <QDebug>
+#include <QPushButton>
 #include <cmath>
 #include <cfloat>

@@ -9,16 +10,32 @@ PointCloudGLWidget::PointCloudGLWidget(QWidget *parent)
    , m_vertexBuffer(nullptr)
    , m_vao(nullptr)
    , m_pointCount(0)
-    , m_fixedCenter(0.0f, 0.0f, 0.0f)
-    , m_centerInitialized(false)
-    , m_orthoSize(2000.0f)  // 正交投影视野大小
+    , m_minZ(0.0f)
+    , m_maxZ(1000.0f)
+    , m_fov(60.0f)          // 透视投影视场角
    , m_rotationX(0.0f)     // 从正面看（0度）
    , m_rotationY(0.0f)     // 不旋转Y轴
-    , m_translation(0.0f, 0.0f, 0.0f)
+    , m_cloudCenter(0.0f, 0.0f, 0.0f)
+    , m_viewDistance(1000.0f)
+    , m_panOffset(0.0f, 0.0f, 0.0f)
+    , m_zoom(1.0f)          // 缩放因子
    , m_leftButtonPressed(false)
    , m_rightButtonPressed(false)
+    , m_firstFrame(true)
+    , m_colorMode(0)  // 默认黑白模式
 {
    setMinimumSize(400, 400);
+
+    // 添加重置视角按钮
+    QPushButton *resetBtn = new QPushButton("重置", this);
+    resetBtn->setFixedSize(60, 30);
+    resetBtn->move(10, 10);
+    resetBtn->setStyleSheet(
+        "QPushButton { background-color: rgba(50, 50, 50, 180); color: white; border: 1px solid #555; border-radius: 4px; }"
+        "QPushButton:hover { background-color: rgba(70, 70, 70, 200); }"
+        "QPushButton:pressed { background-color: rgba(40, 40, 40, 220); }"
+    );
+    connect(resetBtn, &QPushButton::clicked, this, &PointCloudGLWidget::resetView);
 }

 PointCloudGLWidget::~PointCloudGLWidget()
@@ -42,7 +59,7 @@ void PointCloudGLWidget::initializeGL()
 {
    initializeOpenGLFunctions();

-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClearColor(0.1f, 0.1f, 0.15f, 1.0f);  // 深灰色背景
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_PROGRAM_POINT_SIZE);

@@ -67,18 +84,39 @@ void PointCloudGLWidget::setupShaders()
        #version 330 core
        layout(location = 0) in vec3 position;
        uniform mat4 mvp;
+        uniform float minZ;
+        uniform float maxZ;
+        out float depth;
        void main() {
            gl_Position = mvp * vec4(position, 1.0);
-            gl_PointSize = 1.0;  // 减小点的大小
+            gl_PointSize = 1.0;
+            depth = (position.z - minZ) / (maxZ - minZ);
        }
    )";

-    // 片段着色器
+    // 片段着色器 - 支持黑白和彩色两种模式
    const char *fragmentShaderSource = R"(
        #version 330 core
+        in float depth;
+        uniform int colorMode;
        out vec4 fragColor;
        void main() {
-            fragColor = vec4(1.0, 1.0, 1.0, 1.0);
+            float d = clamp(depth, 0.0, 1.0);
+            if (colorMode == 0) {
+                fragColor = vec4(1.0, 1.0, 1.0, 1.0);
+            } else {
+                vec3 color;
+                if (d < 0.25) {
+                    color = mix(vec3(0.0, 0.0, 1.0), vec3(0.0, 1.0, 1.0), d * 4.0);
+                } else if (d < 0.5) {
+                    color = mix(vec3(0.0, 1.0, 1.0), vec3(0.0, 1.0, 0.0), (d - 0.25) * 4.0);
+                } else if (d < 0.75) {
+                    color = mix(vec3(0.0, 1.0, 0.0), vec3(1.0, 1.0, 0.0), (d - 0.5) * 4.0);
+                } else {
+                    color = mix(vec3(1.0, 1.0, 0.0), vec3(1.0, 0.0, 0.0), (d - 0.75) * 4.0);
+                }
+                fragColor = vec4(color, 1.0);
+            }
        }
    )";

@@ -99,11 +137,12 @@ void PointCloudGLWidget::resizeGL(int w, int h)
 {
    m_projection.setToIdentity();

-    // 使用正交投影代替透视投影，避免"喷射状"效果
+    // 使用正交投影，避免透视变形
    float aspect = float(w) / float(h);
-    m_projection.ortho(-m_orthoSize * aspect, m_orthoSize * aspect,
-                       -m_orthoSize, m_orthoSize,
-                       -50000.0f, 50000.0f);  // 近平面和远平面
+    float orthoSize = m_viewDistance * 0.5f / m_zoom;
+    m_projection.ortho(-orthoSize * aspect, orthoSize * aspect,
+                       -orthoSize, orthoSize,
+                       -50000.0f, 50000.0f);
 }

 void PointCloudGLWidget::paintGL()
@@ -114,18 +153,25 @@ void PointCloudGLWidget::paintGL()
        return;
    }

-    // 每帧重新计算正交投影矩阵（确保使用最新的m_orthoSize）
+    // 重新计算正交投影矩阵
    m_projection.setToIdentity();
    float aspect = float(width()) / float(height());
-    m_projection.ortho(-m_orthoSize * aspect, m_orthoSize * aspect,
-                       -m_orthoSize, m_orthoSize,
+    float orthoSize = m_viewDistance * 0.5f / m_zoom;
+    m_projection.ortho(-orthoSize * aspect, orthoSize * aspect,
+                       -orthoSize, orthoSize,
                       -50000.0f, 50000.0f);

-    // 设置view矩阵
+    // 设置view矩阵 - 轨道相机模式（围绕点云中心旋转）
    m_view.setToIdentity();
+    // 1. 用户平移偏移
+    m_view.translate(m_panOffset);
+    // 2. 相机后退到观察距离
+    m_view.translate(0.0f, 0.0f, -m_viewDistance);
+    // 3. 应用旋转（围绕原点，即点云中心）
    m_view.rotate(m_rotationX, 1.0f, 0.0f, 0.0f);
    m_view.rotate(m_rotationY, 0.0f, 1.0f, 0.0f);
-    m_view.translate(m_translation);
+    // 4. 将点云中心移到原点
+    m_view.translate(-m_cloudCenter);

    // 设置model矩阵
    m_model.setToIdentity();
@@ -136,6 +182,9 @@ void PointCloudGLWidget::paintGL()
    // 绑定shader和设置uniform
    m_program->bind();
    m_program->setUniformValue("mvp", mvp);
+    m_program->setUniformValue("minZ", m_minZ);
+    m_program->setUniformValue("maxZ", m_maxZ);
+    m_program->setUniformValue("colorMode", m_colorMode);

    // 绑定VAO和绘制
    m_vao->bind();
@@ -166,10 +215,10 @@ void PointCloudGLWidget::mouseMoveEvent(QMouseEvent *event)
        m_rotationY += delta.x() * 0.5f;
        update();
    } else if (m_rightButtonPressed) {
-        // 右键：平移（根据正交投影视野大小调整平移速度）
-        float scale = m_orthoSize * 0.002f;
-        m_translation.setX(m_translation.x() + delta.x() * scale);
-        m_translation.setY(m_translation.y() - delta.y() * scale);
+        // 右键：平移（根据观察距离调整平移速度）
+        float scale = m_viewDistance * 0.002f;
+        m_panOffset.setX(m_panOffset.x() + delta.x() * scale);
+        m_panOffset.setY(m_panOffset.y() - delta.y() * scale);
        update();
    }
 }
@@ -185,12 +234,12 @@ void PointCloudGLWidget::mouseReleaseEvent(QMouseEvent *event)

 void PointCloudGLWidget::wheelEvent(QWheelEvent *event)
 {
-    // 滚轮：缩放（调整正交投影视野大小）
+    // 滚轮：缩放（调整zoom因子）
    float delta = event->angleDelta().y() / 120.0f;
-    m_orthoSize *= (1.0f - delta * 0.1f);
-    m_orthoSize = qMax(100.0f, qMin(m_orthoSize, 10000.0f));  // 范围：100-10000
+    m_zoom *= (1.0f + delta * 0.1f);
+    m_zoom = qMax(0.1f, qMin(m_zoom, 10.0f));  // 范围：0.1-10倍

-    update();  // 触发重绘，paintGL会使用新的m_orthoSize
+    update();
 }

 void PointCloudGLWidget::updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud)
@@ -199,66 +248,87 @@ void PointCloudGLWidget::updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr cl
        return;
    }

-    // 过滤全零点并转换为顶点数组
+    // 过滤全零点并转换为顶点数组，同时计算包围盒
    m_vertices.clear();
+
    float minX = FLT_MAX, maxX = -FLT_MAX;
    float minY = FLT_MAX, maxY = -FLT_MAX;
    float minZ = FLT_MAX, maxZ = -FLT_MAX;

    for (const auto& point : cloud->points) {
-        if (point.z > 0.01f) {
+        if (point.z > 0.01f) {  // 过滤掉无效的零点
+            const float displayZ = -point.z; // Flip front/back axis for viewer convention.
            m_vertices.push_back(point.x);
-            m_vertices.push_back(point.y);
-            m_vertices.push_back(point.z);
+            m_vertices.push_back(-point.y);
+            m_vertices.push_back(displayZ);

-            // 统计坐标范围
+            // 更新包围盒
            if (point.x < minX) minX = point.x;
            if (point.x > maxX) maxX = point.x;
            if (point.y < minY) minY = point.y;
            if (point.y > maxY) maxY = point.y;
-            if (point.z < minZ) minZ = point.z;
-            if (point.z > maxZ) maxZ = point.z;
+            if (displayZ < minZ) minZ = displayZ;
+            if (displayZ > maxZ) maxZ = displayZ;
        }
    }

    m_pointCount = m_vertices.size() / 3;

-    // 计算点云中心并进行中心化处理
+    // 保存深度范围用于着色
    if (m_pointCount > 0) {
+        m_minZ = minZ;
+        m_maxZ = maxZ;
+    }
+
+    // 只在首帧时自动调整相机位置，之后保持用户交互状态
+    if (m_pointCount > 0 && m_firstFrame) {
+        // 计算点云中心
        float centerX = (minX + maxX) / 2.0f;
        float centerY = (minY + maxY) / 2.0f;
        float centerZ = (minZ + maxZ) / 2.0f;

-        // 第一帧：初始化固定中心点
-        if (!m_centerInitialized) {
-            m_fixedCenter = QVector3D(centerX, centerY, centerZ);
-            m_centerInitialized = true;
-            qDebug() << "[PointCloudGLWidget] Fixed center initialized:" << m_fixedCenter;
-        }
+        // 计算点云尺寸
+        float depthRange = maxZ - minZ;
+        float sizeX = maxX - minX;
+        float sizeY = maxY - minY;
+        float maxSize = std::max({sizeX, sizeY, depthRange});

-        // 使用固定的中心点进行中心化（避免抖动）
-        for (size_t i = 0; i < m_vertices.size(); i += 3) {
-            m_vertices[i] -= m_fixedCenter.x();      // X坐标
-            m_vertices[i + 1] -= m_fixedCenter.y();  // Y坐标
-            m_vertices[i + 2] -= m_fixedCenter.z();  // Z坐标
-        }
-    }
+        // 设置点云中心
+        m_cloudCenter = QVector3D(centerX, centerY, centerZ);

-    // 添加调试日志
-    static int updateCount = 0;
-    if (updateCount < 3 || updateCount % 100 == 0) {
-    // qDebug() << "[PointCloudGLWidget] Update" << updateCount << "- Points:" << m_pointCount
-    // << "Total cloud size:" << cloud->size();
-    // qDebug() << "  X range:" << minX << "to" << maxX;
-    // qDebug() << "  Y range:" << minY << "to" << maxY;
-    // qDebug() << "  Z range:" << minZ << "to" << maxZ;
+        // 计算观察距离，让相机从外部观察点云
+        m_viewDistance = maxSize * 1.5f;
+
+        // 重置平移偏移和旋转角度
+        m_panOffset = QVector3D(0.0f, 0.0f, 0.0f);
+        m_rotationX = 0.0f;
+        m_rotationY = 0.0f;
+
+        // 设置缩放
+        m_zoom = 1.0f;
+
+        qDebug() << "[PointCloudGLWidget] 首帧自动居中 - 点云中心:" << centerX << centerY << centerZ
+                 << "观察距离:" << m_viewDistance;
+        m_firstFrame = false;  // 标记首帧已处理
    }
-    updateCount++;

    updateBuffers();
    update();
 }

+void PointCloudGLWidget::resetView()
+{
+    // 重置所有视角参数到初始状态
+    m_rotationX = 0.0f;
+    m_rotationY = 0.0f;
+    m_panOffset = QVector3D(0.0f, 0.0f, 0.0f);
+    m_zoom = 1.0f;
+    m_firstFrame = true;  // 标记为首帧，下次更新时会重新计算视角
+
+    update();
+    qDebug() << "[PointCloudGLWidget] 视角已重置";
+}
+
 void PointCloudGLWidget::updateBuffers()
 {
    if (m_vertices.empty() || !m_vao || !m_vertexBuffer) {
--- a/src/gui/PointCloudWidget.cpp
+++ b/src/gui/PointCloudWidget.cpp
@@ -54,3 +54,15 @@ void PointCloudWidget::updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr clou
    // 更新OpenGL显示
    m_glWidget->updatePointCloud(cloud);
 }
+
+void PointCloudWidget::setColorMode(bool enabled)
+{
+    if (m_glWidget) {
+        m_glWidget->setColorMode(enabled);
+    }
+}
+
+bool PointCloudWidget::colorMode() const
+{
+    return m_glWidget ? m_glWidget->colorMode() : false;
+}
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,12 +1,15 @@
 #include <QApplication>
 #include <QDateTime>
 #include <QDir>
+#include <QStandardPaths>
+
 #include "gui/MainWindow.h"
 #include "core/Logger.h"

-// Custom message handler to redirect qDebug output to Logger
+// Redirect Qt log output to file logger.
 void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
+    Q_UNUSED(context);
    Logger *logger = Logger::instance();

    switch (type) {
@@ -30,29 +33,32 @@ int main(int argc, char *argv[])
 {
    QApplication app(argc, argv);

-    // 设置应用程序信息
-    app.setOrganizationName("D330Viewer");
-    app.setApplicationName("D330Viewer");
-    app.setApplicationVersion("0.2.0");
+    app.setOrganizationName("Viewer");
+    app.setApplicationName("Viewer");
+    app.setApplicationVersion("0.3.3");

-    // 初始化Logger（在可执行文件同目录下）
-    QString logPath = QCoreApplication::applicationDirPath() + "/d330viewer.log";
+    // Prefer LocalAppData so MSI installs under Program Files can always write logs.
+    QString logDir = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    if (logDir.isEmpty()) {
+        logDir = QCoreApplication::applicationDirPath();
+    }
+    QDir().mkpath(logDir);
+
+    const QString logPath = QDir(logDir).filePath("viewer.log");
    Logger::instance()->setLogFile(logPath);
-    Logger::instance()->setMaxLines(10000);  // 保留最新10000行
+    Logger::instance()->setMaxLines(10000);

-    // 安装消息处理器
    qInstallMessageHandler(messageHandler);

-    qDebug() << "D330Viewer started";
+    qDebug() << "Viewer started";
    qDebug() << "Log file:" << logPath;

-    // 创建并显示主窗口
    MainWindow mainWindow;
    mainWindow.show();

-    int result = app.exec();
+    const int result = app.exec();

-    qDebug() << "D330Viewer exiting";
+    qDebug() << "Viewer exiting";

    return result;
 }
Author	SHA1	Message	Date
GloamXun	a6e2e3280a	feat: 添加点云去噪及其参数调整	2026-03-04 15:59:39 +08:00
GloamXun	c2b525d948	update: readme	2026-03-03 17:15:43 +08:00
GloamXun	cd97cb5d56	fix: 修改日志生成位置	2026-03-03 11:51:05 +08:00
GloamXun	04a5ec269f	update: 扩大ip搜索范围，修改点云可视化逻辑，添加上位机与下位机曝光值同步	2026-02-06 14:47:42 +08:00
GloamXun	03c7cb58da	update: 修改版本号修改软件名称发布v0.3	2026-02-02 14:26:45 +08:00
GloamXun	b1871aa9e7	feat: 添加点云着色按钮适配调整后的下位机图像采集方式	2026-02-02 14:08:30 +08:00