汽车HUD技术调研手册

2025-04-21

HUD技术调研手册

抬头显示起源于战斗机上的开火瞄准系统，抬头显示最早被大规模应用就在飞机上。
抬头显示（HUD）技术的综合分析，涵盖关键技术、技术方向、发展现状及主流产品形态
alt text
AR-HUD得到认可的根本

清晰
准确
舒适
平台化降低成本
作为下一代仪表的一种产品形态，AR-HUD只需要做到这四点，就能在市场中站稳。从用户角度来说，目前对HUD的接受程度不错，但仍不能完全替代传统仪表，两者是并行的状态。从车企角度来说，这个技术是还未完全经过市场考验的新技术，前装搭载和用户使用率收集上看，还处在新兴时期。但处在竞争前沿，这个技术是必须竞争的，必须要有的对标产品。

类型	显示方式	特点	代表车型/企业
C-HUD	独立树脂板投射	结构简单、成本低；视野小、强光下效果差，渐被淘汰	早期低端车型
W-HUD	挡风玻璃反射	成像面积更大（投影距2-4米），集成度高；当前主流（占比＞70%）	丰田、理想L9（替代传统仪表）
AR-HUD	虚实融合于远场路面	支持动态导航（如车道级指引）、ADAS预警；需高精度传感器支持	奔驰S级、问界M9、蔚来ES8
全景HUD	覆盖整个挡风玻璃下部	多乘员共享信息，支持娱乐功能（观影、游戏）	新兴方案（P-HUD）

广视场角（＞10°）、远投影距（＞7.5米）、低延迟（＜100ms）

一、关键技术解析

1、原理和软件

核心硬件和基本原理

包括投影单元（PGU）、反射镜组、自由曲面镜、挡风玻璃（或独立介质）。

通过精密光学计算实现虚像投射，需解决虚像距离（VID）、视场角（FOV）、畸变矫正等问题。 AR-HUD需更复杂光路设计，以支持7-10米远距投影和大成像面积。 HUD的凹面镜和凸面镜之间需要足够的光路空间，才能满足FOV以及虚像VID的要求，因此HUD的体积甚至可以达到15L，是一个相对较大的汽车电子产品，并因此产生碰撞时的风险。未来的趋势是将整个光机系统小型化。

alt text

人眼看到的是虚像，图像由PGU单元产生，经由光源加强经过两次反射投到挡风玻璃上形成像，对于W-HUD来说，人眼和人脑通过自补足来产生清晰虚像。
目前国内做HUD行业的企业较多，最为突出的是华阳集团。华阳早在2012年就开始HUD研发，2018年完成AR-HUD的预研。华阳在HUD研发上的突破主要归功于三个领域的技术能力：激光运动（激光头单元）技术、微投影光学技术、汽车电子技术。华阳是全球最大的激光头制造商，提供全球三分之一的激光头单元产量。

华阳提供的AR-HUD的打包方案有两种：

一体机AR-HUD，结合内置计算平台（MCU、MPU）运行AR算法
基于DCU（域控制单元）系统的AR-HUD，将利用DCU的计算能力运行必要的算法

根据这些信息，AR-HUD或者W-HUD本身典型结构就是光机+计算单元，光机指的是以发射头和反射镜为主体的一整个显示结构，计算单元是用于向光机输送信息的计算结构。主要的技术壁垒的发力点也在这两部分。

AR-HUD的核心技术，包括
(1)AR图像合成(或者叫投影算法、3D坐标变换)
(2)图像畸变校正算法
(3)工厂标定、离线校准与售后校准
(4)眼球追踪算法(实时微调投影)
(5)障碍物追踪算法(提供前车距离显示等)
(6)高精度车道线检测，自车位置检测。
(7)低延迟中间件技术

上述的概念中，描述了基本的硬件组件，实际上HUD这个产品本身有点像投影仪，只不过投影仪的成像平面是一块白布，而HUD的成像平面是一块玻璃并进行了几次反射。对于软件团队来说，HUD更像是一个外设。

《SAE J1757-2_201811 Standard - Optical System HUD for Automotive》

上述由美国机动车工程师协会发布，该SAE标准提供了在典型汽车环境照明条件下确定HUD光学性能的测量方法。它涵盖了室内测量和模拟室外照明，用于HUD虚拟图像的测量。该标准涉及的HUD类型包括w-HUD(挡风玻璃HUD)和c-HUD(组合器HUD)，根据需要作为增强现实(AR)HUD的参考
SAE J1757-2_201811 Standard - Optical System HUD for Automotive

W-HUD与AR-HUD的区别

W-HUD的效果

W-HUD
上图展示了一个基本的W-HUD的实际效果，目前装车量最大也是成熟技术的HUD就是W-HUD，它可以将一些基本的信息投射到挡风玻璃上，在有限的范围内显示一些辅助驾驶的地图等信息，替代了仪表的部分功能，是仪表技术的延展。

AR-HUD的效果

为了直观的展示两种HUD的区别和技术上的差异点，可以先看实际的效果。
上图是华为(VID＞7.5m，FOV：13°X5°)的AR-HUD的效果，包括黑夜和白天，可以很明显的看到，AR-HUD由动态位置部分和非动态位置部分元素构成，固定的元素包括了速度和限速的显示，车道线提示和转向提示等，当然也可以包括车灯等元素。非动态位置的元素包括一个路线的指示标，它跟随实际的车道线进行移动，通过ADAS传来的数据实时调节HUD的显示。当然，AR-HUD还可以动态的显示更多AR元素，例如前车的轮廓和实时距离，左右两侧的建筑的名字，预警行人的路径。

区别点

W-HUD and AR-HUD
从上图可以看到，AR-HUD和W-HUD两者在基本原理上并无巨大差距，真正的区别在于W-HUD只能将固定的元素投影到固定的虚像平面上，AR-HUD使用了复杂的3D坐标转换将元素投影到现实世界的视觉目标点上，同时兼顾了将固定元素投影到固定虚像平面上。假设现实中有那么一个物体A，那么人眼看到的A实像能与投影的shape S相重合或者类似贴合，则能给大脑一种“这个shape S是存在于真实世界表面”这种感觉。

这个图展示了不同HUD产品的FOV区别，从用户体验上来讲，AR-HUD与普通HUD是有一个大致的界限的。如果虚像是固定的平面，那么HUD的视场角则不需要做到那么大，仅仅覆盖某些范围以满足基本的信息显示即可，但是虚像需要贴合真实世界的某些物体，例如车道线、地面、障碍物等，这些物体的位置可能处于更远的视野投影点，则需要更大的FOV以满足显示的需求，AR-HUD的横向FOV至少是10度，虚像平面可控范围至少是7.5米，结合上面对于W-HUD和AR-HUD的区别点解释，可以很好的理解为什么要做大FOV。

双焦面AR-HUD

目前一种量产的技术路线是双焦面HUD光机，要实现真正的AR-HUD，则像面不能只在一个虚像平面上，而是需要多个像面，第一个像面距离近，可以将一些直观的数据放在这个像面，在双焦面AR-HUD上，基本信息显示在近焦面，时速，电量等。把更丰富的道路信息，智能驾驶信息，导航，娱乐，ADAS警示等信息显示在远焦面。远焦面的虚拟相距要大，避免虚拟图像和真实对象(例如车道线和前方车辆)的深度匹配造成的视觉冲突，近焦面的虚像距深度要小，避免与真实世界对象重叠影响驾驶员。

双焦面HUD的PGU单元逻辑分为两个区域，处理数据也是分区进行处理的。

软件与数据流

从系统功能的角度来说，HUD是一个信息展示的平台，具体输入给系统的信息，则可以分成以下的三类

1- 从车身总线上来的数据(CAN)
包括
- 车速
- 档位
- 灯状态
- 转速
- 油量
- et....

这些数据一般经由MCU端管理的CAN总线送入，一般是动力域的数据和整车控制器上的车身信息。

2- 从上层应用来的数据
包括
- 限速（地图数据）
- 微型地图（地图数据）
- 道路转弯标识（地图数据）
- 当前位置（地图数据）
- 音乐和视频（娱乐系统数据）
- 视讯通话和普通电话（通讯系统数据）

这些地图和定位数据是来自于专业的地图商和准确的GPS，北斗信号等，这些数据接入HUD的方式和仪表接入HUD的方式并无很大的区别。

3- ADAS系统来的数据
包括
- 前车距离
- 当前车道，车道线检测
- 变道提醒，预测行车轨迹输出
- 后方来车提醒
- DMS数据，给出驾驶员当前的头部姿态，眼部位置
- etc...

这些ADAS数据本身是有一定约定的，结构化的，容易解析的数据，同时，DMS的数据也可以视为ADAS数据的一部分，即使当前车辆没有辅助驾驶功能而单独有DMS，也可以使用这个数据来修正AR-HUD的显示，它与ADAS数据共存于一个中间件是可能的。

alt text
上图可以很轻易的看到，使用座舱域控制器，所有的信息都在座舱端进行融合和梳理，并由座舱的算力进行处理，HUD仅仅作为一个显示用的外设，和普通的座舱屏幕底层逻辑并没有很大的区别。但是，AR-HUD多出了许多动态显示的元素，比如说换道提示，障碍物提示，车位提示，道路岔口提示，这些元素的显示需要外部的算法提供数据，并由特殊的坐标转换算法投影到对应的位置。同时，由于汽车的运动产生的抖动，人眼睛抬头低头产生的位移，需要DMS系统检测人眼微姿态数据并依此实时修正投影的位置。

alt text

通配化中间件

HUD的中间件与仪表类似,基本可以沿用仪表中间件的设计.
AR-HUD接收中间件数据之后,会再经过一层专用处理的信息聚合层,这一层的主要功能是将各个数据进行融合,并加载各种显示模型,实时计算投影矩阵和投影元素,最后将这些数据输出给HUD进行显示.这一层信息聚合层，也可以叫做AR-Creator。AR-HUD中间件的设计目标：低延迟，高性能；AR-Creator的设计目标是让HUD图像准确，清晰。

举个例子,如果有地图提示的变道提醒,那么中间件应该及时处理并将数据给到HUD处理端，减少延迟，同时，高精度定位或者ADAS数据会告知系统当前车子处于哪个车道，应该变到哪个车道。定位到车道的世界坐标系位置，即系统已知车道和车之间的相对关系，并使用这个相对位置关系将虚拟的变道车道线投影到相应的位置。

AR-Creator

关键点	描述
1.HUD显示与车道线 matching	在多车道的情况下，车辆在第几车道，会影响AR-HUD投影信息指示的正确性，故车辆本身须具备车道侦测的相关技术，提供目前在第几车道的信息，且侦测补正系统会有时间延时，因此必须加上提前预测算法。相关技术：影像识别
2. HUD显示与车头方向 matching	AR HUD显示的信息须避开前方车辆遮蔽，投影在路面上，故需侦测前方障碍物的位置，动态调整AR HUD显示的信息位置,且侦测补正系统会有时间延时，因此必须加上提前预测算法。相关技术：77Ghz毫米波雷达/影像识别。
3. HUD显示与前方障碍物标定 matching	AR-HUD虚拟图像与车外实景结合时，会因车主的坐姿差异产生视角的差异，故需侦测眼球位置，动态调整虚拟图像的投射角度变动。相关技术：DMS/影像识别
4. HUD显示与转弯路口 matching	HUD显示的转弯箭头要达到精准标定到实际道路的路口，精密地图：提供路口精准的经纬度位置；精准定位：提供车辆所在的精准经纬度与方向；车头晃动补偿：HUD显示必须补偿车头上下晃动的偏差；收集高精度地图与V2X及六轴向陀螺仪、影像识别、毫米波雷达、GPS等各类传感器，通过复杂数字演算，精确定位目前车辆的位置，精密度需要至10cm等级。

标定

产线标定

岚图追光豪华汽车，东风的高端产品的AVM/HUD/BEV标定车间。

这个是W-HUD的产线标定方法,可以看到整个标定是一个带反馈回环的参数优化系统,由光机投影出特定的形状,由相机模拟人眼拍摄HUD实际成像形状,通过调整光机输出,直到光机输出使得相机接收到的图像符合一定的约束,去掉畸变和歪斜,并计算出对应关系的像素投影关系.

无畸变
预畸变
处理LUT

主要步骤:

1 获取标准标定版图像及标准标定版图像通过HUD显示的HUD畸变图像
2 获取标准标定版图形学和对应HUD畸变图像中的特征点坐标
3 确定标准标定版图像于对应HUD的畸变图像的映射关系
4 对HUD待显示图像利用求解出的映射关系进行预畸变处理

通过以上描述，可以把由挡风玻璃形成的畸变描述为一种几何失真，或称之为几何畸变，不同于鱼眼相机形成的畸变可以用某种约定的高次多项式展开来描述畸变，HUD的畸变是由多种原因共同构成的，包括光路的复杂性、玻璃的材料、玻璃的厚度、玻璃的反射率、光源的位置、光源的光束等，这些因素过于复杂，无法直接进行分解的数学描述，只能从发射源到接受源之间通过特定的约束来建立关系，并由此求解几何畸变。

几何畸变又可分为线性几何畸变和非线性几何畸变。通常情况下，线性几何畸变指缩放、平移、旋转等畸变。而非线性几何畸变是由成像面和物平面的倾斜、物平面本身的弯曲、光学系统的像差造成的畸变，表现为物体与实际的成像各部分比例失衡。
常见几何畸变退化问题的复原大多是基于成像系统，如模拟鱼眼和针孔系统进行摄像机标定，通过确定摄像机畸变参数对所获取图像进行后续校正和复原处理。其优点是一旦确立成像模型，便可以快速有效地根据模型参数对基本图像进行几何变换，从而实现复原。但通常情况下我们面临的图像其成像系统未知且多样化，因此，这种方法不适合于解决一般性无法预知模型的畸变退化。

比如由成像面不平整造成的曲面畸变。因此，另外一种常见的解决方法是多项式变换技术，其实质是利用数值分析的方法求解几何变换方程。其优点是不需要预先知道成像模型，对复杂曲面畸变能够进行校正和复原。缺点是运算量大，不适宜实时性较高系统，对多项式次数和控制点的选取要求严格，发生复原失控的概率很大，不适用于一些只存在投影变换和镜头畸变的图像。这里我们重点介绍基于多项式变换的几何校正方法，其基本流程是先建立几何校正的数学模型，比如针对畸变特点选择一次多项式或者二次多项式作为几何校正的数学模型；其次利用已知条件确定模型参数，通常以标准未畸变影像为参考，由用户在参考影像与畸变影像上选择控制点，从而解算出多项式系数，即确定出模型参数；最后根据模型对图像进行几何校正。

问题转化为:
现在有一幅无畸变的图像，一幅产生了非均匀几何畸变的图像，注意不是相机标定的畸变。这两幅图像上有已知对应关系的标识点，求解映射表使得能够去除畸变
#include <opencv2/opencv.hpp>
#include <vector>
#define GLOG_USE_GLOG_NO_EXPORT
#include <iostream>
#include <Eigen/Dense>
#include <ceres/ceres.h>
#include <ceres/rotation.h>

using namespace cv;
using namespace std;

Eigen::VectorXf computePolynomialTerms(double x, double y, int degree) {
    int nTerms = (degree + 1) * (degree + 2) / 2;
    Eigen::VectorXf terms(nTerms);
    int index = 0;
    for (int i = 0; i <= degree; ++i) {
        for (int j = 0; j <= degree - i; ++j) {
            terms(index++) = static_cast<float>(std::pow(x, i) * std::pow(y, j));
        }
    }
    return terms;
}

struct PolynomialCostFunctor {
    PolynomialCostFunctor(double observed_x, double observed_y, 
                         double target_x, double target_y, int degree)
        : observed_x_(observed_x), observed_y_(observed_y),
          target_x_(target_x), target_y_(target_y), degree_(degree) {}

    template <typename T>
    bool operator()(const T* const coeffs_x, const T* const coeffs_y, T* residuals) const {
        int nTerms = (degree_ + 1) * (degree_ + 2) / 2;
        int index = 0;
        T predicted_x = T(0);
        T predicted_y = T(0);
        
        for (int i = 0; i <= degree_; ++i) {
            for (int j = 0; j <= degree_ - i; ++j) {
                T term = ceres::pow(T(observed_x_), i) * ceres::pow(T(observed_y_), j);
                predicted_x += coeffs_x[index] * term;
                predicted_y += coeffs_y[index] * term;
                index++;
            }
        }

        residuals[0] = predicted_x - T(target_x_);
        residuals[1] = predicted_y - T(target_y_);
        return true;
    }

private:
    const double observed_x_;
    const double observed_y_;
    const double target_x_;
    const double target_y_;
    const int degree_;
};

Eigen::VectorXd estimatePolynomialTransformation(
    const vector<Point2f>& distortedPoints,
    const vector<Point2f>& undistortedPoints,
    int degree) {
    
    int nTerms = (degree + 1) * (degree + 2) / 2;
    Eigen::VectorXd coefficients(2 * nTerms);
    coefficients.setZero();

    ceres::Problem problem;
    
    for (size_t i = 0; i < distortedPoints.size(); ++i) {
        ceres::CostFunction* cost_function =
            new ceres::AutoDiffCostFunction<PolynomialCostFunctor, 2, 15, 15>(
                new PolynomialCostFunctor(
                    static_cast<double>(distortedPoints[i].x), static_cast<double>(distortedPoints[i].y),
                    static_cast<double>(undistortedPoints[i].x), static_cast<double>(undistortedPoints[i].y), degree));

        problem.AddResidualBlock(cost_function, nullptr, 
                               coefficients.data(), 
                               coefficients.data() + nTerms);
    }

    ceres::Solver::Options options;
    options.linear_solver_type = ceres::DENSE_QR;
    options.minimizer_progress_to_stdout = true;
    options.max_num_iterations = 100;

    ceres::Solver::Summary summary;
    ceres::Solve(options, &problem, &summary);
    std::cout << "优化结果报告:" << std::endl;
    std::cout << summary.FullReport() << std::endl;

    return coefficients;
}

Point2f applyPolynomialTransformation(double x, double y,
    const Eigen::VectorXd& coefficientsX,
    const Eigen::VectorXd& coefficientsY,
    int degree) {

    Eigen::VectorXf terms = computePolynomialTerms(x, y, degree);
    float xNew = 0.0f;
    float yNew = 0.0f;

    for (int i = 0; i < terms.size(); ++i) {
        xNew += static_cast<float>(coefficientsX(i)) * terms(i);
        yNew += static_cast<float>(coefficientsY(i)) * terms(i);
    }

    return Point2f(xNew, yNew);
}

Mat generateUndistortedImage(int width, int height, int rows, int cols, int circleRadius) {
    Mat image = Mat::zeros(height, width, CV_8UC3);
    float spacingX = static_cast<float>(width) / (cols + 1);
    float spacingY = static_cast<float>(height) / (rows + 1);

    for (int r = 0; r < rows; ++r) {
        float firstCenterX = spacingX * 1;
        float lastCenterX = spacingX * cols;
        float centerY = spacingY * (r + 1);

        line(image,
            Point2f(firstCenterX, centerY),
            Point2f(lastCenterX, centerY),
            Scalar(0, 0, 255), 2);

        for (int c = 0; c < cols; ++c) {
            float centerX = spacingX * (c + 1);
            circle(image, Point2f(centerX, centerY), circleRadius, Scalar(255, 255, 255), -1);
        }
    }
    return image;
}

Point2f applyDistortionModel(const Point2f& point, int width, int height) {
    float distortedX = point.x + 2.0f * static_cast<float>(std::pow(point.x, 2)) / (width * width)
        + 2.0f * static_cast<float>(std::sin(point.y / 50.0f));
    float distortedY = point.y + 2.0f * static_cast<float>(std::pow(point.y, 2)) / (height * height)
        + 2.0f * static_cast<float>(std::cos(point.x / 50.0f));

    distortedX = std::max(0.0f, std::min(distortedX, static_cast<float>(width - 1)));
    distortedY = std::max(0.0f, std::min(distortedY, static_cast<float>(height - 1)));

    return Point2f(distortedX, distortedY);
}

pair<Mat, vector<Point2f>> generateDistortedImageAndPoints(
    const Mat& undistortedImage, int rows, int cols) {

    vector<Point2f> undistortedPoints;
    vector<Point2f> distortedPoints;
    float spacingX = static_cast<float>(undistortedImage.cols) / (cols + 1);
    float spacingY = static_cast<float>(undistortedImage.rows) / (rows + 1);

    Mat distortedImage = undistortedImage.clone();
    distortedImage.setTo(Scalar(0, 0, 0));

    for (int r = 0; r < rows; ++r) {
        vector<Point2f> rowPoints;

        for (int c = 0; c < cols; ++c) {
            float centerX = spacingX * (c + 1);
            float centerY = spacingY * (r + 1);
            Point2f undistortedPoint(centerX, centerY);
            undistortedPoints.push_back(undistortedPoint);

            Point2f distortedPoint = applyDistortionModel(undistortedPoint,
                undistortedImage.cols, undistortedImage.rows);
            distortedPoints.push_back(distortedPoint);
            rowPoints.push_back(distortedPoint);

            circle(distortedImage, distortedPoint, 20, Scalar(255, 255, 255), -1);
        }

        if (!rowPoints.empty()) {
            line(distortedImage,
                Point2f(rowPoints.front().x, rowPoints.front().y),
                Point2f(rowPoints.back().x, rowPoints.back().y),
                Scalar(0, 0, 255), 2);
        }
    }

    cout << "\n--- Undistorted Points ---\n";
    for (size_t i = 0; i < undistortedPoints.size(); ++i) {
        const auto& point = undistortedPoints[i];
        cout << "[" << point.x << ", " << point.y << "]\n";
    }

    cout << "\n--- Distorted Points ---\n";
    for (size_t i = 0; i < distortedPoints.size(); ++i) {
        const auto& point = distortedPoints[i];
        cout << "[" << point.x << ", " << point.y << "]\n";
    }

    return { distortedImage, distortedPoints };
}

int main() {
    const int width = 1000;
    const int height = 1000;
    const int rows = 10;
    const int cols = 10;
    const int circleRadius = 20;

    Mat undistortedImage = generateUndistortedImage(width, height, rows, cols, circleRadius);
    auto [distortedImage, distortedPoints] = generateDistortedImageAndPoints(undistortedImage, rows, cols);

    vector<Point2f> undistortedPoints;
    float spacingX = static_cast<float>(width) / (cols + 1);
    float spacingY = static_cast<float>(height) / (rows + 1);

    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < cols; ++c) {
            float centerX = spacingX * (c + 1);
            float centerY = spacingY * (r + 1);
            undistortedPoints.push_back(Point2f(centerX, centerY));
        }
    }

    if (distortedPoints.size() != undistortedPoints.size()) {
        cout << "\nError: Point counts don't match!\n";
        return -1;
    }

    const int degree = 4;
    Eigen::VectorXd coefficients = estimatePolynomialTransformation(distortedPoints, undistortedPoints, degree);
    int nTerms = (degree + 1) * (degree + 2) / 2;
    Eigen::VectorXd coefficientsX = coefficients.head(nTerms);
    Eigen::VectorXd coefficientsY = coefficients.tail(nTerms);

    if (coefficients.hasNaN()) {
        cout << "\nError: Invalid polynomial coefficients (NaN detected)\n";
        return -1;
    }

    cout << "\n--- Polynomial Coefficients ---\n";
    cout << "X Coefficients: [";
    for (int i = 0; i < coefficientsX.size(); ++i) {
        if (i > 0) cout << ", ";
        cout << coefficientsX(i);
    }
    cout << "]\n";

    cout << "Y Coefficients: [";
    for (int i = 0; i < coefficientsY.size(); ++i) {
        if (i > 0) cout << ", ";
        cout << coefficientsY(i);
    }
    cout << "]\n";

    cout << "\n正在生成畸变到非畸变的映射表..." << endl;
    Mat forwardMapX(undistortedImage.size(), CV_32FC1);
    Mat forwardMapY(undistortedImage.size(), CV_32FC1);
    
    cout << "正在生成非畸变到畸变的映射表..." << endl;
    Mat inverseMapX(undistortedImage.size(), CV_32FC1);
    Mat inverseMapY(undistortedImage.size(), CV_32FC1);

    for (int y = 0; y < undistortedImage.rows; ++y) {
        for (int x = 0; x < undistortedImage.cols; ++x) {
            Point2f undistortedPt = applyPolynomialTransformation(
                static_cast<double>(x), static_cast<double>(y),
                coefficientsX,
                coefficientsY,
                degree);
            forwardMapX.at<float>(y, x) = undistortedPt.x;
            forwardMapY.at<float>(y, x) = undistortedPt.y;

            Point2f distortedPt(x, y);
            bool found = false;
            for (size_t i = 0; i < distortedPoints.size(); ++i) {
                if (norm(distortedPt - distortedPoints[i]) < 0.1f) {
                    inverseMapX.at<float>(y, x) = undistortedPoints[i].x;
                    inverseMapY.at<float>(y, x) = undistortedPoints[i].y;
                    found = true;
                    break;
                }
            }
            if (!found) {
                Point2f interpolated = applyPolynomialTransformation(
                    static_cast<double>(x), static_cast<double>(y),
                    coefficientsX,
                    coefficientsY,
                    degree);
                inverseMapX.at<float>(y, x) = interpolated.x;
                inverseMapY.at<float>(y, x) = interpolated.y;
            }
        }
    }

    cout << "\n正在应用前向映射..." << endl;
    Mat forwardMappedImage;
    remap(distortedImage, forwardMappedImage, forwardMapX, forwardMapY, INTER_LINEAR);

    cout << "正在应用逆向映射..." << endl;
    Mat inverseMappedImage;
    remap(undistortedImage, inverseMappedImage, inverseMapX, inverseMapY, INTER_LINEAR);

    for (int r = 0; r < rows; ++r) {
        vector<Point2f> rowMappedPoints;
        for (int c = 0; c < cols; ++c) {
            int idx = r * cols + c;
            Point2f mappedPt = applyPolynomialTransformation(
                static_cast<double>(undistortedPoints[idx].x),
                static_cast<double>(undistortedPoints[idx].y),
                coefficientsX, coefficientsY, degree);
            rowMappedPoints.push_back(mappedPt);
        }

        if (!rowMappedPoints.empty()) {
            line(forwardMappedImage,
                Point2f(rowMappedPoints.front().x, rowMappedPoints.front().y),
                Point2f(rowMappedPoints.back().x, rowMappedPoints.back().y),
                Scalar(0, 0, 255), 2);
            line(inverseMappedImage,
                Point2f(rowMappedPoints.front().x, rowMappedPoints.front().y),
                Point2f(rowMappedPoints.back().x, rowMappedPoints.back().y),
                Scalar(0, 0, 255), 2);
        }
    }

    cout << "显示结果图像..." << endl;
    imshow("Original Image", undistortedImage);
    imwrite("Undistorted.png", undistortedImage);

    imshow("Distorted Image", distortedImage);
    imwrite("Distorted.png", distortedImage);

    imshow("Forward Mapped Image", forwardMappedImage);
    imwrite("ForwardMapped.png", forwardMappedImage);

    imshow("Inverse Mapped Image", inverseMappedImage);
    imwrite("Inverse.png", inverseMappedImage);
    waitKey(0);

    return 0;
}

上面就是标定过程的简单表述和流程表述，总的来说，HUD为了正常显示，需要预先得知风挡玻璃上的图像形状和投射出的图像形状之间的关系，使用这个关系便可以将图像进行预畸变，从而使得风档玻璃上的HUD图案能够显示无畸变的图像。

眼盒

在HUD中：眼盒的实际表现是光机投影范围与人眼可视范围的交集
project_mirror

1
2
3

眼盒是一个AR/VR中的概念，它指的是用户眼睛可以清晰看到完整虚像的区域范围。简单来说，眼盒是用户头部或眼睛在特定范围内移动时，仍然能够看到 HUD 或 AR 设备投射出的完整图像的空间。

用户眼睛在空间中的一个特定区域内，能够看到无畸变、完整虚像的区域，如果用户的眼睛超出眼盒范围，则可能会出现图像丢失、部分遮挡或失真的现象。驾驶员的头部位置可能因身高、座椅调节等因素而不同，因此需要一个足够大的眼盒来适应不同的驾驶员。合理的眼盒设计可以减少驾驶员因头部轻微移动而导致的图像丢失或变形问题。

1. 从人眼角度看：
眼盒是指驾驶员眼睛在空间中的一个特定区域范围，在这个区域内，用户能够清晰、无畸变地看到 HUD 投射出的虚像。
如果眼睛超出了眼盒范围（例如头部过高、过低或偏移），可能会出现图像部分丢失、遮挡或失真的现象。
因此，眼盒的大小直接影响用户的体验，尤其是不同身高、坐姿习惯的驾驶员对眼盒的需求差异较大。

2. 从光机投影角度看：
光机的设计决定了虚像的投射范围和光学系统的成像特性。
眼盒的大小和位置是由光机的光学设计（如反射镜角度、自由曲面镜形状、PGU 的输出参数等）决定的。
如果光机设计的眼盒较小，则用户的眼睛需要保持在非常精确的位置才能看到完整的虚像；如果眼盒较大，则可以适应更多不同的驾驶员姿势。

3. 两者的结合：
眼盒的实际表现是 光机投影范围与人眼可视范围的交集。
光机通过调整反射镜角度、自由曲面镜形状等光学元件，确保虚像能够在一定的空间范围内（即眼盒）清晰可见。
同时，眼盒的设计需要考虑人体工程学因素，例如驾驶员的平均坐姿高度、头部移动范围等，以确保大部分用户都能在自然状态下使用 HUD。

4. 眼盒设计
为了克服静态眼盒设计的局限性，现代 HUD 系统引入了 动态修正技术：

使用 DMS（驾驶员监控系统）实时检测驾驶员的眼部位置和头部姿态。
根据检测结果动态调整光机的投影参数（如反射镜角度、虚像距离等），从而扩大有效的眼盒范围。
动态修正的目标是让驾驶员无论处于什么坐姿或头部位置，都能清晰看到 HUD 投射的虚像。

结合DMS，可以通过实时检测驾驶员的眼部位置和头部姿态，动态调整 HUD 的显示内容，从而优化眼盒的利用效率。
W-HUD 的眼盒相对较小，因为其主要功能是将固定信息投射到固定的虚像平面上，对动态适应性要求较低。一般情况下，W-HUD 的眼盒设计为一个直径约 10-15 厘米的椭球形区域。AR-HUD 对眼盒的要求更高，因为其虚像需要与真实环境融合，且需要支持更大的视场角（FOV）和更远的虚像距离（VID）。AR-HUD 的眼盒通常设计为一个更大的区域（例如直径 20 厘米以上），以适应驾驶员的头部移动和动态显示需求。

增大眼盒通常需要更复杂的光学设计和更高的硬件成本。眼盒过小会导致用户体验下降，过大则可能导致光学系统体积增大和成本上升。要么优化设计要么优化算法。

手动修正

调研了实际的产品之后，有相关的体验，目前高端车型上的HUD以W-HUD和AR-HUD为主，例如腾势N9高端车使用了一个准-AR-HUD，也可以叫Mini AR-HUD可以看一下效果：

第一个视频是广汽hyper的HUD，高端车型，第二个是比亚迪腾势N9高端车型，对标理想L9的车型。可以看到，目前最高端的产品主要还是依赖手动调整HUD的高度。并且是准AR-HUD，并不是完全理论上的AR-HUD。明显的，坐上车感受到的是HUD的范围较小，虽然有障碍物提醒和AR地图导航，但是更像是一个伪装的3D，仍然是W-HUD与AR-HUD之间的一个范畴。

可以看到，调整项有亮度，高度，角度。高度和角度都有正负，对于高度，正是向上调整，负是向下调整，有一个0位置，是初始状态。对于角度来说，正是顺时针旋转，负是逆时针旋转，最大不超过2度。

动态修正

动态修正是更复杂的技术，当出厂标定的参数无法满足身高超过高眼盒范围的部分人群和喜欢将座椅调到特殊位置的人群，太高，HUD的反射光线无法正常投射到标定的眼盒范围内，会直接导致什么都看不见。由于不同驾驶员体型差异导致驾驶员可视范围差异较大，而HUD可满足的成像范围有限，因此需要调节成像范围满足不同驾驶员视野要求。现HUD内部采用可调节球面镜实现抬头显示投影光路的调节，通过转动可调球面镜，调节虚拟图像的成像角度范围，从而实现虚像高度的调整，满足不同驾驶员对成像范围的要求。

为了克服此类的问题，有动态修正算法。如果HUD设计的时候虚像范围本身就很广，即使人坐的高一些坐得低一些都可以看到，那么动态修正也许就不需要。但就目前的HUD技术水平来看，还不足以完全克服这个问题，所以完成量产化HUD的过程中还是需要相关的技术。
东风岚图追光HUD
这里有东风岚图追光的HUD说明手册，可以看到开启 HUD 高度自适应调节功能时，系统会提示驾驶员完成一次高度自适应调节。功能开启后，驾驶员每次系好安全带数秒后，系统将根据当前的视线范围自动调节 HUD 高度至匹配位置，因此每次使用时显示高度可能会略有差异。

动态修正的前提是有动态标定参数，这里举一个比较朴实的例子来说明。

由于眼盒是有范围的，那么可以用多组预先标定好的参数来克服不同高度的问题
在标定时，对不同高度，不同位置（左右偏差），注意这个位置是相对于驾驶员眼部高度和位置的。并且同一款车型，这个位置基本上是固定的。
那么：
- 有一组反射镜角度，这是个集合，能够让虚像投影到不同的高度上
- 对于每一个高度，有一个标定参数，这个参数能让反射镜的当前反射高度下的图像清晰化
- 标定时，采集多个高度的图像，生成多个标定参数
- DMS系统通过识别和监测当前驾驶位置人物的眼盒高度，计算这个高度落入哪个HUD参数区间
- 改变反射镜角度，调整HUD图像的高度，改变当前投影的参数，使画面清晰。

track_face
另一个带坐标系的例子：

1	ffplay -i /home/cty/self_project/DMS/6DRepNet/test_data/output_video.mp4

RetinaFace算法

具体怎么做呢？
HUD和驾驶员身高，座椅高度，当前驾驶员头部姿态都有关系，这几者形成了强耦合关系，是一个复杂几何系统，算法设计的切入点和目标是：驾驶员总能够清晰的看得见HUD。为了实现这个目标，并且可以调节的组件只有HUD光机的输出反射板角度和输出图像数据，就需要预先标定。

如何求取视线角度

这个问题本质上是眼球跟踪的范畴，使用算法准确的求解出当前人的视线在看哪。
最先进的Gaze技术可以查看每一年的Gaze技术论坛GAZE
目前保证精度的算法方向大致有两种：

[!NOTE] 基于几何模型的视线估计（Geometric gaze models）
Contents几何模型通常使用近红外光源或其他光源的角膜反射，通过已知几何形状来拟合眼球模型，从拟合的眼球模型中可以推断出视线方向。由于这些方法依赖于物理模型，因此可以很容易地推广到几乎没有训练数据的新对象，但代价是对输入噪声（例如部分遮挡或光照干扰）的敏感性更高。由于它们还依赖固定光源，因此在无约束环境中不可行。
一般来说，建模使用的依据是通过眼球表面的普尔钦斑点(第一级斑点)，所以光源的位置是不能变动的，同时头部位置也不能发生超过一定阈值的变动，它更适合用在佩戴式的设备上，例如眼镜，从固定光源发射，斑点位置相对固定，通过算法检测眼球中心和斑点之间的关系，带入物理模型即可得知当前眼球的姿态。

[!NOTE] 基于表观的视线估计模型（Appearance-based gaze models）
基于表观的方法使用带标注的眼睛或面部图像的大型数据集进行训练，可以学习更直接的图像到视线方向的映射。深度学习基于表观来建立映射模型，此时眼睛或面部检测的预处理步骤通常是必需的。当然也可以不依赖于眼睛或面部检测器，这使得它在所需特征被部分遮挡且不受约束的自然环境中实现了更高的鲁棒性，注视和头部姿势之间的依赖性可以通过隐式训练来解决，也可以通过单独的分支显式建模。

如何求取头部位姿

2、光机：

PGU图像产生单元

TFT-LCD

TFT-LCD：成本低，但亮度、对比度不足，强光下效果差。基于TFT-LCD的图像生成单元，其原理简单说，就是LCD屏幕在背光照射下，通过每个像素点后的薄膜晶体管控制液晶分子的旋转，以调整光线的明暗。然后，通过RGB滤色片，这些光线被转化为丰富多彩的图像。由于这种方案技术成熟且成本低，目前多数HUD供应商都选择使用它，确保高清晰度、高亮度和高对比度的图像显示。
DLP
DLP（数字光处理）：高亮度（＞1000nit）、高对比度，抗阳光干扰，但专利垄断导致成本高，多见于豪车。 DLP全称是Digital Light Processing，即数字光处理技术，其关键在于数字微镜芯片（DMD）。DMD芯片上集成了数百万个微型镜片，能精确控制光源发出的光线，并通过投影镜头在扩散片上形成图像。DLP技术因其高分辨率、高亮度和出色的成像效果，深受豪华品牌车型的青睐。然而，其复杂的光学结构和较高的设计成本也限制了其广泛应用，同时DLP方案可以较好的解决温度升高的问题，由于其固有的技术特性，在图像分辨率提升上存在一定的困难，成本也较高。
LCoS
LCoS（硅基液晶）：高分辨率、小体积，华为等企业重点布局，但存在偏振光与太阳镜兼容性问题。 LCOS全称为Liquid Crystal On Silicon，即硅基液晶投影技术，它是LCD技术的升级版。这种技术使用了一种特殊的CMOS集成电路芯片，芯片上涂有液晶硅。通过利用液晶的光学特性和硅芯片的电学特性，LCOS能够精确控制光的传播方向和强度，从而生成清晰、生动的图像。LCOS技术的优势在于高分辨率、更广的色域和出色的对比度。
我们常说的LCoS其实是一种基于液晶技术的光学元件，全称为Liquid Crystal on Silicon，直译为“硅基液晶”。 LCoS是基于液晶（Liquid Crystal）材料，与硅基集成电路技术相结合组成的一种反射型显示器件。其结构是在硅片上，利用半导体制程制作驱动面板，然后在电晶体上透过研磨技术磨平，并镀上铝当作反射镜，形成CMOS基板，然后将CMOS基板与含有透明电极之上玻璃基板贴合，再注入液晶，进行封装测试。LCoS技术的主要应用场景的优势是：技术成熟、模组成本低、显示占比高，LCoS技术的缺点是：需要照明单元导致模组复杂、存在背光、功耗高等
Mini-LED
Mini LED背光：新兴技术，支持分区控光，亮度达3000nit以上，色域广且耐高温，适配车载严苛环境。它和手机屏幕有类似之处，对每一个发光单元进行单独控制，可以视作一个亮度超高的大块成像屏幕单元。

LBS

激光振镜LBS。LBS方案是一种激光扫描式投影方案。它使用RGB激光模组发出红、绿、蓝三色光，经过透镜混合后照射到微小的MEMS微镜上。这个微镜在制动器的驱动下转动，从而扫描并形成图像。这种技术结构简洁、体积小，色彩表现更佳。不过，这一技术还不成熟，关键器件如激光光源、MEMS芯片等还需要更多的验证以确保其满足车规要求，另外还存在如亮度、散斑等问题需要进一步解决。这个技术的显著优点在于没有光窗问题，就是HUD显示的时候会较为纯净，没有背后若隐若现的白色漂浮背景

PGU选型的重要性

现在的主流HUD光机供应商，都有多种方案可选择，在成本，显示效果，开发成本，体积等方面，综合考虑对PGU的选型，对项目的推进是重要的，HUD是比摄像头、雷达等装车设计更复杂的车载零部件，要同时考虑体积，位置，效果，成本，涉及多个部门的协作和商议，对供应商或者集成供应商来说是巨大的挑战，但一旦有了成功的设计经验，嫡系车型或者改款车型可以长时间沿用。

光学投影单元

光学投影单元是HUD中体积占比最大的一部分，光学投影单元包含一级反射镜、二级反射镜、风挡玻璃等光学元件，作用是将PGU生成的图像，经过反射镜片多次反射后，将图像放大显示到前挡风玻璃前方，从而驾驶员在眼盒处便能观看到投影在远处的影像。

设计难点1–体积与性能的权衡

视场角、投影距离、眼盒大小是HUD产品的重要性能参数。视场角和投影距离决定了投影画面的可视角度和成像大小，视场角越大可显示的信息就越多，投影距离越远所显示的画面就越大，例如AR-HUD 产品需要达到10度的水平视场角以及7.5米以上的投影距离。眼盒大小决定了人眼可以看到图像的空间范围。为了实现更大的视场角、投影距离和眼盒大小，需要有足够的空间和距离给虚像进行反射和放大，大大提高HUD的结构复杂度和体积，增加HUD在车身中的布置难度，从而增加整体成本。目前体积与视场角、投影距离、眼盒大小之间的的权衡，是HUD设计的一大难点。
HUD_mirrors

设计难点2–阳光倒灌与散热

HUD的成像原理是PGU生成图像后，一部分光线通过反射镜与风挡的反射后进入人眼，从而在眼盒处便能观察到投影出的虚像。由于光路是可逆的，那么沿着原光路的太阳光，必定可以会聚进入PGU单元，如下右图中红色虚线箭头所示，从而引起HUD内部温度急剧升高。阳光倒灌问题要求HUD具备良好的耐高温性能，如果HUD散热性能不佳，在阳光直射和高温环境下容易造成光学和电子元件的损坏，影响HUD使用寿命。目前，保有量最大的PGU技术采用TFT方案，此方案阳光倒灌是普遍存在且急需解决的问题。而使用DLP及LCOS 技术的PGU，通过增加中继扩散膜，可以有效缓解阳光倒灌问题，但是由于成本过高，很少有应用于量产车型。因此，寻找一种低成本的阳光倒灌问题解决方案，是HUD技术的另一大难点。
HUD_sunshine

设计难点3–挡风玻璃

HUD需要使用专用楔形膜玻璃来抵抗和消除重影。因为汽车的前风档玻璃是多层结构，是典型的防爆玻璃，在内层和外层玻璃之间还有一层PVC膜，光路以某个角度入射到风挡玻璃上时，由于内外玻璃层反射角度略有不同，会产生多条互相影响的光路。解决这个问题的方法有两个，一个是改变前挡风玻璃中材料的形状，由均匀的平行PVC膜改为有一定角度的楔形膜，另一个就是研制光路预调制技术，通过改变输入的光路形状和图像，使用普通挡风玻璃也可以消除重影。这可以为车企节约大量的成本。

光波导

光波导技术是一个新的，可能是未来AR-HUD的形态。关于光波导的原理和概念，最典型的就是光纤，当然，它的原理也可以应用到成像上。

光波导的典型应用就是AR眼镜。

AR-HUD的安装体积非常大，给安全设计和仪表盘设计带来了一些麻烦，成本也随之升高，是目前行业的痛点。主流的光机厂商都在探索光波导技术

3、AR-HUD && ADAS Data

高精度地图

高精度地图是变道提示的时候必须的，这里的高精度和自动驾驶的厘米级的高精度地图不一样，仅需要车道级精度即可。

车道线检测

前车距离检测

前车障碍物检测

二、主流技术方向

AR-HUD：增强现实融合

将导航路径、障碍物预警（如行人标识）叠加于真实路面，提升驾驶沉浸感。代表车型：奔驰S级、问界M9、蔚来ES8。

全景HUD（P-HUD）

覆盖挡风玻璃下部（A柱到A柱），为全车乘员提供信息共享，如副驾娱乐交互。
硬件轻量化与多模态交互

小型化：激光扫描、光波导技术缩小模组体积，降低成本（如华为光路方案）。
交互升级：结合手势控制（问界M9）、语音指令，减少视线转移。

三、技术目标

[!NOTE] 第一阶段目标
W-HUD技术的追赶实现：

W-HUD是单焦像面的技术，第一阶段使用W-HUD光机对相关的技术进行探索和开发。
对W-HUD中间件移植，标定，高度调整，自适应高度调整，亮度调整，光机选型等方面进行探索，快速建立起HUD产品的可行性。
对于类似仪表的界面开发，探索使用现成引擎：例如Kanzi、 Unity、 UE等进行开发的快速方法。
对整个流程，摸索出一整套开发体系，如何对接和量产W-HUD产品
HSAE目前没有HUD光机的生产能力，软件部门的发力点是低延迟高吞吐量的高性能中间件，无畸变高清的高性能ARCreator，将光机视作为外设对待

[!第二阶段目标] 第二阶段目标
AR-HUD技术的研究部署，使用双焦面光机进行投影的技术。拓展W-HUD的成熟中间件，并增加组件：与ADAS系统的全面对接。
AR-Creator 层算法开发，研发如何注册与ADAS等元素到虚拟像面的算法
开发mini-AR-HUD产品到AR-HUD产品的跨越
对外形成HUD产品，对内形成AR-Creator开发产品，HUD中间件产品

[!第三阶段技术目标] 第三阶段目标
光波导光机方案的联合开发，下一代AR-HUD产品开发
形成完整的AR-HUD软件开发能力，适配多个HUD光机厂商

三、市场发展现状

渗透率：

2024年中国前装HUD搭载量达356.49万辆（+55.86%），渗透率15.55%；其中AR-HUD增速迅猛（88.43万辆，+273.42%）。预计2029年全球市场规模将达39.17亿美元（CAGR 14.8%）。

国产化突破：

华阳集团（长安、蔚来供应商）、宇瞳光学（批量出货）、德赛西威（AR-HUD娱乐融合）等企业打破海外垄断。

五、未来趋势

内容升级：从基础信息（车速、导航）转向环境感知（障碍物高亮、盲区预警）。

多屏联动：与中控屏、语音助手协同，实现多模态交互（如小鹏P7的语音+HUD融合）。

车路协同终端：通过V2X显示红绿灯状态、事故预警等超视距信息。

成本下探：Mini LED等技术普及推动AR-HUD向中端车型渗透（2025年预计搭载率45%）。

注：技术迭代下，C-HUD已基本退出市场，W-HUD为当前主力，AR-HUD及全景HUD代表未来方向。国产供应链的成熟将加速技术平民化进程。

根据泽景电子招股说明书显示，虽然生意越做越大，但研发投入和财务成本较高，导致泽景电子还处于亏损状态，且资产负债率较高。数据显示，2022年-2024年，泽景电子营业收入分别从2.14亿元增长至5.78亿元，三年累计净亏损达5.69亿元。到2024年末，泽景电子的资产负债率高达215.6%，其中流动负债净额9.66亿元。此外，目前市场上的AR HUD产品采用的是定制化的开发方式，不同车型配备的AR HUD产品不同，导致HUD厂商无法依靠平台化的开发方式降低生产成本。

五、参考资料

华阳AR-HUD技术分析
 简要HUD光学原理
 发展趋势
 mediapip face mesh
佐思汽研调研报告
 CES2025 P-HUD
AR-HUD的理解