PCL点云处理：射线与AABB包围盒相交检测原理与实现

做点云处理的朋友迟早会碰到这么一个问题：一根射线从某个点出发，朝一个方向打过去，它究竟有没有打中某个AABB包围盒？如果打中了，入射点在哪、距离是多少？这听起来是个很底层的几何问题，但实际项目里十有八九会用到。PCL里做点云拾取、激光雷达射线模拟、空间查询、目标检测结果筛选，全都绕不开射线与AABB包围盒的相交判定。这篇文章把我自己在PCL里把这个功能从原理到代码完整跑通的经验整理出来，包括数学推导、PCL自带工具的用法、手写实现细节，还有几个容易踩的坑，适合正在做点云可视化交互、碰撞检测或者空间索引查询的开发者参考。

1. 为什么射线与AABB包围盒求交是空间分析里绕不开的一步

1.1 射线在点云里的典型工作场景

先说说射线与包围盒求交到底在哪些场景出现。最直观的是鼠标拾取。你用PCLVisualizer显示一帧点云，用户鼠标点了一下屏幕上的某个位置，程序怎么知道用户点中了哪个物体？常规做法是把鼠标点击坐标反投影成一条三维射线，然后拿这条射线去和场景里各个物体的包围盒做相交测试，命中之后再做更精细的检测。如果没有这一步，拾取功能就得遍历所有点，几百万个点逐个算距离，帧率立马崩掉。

第二个场景是激光雷达仿真。机器人或自动驾驶领域常用PCL做传感器模拟，从一个位置发射若干条射线，模拟激光打出去之后的回波。射线打到的第一个物体就是“障碍物”。如果对每条射线直接遍历点云找最近点，复杂度高到无法接受，通常是先对场景做体素或包围盒划分，然后只对射线穿过的那些空间区域做精细检测。

第三个场景是目标检测结果的快速过滤。比如你先用一个算法框出了一堆候选目标，每个目标有一个3D包围盒，接下来要判断另一个点或另一条路径是否与这些目标冲突。这时候用射线与AABB相交测试做初筛，能瞬间把几百个候选目标里的绝大多数排除掉，只留下真正可能相关的几个，后面再上精确计算。

这里说的AABB不是点云里每个点，而是包含了一簇点的轴对齐最小长方体。把“一堆点”的问题先转化成“一个盒子”的问题，是几乎所有空间加速算法的基础思路。

1.2 用AABB而不是直接拿点云里的精确点做求交

我见过不少人一上来就写一个函数，遍历点云里所有点，求射线到每个点的距离，然后找最小距离。这种做法在点数量少的时候没问题，但点云动辄几十万上百万个点，每条射线都要全量遍历一次，完全不具备实时性。

包围盒的作用是把问题的规模先降一个量级。AABB是最简单的包围盒形式，它不需要存储旋转信息，只保存两个对角点：最小点（min）和最大点（max），六个面分别平行于三个坐标轴。正因为面与轴平行，相交计算可以用非常小的开销完成，全程只需要若干次加减法和除法，没有任何三角函数、矩阵乘法这类重计算。这是AABB能在实时系统里存活下来的根本原因。

在实际项目中，我习惯把计算分成两段：先用AABB做粗检测，剔除掉大部分明显不相交的物体；对命中的物体，再根据业务需求决定是否进一步用点级数据做精检测。这样做的好处是，粗检测阶段极快，精检测阶段的数据量被压到很小，整体性能能提升一到两个数量级。射线与AABB相交测试就是这套流程里最关键的第一道关卡。

1.3 三种常用包围盒该怎么选

除了AABB，常用的还有OBB（有向包围盒）和球形包围盒。做技术选型时应该清楚它们的差异。

PCL场景里我大部分时间选AABB。原因有两个：一是PCL自身的八叉树和体素结构天然基于轴对齐空间划分，AABB与这些结构完美契合；二是点云数据本身没有“朝向”的概念，即使物体有姿态，你通常也只关心它落在哪个空间范围，AABB的冗余空间在多数情况下可以接受。只有在做精细的刚体碰撞检测、物体需要旋转时，才值得引入OBB。从计算角度看，AABB求交只需要三次区间判定的逻辑，而OBB要处理轴投影和分离轴定理，代码量和性能开销都明显上了一个台阶。

2. 数学原理：射线与AABB的相交判定到底在算什么

2.1 射线方程和AABB的两种表达方式

射线在三维空间里可以用一个起点加一个方向向量完整描述：

P(t) = origin + t * dir, t >= 0

其中origin是射线起点，dir是方向向量，t是距离参数。当t = 0时就是在起点位置，t越大离起点越远。射线和线段的区别就在于t的定义域：射线要求t >= 0，线段则限制在某个区间内。

AABB的表达方式一般有两种。一种是“最小点-最大点”式：min_bound和max_bound，分别代表长方体在三个坐标轴上的最小值和最大值。另一种是“中心点-半径”式：center和half_extent。前一种直观，后一种在某些推导里更简洁。PCL里通过getMinMax3D拿到的正是前一种格式，我后面写的代码也统一用最小点和最大点。

AABB本质上是在三个轴上各自定义一个封闭区间：

x in [min_x, max_x] y in [min_y, max_y] z in [min_z, max_z]

射线与AABB相交，等价于射线的参数t在三个轴方向上都能落入对应的区间。这就把一个三维求交问题拆成了三个一维区间问题。

2.2 Slab法：把三维求交拆成三个一维区间问题

Slab法（也叫几何分支求交法）是解决射线与AABB相交的主流方法。它的思路很朴素：AABB在空间中可以看作三组平行平面的交集，射线要穿过这个盒子，就必须依次穿过三组平面。

对每一个坐标轴，我们都能算出射线进入该轴方向两个平面对应的t值。以x轴为例：

t1 = (min_x - origin_x) / dir_x t2 = (max_x - origin_x) / dir_x

注意dir_x可能为负，所以t1和t2的大小关系不确定。我们统一取：

t_entry_x = min(t1, t2) t_exit_x = max(t1, t2)

对y轴和z轴做同样的计算，得到三个区间：

[t_entry_x, t_exit_x] [t_entry_y, t_exit_y] [t_entry_z, t_exit_z]

射线真正穿过AABB的部分，是这三个区间的交集。令：

t_near = max(t_entry_x, t_entry_y, t_entry_z) t_far = min(t_exit_x, t_exit_y, t_exit_z)

如果全局的t_near <= t_far，并且t_far >= 0，说明射线确实在某个范围里位于盒子内部，相交成立。相交点坐标可以由origin + t_near * dir给出，t_near的意义就是射线起点到进入盒子的距离。

这个方法之所以叫Slab法，是因为它把AABB理解成三组“薄板”（slab）夹出来的区域，每组薄板由两个平行平面定义。你不需要判断射线和每个面具体交在哪，只需要分别处理三个轴的区间，最后合并结论即可。整个过程没有分支预测复杂化的问题，对CPU流水线也很友好。

2.3 边界条件：方向为0、起点在盒内、正好擦边

原理讲完，实际编码时真正的门槛是边界条件。我列出几个必须处理的特殊情况。

第一种是方向向量的某个分量为0。比如dir_x = 0，意味着射线在x方向没有移动，此时射线要么一直处于某个x值，永远不接近x方向的两个平面。判断方法很直接：如果origin_x不在[min_x, max_x]区间里，射线不可能与盒子相交；如果origin_x在区间里，这一轴不构成约束，直接跳过。这就是代码里那个fabs(dir[axis]) < 1e-8分支要做的事。

第二种是射线起点已经在AABB内部。直觉上，这算是相交，而且t_near应该为0，因为射线一开始就等于在盒子里。代码里t_near的初始值设为0，就是为了处理这种情况。如果你希望“从内部出发”不算命中，需要把初始值改成负无穷或加一个t_near下限判断，具体看业务需求。

第三种是射线恰好擦过AABB的边或顶点。比如射线刚好经过盒子的一条棱，此时t_near和t_far可能相等。按t_near <= t_far的判定，这是相交。工程上通常接受这个结果，因为浮点数精度很难保证“恰好擦边”的精确判定，与其纠结边界上的模糊情况，不如直接算命中。如果你需要严格排除这种情况，可以给t_near和t_far的差值加一个极小阈值（比如1e-6），但大多数场景没必要。

还有一点容易被忽略：求交前是否对方向向量做了归一化。如果dir是单位向量，t_hit就是射线起点到交点的欧氏距离；如果dir不是单位向量，t_hit只是参数距离，不是真实米制距离。这个坑我后面会专门说。

3. PCL环境下三种实现方式

3.1 PCL自带工具函数直接用

如果你用的是PCL 1.12或更高版本，官方在pcl/geometry/geometry.h里提供了一个现成函数：pcl::geometry::rayIntersectsWithBox。这个函数可以直接拿着用，不需要自己造轮子。

大概用法是这样：

#include <pcl/geometry/geometry.h> Eigen::Vector3f origin(0.0f, 0.0f, 0.0f); Eigen::Vector3f dir(1.0f, 0.0f, 0.0f); Eigen::Vector3f min_bound(-1.0f, -1.0f, -1.0f); Eigen::Vector3f max_bound(1.0f, 1.0f, 1.0f); float t_min = 0.0f; float t_max = 0.0f; bool hit = pcl::geometry::rayIntersectsWithBox( origin, dir, min_bound, max_bound, t_min, t_max);

这个函数会返回是否相交，同时把进入和离开盒子的两个t值填到t_min和t_max里。用起来很方便，但有一个前提你得先确认：你下载的PCL版本里到底有没有这个函数，因为不同小版本之间API有过调整。如果没有，最稳妥的办法就是自己写一个，下面会详细讲。

3.2 自己写一个Ray-AABB相交函数

我对网上能找到的实现做过横向对比，发现很多版本的代码在处理dir分量为0时直接除零，或者没有考虑起点在盒子内部的场景。这里给一份我自己在PCL项目里反复用过的实现，既处理了平行轴的情况，也兼容了起点在盒内的语义。

#include <Eigen/Core> #include <algorithm> #include <cmath> #include <limits> bool rayIntersectsAABB( const Eigen::Vector3f& origin, const Eigen::Vector3f& dir, const Eigen::Vector3f& min_bound, const Eigen::Vector3f& max_bound, float& t_hit) { float t_near = 0.0f; float t_far = std::numeric_limits<float>::infinity(); for (int axis = 0; axis < 3; ++axis) { float o = origin[axis]; float d = dir[axis]; float min_b = min_bound[axis]; float max_b = max_bound[axis]; if (std::fabs(d) < 1e-8f) { // 射线在该轴方向几乎不移动 if (o < min_b || o > max_b) return false; } else { float inv_d = 1.0f / d; float t1 = (min_b - o) * inv_d; float t2 = (max_b - o) * inv_d; if (t1 > t2) std::swap(t1, t2); t_near = std::max(t_near, t1); t_far = std::min(t_far, t2); if (t_near > t_far) return false; } } t_hit = t_near; return true; }

这段代码的核心逻辑和前面讲的Slab法完全一致，只是把三个轴的判定合到了循环里。注意t_near初始化为0表示射线从起点开始才有效，起点在盒内时会直接返回t_hit = 0。如果你在项目里需要的是射线打在盒子外表面的点，而对起点在内部这种情况直接返回“穿透”，这个语义需要另行调整。

3.3 和PCL点云数据衔接起来

射线和盒子的判定逻辑清楚了，接下来最自然的疑问是：PCL点云里哪来的包围盒？答案是通过getMinMax3D函数，一次遍历就能拿到整个点云的最小点和最大点。

#include <pcl/common/common.h> pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>); // ... 加载或生成点云数据 Eigen::Vector4f min_pt, max_pt; pcl::getMinMax3D(*cloud, min_pt, max_pt); Eigen::Vector3f min_bound = min_pt.head<3>(); Eigen::Vector3f max_bound = max_pt.head<3>();

拿到min_bound和max_bound之后，就可以直接传给上面说的相交函数。如果你想在单个物体上做更精细的判断，可以先用欧式聚类提取出若干个子点云，再对每个子点云分别求包围盒，构建出一组“包围盒列表”。这样当射线射过来时，先用射线对所有包围盒做一次循环求交，立即就能知道命中了哪个物体，效率远高于全局点云搜索。

4. 实操过程：完整的射线AABB相交检测示例

4.1 搭建测试场景

理论说多了没用，我直接给一个可以跑起来的完整示例。场景设计如下：我生成一个包含三个立方体点云块的场景，每个块规模不同，分别放在空间中的不同位置。然后从原点发射一条沿x轴正方向的射线，看它会命中哪个包围盒，以及命中点距离多远。

这里有一个工程细节：为了让结果可复现，最好固定随机种子生成点云数据。实际测试时你完全可以用真实扫描的点云文件替换，逻辑不变。

4.2 核心代码实现与逐段讲解

先写一个辅助函数，把点云的最小点和最大点提取出来，然后组合成AABB：

struct AABB { Eigen::Vector3f min_bound; Eigen::Vector3f max_bound; }; AABB computeAABB(const pcl::PointCloud<pcl::PointXYZ>::Ptr& cloud) { Eigen::Vector4f min_pt, max_pt; pcl::getMinMax3D(*cloud, min_pt, max_pt); AABB box; box.min_bound = min_pt.head<3>(); box.max_bound = max_pt.head<3>(); return box; }

这里有两点值得说明。第一，getMinMax3D返回的是Vector4f，最后一维是齐次坐标的1.0，取head<3>()拿前三个分量即可。第二，如果你处理的是带强度的PointXYZI或者带颜色的PointXYZRGB，getMinMax3D同样适用，因为模板函数只关心xyz坐标。

接下来是主流程，生成三个点云块，构建包围盒列表，发射射线并逐一测试：

#include <pcl/point_types.h> #include <pcl/point_cloud.h> #include <pcl/common/common.h> #include <pcl/visualization/pcl_visualizer.h> #include <iostream> #include <random> int main() { // 构造三个点云块 pcl::PointCloud<pcl::PointXYZ>::Ptr cloud1(new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr cloud2(new pcl::PointCloud<pcl::PointXYZ>); pcl::PointCloud<pcl::PointXYZ>::Ptr cloud3(new pcl::PointCloud<pcl::PointXYZ>); std::default_random_engine engine(42); std::uniform_real_distribution<float> dist(0.0f, 1.0f); // 块1：位于 x=1~2, y=0~1, z=0~1 for (int i = 0; i < 500; ++i) { pcl::PointXYZ pt; pt.x = 1.0f + dist(engine); pt.y = 0.0f + dist(engine); pt.z = 0.0f + dist(engine); cloud1->push_back(pt); } // 块2：位于 x=3~4, y=-1~0, z=0~1 for (int i = 0; i < 800; ++i) { pcl::PointXYZ pt; pt.x = 3.0f + dist(engine); pt.y = -1.0f + dist(engine); pt.z = 0.0f + dist(engine); cloud2->push_back(pt); } // 块3：位于 x=-2~-1, y=0~1, z=1~2 for (int i = 0; i < 600; ++i) { pcl::PointXYZ pt; pt.x = -2.0f + dist(engine); pt.y = 0.0f + dist(engine); pt.z = 1.0f + dist(engine); cloud3->push_back(pt); } std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr> clouds = {cloud1, cloud2, cloud3}; std::vector<AABB> boxes; for (auto& c : clouds) boxes.push_back(computeAABB(c)); // 发射射线：从原点沿 x 轴正方向 Eigen::Vector3f origin(0.0f, 0.0f, 0.0f); Eigen::Vector3f dir(1.0f, 0.0f, 0.0f); for (size_t i = 0; i < boxes.size(); ++i) { float t_hit = 0.0f; bool hit = rayIntersectsAABB(origin, dir, boxes[i].min_bound, boxes[i].max_bound, t_hit); if (hit) { Eigen::Vector3f pt = origin + t_hit * dir; std::cout << "命中包围盒 " << i << "，t = " << t_hit << "，入射点 = (" << pt.x() << ", " << pt.y() << ", " << pt.z() << ")" << std::endl; } else { std::cout << "未命中包围盒 " << i << std::endl; } } return 0; }

运行后预期结果是：包围盒0命中，t约为1.0；包围盒1未命中（它虽然也在x正方向，但y范围在-1~0，射线在y=0平面上，刚好不在盒子内部）；包围盒2未命中（在x负方向）。这里恰好展示了一个容易踩的边界情况：盒子1的y轴范围是[-1, 0]，射线在y=0处，按浮点比较算是落在盒子的边界上，但因为盒子的y区间是[-1, 0]，0确实包含在闭区间里，所以实际上应该命中。结果会命中盒子1，命中的t约为3.0。如果你在调试时发现结果和预期不符，多半是闭区间判断写成了开区间判断。

4.3 用PCLVisualizer验证结果

纯打印结果不够直观，我习惯把验证过程可视化，直接看到那条射线有没有穿过盒子。下面是一个最小可视化流程：

pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("Ray AABB Test")); viewer->setBackgroundColor(0.1, 0.1, 0.1); int cloud_id = 0; for (auto& c : clouds) { pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> color(c, 255 - cloud_id * 60, 60 + cloud_id * 40, 60); viewer->addPointCloud(c, color, "cloud_" + std::to_string(cloud_id)); ++cloud_id; } // 添加包围盒框线 for (size_t i = 0; i < boxes.size(); ++i) { viewer->addCube(boxes[i].min_bound[0], boxes[i].max_bound[0], boxes[i].min_bound[1], boxes[i].max_bound[1], boxes[i].min_bound[2], boxes[i].max_bound[2], 1.0, 1.0, 0.0, "box_" + std::to_string(i)); } // 添加射线 viewer->addLine(origin, origin + dir * 6.0f, 1.0, 0.0, 0.0, "ray"); viewer->spin();

addCube的六个参数依次是x/min、x/max、y/min、y/max、z/min、z/max。如果你后续想在射线命中点处加一个球体标记，可以用addSphere，颜色选红色，半径给0.05左右，位置就是origin + t_hit * dir。这样一跑，射线、包围盒框、命中点全都显示在窗口里，一目了然。

4.4 批量相交测试怎么组织

实际项目很少只测一条射线，通常是一组射线打向一组盒子。比如激光雷达仿真时要发射几十条甚至几百条射线。这时候批量处理有很多优化空间。

最直接的方式是双重循环：

for (size_t i = 0; i < rays.size(); ++i) { for (size_t j = 0; j < boxes.size(); ++j) { if (rayIntersectsAABB(rays[i].origin, rays[i].dir, boxes[j].min_bound, boxes[j].max_bound, t)) { // 记录命中结果 } } }

这个写法的复杂度是O(N*M)，射线多、盒子多时会成为性能瓶颈。我在项目里常用的优化手段有三种。

第一种是八叉树粗过滤。把场景里的盒子按空间位置构建成八叉树，每条射线只查询路径经过的节点，那些明显不相干的盒子根本不会出现在求交列表里。PCL自带的OctreePointCloudSearch支持体素级查询，可以先对被射线击中的体素做检测，再只对命中的体素关联的点云做更细的AABB求交。

第二种是方向预排序。把所有盒子根据射线方向投影到某一轴上做排序，射线只和投影区间与自身有重叠的盒子求交。这有点像扫描线算法，代码复杂一些，但在批量查询场景下收益很明显。

第三种是并行化。批量的射线与盒子求交是典型的并行友好型任务，PCL配合OpenMP或者TBB都能做。每条射线的求交过程完全独立，不存在写冲突，用#pragma omp parallel for就能吃到多核红利。要注意的是，命中结果的记录不能直接写共用的vector，最好每个线程先存到局部列表，最后再合并，否则会有竞争。

5. 常见坑与优化技巧实录

5.1 方向向量没有归一化，导致t值含义混乱

我最早在这个函数上栽过的跟头，就是传进去的方向向量没有归一化。t_hit本意是“从起点到交点的距离”，这个含义只有在dir是单位向量时才成立。如果你传了一个长度为10的方向向量，算出来的t_hit会比真实距离小10倍，后面拿这个t去算命中点坐标，位置会完全错误。

解决办法有两个。一是在调用求交函数前统一对dir做normalize处理；二是在函数内部对t_hit做归一化换算。我建议前者，因为方向向量归一化在很多场景下是本来就该做的前置条件，能保证整条数据链路语义一致。我在代码里还特意加了断言或者注释提醒调用方：dir必须归一化。团队协作时，这类隐性约定最容易出问题。

5.2 方向分量极小时用阈值判断，别直接比0

浮点数比较不要直接写成d == 0.0f，编译器优化和舍入误差都可能导致意外结果。我习惯用fabs(d) < 1e-8f来判定“方向分量几乎为0”。这个阈值也不是随便定的，要考虑你的数据尺度。如果点云坐标是毫米级（数值很大），1e-8就太严格了，调成1e-6或1e-5更合适；如果是归一化坐标，1e-8基本够用。

方向分量极小时的另一个隐患是除法结果溢出。即使没有完全等于0，只要d非常小，1.0f/d就会产生极大的数，导致t1和t2的计算结果不稳定。用阈值提前拦截，能让代码在数值边界上表现得更稳健。

5.3 相交点在盒子边界上，算不算命中

这个问题没有标准答案，取决于业务规则。做碰撞检测时，机器人刚好擦着障碍物的边过去，算不算碰撞？做点云拾取时，用户点选的射线刚好穿过物体边缘，应不应该选中？我建议把这类判断做成可配置的参数，而不是写死在求交函数里。

如果你想排除边界擦碰，可以在判定时给t_near和t_far的差加一个容差：

if (t_near > t_far) return false; if (t_far - t_near < 1e-6f) return false; // 视为擦边，不命中

如果希望边界也算命中，保留原来的闭区间判定即可。注意这里的1e-6阈值同样需要根据坐标尺度调整。把这种策略通过函数参数传进去，或者定义成常量，都可以，看你的工程风格。

5.4 八叉树加速的实用路径

射线与AABB的裸函数已经很快了，但面对海量盒子，循环次数多了以后依然会卡。我实际项目中用的比较多的加速方案是基于八叉树的体素命中检测。

PCL里可以这样操作：先把整个场景的点云构建成OctreePointCloudSearch，然后对一条射线调用体素级查询，拿到射线经过的所有叶节点对应的体素中心。接下来，再对每个命中的体素做一次范围搜索，找到局部点云，再基于局部点云的AABB做精细求交。

#include <pcl/octree/octree_search.h> pcl::octree::OctreePointCloudSearch<pcl::PointXYZ> octree(0.1f); octree.setInputCloud(scene_cloud); octree.addPointsFromInputCloud(); std::vector<int> voxel_idx; std::vector< Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > voxel_centers; octree.getIntersectedVoxelCenter(origin, dir, voxel_idx, voxel_centers);

octree分辨率（这里设为0.1）决定了体素大小，也直接决定了加速效果。分辨率太小，命中的体素数多，反而更慢；分辨率太大，粗过滤精度低。我一般结合点云密度和业务精度需求来调，常用范围在0.05到0.5之间，具体哪个合适一定要实测。

这一步相当于“按空间排好队的AABB列表”，射线只需要在少数体素里找交点，而不是去遍历全部包围盒。如果场景里盒子数量超过几百个，这个优化带来的帧率提升非常明显。

5.5 常见问题速查表

我把实战中遇到的高频问题整理成一张表，排查时可以直接对照。

还有一点值得提，就是PCL版本升级后面向对象API可能会变。比如pcl::geometry::rayIntersectsWithBox这个函数在不同版本里的参数类型可能不太一样。遇到编译不过的时候，优先去你本地的PCL头文件里查一下实际签名，不要直接抄网上的老代码。我在不同机器上编译PCL项目时就碰到过这种问题，PCL 1.11和1.12之间就有不少微小变动。

最后聊两句工程上的体会

这个功能如果只看原理，一条公式就能讲完，但真正落到PCL项目里，牵扯到的东西远比公式多。方向向量的归一化约定、浮点比较阈值、包围盒边界语义、批量场景下的数据结构选择，每一处细节都可能让程序在特定数据下表现异常。我自己的习惯是，不管用不用PCL自带函数，都会在手边保留一份这个几十行的手写实现，既便于调试时对比结果，也能在定制场景里改参数而不影响主流程。

另外，如果你打算把这段逻辑做成一个公共工具函数，记得把输入约定写清楚：origin和dir是什么坐标系，dir是否需要归一化，t_hit返回的是参数距离还是真实距离，AABB是否包含边界。这些约定看似琐碎，团队协作时能省掉大量互相扯皮的时间。最后再分享一个小技巧：调试时把t_near和t_far在三个轴上的中间值打印出来，很多看代码半天找不到的相交问题，一眼就能定位到是哪个轴把区间切断了。