前言

伴随着无人驾驶技术的发展，越来越多人接触到了更新的科技，也越来越好奇计算机世界到底是如何实现自动驾驶，而自动驾驶系统附带的某些功能又是如何实现的也引起了很多人的好奇。这次将讲述并且实践系统中 「360° 倒车影像」背后的算法逻辑。

逆透视变换

在画面获取时，整车会调用多个摄像头，拼成一幅「360°全景照片」

而形成俯视视角的 「360° 倒车影像」 要经过一层数学运算，也就是逆透视变换，简称IPM。

在这个领域，有很多种IPM变换方式，比如「对应点对单应变换方法」、「简化相机模型逆透视变换」，但都利用了矩阵的变换法则。

对应点对单应变换方法

这个变化方式相对简单，不过多描述。

输入至少四个对应点对，不能有三点及以上共线，不需要知道摄相机参数或者平面位置的任何信息，利用点对，求解透视变换矩阵，其中矩阵是一个三阶方阵，因此可以构建一个线性方程求解。如果大于四个点，可以使用 $ransac$ 方法求解，而选点的方法通常采用手动选取，一般是选择消失点。

$$

\begin{bmatrix} ti x'i \ ti y'i \ ti \end{bmatrix} = map_matrix \cdot \begin{bmatrix} xi \ y_i \ 1 \end{bmatrix}

$$

$$

dst(i) = (x'i, y'i), src(i) = (xi, yi), i = 0, 1, 2, 3

$$

这个变化在代码上实现相对简单，可以相对容易实现 IPM 变换，这里就不再过多赘述，也不提供代码示例。

简化相机模型 IPM方法

这是这次重点要解析的变换方法，这个算法的本质是利用相机成像过程中的各种坐标之间的转换关系，再对它进行抽象和简化，最终得到的世界坐标。

然后再建立世界坐标与图像坐标的对应关系，使用该关系进行数学变换得来。

不同于某些复杂、冗长的计算公式，这里我们依旧采用坐标运算。针对这种 IPM 计算方法，我们需要先测量摄像头实际参数。

这里仰角 $θ$ 为 $23°$，中心高度 $H$ 为 $37 cm$，视点到视平面距离 $d$ 为 $87 cm$，然后求世界坐标 $P_W$。

设摄像头图像坐标为 $\boldsymbol{P_G} = (x, y, z, 1)$，并由世界坐标与图像坐标的关系建立矩阵方程，

$$ \boldsymbol{PG} = \boldsymbol{PW} \begin{bmatrix} 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & -H & 1 \end{bmatrix} \begin{bmatrix} \cos\theta & 0 & -\sin\theta & 0 \ 0 & 1 & 0 & 0 \ \sin\theta & 0 & \cos\theta & 0 \ 0 & 0 & 0 & 1 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 & 0 & \frac{1}{d} \ 0 & 1 & 0 & 0 \ 0 & 0 & 1 & 0 \ 0 & 0 & 0 & 1 \end{bmatrix}. \tag{1} $$

将图像坐标代入式$(1)$，求得世界坐标的矩阵，即

$$ \boldsymbol{P_W} = \left[ \frac{x\cos\theta - z\sin\theta}{1 - \frac{x}{d}} \quad \frac{y}{1 - \frac{x}{d}} \quad \frac{x\sin\theta + z\cos\theta - \frac{H}{d}}{1 - \frac{x}{d}} \quad 1 \right]. \tag{2} $$

令 $A = H\cos\theta$ 以及 $B = -d$ 还有 $C = d\sin\theta - \frac{H}{d}$ 以及 $D = \cos\theta$ 还有 $E = d\sin\theta$，由几何关系可知 $x\sin\theta + z\cos\theta - \frac{H}{d} = 0$。求得 $\boldsymbol{P_W}$ 最简形式为

$$ \boldsymbol{P_W} = \left[ \frac{A + Bz}{C + Dz} \quad \frac{Ey}{C + Dz} \quad 0 \quad 1 \right]. \tag{3} $$

最后，处理图像。由于所处理的图像是二位平面图，故图像深度恒为0。根据$(3)$，只需要把数组的横纵坐标带入，即可求得世界坐标下坐标值，即 IPM 后的俯视图。

#include <cmath>
#include <cstdint>
#include <vector>
#include <algorithm>

namespace ipm
{
    // =========================
    // 基础数据结构
    // =========================

    struct Vec3
    {
        double x;
        double y;
        double z;
    };

    struct GroundPoint
    {
        double X;     // 世界坐标 X（左右）
        double Y;     // 世界坐标 Y（前后）
        bool valid;   // 是否与地面有有效交点
    };

    struct CameraParam
    {
        // 焦距（像素单位）
        // 如果你只有一个 d，可以令 fx = fy = d
        double fx;
        double fy;

        // 主点（通常是图像中心）
        double cx;
        double cy;

        // 相机离地高度，单位例如 cm
        double H;

        // 相机向下俯角（弧度）
        double pitch;
    };

    struct IPMParam
    {
        // 输出俯视图尺寸
        int outWidth;
        int outHeight;

        // 世界坐标范围（单位与 H 一致，例如 cm）
        // X: 左右范围
        // Y: 前后范围
        double minX;
        double maxX;
        double minY;
        double maxY;
    };

    // =========================
    // 工具函数
    // =========================

    inline double clampDouble(double v, double lo, double hi)
    {
        return (v < lo) ? lo : ((v > hi) ? hi : v);
    }

    inline uint8_t clampToByte(double v)
    {
        if (v < 0.0) return 0;
        if (v > 255.0) return 255;
        return static_cast<uint8_t>(v + 0.5);
    }

    // 绕 X 轴旋转：把相机坐标系下的方向，转到世界坐标系
    // 这里假定：
    // - 世界 Z 轴向上
    // - 相机光轴默认朝世界 Y 正方向
    // - pitch > 0 表示相机向下俯视
    //
    // 为了和图像坐标（v向下）匹配，构造一个工程上常用的映射：
    //
    // 相机系射线 rc = [x, y, 1]
    // 先映射到“未俯仰时”的世界方向：
    //   x -> Xw
    //   y -> -Zw
    //   z -> Yw
    //
    // 再绕世界 X 轴旋转 pitch
    //
    inline Vec3 cameraRayToWorldRay(const Vec3& rc, double pitch)
    {
        // 未俯仰时的世界方向
        // 相机右 -> 世界右
        // 相机下 -> 世界负上
        // 相机前 -> 世界前
        const double X0 = rc.x;
        const double Y0 = rc.z;
        const double Z0 = -rc.y;

        const double c = std::cos(pitch);
        const double s = std::sin(pitch);

        // 绕 X 轴旋转
        Vec3 rw;
        rw.x = X0;
        rw.y = c * Y0 - s * Z0;
        rw.z = s * Y0 + c * Z0;

        return rw;
    }

    // =========================
    // 像素点 -> 地面世界坐标
    // =========================
    //
    // 输入像素点 (u, v)，计算它在地面 Z=0 上对应的世界点 (X, Y)
    //
    // 注意：
    // 1. 如果这条射线朝天或者平行地面，则 invalid
    // 2. fx, fy 用像素单位
    // 3. H 的单位决定输出世界坐标单位
    //
    inline GroundPoint imagePixelToGround(
        double u,
        double v,
        const CameraParam& cam)
    {
        // 1) 像素坐标 -> 相机归一化坐标
        Vec3 rc;
        rc.x = (u - cam.cx) / cam.fx;
        rc.y = (v - cam.cy) / cam.fy;
        rc.z = 1.0;

        // 2) 相机射线 -> 世界射线
        Vec3 rw = cameraRayToWorldRay(rc, cam.pitch);

        // 3) 相机中心在世界坐标中的位置
        // Cw = (0, 0, H)
        // 射线方程：P(t) = Cw + t * rw
        //
        // 与地面 Zw = 0 相交：
        // H + t * rw.z = 0  =>  t = -H / rw.z
        //
        GroundPoint gp{};
        gp.valid = false;

        // 射线没有指向地面，或者几乎平行地面
        if (std::abs(rw.z) < 1e-12)
            return gp;

        const double t = -cam.H / rw.z;

        // 只接受“向前”的交点
        if (t <= 0.0)
            return gp;

        gp.X = t * rw.x;
        gp.Y = t * rw.y;
        gp.valid = true;
        return gp;
    }

    // =========================
    // 世界坐标 -> 俯视图像素
    // =========================
    //
    // 把地面点 (X, Y) 映射到输出俯视图中的 (bx, by)
    //
    // 输出图约定：
    // - 左边是 minX，右边是 maxX
    // - 上边是 maxY（更远处）
    // - 下边是 minY（更近处）
    //
    inline bool groundToBirdPixel(
        double X, double Y,
        const IPMParam& ipmParam,
        double& bx, double& by)
    {
        if (X < ipmParam.minX || X > ipmParam.maxX ||
            Y < ipmParam.minY || Y > ipmParam.maxY)
        {
            return false;
        }

        const double xRatio =
            (X - ipmParam.minX) / (ipmParam.maxX - ipmParam.minX);

        const double yRatio =
            (Y - ipmParam.minY) / (ipmParam.maxY - ipmParam.minY);

        // X 从左到右
        bx = xRatio * (ipmParam.outWidth - 1);

        // 希望“远处在图像上方”
        by = (1.0 - yRatio) * (ipmParam.outHeight - 1);

        return true;
    }

    // =========================
    // 双线性采样（灰度图）
    // =========================
    inline uint8_t bilinearSampleGray(
        const uint8_t* src,
        int width,
        int height,
        int stride,
        double u,
        double v)
    {
        if (u < 0.0 || v < 0.0 || u > width - 1.0 || v > height - 1.0)
            return 0;

        const int x0 = static_cast<int>(std::floor(u));
        const int y0 = static_cast<int>(std::floor(v));
        const int x1 = std::min(x0 + 1, width - 1);
        const int y1 = std::min(y0 + 1, height - 1);

        const double dx = u - x0;
        const double dy = v - y0;

        const double p00 = src[y0 * stride + x0];
        const double p10 = src[y0 * stride + x1];
        const double p01 = src[y1 * stride + x0];
        const double p11 = src[y1 * stride + x1];

        const double v0 = p00 * (1.0 - dx) + p10 * dx;
        const double v1 = p01 * (1.0 - dx) + p11 * dx;
        const double val = v0 * (1.0 - dy) + v1 * dy;

        return clampToByte(val);
    }

    // =========================
    // 双线性采样（RGB 三通道）
    // 每像素 3 字节，RGBRGB...
    // =========================
    inline void bilinearSampleRGB(
        const uint8_t* src,
        int width,
        int height,
        int stride,
        double u,
        double v,
        uint8_t outRGB[3])
    {
        if (u < 0.0 || v < 0.0 || u > width - 1.0 || v > height - 1.0)
        {
            outRGB[0] = outRGB[1] = outRGB[2] = 0;
            return;
        }

        const int x0 = static_cast<int>(std::floor(u));
        const int y0 = static_cast<int>(std::floor(v));
        const int x1 = std::min(x0 + 1, width - 1);
        const int y1 = std::min(y0 + 1, height - 1);

        const double dx = u - x0;
        const double dy = v - y0;

        const uint8_t* p00 = src + y0 * stride + x0 * 3;
        const uint8_t* p10 = src + y0 * stride + x1 * 3;
        const uint8_t* p01 = src + y1 * stride + x0 * 3;
        const uint8_t* p11 = src + y1 * stride + x1 * 3;

        for (int c = 0; c < 3; ++c)
        {
            const double v0 = p00[c] * (1.0 - dx) + p10[c] * dx;
            const double v1 = p01[c] * (1.0 - dx) + p11[c] * dx;
            const double val = v0 * (1.0 - dy) + v1 * dy;
            outRGB[c] = clampToByte(val);
        }
    }

    // =========================
    // 俯视图像素 -> 世界坐标
    // =========================
    //
    // 这是做“逆映射”的关键：
    // 对输出俯视图的每个像素，先求它在世界地面的点，
    // 再反算它在原图中的位置，最后从原图采样。
    //
    inline void birdPixelToGround(
        double bx,
        double by,
        const IPMParam& ipmParam,
        double& X,
        double& Y)
    {
        const double xRatio = bx / (ipmParam.outWidth - 1);
        const double yRatio = 1.0 - by / (ipmParam.outHeight - 1);

        X = ipmParam.minX + xRatio * (ipmParam.maxX - ipmParam.minX);
        Y = ipmParam.minY + yRatio * (ipmParam.maxY - ipmParam.minY);
    }

    // =========================
    // 世界地面点 -> 原图像素
    // =========================
    //
    // 已知世界点 (X, Y, 0)，反投影到输入图像，便于做逆映射采样。
    //
    inline bool groundToImagePixel(
        double X,
        double Y,
        const CameraParam& cam,
        double& u,
        double& v)
    {
        // 世界点 Pw = (X, Y, 0)
        // 相机中心 Cw = (0, 0, H)
        // 世界方向向量 d_w = Pw - Cw = (X, Y, -H)
        const double dwx = X;
        const double dwy = Y;
        const double dwz = -cam.H;

        // 需要把世界方向转回相机方向
        // cameraRayToWorldRay 里用的是：Rw = Rx(pitch) * base
        // 因此这里做逆旋转：Rx(-pitch)
        const double c = std::cos(cam.pitch);
        const double s = std::sin(cam.pitch);

        // 先逆旋转到未俯仰状态
        const double X0 = dwx;
        const double Y0 = c * dwy + s * dwz;
        const double Z0 = -s * dwy + c * dwz;

        // 再映射回相机坐标
        // base: [X0, Y0, Z0] = [xc, zc, -yc]
        const double xc = X0;
        const double yc = -Z0;
        const double zc = Y0;

        // 在相机后方，无效
        if (zc <= 1e-12)
            return false;

        u = cam.fx * (xc / zc) + cam.cx;
        v = cam.fy * (yc / zc) + cam.cy;
        return true;
    }

    // =========================
    // 灰度图 IPM
    // =========================
    //
    // src: 输入灰度图
    // dst: 输出灰度图，需由外部分配 outHeight * dstStride 字节
    //
    inline void warpIPMGray(
        const uint8_t* src,
        int srcWidth,
        int srcHeight,
        int srcStride,
        uint8_t* dst,
        int dstStride,
        const CameraParam& cam,
        const IPMParam& ipmParam)
    {
        for (int by = 0; by < ipmParam.outHeight; ++by)
        {
            uint8_t* dstRow = dst + by * dstStride;

            for (int bx = 0; bx < ipmParam.outWidth; ++bx)
            {
                // 1) 输出俯视图像素 -> 世界地面点
                double X, Y;
                birdPixelToGround(static_cast<double>(bx),
                                  static_cast<double>(by),
                                  ipmParam, X, Y);

                // 2) 世界地面点 -> 原图像素
                double u, v;
                if (!groundToImagePixel(X, Y, cam, u, v))
                {
                    dstRow[bx] = 0;
                    continue;
                }

                // 3) 双线性采样
                dstRow[bx] = bilinearSampleGray(src, srcWidth, srcHeight, srcStride, u, v);
            }
        }
    }

    // =========================
    // RGB 图 IPM
    // =========================
    //
    // src: 输入 RGB 图，按 RGBRGB... 排列
    // dst: 输出 RGB 图，按 RGBRGB... 排列
    //
    inline void warpIPMRGB(
        const uint8_t* src,
        int srcWidth,
        int srcHeight,
        int srcStride,
        uint8_t* dst,
        int dstStride,
        const CameraParam& cam,
        const IPMParam& ipmParam)
    {
        for (int by = 0; by < ipmParam.outHeight; ++by)
        {
            uint8_t* dstRow = dst + by * dstStride;

            for (int bx = 0; bx < ipmParam.outWidth; ++bx)
            {
                double X, Y;
                birdPixelToGround(static_cast<double>(bx),
                                  static_cast<double>(by),
                                  ipmParam, X, Y);

                double u, v;
                if (!groundToImagePixel(X, Y, cam, u, v))
                {
                    uint8_t* p = dstRow + bx * 3;
                    p[0] = p[1] = p[2] = 0;
                    continue;
                }

                uint8_t rgb[3];
                bilinearSampleRGB(src, srcWidth, srcHeight, srcStride, u, v, rgb);

                uint8_t* p = dstRow + bx * 3;
                p[0] = rgb[0];
                p[1] = rgb[1];
                p[2] = rgb[2];
            }
        }
    }

}

如果你还在为边缘计算下"既要又要"而犯愁，那么这篇文章或许值得一看。

Abstract

在轻量级卷积神经网络的设计中，如何在有限的 FLOPs 下平衡“局部感受野”与“全局空间感知”始终是一个核心难题。

传统的 $3 \times 3$ 卷积受限于感受野大小，而常规的 SE-Block 注意力机制则因全局池化操作导致了空间位置信息的坍塌，为此特地开发了一种新型算子。该结构创新性地融合了 $5 \times 5$ 大核深度卷积 与 坐标注意力机制（Coordinate Attention），并通过 强制残差策略与 GroupNorm 优化，成功构建了一种对硬件友好且具备鲁棒位置编码能力的特征提取范式。

1.设计动机与理论背景

在分析代码之前，我们需要理解该模块试图解决的三个核心痛点：

• 有效感受野（ERF）的局限性：传统轻量级网络过度依赖 $3 \times 3$ 卷积堆叠。根据研究，深层网络的实际有效感受野往往呈高斯分布且随深度衰减，难以捕捉大尺度语义目标。
• 空间语义的错位（Spatial Misalignment）：标准的 SE 模块通过 Global Average Pooling 将特征图压缩为 $1 \times 1 \times C$，虽然强化了通道依赖，却彻底丢失了物体的空间坐标信息。

• 微批次统计的不稳定性（Micro-Batch Instability）：在端侧设备进行迁移学习或微调时，受限于显存，Batch Size 往往极小（如 2 或 4），此时 BatchNorm 的统计量估计将产生巨大偏差，导致训练发散。

  而本次构建的注意力融合卷积核正是基于上述理论背景提出的解决方案。

2.核心架构拆解

该模块并非简单的层级堆叠，而是一个精心设计的特征重构闭环。以下结合代码逻辑，分步骤进行深度剖析：

2.1大核深度卷积带来的归纳偏置

代码实现：

self.dw_conv = nn.Conv2d(c1, c1, kernel_size=5, stride=s, padding=2, groups=c1, bias=False)

设计：将卷积核从 $3 \times 3$ 提升至 $5 \times 5$。从信息论角度看，这增加了单个神经元的“可视区域”。

理论优势： $5 \times 5$ 卷积的感受野面积是 $3 \times 3$ 的 $25/9 \approx 2.78$ 倍。在轻量级网络（如 MobileNetV3）中，这种大核深度卷积 能有效模拟 Transformer 中的 Token Mixer 行为，增强对纹理和形状的捕捉能力，且 NCNN 等推理框架对 $5 \times 5$ DW 算子已具备极高的 Winograd 算法优化支持。

2.2 正交特征分解与坐标注意力

这是本模块的“灵魂”。不同于 SE 的全局池化，该模块利用两个正交的 1D Global Pooling 操作将空间信息分解。

步骤 I：正交投影

x_h = self.pool_h(feat)  # Output: (N, C, H, 1)
x_w = self.pool_w(feat)  # Output: (N, C, 1, W)

• 数学表征：输入张量 $X$ 被分别沿水平坐标 $X$ 和垂直坐标 $Y$ 进行聚合。这种操作生成了两个方向感知特征图，使得网络能够捕捉沿着一个空间方向的长距离依赖，同时保存另一个方向的精确位置信息。

步骤 II：跨维度交互与降维

y = torch.cat([x_h, x_w], dim=2)
y = self.conv_pool(y)
y = self.gn(y) # GroupNorm for stability

• 优化策略： 此处引入了 reduction=16 的瓶颈层以降低模型复杂度。

• 改进： GroupNorm 的引入是点睛之笔。在注意力分支的中间层，特征通道被压缩，且往往伴随着极小的 Batch Size。GN 将通道分组进行归一化，其统计量不依赖于 Batch Size，从而解决了在微调任务中 BN 层导致的“统计量漂移”问题。

步骤 III：注意力重校准

a_h = self.conv_h(x_h).sigmoid()
a_w = self.conv_w(x_w).sigmoid()
out = identity_feat * a_w * a_h

• 特征融合： 最终的输出特征图是通过原始特征与两个方向的注意力图进行 Hadamard Product 得到的。这相当于为特征图上的每一个像素点 $(i, j)$ 赋予了一个基于全局上下文计算的“重要性权重”。

2.3 强制残差流

if self.use_res:
    return x + out

• 梯度流保护： 注意力机制本质上是一种“Soft Gating”。在训练初期，注意力权重可能接近于零。强制残差连接构建了一条 恒等映射 通路，确保了在最坏情况下（注意力层失效），该模块退化为标准的卷积层，从而保证了深层网络梯度的有效反向传播，避免了梯度消失。

3. 详细执行流与张量演化

为了更清晰地展示该模块内部的数据流转，我们将 Forward 过程形式化为以下详细步骤：

1. 空间特征提取：

• 输入 $X \in \mathbb{R}^{N \times C_1 \times H \times W}$。

• 经过 $5 \times 5$ DWConv $\rightarrow$ $1 \times 1$ PWConv $\rightarrow$ BN $\rightarrow$ Hardswish。

• 输出中间特征 $F \in \mathbb{R}^{N \times C_2 \times H \times W}$。

2. 坐标信息编码：

   • H-Pooling: 将 $F$ 压缩为 $Z^h \in \mathbb{R}^{N \times C_2 \times H \times 1}$。
   • W-Pooling: 将 $F$ 压缩为 $Z^w \in \mathbb{R}^{N \times C_2 \times 1 \times W}$。

3. 变换与激活 ：

• 拼接 $Z^h$ 与 $Z^w$ 并通过 $1 \times 1$ 卷积降维至 $C_{mid}$。
• 应用 GroupNorm(1, mip) 进行归一化（此处 Group=1 等效于 LayerNorm，但针对通道维度）。
• 应用 Non-linear 激活函数。

4. 解码与重加权：

• 将特征张量重新切分为空间感知的权重向量 $A^h$ 和 $A^w$。
• $Y = F \odot A^h \odot A^w$ （其中 $\odot$ 表示广播机制下的逐元素相乘）。

5. 特征重构 (Reconstruction)：

• 最终输出 $O = X + Y$ (若满足残差条件)。

4. 实验验证与数据可视化

为了验证 该卷积核 在真实场景中的有效性，我们在受控环境下进行了严格的对比实验。

实验设置：

• 数据集：自定义检测数据集（包含警棍、手电筒、刀具等高相似度类别）。

• 训练策略：SGD 优化器，Cosine LR 调度，训练周期为 5000 Epochs（以确保模型完全收敛）。

Baseline：仅将本模块替换为标准的 3x3 DWConv，其余网络架构保持完全一致。

4.1 总体性能评估：计算量与精度的权衡 (Trade-off Analysis)

数据解读： 如上表所示，该卷积核 在参数量几乎不增加、FLOPs 仅增加 0.05G（几乎可忽略不计）的前提下，实现了 mAP@50-95 惊人的 10% 绝对增长。这证明了该模块并非通过简单的堆砌参数换取性能，而是通过更高效的空间特征建模提升了模型的表征能力。

4.2 难例挖掘与细粒度分类

在测试中“类间相似性” 是最大的挑战。

例如，长条形的“警棍”与“手电筒”在低分辨率下极难区分。

我们提取了模型在这些特定类别上的 Top-1 准确率 (Accuracy) 进行对比分析：

5. Conclusion

该算子展示了一种极具前瞻性的轻量级网络设计思路。

1. 通过 $5 \times 5$ 卷积 引入了更强的空间归纳偏置。
2. 通过 坐标注意力 解决了标准 CNN 缺乏位置感知能力的问题。
3. 通过 GroupNorm 和 Hardswish 展现了优秀的工程落地意识，使其在 小样本微调 和端侧推理 场景下具有极高的实用价值。

该模块不仅是一个即插即用的组件，更为后续的轻量级检测网络设计提供了一个标准的空间-通道解耦 范式。