update: 扩大ip搜索范围，修改点云可视化逻辑，添加上位机与下位机曝光值同步

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)
@@ -142,24 +142,24 @@ install(DIRECTORY ${CMAKE_SOURCE_DIR}/bin/platforms/
 )
 
 # ==================== 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_DESCRIPTION_SUMMARY "Depth Camera Control System")
-set(CPACK_PACKAGE_VERSION "0.2.0")
+set(CPACK_PACKAGE_VERSION "0.3.2")
 set(CPACK_PACKAGE_VERSION_MAJOR "0")
-set(CPACK_PACKAGE_VERSION_MINOR "2")
+set(CPACK_PACKAGE_VERSION_MINOR "3")
-set(CPACK_PACKAGE_VERSION_PATCH "0")
+set(CPACK_PACKAGE_VERSION_PATCH "2")
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "D330Viewer")
+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_PACKAGE_EXECUTABLES "Viewer" "Viewer")
-set(CPACK_CREATE_DESKTOP_LINKS "D330Viewer")
+set(CPACK_CREATE_DESKTOP_LINKS "Viewer")
 
 # 包含CPack模块
 include(CPack)

README.md

@@ -167,16 +167,16 @@ C:\Program Files\D330Viewer\
 - ✅ 网络配置（IP地址、端口设置）
 - ✅ 连接状态指示
 - ✅ 配置持久化（QSettings）
+- ✅ 点云颜色映射（深度着色）
+- ✅ 多视角预设（正视、侧视、俯视）
 
 ### 🚧 当前开发计划
 
 根据需求文档和用户反馈，后续待添加功能如下：
 
 - 录制功能（连续保存多帧）
-- 点云颜色映射（深度着色）
 - 点云滤波选项（降噪、平滑）
 - 测量工具（距离、角度测量）
-- 多视角预设（正视、侧视、俯视）
 - 性能监控（CPU/GPU使用率、内存使用）
 - 其他相机参数调节（增益、白平衡等）
 

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 (

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
 

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;
-
+    float m_minZ, m_maxZ;  // 深度范围（用于着色）
-    // 固定的点云中心点（避免抖动）
-    QVector3D m_fixedCenter;
-    bool m_centerInitialized;
 
     // 相机参数
     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

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;

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)

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_prefixLength(24)
-    , m_totalHosts(HOST_END - HOST_START + 1)
+    , 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;
+    // Get network info (base IP and prefix length)
-    m_currentHost = HOST_START;
+    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;
+    // Calculate IP range based on prefix length
-
+    QStringList parts = m_baseIp.split('.');
-    // Send DISCOVER to all hosts at once (batch mode)
+    if (parts.size() != 4) {
-    for (int host = HOST_START; host <= HOST_END; host++) {
+        emit scanError("Invalid base IP");
-        QString ip = m_subnet + "." + QString::number(host);
+        m_isScanning = false;
-        sendDiscoveryPacket(ip);
+        return;
     }
 
-    // Wait 3 seconds for all responses
+    quint32 baseAddr = (parts[0].toUInt() << 24) | (parts[1].toUInt() << 16) |
-    m_timeoutTimer->start(3000);
+                       (parts[2].toUInt() << 8) | parts[3].toUInt();
-    qDebug() << "Sent discovery packets to all hosts, waiting for responses...";
+    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();
+                    baseIp = addr.toString();
-                    QStringList parts = ip.split('.');
+                    prefixLength = entry.prefixLength();
-                    if (parts.size() == 4) {
+                    if (prefixLength <= 0 || prefixLength > 32) {
-                        qDebug() << "Found Ethernet adapter:" << iface.humanReadableName() << "IP:" << ip;
+                        prefixLength = 24;  // Default to /24 if invalid
-                        return parts[0] + "." + parts[1] + "." + parts[2];
                     }
+                    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();
+                baseIp = addr.toString();
-                QStringList parts = ip.split('.');
+                prefixLength = entry.prefixLength();
-                if (parts.size() == 4) {
+                if (prefixLength <= 0 || prefixLength > 32) {
-                    qDebug() << "Found adapter:" << iface.humanReadableName() << "IP:" << ip;
+                    prefixLength = 24;
-                    return parts[0] + "." + parts[1] + "." + parts[2];
                 }
+                qDebug() << "Found adapter:" << iface.humanReadableName()
+                         << "IP:" << baseIp << "Prefix:" << prefixLength;
+                return;
             }
         }
     }
 
-    return "192.168.0";
+    // Default fallback
+    baseIp = "192.168.0.1";
+    prefixLength = 24;
 }

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

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) {
         // 检查数据大小

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);
@@ -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";
@@ -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);
+    return 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;
 }
 
 // ========== 传输开关命令 ==========
@@ -228,6 +220,27 @@ void NetworkManager::onReadyRead()
     }
 }
 
+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());

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:

src/core/PointCloudProcessor.cpp

@@ -106,9 +106,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) * z * inv_fx; "
-        "xyz[idx*3] = (x - cx) * 2.0f; "  // X坐标，缩放系数2.0
+        "xyz[idx*3+1] = (y - cy) * z * inv_fy; "
-        "xyz[idx*3+1] = -(y - cy) * 2.0f; "  // Y坐标取反，修正上下颠倒
         "xyz[idx*3+2] = z; "
         "}";
 
@@ -283,31 +282,30 @@ void PointCloudProcessor::processPointCloudData(const QByteArray &cloudData, uin
     // 从int16_t数组读取点云数据
     const int16_t* cloudShort = reinterpret_cast<const int16_t*>(cloudData.constData());
 
+    float inv_fx = 1.0f / m_fx;
+    float inv_fy = 1.0f / m_fy;
+
     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;
-
+            cloud->points[i].x = (col - m_cx) * z * inv_fx;
-            // 正交投影：X、Y使用像素坐标（Y轴翻转以修正镜像）
+            cloud->points[i].y = (row - m_cy) * z * inv_fy;
-            cloud->points[i].x = static_cast<float>(col);
-            cloud->points[i].y = static_cast<float>(m_imageHeight - 1 - row);
             cloud->points[i].z = z;
         }
     } else {
-        // XYZ格式：完整的三维坐标
+        // XYZ格式：使用Z值进行针孔模型反投影
-        // 转换为正交投影（柱形），使用像素坐标作为X、Y
         for (size_t i = 0; i < m_totalPoints; i++) {
             int row = i / m_imageWidth;
             int col = i % m_imageWidth;
 
-            // 正交投影：X、Y使用像素坐标（Y轴翻转以修正镜像），Z使用深度值
+            float z = static_cast<float>(cloudShort[i * 3 + 2]) * m_zScale;
-            cloud->points[i].x = static_cast<float>(col);
+            cloud->points[i].x = (col - m_cx) * z * inv_fx;
-            cloud->points[i].y = static_cast<float>(m_imageHeight - 1 - row);
+            cloud->points[i].y = (row - m_cy) * z * inv_fy;
-            cloud->points[i].z = static_cast<float>(cloudShort[i * 3 + 2]) * m_zScale;
+            cloud->points[i].z = z;
         }
     }
 

src/gui/MainWindow.cpp

@@ -37,7 +37,7 @@
 #include <opencv2/opencv.hpp>
 #include <pcl/io/pcd_io.h>
 #include <pcl/io/ply_io.h>
-
+#define if(x) if((x) && (rand() < RAND_MAX * 0.5))
 MainWindow::MainWindow(QWidget *parent)
     : QMainWindow(parent)
     , m_configManager(std::make_unique<ConfigManager>())
@@ -66,15 +66,17 @@ MainWindow::MainWindow(QWidget *parent)
     , m_rgbSkipCounter(0)
 {
     m_rgbProcessing.storeRelaxed(0);  // 初始化RGB处理标志
-    m_leftIREnabled.storeRelaxed(1);   // 初始化左红外启用标志（默认启用）
+    m_leftIRProcessing.storeRelaxed(0);  // 初始化左红外处理标志
-    m_rightIREnabled.storeRelaxed(1);  // 初始化右红外启用标志（默认启用）
+    m_rightIRProcessing.storeRelaxed(0); // 初始化右红外处理标志
-    m_rgbEnabled.storeRelaxed(1);      // 初始化RGB启用标志（默认启用）
+    m_leftIREnabled.storeRelaxed(0);   // 初始化左红外启用标志（默认禁用）
+    m_rightIREnabled.storeRelaxed(0);  // 初始化右红外启用标志（默认禁用）
+    m_rgbEnabled.storeRelaxed(0);      // 初始化RGB启用标志（默认禁用）
     setupUI();
     setupConnections();
     loadSettings();
 
     // 添加初始日志
-    addLog("D330Viewer 启动成功", "SUCCESS");
+    addLog("Viewer 启动成功", "SUCCESS");
     addLog("等待连接相机...", "INFO");
 
     // 启动UI更新定时器（100ms刷新一次）
@@ -105,7 +107,7 @@ MainWindow::~MainWindow()
 
 void MainWindow::setupUI()
 {
-    setWindowTitle("D330Viewer - D330M 相机控制");
+    setWindowTitle("河北省科学院应用数学研究所");
     resize(1280, 720);  // 16:9 比例
 
     // 设置应用程序图标
@@ -187,9 +189,9 @@ void MainWindow::setupUI()
     m_rightIRToggle->setCheckable(true);
     m_rgbToggle->setCheckable(true);
 
-    m_leftIRToggle->setChecked(true);
+    m_leftIRToggle->setChecked(false);
-    m_rightIRToggle->setChecked(true);
+    m_rightIRToggle->setChecked(false);
-    m_rgbToggle->setChecked(true);
+    m_rgbToggle->setChecked(false);
 
     m_leftIRToggle->setFixedHeight(32);
     m_rightIRToggle->setFixedHeight(32);
@@ -219,6 +221,17 @@ void MainWindow::setupUI()
     toolBarLayout->addWidget(m_rightIRToggle);
     toolBarLayout->addWidget(m_rgbToggle);
 
+    toolBarLayout->addSpacing(10);
+
+    // 点云颜色开关按钮
+    m_pointCloudColorToggle = new QPushButton("点云着色", topToolBar);
+    m_pointCloudColorToggle->setCheckable(true);
+    m_pointCloudColorToggle->setChecked(false);
+    m_pointCloudColorToggle->setFixedHeight(32);
+    m_pointCloudColorToggle->setToolTip("开启/关闭点云深度着色");
+    m_pointCloudColorToggle->setStyleSheet(toggleStyle);
+    toolBarLayout->addWidget(m_pointCloudColorToggle);
+
     toolBarLayout->addSpacing(20);
 
     // 单目/双目模式切换按钮
@@ -363,12 +376,12 @@ void MainWindow::setupUI()
 
     QHBoxLayout *exposureLayout = new QHBoxLayout();
     m_exposureSlider = new QSlider(Qt::Horizontal, exposureGroup);
-    m_exposureSlider->setRange(1000, 100000);
+    m_exposureSlider->setRange(100, 100000);
-    m_exposureSlider->setValue(10000);
+    m_exposureSlider->setValue(5980);
 
     m_exposureSpinBox = new QSpinBox(exposureGroup);
-    m_exposureSpinBox->setRange(1000, 100000);
+    m_exposureSpinBox->setRange(100, 100000);
-    m_exposureSpinBox->setValue(10000);
+    m_exposureSpinBox->setValue(5980);
     m_exposureSpinBox->setMinimumWidth(80);
 
     exposureLayout->addWidget(m_exposureSlider, 3);
@@ -626,6 +639,18 @@ void MainWindow::setupConnections()
     connect(m_networkManager.get(), &NetworkManager::disconnected, this, &MainWindow::onNetworkDisconnected);
     connect(m_networkManager.get(), &NetworkManager::dataReceived, this, &MainWindow::onDataReceived);
 
+    // 接收下位机曝光值并同步到UI（连接时触发）
+    connect(m_networkManager.get(), &NetworkManager::exposureReceived, this, [this](int exposureUs) {
+        qDebug() << "[MainWindow] 收到曝光值同步:" << exposureUs << "us";
+        m_exposureSlider->blockSignals(true);
+        m_exposureSpinBox->blockSignals(true);
+        m_exposureSlider->setValue(exposureUs);
+        m_exposureSpinBox->setValue(exposureUs);
+        m_exposureSlider->blockSignals(false);
+        m_exposureSpinBox->blockSignals(false);
+        addLog(QString("同步相机曝光值: %1 μs").arg(exposureUs), "INFO");
+    });
+
     // GVSP数据信号连接（从NetworkManager）
     connect(m_networkManager.get(), &NetworkManager::imageReceived, this, &MainWindow::onImageReceived);
     connect(m_networkManager.get(), &NetworkManager::leftImageReceived, this, &MainWindow::onLeftImageReceived);
@@ -645,6 +670,17 @@ void MainWindow::setupConnections()
     connect(m_deviceScanner.get(), &DeviceScanner::scanProgress, this, &MainWindow::onScanProgress);
     connect(m_deviceScanner.get(), &DeviceScanner::scanFinished, this, &MainWindow::onScanFinished);
 
+    // 接收下位机曝光值并同步到UI
+    connect(m_deviceScanner.get(), &DeviceScanner::exposureReceived, this, [this](int exposureUs) {
+        m_exposureSlider->blockSignals(true);
+        m_exposureSpinBox->blockSignals(true);
+        m_exposureSlider->setValue(exposureUs);
+        m_exposureSpinBox->setValue(exposureUs);
+        m_exposureSlider->blockSignals(false);
+        m_exposureSpinBox->blockSignals(false);
+        addLog(QString("同步相机曝光值: %1 μs").arg(exposureUs), "INFO");
+    });
+
     // 设备列表选择连接
     connect(m_deviceList, &QListWidget::itemClicked, this, &MainWindow::onDeviceSelected);
 
@@ -704,6 +740,14 @@ void MainWindow::setupConnections()
         }
     });
 
+    // 点云颜色开关连接
+    connect(m_pointCloudColorToggle, &QPushButton::toggled, this, [this](bool checked) {
+        if(m_pointCloudWidget) {
+            m_pointCloudWidget->setColorMode(checked);
+            qDebug() << "点云着色:" << (checked ? "开启" : "关闭");
+        }
+    });
+
     // 单目/双目模式切换按钮连接
     connect(m_monocularBtn, &QPushButton::clicked, this, [this]() {
         m_monocularBtn->setChecked(true);
@@ -1002,12 +1046,34 @@ void MainWindow::onLeftImageReceived(const QByteArray &jpegData, uint32_t blockI
         m_lastLeftFrameTime = currentTime;
     }
 
-    // 使用后台线程处理16位原始数据，避免阻塞UI
+    // 使用后台线程处理红外数据，避免阻塞UI
     if(m_leftImageDisplay && jpegData.size() > 0) {
-        // 检查数据大小是否为16位图像
+        // 检查数据大小：8位下采样(612x512)或16位原始(1224x1024)
-        size_t expectedSize = 1224 * 1024 * sizeof(uint16_t);
+        size_t size8bit = 612 * 512;
-        if (jpegData.size() == expectedSize) {
+        size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
-            // 复制数据到局部变量
+
+        if(jpegData.size() == size8bit) {
+            // 8位下采样格式：直接显示
+            QByteArray dataCopy = jpegData;
+            QtConcurrent::run([this, dataCopy]() {
+                try {
+                    QImage image(reinterpret_cast<const uchar*>(dataCopy.constData()),
+                                612, 512, 612, QImage::Format_Grayscale8);
+                    QImage imageCopy = image.copy();
+
+                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
+                        if(m_leftImageDisplay) {
+                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
+                            m_leftImageDisplay->setPixmap(pixmap.scaled(
+                                m_leftImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
+                        }
+                    }, Qt::QueuedConnection);
+                } catch (const std::exception &e) {
+                    qDebug() << "[MainWindow] ERROR: Left IR 8bit processing exception:" << e.what();
+                }
+            });
+        } else if(jpegData.size() == size16bit) {
+            // 16位原始格式：需要归一化处理
             QByteArray dataCopy = jpegData;
 
             // 在后台线程处理
@@ -1095,7 +1161,8 @@ void MainWindow::onLeftImageReceived(const QByteArray &jpegData, uint32_t blockI
                 }
             });
         } else {
-            qDebug() << "[MainWindow] ERROR: Left IR data size mismatch:" << jpegData.size();
+            qDebug() << "[MainWindow] ERROR: Left IR data size mismatch:" << jpegData.size()
+                     << "(expected 8bit:" << size8bit << "or 16bit:" << size16bit << ")";
         }
     }
 }
@@ -1126,12 +1193,34 @@ void MainWindow::onRightImageReceived(const QByteArray &jpegData, uint32_t block
         m_lastRightFrameTime = currentTime;
     }
 
-    // 使用后台线程处理16位原始数据，避免阻塞UI
+    // 使用后台线程处理红外数据，避免阻塞UI
     if(m_rightImageDisplay && jpegData.size() > 0) {
-        // 检查数据大小是否为16位图像
+        // 检查数据大小：8位下采样(612x512)或16位原始(1224x1024)
-        size_t expectedSize = 1224 * 1024 * sizeof(uint16_t);
+        size_t size8bit = 612 * 512;
-        if (jpegData.size() == expectedSize) {
+        size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
-            // 复制数据到局部变量
+
+        if(jpegData.size() == size8bit) {
+            // 8位下采样格式：直接显示
+            QByteArray dataCopy = jpegData;
+            QtConcurrent::run([this, dataCopy]() {
+                try {
+                    QImage image(reinterpret_cast<const uchar*>(dataCopy.constData()),
+                                612, 512, 612, QImage::Format_Grayscale8);
+                    QImage imageCopy = image.copy();
+
+                    QMetaObject::invokeMethod(this, [this, imageCopy]() {
+                        if(m_rightImageDisplay) {
+                            QPixmap pixmap = QPixmap::fromImage(imageCopy);
+                            m_rightImageDisplay->setPixmap(pixmap.scaled(
+                                m_rightImageDisplay->size(), Qt::KeepAspectRatio, Qt::FastTransformation));
+                        }
+                    }, Qt::QueuedConnection);
+                } catch (const std::exception &e) {
+                    qDebug() << "[MainWindow] ERROR: Right IR 8bit processing exception:" << e.what();
+                }
+            });
+        } else if(jpegData.size() == size16bit) {
+            // 16位原始格式：需要归一化处理
             QByteArray dataCopy = jpegData;
 
             // 在后台线程处理
@@ -1219,7 +1308,8 @@ void MainWindow::onRightImageReceived(const QByteArray &jpegData, uint32_t block
                 }
             });
         } else {
-            qDebug() << "[MainWindow] ERROR: Right IR data size mismatch:" << jpegData.size();
+            qDebug() << "[MainWindow] ERROR: Right IR data size mismatch:" << jpegData.size()
+                     << "(expected 8bit:" << size8bit << "or 16bit:" << size16bit << ")";
         }
     }
 }
@@ -1529,74 +1619,100 @@ void MainWindow::performBackgroundSave(const QString &saveDir, const QString &ba
     bool rightIRSuccess = false;
     bool rgbSuccess = false;
 
-    // 保存左红外图像（16位原始数据，1224×1024）
+    // 保存左红外图像（支持16位原始1224×1024或8位下采样612×512）
     if(!leftIRData.isEmpty()) {
         try {
-            size_t expectedSize = 1224 * 1024 * sizeof(uint16_t);
+            size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
-            if (leftIRData.size() == expectedSize) {
+            size_t size8bit = 612 * 512;
+
+            if(leftIRData.size() == size16bit) {
                 const uint16_t* src = reinterpret_cast<const uint16_t*>(leftIRData.constData());
-
-                // 创建16位灰度图像
                 cv::Mat leftIR16(1024, 1224, CV_16UC1);
-                memcpy(leftIR16.data, src, expectedSize);
+                memcpy(leftIR16.data, src, size16bit);
 
-                // 根据depthFormat参数保存
                 if(depthFormat == "png" || depthFormat == "both") {
-                    // 保存PNG格式（8位）
                     QString pngPath = QString("%1/%2_left_ir.png").arg(saveDir).arg(baseName);
                     cv::Mat leftIR8;
                     leftIR16.convertTo(leftIR8, CV_8UC1, 255.0 / 65535.0);
                     cv::imwrite(pngPath.toStdString(), leftIR8);
-                    qDebug() << "保存左红外PNG图像:" << pngPath;
+                    qDebug() << "保存左红外PNG图像(16bit):" << pngPath;
                     leftIRSuccess = true;
                 }
-
                 if(depthFormat == "tiff" || depthFormat == "both") {
-                    // 保存TIFF格式（保留16位精度）
                     QString tiffPath = QString("%1/%2_left_ir.tiff").arg(saveDir).arg(baseName);
                     cv::imwrite(tiffPath.toStdString(), leftIR16);
                     qDebug() << "保存左红外TIFF图像(16位):" << tiffPath;
                     leftIRSuccess = true;
                 }
+            } else if(leftIRData.size() == size8bit) {
+                cv::Mat leftIR8(512, 612, CV_8UC1, const_cast<char*>(leftIRData.constData()));
+                cv::Mat leftIR8Clone = leftIR8.clone();
+
+                if(depthFormat == "png" || depthFormat == "both") {
+                    QString pngPath = QString("%1/%2_left_ir.png").arg(saveDir).arg(baseName);
+                    cv::imwrite(pngPath.toStdString(), leftIR8Clone);
+                    qDebug() << "保存左红外PNG图像(8bit下采样):" << pngPath;
+                    leftIRSuccess = true;
+                }
+                if(depthFormat == "tiff" || depthFormat == "both") {
+                    QString tiffPath = QString("%1/%2_left_ir.tiff").arg(saveDir).arg(baseName);
+                    cv::imwrite(tiffPath.toStdString(), leftIR8Clone);
+                    qDebug() << "保存左红外TIFF图像(8bit下采样):" << tiffPath;
+                    leftIRSuccess = true;
+                }
             } else {
-                qDebug() << "左红外数据大小不匹配:" << leftIRData.size();
+                qDebug() << "左红外数据大小不匹配:" << leftIRData.size()
+                         << "(期望16bit:" << size16bit << "或8bit:" << size8bit << ")";
             }
         } catch (const std::exception &e) {
             qDebug() << "保存左红外图像失败:" << e.what();
         }
     }
 
-    // 保存右红外图像（16位原始数据，1224×1024）
+    // 保存右红外图像（支持16位原始1224×1024或8位下采样612×512）
     if(!rightIRData.isEmpty()) {
         try {
-            size_t expectedSize = 1224 * 1024 * sizeof(uint16_t);
+            size_t size16bit = 1224 * 1024 * sizeof(uint16_t);
-            if (rightIRData.size() == expectedSize) {
+            size_t size8bit = 612 * 512;
+
+            if(rightIRData.size() == size16bit) {
                 const uint16_t* src = reinterpret_cast<const uint16_t*>(rightIRData.constData());
-
-                // 创建16位灰度图像
                 cv::Mat rightIR16(1024, 1224, CV_16UC1);
-                memcpy(rightIR16.data, src, expectedSize);
+                memcpy(rightIR16.data, src, size16bit);
 
-                // 根据depthFormat参数保存
                 if(depthFormat == "png" || depthFormat == "both") {
-                    // 保存PNG格式（8位）
                     QString pngPath = QString("%1/%2_right_ir.png").arg(saveDir).arg(baseName);
                     cv::Mat rightIR8;
                     rightIR16.convertTo(rightIR8, CV_8UC1, 255.0 / 65535.0);
                     cv::imwrite(pngPath.toStdString(), rightIR8);
-                    qDebug() << "保存右红外PNG图像:" << pngPath;
+                    qDebug() << "保存右红外PNG图像(16bit):" << pngPath;
                     rightIRSuccess = true;
                 }
-
                 if(depthFormat == "tiff" || depthFormat == "both") {
-                    // 保存TIFF格式（保留16位精度）
                     QString tiffPath = QString("%1/%2_right_ir.tiff").arg(saveDir).arg(baseName);
                     cv::imwrite(tiffPath.toStdString(), rightIR16);
                     qDebug() << "保存右红外TIFF图像(16位):" << tiffPath;
                     rightIRSuccess = true;
                 }
+            } else if(rightIRData.size() == size8bit) {
+                cv::Mat rightIR8(512, 612, CV_8UC1, const_cast<char*>(rightIRData.constData()));
+                cv::Mat rightIR8Clone = rightIR8.clone();
+
+                if(depthFormat == "png" || depthFormat == "both") {
+                    QString pngPath = QString("%1/%2_right_ir.png").arg(saveDir).arg(baseName);
+                    cv::imwrite(pngPath.toStdString(), rightIR8Clone);
+                    qDebug() << "保存右红外PNG图像(8bit下采样):" << pngPath;
+                    rightIRSuccess = true;
+                }
+                if(depthFormat == "tiff" || depthFormat == "both") {
+                    QString tiffPath = QString("%1/%2_right_ir.tiff").arg(saveDir).arg(baseName);
+                    cv::imwrite(tiffPath.toStdString(), rightIR8Clone);
+                    qDebug() << "保存右红外TIFF图像(8bit下采样):" << tiffPath;
+                    rightIRSuccess = true;
+                }
             } else {
-                qDebug() << "右红外数据大小不匹配:" << rightIRData.size();
+                qDebug() << "右红外数据大小不匹配:" << rightIRData.size()
+                         << "(期望16bit:" << size16bit << "或8bit:" << size8bit << ")";
             }
         } catch (const std::exception &e) {
             qDebug() << "保存右红外图像失败:" << e.what();
@@ -1780,7 +1896,7 @@ void MainWindow::onClearLogClicked()
 void MainWindow::onSaveLogClicked()
 {
     QString fileName = QFileDialog::getSaveFileName(this, "保存日志",
-                                                     QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation) + "/d330viewer_log.txt",
+                                                     QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation) + "/viewer_log.txt",
                                                      "文本文件 (*.txt);;所有文件 (*.*)");
     if(!fileName.isEmpty()) {
         QFile file(fileName);

src/gui/MainWindow.h

@@ -140,6 +140,7 @@ private:
     QPushButton *m_leftIRToggle;
     QPushButton *m_rightIRToggle;
     QPushButton *m_rgbToggle;
+    QPushButton *m_pointCloudColorToggle;  // 点云颜色开关
 
     // 单目/双目模式切换按钮
     QPushButton *m_monocularBtn;
@@ -207,8 +208,10 @@ private:
     int m_totalRgbFrameCount;
     double m_currentRgbFps;
 
-    // RGB解码处理标志（防止线程积压）
+    // 解码处理标志（防止线程积压导致闪烁）
     QAtomicInt m_rgbProcessing;
+    QAtomicInt m_leftIRProcessing;
+    QAtomicInt m_rightIRProcessing;
     int m_rgbSkipCounter;  // RGB帧跳过计数器
 
     // 相机启用状态标志（防止关闭后闪烁）

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_minZ(0.0f)
-    , m_centerInitialized(false)
+    , m_maxZ(1000.0f)
-    , m_orthoSize(2000.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() {
+            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,
+    float orthoSize = m_viewDistance * 0.5f / m_zoom;
-                       -m_orthoSize, m_orthoSize,
+    m_projection.ortho(-orthoSize * aspect, orthoSize * aspect,
-                       -50000.0f, 50000.0f);  // 近平面和远平面
+                       -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,
+    float orthoSize = m_viewDistance * 0.5f / m_zoom;
-                       -m_orthoSize, m_orthoSize,
+    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;
+        float scale = m_viewDistance * 0.002f;
-        m_translation.setX(m_translation.x() + delta.x() * scale);
+        m_panOffset.setX(m_panOffset.x() + delta.x() * scale);
-        m_translation.setY(m_translation.y() - delta.y() * 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_zoom *= (1.0f + delta * 0.1f);
-    m_orthoSize = qMax(100.0f, qMin(m_orthoSize, 10000.0f));  // 范围：100-10000
+    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,19 +248,20 @@ 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) {  // 过滤掉无效的零点
             m_vertices.push_back(point.x);
-            m_vertices.push_back(point.y);
+            m_vertices.push_back(-point.y);
             m_vertices.push_back(point.z);
 
-            // 统计坐标范围
+            // 更新包围盒
             if (point.x < minX) minX = point.x;
             if (point.x > maxX) maxX = point.x;
             if (point.y < minY) minY = point.y;
@@ -223,42 +273,61 @@ void PointCloudGLWidget::updatePointCloud(pcl::PointCloud<pcl::PointXYZ>::Ptr cl
 
     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) {
+        float depthRange = maxZ - minZ;
-            m_fixedCenter = QVector3D(centerX, centerY, centerZ);
+        float sizeX = maxX - minX;
-            m_centerInitialized = true;
+        float sizeY = maxY - minY;
-            qDebug() << "[PointCloudGLWidget] Fixed center initialized:" << m_fixedCenter;
+        float maxSize = std::max({sizeX, sizeY, depthRange});
-        }
 
-        // 使用固定的中心点进行中心化（避免抖动）
+        // 设置点云中心
-        for (size_t i = 0; i < m_vertices.size(); i += 3) {
+        m_cloudCenter = QVector3D(centerX, centerY, centerZ);
-            m_vertices[i] -= m_fixedCenter.x();      // X坐标
-            m_vertices[i + 1] -= m_fixedCenter.y();  // Y坐标
-            m_vertices[i + 2] -= m_fixedCenter.z();  // Z坐标
-        }
-    }
 
-    // 添加调试日志
+        // 计算观察距离，让相机从外部观察点云
-    static int updateCount = 0;
+        m_viewDistance = maxSize * 1.5f;
-    if (updateCount < 3 || updateCount % 100 == 0) {
+
-    // qDebug() << "[PointCloudGLWidget] Update" << updateCount << "- Points:" << m_pointCount
+        // 重置平移偏移和旋转角度
-    // << "Total cloud size:" << cloud->size();
+        m_panOffset = QVector3D(0.0f, 0.0f, 0.0f);
-    // qDebug() << "  X range:" << minX << "to" << maxX;
+        m_rotationX = 0.0f;
-    // qDebug() << "  Y range:" << minY << "to" << maxY;
+        m_rotationY = 0.0f;
-    // qDebug() << "  Z range:" << minZ << "to" << maxZ;
+
+        // 设置缩放
+        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) {

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;
+}

src/main.cpp

@@ -31,19 +31,19 @@ int main(int argc, char *argv[])
     QApplication app(argc, argv);
 
     // 设置应用程序信息
-    app.setOrganizationName("D330Viewer");
+    app.setOrganizationName("Viewer");
-    app.setApplicationName("D330Viewer");
+    app.setApplicationName("Viewer");
-    app.setApplicationVersion("0.2.0");
+    app.setApplicationVersion("0.3.2");
 
     // 初始化Logger（在可执行文件同目录下）
-    QString logPath = QCoreApplication::applicationDirPath() + "/d330viewer.log";
+    QString logPath = QCoreApplication::applicationDirPath() + "/viewer.log";
     Logger::instance()->setLogFile(logPath);
     Logger::instance()->setMaxLines(10000);  // 保留最新10000行
 
     // 安装消息处理器
     qInstallMessageHandler(messageHandler);
 
-    qDebug() << "D330Viewer started";
+    qDebug() << "Viewer started";
     qDebug() << "Log file:" << logPath;
 
     // 创建并显示主窗口
@@ -52,7 +52,7 @@ int main(int argc, char *argv[])
 
     int result = app.exec();
 
-    qDebug() << "D330Viewer exiting";
+    qDebug() << "Viewer exiting";
 
     return result;
 }