企业官网建设流程全解析

《Python机器人基础原理》第十二篇：工业机械臂仿真——输入关节角度计算雅可比矩阵，解析末端运动速度

1. 实际工业应用场景

周三下午，某汽车零部件焊接产线。一台4-DOF关节型工业机械臂正在对变速箱壳体进行点焊作业。机器人构型：3旋转+1垂直平移（SCARA变体），大臂长500 mm，小臂长400 mm，基座安装高度d₁=350 mm，z轴行程±150 mm。关节硬件限位：θ₁ ±160°、θ₂ ±120°、θ₃ ±180°、d₄ ±150 mm。额定负载12 kg，末端焊枪质量1.5 kg。焊接工艺要求末端线速度控制在80~120 mm/s之间。

下午两点半，控制工程师小王盯着示波器上末端实际速度曲线，眉头拧成了疙瘩。

"又是这样。"他对旁边的运动规划工程师小赵说，"轨迹规划给的关节速度曲线看起来很平滑，但末端实际速度在靠近工作空间边界的时候忽快忽慢，焊点质量不稳定。"

小赵凑过来看了一眼："你用的末端速度是直接拿关节速度乘以臂长粗算的？"

"对，我给θ₂_dot设了0.8 rad/s，按小臂力臂0.4 m算出来末端线速度应该是320 mm/s——结果实际焊的时候速度飘到了工艺窗口外面。"

"问题就在这。0.8 rad/s的肘关节速度，在r=850 mm的位置末端速度确实大约是320 mm/s——但那是纯肘关节贡献的分量。你没算基座旋转和肘关节的耦合项。真正的总末端速度需要雅可比矩阵把四个关节的速度全部线性叠加。"

"雅可比？那不是课本第3章的东西吗？"

"第3章连杆参数和运动学求解的延伸。你现在做离线仿真验证，正好可以把雅可比算出来，看看每个工作点的速度放大倍数到底是多少，哪些位形下末端速度会突破80~120 mm/s的焊接窗口。"

本篇解决的问题：给定一组关节角度，计算该位形下的解析雅可比矩阵（6×4），将关节空间速度向量（θ₁dot, θ₂dot, θ₃dot, d₄dot）映射到末端笛卡尔速度（v_x, v_y, v_z, ω_x, ω_y, ω_z）。通过雅可比矩阵的条件数和各列向量模长，分析不同工作区域内末端速度的放大/缩小效应，为轨迹规划阶段的关节速度限幅提供依据。

⚠️ 声明：本篇全部代码为课程离线仿真，运行在普通PC上，用于雅可比矩阵计算与速度映射分析。不可直接用于真实机器人控制器、伺服驱动器或焊接产线。真实工业现场需结合实时动力学补偿、关节扭矩限幅与安全监控。

2. 痛点分析

课程模块 本篇对应的工程痛点

第3章 连杆参数及运动学求解 → 3.5 速度雅可比 关节空间速度到末端笛卡尔速度的线性映射，需要解析雅可比矩阵

第3章 连杆参数及运动学求解 → 3.3 正运动学 雅可比矩阵各列由正运动学齐次变换矩阵推导，依赖D-H参数链

第6章 轨迹规划与控制 → 6.2 关节空间规划 轨迹规划阶段需要逆雅可比（或伪逆）将末端速度需求转换为关节速度

第2章 位姿描述与坐标变换 雅可比矩阵各列涉及旋转轴方向向量在不同坐标系间的变换

本篇代码解决 L3 离线运动学分析层。输入一组关节角度，输出该位形下的6×4雅可比矩阵，以及给定关节速度下的末端速度向量。代码不是设备实时控制器，不做伺服闭环，不做轨迹插补。它做的事情是：告诉运动规划工程师"在这个位形下，关节速度到末端速度的映射关系是什么，哪些方向被放大了，哪些被缩小了"，并量化哪些工作区域满足80~120 mm/s的焊接速度窗口。

不覆盖：逆雅可比求解（伪逆/阻尼最小二乘）、动力学计算、碰撞检测、实时控制、6轴冗余机械臂、力控制。

3. 核心逻辑讲解

物理直觉

雅可比矩阵本质上是"速度版的传动比表"。想象一辆自行车：你蹬踏板的角速度和车轮线速度之间有一个固定的比例关系，这个比例由齿轮比和轮径决定。机械臂的雅可比矩阵就是每一对"关节运动→末端运动"之间的传动比——只不过机械臂有4个关节、末端有6个速度分量（3个线速度+3个角速度），所以传动比表是一个6行4列的矩阵。

每一列代表"如果只让第i个关节以单位速度运动、其他关节不动，末端会产生怎样的速度"。第1列告诉你基座旋转对末端的影响（力臂=末端到基座z轴的水平距离），第2列告诉你肘关节旋转的影响（力臂≈小臂长度），以此类推。把4个关节的速度同时乘以各自那列再加起来，就得到末端的总速度。

业务逻辑 → 代码映射

输入：一组关节角度 q = [θ₁, θ₂, θ₃, d₄]

↓

步骤1：正运动学计算各连杆变换矩阵 T₀¹, T₁², T₂³, T₃⁴

↓

步骤2：提取各连杆坐标系原点位置 p_i 和旋转轴方向 z_i

↓

步骤3：构建雅可比矩阵各列——

线速度列 jv_i = z_{i-1} × (p_end - p_{i-1}) （旋转关节）

线速度列 jv_i = z_3 （平移关节，沿第3连杆z轴）

角速度列 jw_i = z_{i-1} （旋转关节）

角速度列 jw_i = [0,0,0] （平移关节，不产生角速度）

↓

步骤4：组装 J = [jv₁ jv₂ jv₃ jv₄; jw₁ jw₂ jw₃ jw₄]

↓

步骤5：输入关节速度 q_dot，计算末端速度 v_end = J × q_dot

↓

步骤6：计算条件数 cond(J) = σ_max / σ_min 评估该位形的速度映射"健康度"

关键公式文字翻译

旋转关节线速度列：z{i-1} × (p_end - p{i-1})。z{i-1}是第i个关节的旋转轴方向向量（在基座标系中表示），p_end是末端位置，p{i-1}是第i-1个连杆坐标系原点。叉乘的物理含义：绕z轴旋转时，距离旋转轴|p_end - p_{i-1}|远的位置，线速度大小等于角速度乘以力臂长度，方向垂直于"从旋转轴到末端的连线"和"旋转轴"构成的平面。

旋转关节角速度列：直接就是z_{i-1}。因为绕某个轴旋转时，末端角速度就等于该关节的角速度向量（叠加原理）。

平移关节：线速度列等于第3连杆的z轴方向单位向量（因为第4级D-H变换中α₄=-π/2会翻转z轴，平移方向应取翻转前的第3连杆z轴），角速度列为全零（平移不产生旋转）。

条件数：cond(J) = σ_max / σ_min，即最大奇异值除以最小奇异值。不做奇异值过滤——当构型接近奇异时σ_min→0，cond→∞，这正是需要观测的物理趋势。过滤掉趋零奇异值会掩盖奇异，与"条件数越大越接近奇异"的核心叙事矛盾。

4. OOP代码实现

技术栈

严格限定：numpy, scipy, matplotlib。不引入pybullet、roboticstoolbox等任何第三方机器人库。sympy仅用于符号推导验证，本篇核心计算全部使用数值方法。

项目结构树

robot_jacobian_sim/

├── run_jacobian_sim.py

├── requirements.txt

├── jacobian/

│ ├── __init__.py

│ ├── models.py

│ ├── forward_kinematics.py

│ ├── jacobian_solver.py

│ └── visualize.py

├── tests/

│ ├── __init__.py

│ └── test_jacobian_sim.py

└── results/

核心源码

"jacobian/models.py" — dataclass数据模型

"""

4-DOF工业机械臂数据模型

连杆参数、D-H表、关节限位、速度向量结构体

"""

from dataclasses import dataclass, field

from typing import List, Tuple

import numpy as np

@dataclass

class JointLimit:

"""

单关节硬件限位

min_val: 最小允许值 (rad 或 m)

max_val: 最大允许值 (rad 或 m)

"""

min_val: float

max_val: float

joint_name: str = ""

def __post_init__(self):

if self.min_val >= self.max_val:

raise ValueError(

f"JointLimit: min_val({self.min_val})必须严格小于"

f"max_val({self.max_val})")

if not np.isfinite(self.min_val) or not np.isfinite(self.max_val):

raise ValueError("JointLimit: 限位值必须为有限数值")

def contains(self, value: float) -> bool:

"""

判断关节值是否在限位区间内

浮点比较使用1e-10容差，避免边界舍入误判

"""

return (self.min_val - 1e-10) <= value <= (self.max_val + 1e-10)

@dataclass

class JointLimitSet:

"""

完整关节限位集合（4-DOF工业机械臂）

"""

limits: List[JointLimit]

def __post_init__(self):

if len(self.limits) != 4:

raise ValueError(f"需要4个关节限位, 实际{len(self.limits)}个")

@classmethod

def default_4dof_welding(cls):

"""

默认4-DOF焊接机械臂关节限位

θ1: ±160° θ2: ±120° θ3: ±180° d4: ±150 mm

"""

pi = 3.141592653589793

return cls(limits=[

JointLimit(-160 * pi / 180, 160 * pi / 180, 'joint1_base_yaw'),

JointLimit(-120 * pi / 180, 120 * pi / 180, 'joint2_elbow_yaw'),

JointLimit(-180 * pi / 180, 180 * pi / 180, 'joint3_wrist_roll'),

JointLimit(-0.150, 0.150, 'joint4_z_lift'),

])

def check_all_with_indices(self, joint_values: List[float]) -> Tuple[bool, List[int]]:

"""

检查全部关节是否在限位内

返回：(全部通过?, 超限关节索引列表)

使用索引而非字符串匹配，避免子串匹配脆弱性

"""

if len(joint_values) != 4:

raise ValueError(f"需要4个关节值, 实际{len(joint_values)}个")

all_pass = True

violation_indices = []

for i, (val, limit) in enumerate(zip(joint_values, self.limits)):

if not limit.contains(val):

all_pass = False

violation_indices.append(i)

return all_pass, violation_indices

@dataclass

class DHParam:

"""标准D-H参数"""

theta: float

d: float

a: float

alpha: float

def __post_init__(self):

for name, val in [('theta', self.theta), ('d', self.d),

('a', self.a), ('alpha', self.alpha)]:

if not np.isfinite(val):

raise ValueError(f"DHParam.{name}必须为有限数值")

@dataclass

class SCARAParams:

"""

4-DOF工业机械臂完整参数

大臂500mm, 小臂400mm, d1=350mm

"""

links: List[DHParam]

joint_names: List[str] = field(default_factory=lambda: [

'joint1_base_yaw', 'joint2_elbow_yaw',

'joint3_wrist_roll', 'joint4_z_lift'

])

@classmethod

def default_welding(cls):

pi = 3.141592653589793

links = [

DHParam(0.0, 0.350, 0.500, 0.0),

DHParam(0.0, 0.0, 0.400, 0.0),

DHParam(0.0, 0.0, 0.0, 0.0),

DHParam(0.0, 0.0, 0.0, -pi/2),

]

return cls(links=links)

@dataclass

class JointVelocity:

"""

关节速度向量 (rad/s 或 m/s)

"""

values: List[float]

def __post_init__(self):

if len(self.values) != 4:

raise ValueError(f"需要4个关节速度值, 实际{len(self.values)}个")

for i, v in enumerate(self.values):

if not np.isfinite(v):

raise ValueError(f"JointVelocity.values[{i}]必须为有限数值")

def as_array(self) -> np.ndarray:

return np.array(self.values, dtype=float)

"jacobian/forward_kinematics.py" — 正运动学求解器

"""

正运动学求解器：计算各连杆变换矩阵，供雅可比计算使用

"""

import numpy as np

from jacobian.models import SCARAParams

class ForwardKinematicsSCARA:

"""

4-DOF SCARA正运动学求解器

输出各连杆在基座标系中的变换矩阵列表

"""

def __init__(self, params: SCARAParams):

self.params = params

def compute_all_transforms(self, joint_values):

"""

计算从基座到各连杆的齐次变换矩阵

返回：T_list[i] = T_0^{i+1}，i=0,1,2,3

同时返回各连杆坐标系原点在基座标系中的位置 p_list[i]

以及各连杆z轴方向在基座标系中的单位向量 z_list[i]

注意：z_list[3]是第4连杆系z轴（经α₄=-π/2翻转），

不是关节4平移方向；平移方向用z_list[2]（第3连杆z轴）

"""

if len(joint_values) != 4:

raise ValueError(f"需要4个关节值, 实际{len(joint_values)}个")

T_list = []

p_list = []

z_list = []

T = np.eye(4)

for i in range(3):

self.params.links[i].theta = joint_values[i]

T_i = self._dh_matrix(self.params.links[i])

T = T @ T_i

T_list.append(T.copy())

p_list.append(T[0:3, 3].copy())

z_list.append(T[0:3, 2].copy())

# 第4关节：平移，α₄=-π/2

self.params.links[3].d = joint_values[3]

T_3 = self._dh_matrix(self.params.links[3])

T = T @ T_3

T_list.append(T.copy())

p_list.append(T[0:3, 3].copy())

# 注意：z_list[3]是第4连杆系z轴（经α₄=-π/2翻转），

# 不是关节4平移方向；平移方向用z_list[2]

z_list.append(T[0:3, 2].copy())

return T_list, p_list, z_list

def compute_end_effector_pose(self, joint_values):

"""计算末端执行器位姿"""

T_list, p_list, z_list = self.compute_all_transforms(joint_values)

T_end = T_list[-1]

x, y, z = T_end[0, 3], T_end[1, 3], T_end[2, 3]

yaw = joint_values[0] + joint_values[1] + joint_values[2]

yaw = np.arctan2(np.sin(yaw), np.cos(yaw))

return x, y, z, yaw

@staticmethod

def _dh_matrix(param):

ct, st = np.cos(param.theta), np.sin(param.theta)

ca, sa = np.cos(param.alpha), np.sin(param.alpha)

return np.array([

[ct, -st*ca, st*sa, param.a*ct],

[st, ct*ca, -ct*sa, param.a*st],

[0, sa, ca, param.d],

[0, 0, 0, 1]

], dtype=float)

"jacobian/jacobian_solver.py" — 雅可比矩阵求解器（核心业务类）

"""

雅可比矩阵求解器：输入关节角度，计算解析雅可比矩阵

基于运动学递推公式：J_i = [z_{i-1} × (p_end - p_{i-1}); z_{i-1}] (旋转关节)

本篇计算正映射 J·q_dot → 末端速度

逆映射（伪逆/DLS）为下一步，本篇不覆盖

"""

import numpy as np

from jacobian.models import SCARAParams

from jacobian.forward_kinematics import ForwardKinematicsSCARA

class JacobianSolver:

"""

4-DOF SCARA雅可比矩阵解析求解器

输入：关节角度 q = [θ1, θ2, θ3, d4]

输出：6×4雅可比矩阵 J

"""

def __init__(self, params: SCARAParams):

self.params = params

self.fk = ForwardKinematicsSCARA(params)

def compute_jacobian(self, joint_values) -> np.ndarray:

"""

计算给定关节角度下的6×4雅可比矩阵

返回：J (6×4 numpy array)

"""

if len(joint_values) != 4:

raise ValueError(f"需要4个关节值, 实际{len(joint_values)}个")

T_list, p_list, z_list = self.fk.compute_all_transforms(joint_values)

p_end = p_list[-1]

z_base = np.array([0.0, 0.0, 1.0])

J = np.zeros((6, 4))

# 第1列：joint1 (旋转关节，绕基座z轴)

J[0:3, 0] = np.cross(z_base, p_end - np.zeros(3))

J[3:6, 0] = z_base

# 第2列：joint2 (旋转关节，绕第1连杆z轴)

J[0:3, 1] = np.cross(z_list[0], p_end - p_list[0])

J[3:6, 1] = z_list[0]

# 第3列：joint3 (旋转关节，绕第2连杆z轴)

J[0:3, 2] = np.cross(z_list[1], p_end - p_list[1])

J[3:6, 2] = z_list[1]

# 第4列：joint4 (平移关节，沿第3连杆z轴方向)

# 注意：用z_list[2]（第3连杆z轴），不用z_list[3]（经α₄翻转）

J[0:3, 3] = z_list[2]

J[3:6, 3] = np.array([0.0, 0.0, 0.0])

return J

def compute_end_velocity(self, joint_values, joint_velocities):

"""

给定关节角度和关节速度，计算末端笛卡尔速度

v_end = J(q) × q_dot

返回：(v_end (6×1), J (6×4))

"""

J = self.compute_jacobian(joint_values)

q_dot = np.array(joint_velocities, dtype=float)

if q_dot.shape[0] != 4:

raise ValueError(f"需要4个关节速度值, 实际{q_dot.shape[0]}个")

v_end = J @ q_dot

return v_end, J

def compute_condition_number(self, joint_values) -> float:

"""

计算雅可比矩阵的条件数（使用2-范数奇异值）

cond(J) = σ_max / σ_min

不做奇异值过滤——σ_min→0时cond→∞正是接近奇异的物理趋势

过滤趋零奇异值会掩盖奇异，与核心叙事矛盾

"""

J = self.compute_jacobian(joint_values)

singular_values = np.linalg.svd(J, compute_uv=False)

# 6×4矩阵最多4个非零奇异值，直接取max/min

if singular_values[-1] < 1e-15:

return float('inf')

return float(singular_values[0] / singular_values[-1])

def get_min_singular_value(self, joint_values) -> float:

"""

返回最小奇异值（辅助指标，独立输出）

"""

J = self.compute_jacobian(joint_values)

singular_values = np.linalg.svd(J, compute_uv=False)

return float(singular_values[-1])

def analyze_jacobian_columns(self, joint_values) -> dict:

"""

分析雅可比各列向量的模长

反映每个关节对末端各方向速度的贡献大小

"""

J = self.compute_jacobian(joint_values)

analysis = {

'column_norms': [],

'linear_velocity_contributions': [],

'angular_velocity_contributions': []

}

for i in range(4):

col = J[:, i]

analysis['column_norms'].append(float(np.linalg.norm(col)))

analysis['linear_velocity_contributions'].append(

float(np.linalg.norm(col[0:3])))

analysis['angular_velocity_contributions'].append(

float(np.linalg.norm(col[3:6])))

return analysis

"jacobian/visualize.py" — 可视化模块

"""

雅可比仿真结果可视化：4张核心图表

"""

import numpy as np

import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']

plt.rcParams['axes.unicode_minus'] = False

class Visualizer:

def __init__(self, results_dir="results"):

self.results_dir = results_dir

import os

os.makedirs(results_dir, exist_ok=True)

def plot_condition_number_vs_reach(self, reach_distances, condition_numbers,

min_singular_values=None):

"""

① 条件数随水平距离变化曲线

工程结论：距离工作空间边界越近，条件数越大，速度映射越不均匀

"""

fig, ax1 = plt.subplots(figsize=(10, 5))

color1 = 'tab:blue'

ax1.plot(np.array(reach_distances) * 1000, condition_numbers,

color=color1, linewidth=1.5, marker='o', markersize=4)

ax1.set_xlabel('Horizontal Reach Distance r (mm)')

ax1.set_ylabel('Jacobian Condition Number', color=color1)

ax1.tick_params(axis='y', labelcolor=color1)

ax1.grid(True, alpha=0.3)

# 标注工作空间边界

max_reach = max(reach_distances) * 1000

min_reach = min(reach_distances) * 1000

ax1.axvline(x=max_reach, color='red', linestyle='--',

linewidth=1, alpha=0.7, label=f'Max Reach {max_reach:.0f}mm')

ax1.axvline(x=min_reach, color='red', linestyle='--',

linewidth=1, alpha=0.7, label=f'Min Reach {min_reach:.0f}mm')

# 双y轴：最小奇异值

if min_singular_values is not None:

ax2 = ax1.twinx()

color2 = 'tab:orange'

ax2.plot(np.array(reach_distances) * 1000, min_singular_values,

color=color2, linewidth=1, marker='s', markersize=3,

alpha=0.7)

ax2.set_ylabel('Min Singular Value', color=color2)

ax2.tick_params(axis='y', labelcolor=color2)

plt.title('Jacobian Condition Number vs. Horizontal Reach Distance')

fig.tight_layout()

path = f"{self.results_dir}/01_condition_number_vs_reach.png"

plt.savefig(path, dpi=150)

plt.close()

return path

def plot_jacobian_column_norms(self, test_configs, column_data):

"""

② 雅可比各列模长对比柱状图

工程结论：展示各关节在不同位形下对末端速度的贡献大小

"""

fig, axes = plt.subplots(2, 2, figsize=(12, 9))

axes = axes.flatten()

joint_names = ['Joint1 (Base Yaw)', 'Joint2 (Elbow)',

'Joint3 (Wrist)', 'Joint4 (Z Lift)']

for j in range(4):

ax = axes[j]

norms = [col_data[i][j] for i in range(len(col_data))]

labels = [f'C{cfg["label"]}' for cfg in test_configs]

bars = ax.bar(range(len(norms)), norms, alpha=0.8,

edgecolor='black')

for bar, norm in zip(bars, norms):

if norm > 1.5:

bar.set_color('red')

elif norm > 0.8:

bar.set_color('orange')

else:

bar.set_color('steelblue')

ax.set_xticks(range(len(labels)))

ax.set_xticklabels(labels, rotation=45, ha='right', fontsize=7)

ax.set_ylabel('Column Norm ||J_i||')

ax.set_title(f'{joint_names[j]}\nVelocity Contribution Magnitude')

ax.grid(True, alpha=0.3, axis='y')

plt.tight_layout()

path = f"{self.results_dir}/02_jacobian_column_norms.png"

plt.savefig(path, dpi=150)

plt.close()

return path

def plot_end_velocity_vectors(self, test_configs, velocities,

velocity_magnitudes):

"""

③ 末端速度向量分量对比 + 速度窗口分析

工程结论：给定相同关节速度，不同位形下末端速度差异巨大；

标注80~120 mm/s焊接速度窗口

"""

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(11, 10))

# 上图：速度分量

n = len(test_configs)

x = np.arange(n)

width = 0.12

vx = [vel[0] for vel in velocities]

vy = [vel[1] for vel in velocities]

vz = [vel[2] for vel in velocities]

wx = [vel[3] for vel in velocities]

wy = [vel[4] for vel in velocities]

wz = [vel[5] for vel in velocities]

ax1.bar(x - 2.5*width, vx, width, label='v_x (m/s)', alpha=0.8)

ax1.bar(x - 1.5*width, vy, width, label='v_y (m/s)', alpha=0.8)

ax1.bar(x - 0.5*width, vz, width, label='v_z (m/s)', alpha=0.8)

ax1.bar(x + 0.5*width, wx, width, label='ω_x (rad/s)', alpha=0.8)

ax1.bar(x + 1.5*width, wy, width, label='ω_y (rad/s)', alpha=0.8)

ax1.bar(x + 2.5*width, wz, width, label='ω_z (rad/s)', alpha=0.8)

ax1.set_xticks(x)

ax1.set_xticklabels([cfg['label'] for cfg in test_configs],

rotation=45, ha='right')

ax1.set_ylabel('Velocity Component Magnitude')

ax1.set_title('End-Effector Velocity Components under Identical Joint Speeds'

'\n([θ1_dot=0.5, θ2_dot=0.3, θ3_dot=0.2, d4_dot=0.1])')

ax1.legend(fontsize=7)

ax1.grid(True, alpha=0.3, axis='y')

# 下图：末端线速度模长 + 焊接窗口

speed_mm_s = [mag * 1000 for mag in velocity_magnitudes]

colors = ['green' if 80 <= s <= 120 else 'red' for s in speed_mm_s]

ax2.bar(x, speed_mm_s, color=colors, alpha=0.8, edgecolor='black')

ax2.axhline(y=80, color='green', linestyle='--', linewidth=1.5,

label='Welding Window Min (80 mm/s)')

ax2.axhline(y=120, color='green', linestyle='--', linewidth=1.5,

label='Welding Window Max (120 mm/s)')

ax2.set_xticks(x)

ax2.set_xticklabels([cfg['label'] for cfg in test_configs],

rotation=45, ha='right')

ax2.set_ylabel('End-Effector Linear Speed (mm/s)')

ax2.set_title('End-Effector Speed vs. Welding Window (80~120 mm/s)')

ax2.legend(fontsize=8)

ax2.grid(True, alpha=0.3, axis='y')

plt.tight_layout()

path = f"{self.results_dir}/03_end_velocity_vectors.png"

plt.savefig(path, dpi=150)

plt.close()

return path

def plot_singular_value_spectrum(self, test_configs, svd_data):

"""

④ 雅可比矩阵奇异值谱

工程结论：奇异值分布越不均匀（最小奇异值趋近0），构型越接近奇异

"""

fig, ax = plt.subplots(figsize=(10, 6))

n = len(test_configs)

x = np.arange(n)

width = 0.2

colors = ['steelblue', 'orange', 'green', 'red']

labels = ['σ₁ (max)', 'σ₂', 'σ₃', 'σ₄ (min)']

for i in range(4):

sv = [svd_data[j][i] if i < len(svd_data[j]) else 0

for j in range(n)]

ax.bar(x + i*width, sv, width,

label=labels[i], color=colors[i], alpha=0.8,

edgecolor='black')

ax.set_xlabel('Test Configuration')

ax.set_ylabel('Singular Value Magnitude')

ax.set_title('Jacobian Singular Value Spectrum per Configuration')

ax.set_xticks(x + 1.5*width)

ax.set_xticklabels([cfg['label'] for cfg in test_configs],

rotation=45, ha='right')

ax.legend(fontsize=8)

ax.grid(True, alpha=0.3, axis='y')

plt.tight_layout()

path = f"{self.results_dir}/04_singular_value_spectrum.png"

plt.savefig(path, dpi=150)

plt.close()

return path

5. 可视化要求

序号 图表文件 服务结论

①

"01_condition_number_vs_reach.png" 条件数+最小奇异值随水平距离变化，展示工作空间边界附近的奇异趋势

②

"02_jacobian_column_norms.png" 各关节在不同位形下对末端速度的贡献大小对比

③

"03_end_ve

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！