塞瓦定理源码解析:3步搞定几何计算项目
看了一堆教程还是不会写项目，这种痛苦我太懂了。
很多同行拿到“塞瓦定理”这个名词，脑子里全是 \(AD \cdot BE \cdot CF = BD \cdot CE \cdot AF\) 的公式，或者三角形内一点连线的比例关系。
但当你真正要把它变成一段可运行、可复用的代码，或者集成到GIS系统、CAD插件、甚至自动驾驶路径规划模块里时，卡壳了。
这时候，单纯背公式没用，你得看源码解析。
今天我们就从零搭建一个基于Python的塞瓦定理验证与计算工具。
这不是为了做题，而是为了让你明白，数学定理如何落地为工程代码。
1. 项目目标与痛点拆解
咱们先明确这个实战项目要解决什么问题。
在公路工程、地理信息系统（GIS）或者机器人导航中，我们经常需要判断三条线是否共点，或者根据两个交点推算第三个交点的位置。
塞瓦定理的核心价值在于：已知三角形三边上的分点，判断连线是否共点；或者已知两连线共点，求第三边的分点比例。
传统做法是画图、量角器，或者手算坐标，效率极低且误差大。
我们的项目目标是：
输入三角形三个顶点坐标 \((A, B, C)\)。
输入两条边上的分点 \(D\) (在BC上) 和 \(E\) (在CA上)。
利用塞瓦定理的逆定理，自动判断 \(AD\) 与 \(BE\) 的连线是否与第三条边 \(AB\) 上的某点 \(F\) 的连线 \(CF\) 共点。
如果共点，精确计算出点 \(F\) 在 \(AB\) 上的位置坐标。
提供可视化验证功能，画出三角形、连线及交点。
这个工具可以直接嵌入到大型工程软件中，作为几何校验的一个子模块。
2. 目录结构规划
工程化思维的第一步，是规划好目录结构。不要把所有代码堆在一个文件里，那是新手行为。
我们采用模块化设计：
ceva_project/
├── main.py # 程序入口，负责调用逻辑
├── core/
│ ├── __init__.py
│ ├── geometry.py # 基础几何计算：距离、向量、直线方程
│ └── ceva.py # 塞瓦定理核心算法封装
├── utils/
│ ├── __init__.py
│ └── visualizer.py# 绘图工具，基于Matplotlib
├── tests/
│ └── test_ceva.py # 单元测试
└── requirements.txt # 依赖库
这种结构的好处是，geometry.py 里的向量计算可以复用于其他几何项目，ceva.py 专注于定理逻辑，互不干扰。
3. 核心代码实现与逐行讲解
这部分是重头戏，也是源码解析的核心。
我们将分两步走：先实现基础几何运算，再实现塞瓦定理逻辑。
3.1 基础几何模块 (core/geometry.py)
在Python中，处理坐标最好的方式是使用向量。
import numpy as np
class Vector:
基础向量类，封装2D/3D坐标运算
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar)
def dot(self, other):
点积
return self.x * other.x + self.y * other.y
def cross(self, other):
叉积，在2D中返回标量，用于判断共线或计算面积
return self.x * other.y - self.y * other.x
def norm(self):
向量模长
return np.sqrt(self.x ** 2 + self.y ** 2)
def to_tuple(self):
return (self.x, self.y)
def distance(p1, p2):
计算两点间欧氏距离
dx = p1.x - p2.x
dy = p1.y - p2.y
return np.sqrt(dx**2 + dy**2)
def line_intersection(p1, p2, p3, p4):
计算直线 p1p2 与 p3p4 的交点
返回交点 Vector 或 None (若平行)
基于参数方程求解
# 向量 p1-p2 和 p3-p4
v1 = p2 - p1
v2 = p4 - p3
# 叉积为0说明平行或重合
denominator = v1.cross(v2)
if abs(denominator) 1e-9:
return None
# 向量 p1-p3
v3 = p3 - p1
# 解方程组求参数 t 和 u
t = v3.cross(v2) / denominator
# 交点 = p1 + t * v1
intersection = p1 + v1 * t
return intersection
关键点解析：
为什么用 numpy？因为后续如果扩展到3D空间，或者处理大量点云数据，NumPy的矩阵运算效率远高于纯Python循环。
cross 方法在2D几何中至关重要，它的符号代表旋转方向，绝对值代表平行四边形面积。这是判断三点共线的基础。
line_intersection 使用了参数方程法，比斜率截距法更稳健，因为斜率截距法无法处理垂直线（斜率无穷大）。
3.2 塞瓦定理核心逻辑 (core/ceva.py)
这是本次源码解析的灵魂。
塞瓦定理的代数形式是：若 \(D, E, F\) 分别在 \(BC, CA, AB\) 上，则 \(AD, BE, CF\) 共点当且仅当：
\(\frac{BD}{DC} \cdot \frac{CE}{EA} \cdot \frac{AF}{FB} = 1\)
但在工程中，我们往往不知道 \(F\) 点，我们需要的是：已知 \(A, B, C, D, E\)，求 \(F\) 的坐标，并验证 \(AD, BE, CF\) 是否真的共点。
from core.geometry import Vector, distance, line_intersection
class CevaTheoremSolver:
塞瓦定理求解器
输入：三角形顶点 A, B, C 和边 BC 上的点 D, 边 CA 上的点 E
输出：边 AB 上的点 F，以及共点 P
def __init__(self, A: Vector, B: Vector, C: Vector, D: Vector, E: Vector):
self.A = A
self.B = B
self.C = C
self.D = D
self.E = E
self.F = None
self.P = None
self.is_valid = False
self.error_msg =
def solve(self):
执行求解过程
# 1. 计算线段长度
# 注意：D 必须在 BC 线段上，E 必须在 CA 线段上
# 工程实践中，建议先做点在线段上的校验
len_BC = distance(self.B, self.C)
len_CA = distance(self.C, self.A)
len_AB = distance(self.A, self.B)
# 计算 D 分 BC 的比例
# BD / DC
len_BD = distance(self.B, self.D)
len_DC = distance(self.D, self.C)
# 计算 E 分 CA 的比例
# CE / EA
len_CE = distance(self.C, self.E)
len_EA = distance(self.E, self.A)
# 2. 根据塞瓦定理计算 AF / FB
# (BD/DC) * (CE/EA) * (AF/FB) = 1
# = AF/FB = (DC/BD) * (EA/CE)
if len_BD == 0 or len_DC == 0 or len_CE == 0 or len_EA == 0:
self.error_msg = 分点不能与顶点重合
return False
ratio_AF_FB = (len_DC / len_BD) * (len_EA / len_CE)
# 3. 根据比例 AF/FB 确定 F 点坐标
# F 分 AB 为 AF : FB = ratio_AF_FB : 1
# 利用向量定比分点公式
# F = (A + ratio * B) / (1 + ratio)
# 注意：这里比例是 AF:FB，所以权重是 FB:AF
# 向量形式：F = (FB * A + AF * B) / (AF + FB)
# 设 FB = 1, AF = ratio, 则 F = (1*A + ratio*B) / (1 + ratio)
ratio = ratio_AF_FB
self.F = Vector(
(self.A.x + ratio * self.B.x) / (1 + ratio),
(self.A.y + ratio * self.B.y) / (1 + ratio)
)
# 4. 验证共点性
# 求 AD 和 BE 的交点 P
self.P = line_intersection(self.A, self.D, self.B, self.E)
if self.P is None:
self.error_msg = AD 与 BE 平行，无交点
return False
# 5. 验证 P 是否在 CF 上
# 计算向量 CP 和 CF 的叉积，如果接近0，则共线
v_CP = self.P - self.C
v_CF = self.F - self.C
cross_val = v_CP.cross(v_CF)
# 浮点数误差容限
if abs(cross_val) 1e-6:
self.is_valid = True
return True
else:
self.error_msg = f计算误差较大，交叉积为 {cross_val}
return False
def get_results(self):
if not self.is_valid:
return None
return {
F: self.F,
P: self.P,
ratio_AF_FB: (self.F - self.A).norm() / (self.B - self.F).norm()
}
源码解析重点：
浮点数陷阱：在步骤5中，判断共线不能直接等于0。计算机是二进制浮点运算，必须设置一个阈值 1e-6。这是所有几何算法源码中必须处理的细节。
定比分点公式：很多教程只给比例，不给坐标转换公式。上面的 Vector((A.x + ratio * B.x) / (1 + ratio)...) 是向量法求分点坐标的标准写法，务必理解其几何意义：点 \(F\) 是 \(A\) 和 \(B\) 的加权平均。
异常处理：如果 \(D\) 点不在 \(BC\) 线段上，而在延长线上，塞瓦定理依然成立（广义塞瓦定理），但比例会变负。本代码假设 \(D, E\) 在线段内部，若需处理外部点，需修改长度计算为有向长度。
4. 运行与测试
代码写好了，怎么跑？怎么测？
4.1 依赖安装
创建 requirements.txt：
numpy=1.21.0
matplotlib=3.4.0
pytest=6.2.0
执行 pip install -r requirements.txt。
4.2 编写测试用例 (tests/test_ceva.py)
测试是保证工程稳定性的关键。我们不能只靠肉眼画图。
import pytest
from core.geometry import Vector
from core.ceva import CevaTheoremSolver
def test_ceva_basic():
# 定义一个三角形
A = Vector(0, 0)
B = Vector(10, 0)
C = Vector(5, 10)
# D 是 BC 中点
D = Vector((B.x + C.x) / 2, (B.y + C.y) / 2)
# E 是 CA 中点
E = Vector((C.x + A.x) / 2, (C.y + A.y) / 2)
solver = CevaTheoremSolver(A, B, C, D, E)
result = solver.solve()
assert result == True
results = solver.get_results()
# 中线的交点（重心）坐标应该是三个顶点坐标的平均值
expected_P = Vector(
(A.x + B.x + C.x) / 3,
(A.y + B.y + C.y) / 3
)
# 验证交点 P 是否接近重心
assert abs(results[P].x - expected_P.x) 1e-5
assert abs(results[P].y - expected_P.y) 1e-5
# 验证 F 点也是 AB 中点
assert abs(results[F].x - 5) 1e-5
assert abs(results[F].y - 0) 1e-5
def test_ceva_non_centroid():
# 构造非中线情况
A = Vector(0, 0)
B = Vector(10, 0)
C = Vector(0, 10)
# D 在 BC 上，BD:DC = 1:2
D = Vector((1*10 + 2*0) / 3, (1*0 + 2*10) / 3) # (10/3, 20/3)
# E 在 CA 上，CE:EA = 1:2
E = Vector((1*0 + 2*0) / 3, (1*10 + 2*0) / 3) # (0, 10/3)
solver = CevaTheoremSolver(A, B, C, D, E)
assert solver.solve() == True
运行测试：pytest tests/ -v
如果测试通过，说明你的核心逻辑是正确的。
4.3 可视化验证 (utils/visualizer.py)
有时候，代码逻辑对了，但直觉上不对劲，这时候需要画图。
import matplotlib.pyplot as plt
from core.geometry import Vector
def plot_ceva(A, B, C, D, E, F, P):
fig, ax = plt.subplots(figsize=(8, 8))
# 画三角形
ax.plot([A.x, B.x, C.x, A.x], [A.y, B.y, C.y, A.y], 'k-', linewidth=2)
# 画塞瓦线
ax.plot([A.x, D.x], [A.y, D.y], 'r--', label='AD')
ax.plot([B.x, E.x], [B.y, E.y], 'g--', label='BE')
ax.plot([C.x, F.x], [C.y, F.y], 'b--', label='CF')
# 标点
ax.plot(A.x, A.y, 'ko')
ax.text(A.x + 0.2, A.y + 0.2, 'A', fontsize=12)
# ... 其他点类似 ...
ax.plot(P.x, P.y, 'ro', markersize=10, label='Intersection P')
ax.set_title(Ceva Theorem Visualization)
ax.legend()
ax.set_aspect('equal')
plt.grid(True)
plt.show()
5. 优化扩展与避坑指南
项目能跑只是第一步，要成为资深工程师，你得知道如何优化和避坑。
5.1 性能优化
如果要在实时系统中（如游戏引擎、AR导航）使用此算法，Python 的原生对象可能较慢。
优化方案：
向量化：如果你需要批量处理成千上万个三角形，不要写循环。将 \(A, B, C, D, E\) 存为 NumPy 数组，利用广播机制一次性计算所有交点。
Cython/PyBind11：对于极度追求性能的底层模块，可以将核心几何计算用 C++ 重写，通过 PyBind11 暴露给 Python 调用。
5.2 常见坑点
点在线段上的判断：
很多新手直接用距离相加判断 \(BD + DC = BC\)。这在浮点数下极易出错。
正确做法：利用向量叉积判断共线，利用点积判断方向。
def point_on_segment(p, a, b):
v1 = p - a
v2 = b - a
if abs(v1.cross(v2)) 1e-9:
return False
# 检查 p 是否在 a, b 之间
return 0 = v1.dot(v2) = v2.dot(v2)
退化三角形：
如果 \(A, B, C\) 共线，三角形面积为0，塞瓦定理的几何意义失效。必须在入口处校验三角形面积是否大于阈值。
外部点处理：
如果 \(D\) 在 \(BC\) 延长线上，\(BD/DC\) 的比值应为负。上述代码使用欧氏距离，导致比值始终为正，无法处理外分点。
修正：使用有向距离。可以通过投影计算或者向量点积来判断方向，赋予距离正负号。
5.3 权威来源参考
在编写几何算法时，推荐参考 Wolfram MathWorld 或 Wikipedia 上的几何条目，特别是关于“Ceva's Theorem”的代数证明部分。
另外，在工业级GIS开发中，GEOS (Geometry Engine - Open Source) 库的官方文档中有关于拓扑操作和精度处理的章节，值得深入研读，特别是关于 robustness 的部分，这能帮你解决很多浮点数带来的“幽灵Bug”。
6. 小结
通过这个从零搭建的塞瓦定理项目，我们完成了从数学公式到工程代码的闭环。
你掌握了：
如何设计模块化的几何计算库。
如何翻译塞瓦定理的比例关系为向量坐标运算。
如何处理浮点数精度这一工程中的大坑。
如何通过单元测试和可视化双重验证代码正确性。
这个 CevaTheoremSolver 类，你可以直接拷贝到你的项目中，用于任何需要判断三线共点或计算分点坐标的场景。
编程的魅力不在于背诵定理，而在于将其转化为解决具体问题的工具。
这个知识点你面试被问过吗？或者你在实际项目中遇到过类似“浮点数导致几何判断失效”的坑吗？留言说说，咱们一起避坑。 
长河君 · 2026/9/23 16:58:42 · 阅读 1.2k 塞瓦定理源码解析:3步搞定几何计算项目
塞瓦定理源码解析:3步搞定几何计算项目
看了一堆教程还是不会写项目，这种痛苦我太懂了。
很多同行拿到“塞瓦定理”这个名词，脑子里全是 \(AD \cdot BE \cdot CF = BD \cdot CE \cdot AF\) 的公式，或者三角形内一点连线的比例关系。
但当你真正要把它变成一段可运行、可复用的代码，或者集成到GIS系统、CAD插件、甚至自动驾驶路径规划模块里时，卡壳了。
这时候，单纯背公式没用，你得看源码解析。
今天我们就从零搭建一个基于Python的塞瓦定理验证与计算工具。
这不是为了做题，而是为了让你明白，数学定理如何落地为工程代码。
1. 项目目标与痛点拆解
咱们先明确这个实战项目要解决什么问题。
在公路工程、地理信息系统（GIS）或者机器人导航中，我们经常需要判断三条线是否共点，或者根据两个交点推算第三个交点的位置。
塞瓦定理的核心价值在于：已知三角形三边上的分点，判断连线是否共点；或者已知两连线共点，求第三边的分点比例。
传统做法是画图、量角器，或者手算坐标，效率极低且误差大。
我们的项目目标是：
输入三角形三个顶点坐标 \((A, B, C)\)。
输入两条边上的分点 \(D\) (在BC上) 和 \(E\) (在CA上)。
利用塞瓦定理的逆定理，自动判断 \(AD\) 与 \(BE\) 的连线是否与第三条边 \(AB\) 上的某点 \(F\) 的连线 \(CF\) 共点。
如果共点，精确计算出点 \(F\) 在 \(AB\) 上的位置坐标。
提供可视化验证功能，画出三角形、连线及交点。
这个工具可以直接嵌入到大型工程软件中，作为几何校验的一个子模块。
2. 目录结构规划
工程化思维的第一步，是规划好目录结构。不要把所有代码堆在一个文件里，那是新手行为。
我们采用模块化设计：
ceva_project/
├── main.py # 程序入口，负责调用逻辑
├── core/
│ ├── __init__.py
│ ├── geometry.py # 基础几何计算：距离、向量、直线方程
│ └── ceva.py # 塞瓦定理核心算法封装
├── utils/
│ ├── __init__.py
│ └── visualizer.py# 绘图工具，基于Matplotlib
├── tests/
│ └── test_ceva.py # 单元测试
└── requirements.txt # 依赖库
这种结构的好处是，geometry.py 里的向量计算可以复用于其他几何项目，ceva.py 专注于定理逻辑，互不干扰。
3. 核心代码实现与逐行讲解
这部分是重头戏，也是源码解析的核心。
我们将分两步走：先实现基础几何运算，再实现塞瓦定理逻辑。
3.1 基础几何模块 (core/geometry.py)
在Python中，处理坐标最好的方式是使用向量。
import numpy as np
class Vector:
基础向量类，封装2D/3D坐标运算
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __mul__(self, scalar):
return Vector(self.x * scalar, self.y * scalar)
def dot(self, other):
点积
return self.x * other.x + self.y * other.y
def cross(self, other):
叉积，在2D中返回标量，用于判断共线或计算面积
return self.x * other.y - self.y * other.x
def norm(self):
向量模长
return np.sqrt(self.x ** 2 + self.y ** 2)
def to_tuple(self):
return (self.x, self.y)
def distance(p1, p2):
计算两点间欧氏距离
dx = p1.x - p2.x
dy = p1.y - p2.y
return np.sqrt(dx**2 + dy**2)
def line_intersection(p1, p2, p3, p4):
计算直线 p1p2 与 p3p4 的交点
返回交点 Vector 或 None (若平行)
基于参数方程求解
# 向量 p1-p2 和 p3-p4
v1 = p2 - p1
v2 = p4 - p3
# 叉积为0说明平行或重合
denominator = v1.cross(v2)
if abs(denominator) 1e-9:
return None
# 向量 p1-p3
v3 = p3 - p1
# 解方程组求参数 t 和 u
t = v3.cross(v2) / denominator
# 交点 = p1 + t * v1
intersection = p1 + v1 * t
return intersection
关键点解析：
为什么用 numpy？因为后续如果扩展到3D空间，或者处理大量点云数据，NumPy的矩阵运算效率远高于纯Python循环。
cross 方法在2D几何中至关重要，它的符号代表旋转方向，绝对值代表平行四边形面积。这是判断三点共线的基础。
line_intersection 使用了参数方程法，比斜率截距法更稳健，因为斜率截距法无法处理垂直线（斜率无穷大）。
3.2 塞瓦定理核心逻辑 (core/ceva.py)
这是本次源码解析的灵魂。
塞瓦定理的代数形式是：若 \(D, E, F\) 分别在 \(BC, CA, AB\) 上，则 \(AD, BE, CF\) 共点当且仅当：
\(\frac{BD}{DC} \cdot \frac{CE}{EA} \cdot \frac{AF}{FB} = 1\)
但在工程中，我们往往不知道 \(F\) 点，我们需要的是：已知 \(A, B, C, D, E\)，求 \(F\) 的坐标，并验证 \(AD, BE, CF\) 是否真的共点。
from core.geometry import Vector, distance, line_intersection
class CevaTheoremSolver:
塞瓦定理求解器
输入：三角形顶点 A, B, C 和边 BC 上的点 D, 边 CA 上的点 E
输出：边 AB 上的点 F，以及共点 P
def __init__(self, A: Vector, B: Vector, C: Vector, D: Vector, E: Vector):
self.A = A
self.B = B
self.C = C
self.D = D
self.E = E
self.F = None
self.P = None
self.is_valid = False
self.error_msg =
def solve(self):
执行求解过程
# 1. 计算线段长度
# 注意：D 必须在 BC 线段上，E 必须在 CA 线段上
# 工程实践中，建议先做点在线段上的校验
len_BC = distance(self.B, self.C)
len_CA = distance(self.C, self.A)
len_AB = distance(self.A, self.B)
# 计算 D 分 BC 的比例
# BD / DC
len_BD = distance(self.B, self.D)
len_DC = distance(self.D, self.C)
# 计算 E 分 CA 的比例
# CE / EA
len_CE = distance(self.C, self.E)
len_EA = distance(self.E, self.A)
# 2. 根据塞瓦定理计算 AF / FB
# (BD/DC) * (CE/EA) * (AF/FB) = 1
# = AF/FB = (DC/BD) * (EA/CE)
if len_BD == 0 or len_DC == 0 or len_CE == 0 or len_EA == 0:
self.error_msg = 分点不能与顶点重合
return False
ratio_AF_FB = (len_DC / len_BD) * (len_EA / len_CE)
# 3. 根据比例 AF/FB 确定 F 点坐标
# F 分 AB 为 AF : FB = ratio_AF_FB : 1
# 利用向量定比分点公式
# F = (A + ratio * B) / (1 + ratio)
# 注意：这里比例是 AF:FB，所以权重是 FB:AF
# 向量形式：F = (FB * A + AF * B) / (AF + FB)
# 设 FB = 1, AF = ratio, 则 F = (1*A + ratio*B) / (1 + ratio)
ratio = ratio_AF_FB
self.F = Vector(
(self.A.x + ratio * self.B.x) / (1 + ratio),
(self.A.y + ratio * self.B.y) / (1 + ratio)
)
# 4. 验证共点性
# 求 AD 和 BE 的交点 P
self.P = line_intersection(self.A, self.D, self.B, self.E)
if self.P is None:
self.error_msg = AD 与 BE 平行，无交点
return False
# 5. 验证 P 是否在 CF 上
# 计算向量 CP 和 CF 的叉积，如果接近0，则共线
v_CP = self.P - self.C
v_CF = self.F - self.C
cross_val = v_CP.cross(v_CF)
# 浮点数误差容限
if abs(cross_val) 1e-6:
self.is_valid = True
return True
else:
self.error_msg = f计算误差较大，交叉积为 {cross_val}
return False
def get_results(self):
if not self.is_valid:
return None
return {
F: self.F,
P: self.P,
ratio_AF_FB: (self.F - self.A).norm() / (self.B - self.F).norm()
}
源码解析重点：
浮点数陷阱：在步骤5中，判断共线不能直接等于0。计算机是二进制浮点运算，必须设置一个阈值 1e-6。这是所有几何算法源码中必须处理的细节。
定比分点公式：很多教程只给比例，不给坐标转换公式。上面的 Vector((A.x + ratio * B.x) / (1 + ratio)...) 是向量法求分点坐标的标准写法，务必理解其几何意义：点 \(F\) 是 \(A\) 和 \(B\) 的加权平均。
异常处理：如果 \(D\) 点不在 \(BC\) 线段上，而在延长线上，塞瓦定理依然成立（广义塞瓦定理），但比例会变负。本代码假设 \(D, E\) 在线段内部，若需处理外部点，需修改长度计算为有向长度。
4. 运行与测试
代码写好了，怎么跑？怎么测？
4.1 依赖安装
创建 requirements.txt：
numpy=1.21.0
matplotlib=3.4.0
pytest=6.2.0
执行 pip install -r requirements.txt。
4.2 编写测试用例 (tests/test_ceva.py)
测试是保证工程稳定性的关键。我们不能只靠肉眼画图。
import pytest
from core.geometry import Vector
from core.ceva import CevaTheoremSolver
def test_ceva_basic():
# 定义一个三角形
A = Vector(0, 0)
B = Vector(10, 0)
C = Vector(5, 10)
# D 是 BC 中点
D = Vector((B.x + C.x) / 2, (B.y + C.y) / 2)
# E 是 CA 中点
E = Vector((C.x + A.x) / 2, (C.y + A.y) / 2)
solver = CevaTheoremSolver(A, B, C, D, E)
result = solver.solve()
assert result == True
results = solver.get_results()
# 中线的交点（重心）坐标应该是三个顶点坐标的平均值
expected_P = Vector(
(A.x + B.x + C.x) / 3,
(A.y + B.y + C.y) / 3
)
# 验证交点 P 是否接近重心
assert abs(results[P].x - expected_P.x) 1e-5
assert abs(results[P].y - expected_P.y) 1e-5
# 验证 F 点也是 AB 中点
assert abs(results[F].x - 5) 1e-5
assert abs(results[F].y - 0) 1e-5
def test_ceva_non_centroid():
# 构造非中线情况
A = Vector(0, 0)
B = Vector(10, 0)
C = Vector(0, 10)
# D 在 BC 上，BD:DC = 1:2
D = Vector((1*10 + 2*0) / 3, (1*0 + 2*10) / 3) # (10/3, 20/3)
# E 在 CA 上，CE:EA = 1:2
E = Vector((1*0 + 2*0) / 3, (1*10 + 2*0) / 3) # (0, 10/3)
solver = CevaTheoremSolver(A, B, C, D, E)
assert solver.solve() == True
运行测试：pytest tests/ -v
如果测试通过，说明你的核心逻辑是正确的。
4.3 可视化验证 (utils/visualizer.py)
有时候，代码逻辑对了，但直觉上不对劲，这时候需要画图。
import matplotlib.pyplot as plt
from core.geometry import Vector
def plot_ceva(A, B, C, D, E, F, P):
fig, ax = plt.subplots(figsize=(8, 8))
# 画三角形
ax.plot([A.x, B.x, C.x, A.x], [A.y, B.y, C.y, A.y], 'k-', linewidth=2)
# 画塞瓦线
ax.plot([A.x, D.x], [A.y, D.y], 'r--', label='AD')
ax.plot([B.x, E.x], [B.y, E.y], 'g--', label='BE')
ax.plot([C.x, F.x], [C.y, F.y], 'b--', label='CF')
# 标点
ax.plot(A.x, A.y, 'ko')
ax.text(A.x + 0.2, A.y + 0.2, 'A', fontsize=12)
# ... 其他点类似 ...
ax.plot(P.x, P.y, 'ro', markersize=10, label='Intersection P')
ax.set_title(Ceva Theorem Visualization)
ax.legend()
ax.set_aspect('equal')
plt.grid(True)
plt.show()
5. 优化扩展与避坑指南
项目能跑只是第一步，要成为资深工程师，你得知道如何优化和避坑。
5.1 性能优化
如果要在实时系统中（如游戏引擎、AR导航）使用此算法，Python 的原生对象可能较慢。
优化方案：
向量化：如果你需要批量处理成千上万个三角形，不要写循环。将 \(A, B, C, D, E\) 存为 NumPy 数组，利用广播机制一次性计算所有交点。
Cython/PyBind11：对于极度追求性能的底层模块，可以将核心几何计算用 C++ 重写，通过 PyBind11 暴露给 Python 调用。
5.2 常见坑点
点在线段上的判断：
很多新手直接用距离相加判断 \(BD + DC = BC\)。这在浮点数下极易出错。
正确做法：利用向量叉积判断共线，利用点积判断方向。
def point_on_segment(p, a, b):
v1 = p - a
v2 = b - a
if abs(v1.cross(v2)) 1e-9:
return False
# 检查 p 是否在 a, b 之间
return 0 = v1.dot(v2) = v2.dot(v2)
退化三角形：
如果 \(A, B, C\) 共线，三角形面积为0，塞瓦定理的几何意义失效。必须在入口处校验三角形面积是否大于阈值。
外部点处理：
如果 \(D\) 在 \(BC\) 延长线上，\(BD/DC\) 的比值应为负。上述代码使用欧氏距离，导致比值始终为正，无法处理外分点。
修正：使用有向距离。可以通过投影计算或者向量点积来判断方向，赋予距离正负号。
5.3 权威来源参考
在编写几何算法时，推荐参考 Wolfram MathWorld 或 Wikipedia 上的几何条目，特别是关于“Ceva's Theorem”的代数证明部分。
另外，在工业级GIS开发中，GEOS (Geometry Engine - Open Source) 库的官方文档中有关于拓扑操作和精度处理的章节，值得深入研读，特别是关于 robustness 的部分，这能帮你解决很多浮点数带来的“幽灵Bug”。
6. 小结
通过这个从零搭建的塞瓦定理项目，我们完成了从数学公式到工程代码的闭环。
你掌握了：
如何设计模块化的几何计算库。
如何翻译塞瓦定理的比例关系为向量坐标运算。
如何处理浮点数精度这一工程中的大坑。
如何通过单元测试和可视化双重验证代码正确性。
这个 CevaTheoremSolver 类，你可以直接拷贝到你的项目中，用于任何需要判断三线共点或计算分点坐标的场景。
编程的魅力不在于背诵定理，而在于将其转化为解决具体问题的工具。
这个知识点你面试被问过吗？或者你在实际项目中遇到过类似“浮点数导致几何判断失效”的坑吗？留言说说，咱们一起避坑。