1. 项目概述：当游戏引擎遇上计算机视觉

在游戏开发中，我们经常需要让一个物体旋转、缩放、平移，或者让一张UI贴图产生透视扭曲，以营造出丰富的视觉效果。而在计算机视觉领域，我们同样需要对图像进行校正、配准，或者将一个物体从图像中“抠”出来并摆正。这两件看似风马牛不相及的事情，背后其实共享着同一套强大的数学工具——仿射变换。

仿射变换，这个听起来有点学术的词汇，本质上就是一套描述二维或三维空间中“形状保持”变换的规则。它保证了变换后，直线依然是直线，平行线依然平行，但可以改变物体的位置、大小、方向和形状。无论是Unity里让一个角色模型原地旋转，还是OpenCV里把一张倾斜的身份证照片摆正，都离不开它。

我之所以想聊聊这个话题，是因为在实际工作中，我发现很多开发者对这两个库中的矩阵操作存在一些混淆。Unity的Transform组件和Matrix4x4类，与OpenCV的cv2.warpAffine和cv2.getAffineTransform，虽然底层数学原理相通，但在API设计、坐标系习惯和实际应用场景上却大相径庭。理解这些差异，不仅能让你在Unity中更精准地控制物体，也能让你在接入OpenCV处理图像时，避免因坐标系转换错误导致的“鬼畜”效果。这篇文章，我就从一个游戏开发者的视角出发，拆解仿射变换在这两个领域的异同，并分享一些从踩坑中总结出来的实操经验。

2. 仿射变换的核心原理：一张“万能”的变换配方

在深入对比Unity和OpenCV之前，我们必须先统一思想，理解仿射变换这张“万能配方”到底是怎么工作的。它不是一个黑盒魔法，而是一个清晰、确定的数学过程。

2.1 矩阵：变换的“烹饪手册”

仿射变换的核心是一个矩阵。对于二维空间，这是一个2x3的矩阵；如果使用齐次坐标（为了统一平移操作），则可以扩展为3x3的方阵。这个矩阵里，编码了所有我们想做的变换信息。

一个标准的2x3仿射变换矩阵M长这样：

[ a b tx ] [ c d ty ]

• a, b, c, d (线性变换部分)：这四位“大厨”负责处理旋转、缩放和剪切（错切）。
  • 缩放：如果b和c为0，a和d就分别控制X轴和Y轴的缩放比例。a=2, d=1意味着横向拉宽一倍，纵向不变。
  • 旋转：旋转是缩放和剪切的特定组合。例如，逆时针旋转θ角，对应的矩阵是[cosθ, -sinθ; sinθ, cosθ]。
  • 剪切：b控制Y坐标对X坐标的影响（水平剪切），c控制X坐标对Y坐标的影响（垂直剪切）。想象一下把矩形推成一个平行四边形。
• tx, ty (平移部分)：这两位“搬运工”负责把整个图形在平面上挪个位置。tx是X方向的位移，ty是Y方向的位移。

那么，如何用这个“烹饪手册”对一个点(x, y)进行“烹饪”（变换）呢？公式非常简单：

x' = a * x + b * y + tx y' = c * x + d * y + ty

新坐标(x', y')就是旧坐标经过矩阵运算后的结果。这个计算对图像或模型上的每一个顶点（像素）都执行一遍，就完成了整体的变换。

注意：这里的变换顺序是先进行线性变换（旋转/缩放/剪切），再进行平移。这个顺序非常重要，因为矩阵乘法不满足交换律。先平移再旋转，和先旋转再平移，得到的结果天差地别。在Unity中设置物体的position和rotation时，引擎内部也是按照特定顺序（通常是缩放->旋转->平移）来组合矩阵的。

2.2 齐次坐标：让平移“入乡随俗”

你可能已经发现，上面的2x3矩阵在做乘法（a*x + b*y）和加法（+ tx）时有点“分裂”。为了用统一的矩阵乘法来表示所有操作，数学家引入了齐次坐标。

我们把二维点(x, y)升级为三维向量(x, y, 1)。这样，仿射变换就可以用一个3x3的矩阵乘法完美表达了：

[ x' ] [ a b tx ] [ x ] [ y' ] = [ c d ty ] * [ y ] [ 1 ] [ 0 0 1 ] [ 1 ]

这个3x3矩阵的第三行永远是[0, 0, 1]，它的作用就是保证齐次坐标的最后一个分量永远是1，从而将平移操作“伪装”成了矩阵乘法的一部分。这种表示法在图形学和计算机视觉中极为普遍，因为它让变换的组合（连续乘矩阵）和求逆（求矩阵的逆）变得异常方便。

2.3 插值：填补像素的“空白”

当我们对一张数字图像进行仿射变换时，会面临一个现实问题：变换后的像素点坐标(x', y')很可能不是整数。也就是说，目标图像上的某个像素点，对应到源图像上的位置，可能落在四个像素的中间。

这时候就需要插值来决定这个位置的颜色。常见的插值方法有：

1. 最近邻插值：取距离最近的那个源像素的颜色。速度最快，但会产生明显的锯齿（像素块感）。在早期性能受限的游戏或需要像素艺术风格时可能会用。
2. 双线性插值：取周围四个像素，根据距离进行加权平均。效果平滑，是质量和速度的较好平衡，在图像处理和游戏纹理采样中最为常用。
3. 双三次插值：取周围16个像素，用更复杂的函数计算。效果最平滑，但计算量也最大，常用于高质量的照片编辑。

在OpenCV的warpAffine函数中，你可以通过flags参数指定插值方法。而在Unity中，纹理的过滤模式（Filter Mode）本质上也是一种插值策略，Bilinear就是双线性过滤。

3. Unity中的仿射变换：以物体为中心的世界

在Unity的游戏世界里，仿射变换无处不在，但它通常被封装在更高层、更易用的组件和属性里，开发者很少需要直接和矩阵打交道。

3.1 Transform组件：对矩阵的友好封装

每个GameObject都有一个Transform组件，它直观地暴露了位置（position）、旋转（rotation）和缩放（scale）这三个属性。当你修改这些属性时，Unity底层就是在为你计算并应用一个仿射变换矩阵（实际上是4x4的，因为包含三维信息）。

一个关键差异：左手坐标系 vs. 右手坐标系这是Unity和许多传统数学/计算机视觉库（包括OpenCV的某些函数）的第一个重大区别。Unity使用的是左手坐标系：X轴向右，Y轴向上，Z轴向前（屏幕内）。而许多数学库和OpenCV在处理2D图像时，通常隐含一个右手坐标系：X轴向右，Y轴向下（图像的行方向），Z轴向外（或忽略）。

这个Y轴方向的差异，是导致很多变换结果“看起来是反的”的罪魁祸首。例如，一个在数学上正45度的旋转，在Unity的2D场景（X-Y平面）里，因为Y轴向上，旋转方向是符合常规认知的。但在OpenCV中，如果以图像左上角为原点，Y轴向下，一个正的旋转角度可能会导致图像顺时针旋转。

矩阵的访问与组合你可以通过transform.localToWorldMatrix获取物体从本地空间到世界空间的变换矩阵（一个Matrix4x4对象）。你也可以自己创建和组合矩阵：

// 创建一个绕Z轴旋转30度的矩阵（2D旋转） Matrix4x4 rotationMatrix = Matrix4x4.Rotate(Quaternion.Euler(0, 0, 30)); // 创建一个平移矩阵 Matrix4x4 translationMatrix = Matrix4x4.Translate(new Vector3(5, 2, 0)); // 组合变换：先旋转，再平移 Matrix4x4 combinedMatrix = translationMatrix * rotationMatrix; // 应用到一个点上 Vector3 originalPoint = new Vector3(1, 0, 0); Vector3 transformedPoint = combinedMatrix.MultiplyPoint(originalPoint);

实操心得：注意矩阵乘法的顺序！在Unity中，矩阵乘法是左乘，即M_final = M_last * M_first * ... * M_second * M_first。这表示变换是从右向左依次应用的。上面代码中translationMatrix * rotationMatrix意味着先执行rotationMatrix的旋转，再执行translationMatrix的平移。

3.2 在Shader与图形编程中的直接应用

在需要高性能或特殊效果的场合，我们会在Shader或Graphics.DrawMesh等底层API中直接使用矩阵。

• 顶点着色器：最基本的操作就是将顶点的本地坐标乘以模型-视图-投影矩阵（MVP矩阵），将其变换到屏幕空间。这个MVP矩阵就是一系列仿射变换（和投影变换）的组合。
• UI与2D Sprite：当处理UI RectTransform或2D Sprite的扭曲、倾斜效果时，可能会直接修改其material的_Matrix属性来实现动态的仿射变换，比如制作一个被风吹动的旗帜效果。

常见问题：非均匀缩放导致的“剪切”错觉在Unity中，如果你对一个父物体进行了非均匀缩放（例如X缩放2，Y缩放1），其子物体的旋转可能会产生意想不到的“剪切”效果。这是因为子物体的旋转是在父物体的缩放坐标系下进行的，非均匀缩放会扭曲这个坐标系。解决方案是尽量避免对包含旋转子物体的父级进行非均匀缩放，或者将缩放和旋转拆分到不同的层级。

4. OpenCV中的仿射变换：以图像为画布的操作

OpenCV处理仿射变换的哲学更接近“图像处理实验室”。它提供了一系列直接操作像素矩阵的函数，非常函数化，目标明确。

4.1 核心API：warpAffine与变换矩阵的获取

OpenCV进行仿射变换的核心就两步：1. 获取变换矩阵M；2. 应用变换。

1. cv2.warpAffine(src, M, dsize, ...)这是执行变换的主函数。你把源图像src、2x3的变换矩阵M、以及输出图像的尺寸dsize给它，它就能返回变换后的图像。关键参数flags用于指定插值方法（如cv2.INTER_LINEAR双线性插值）。

2. 获取变换矩阵M的两种主要方式

• cv2.getRotationMatrix2D(center, angle, scale)：这是最常用的方式之一，专门用于生成围绕指定中心点center旋转angle度，并缩放scale倍的变换矩阵。它内部帮你计算好了正弦余弦值，非常方便。

  import cv2 import numpy as np height, width = image.shape[:2] center = (width // 2, height // 2) # 通常以图像中心为旋转中心 angle = 45 # 逆时针旋转45度 scale = 0.8 # 缩小到80% M = cv2.getRotationMatrix2D(center, angle, scale) rotated_image = cv2.warpAffine(image, M, (width, height))

• cv2.getAffineTransform(src_pts, dst_pts)：这种方式更通用。你提供源图像中的三个点src_pts和目标图像中对应的三个点dst_pts，OpenCV会解算出一个能将这组三点映射过去的仿射变换矩阵。这常用于图像的校正，比如把一张斜拍的名片四个角点中的三个，映射到一个矩形框上。

  # 假设我们想校正一个倾斜的矩形区域 src_triangle = np.float32([[50, 50], [200, 100], [60, 200]]) dst_triangle = np.float32([[0, 0], [200, 0], [0, 150]]) M = cv2.getAffineTransform(src_triangle, dst_triangle) corrected_image = cv2.warpAffine(image, M, (250, 200))

4.2 坐标系与原点：Y轴向下的陷阱

这是与Unity对比时最需要警惕的一点！在OpenCV处理图像时，默认的原点(0,0)在图像的左上角，并且Y轴是向下的。这与我们常见的数学坐标系和Unity的2D坐标系（原点在左下角或中心，Y轴向上）截然不同。

这意味着：

1. 坐标定义：当你用鼠标点击图像上一个点，其(x, y)坐标的y值是从顶部开始计算的。
2. 旋转方向：在使用getRotationMatrix2D时，正角度代表逆时针旋转。但由于Y轴向下，从屏幕观察者的视角看，逆时针旋转在图像上可能表现为“顺时针”视觉效果。不过，函数本身定义的数学旋转方向是固定的（绕原点逆时针），只是由于坐标系不同，观察感受有异。最稳妥的方式是不要依赖直觉，而是用几个点实际测试一下。
3. 矩阵值：由于这个坐标系差异，从OpenCV计算出来的同一个几何变换的矩阵，其数值可能与你在Unity中为达到相同视觉效果而设置的矩阵数值不同。

避坑技巧：如果你需要将OpenCV检测到的特征点坐标（基于图像左上角原点）用于Unity中的物体定位，通常需要进行坐标系转换：y_unity = image_height - y_opencv。更复杂的，如果Unity摄像机视角不同，还需要结合视口和投影矩阵进行转换。

4.3 应用场景：从图像校正到AR

OpenCV中的仿射变换是许多高级功能的基石：

• 图像配准与对齐：将不同时间、角度拍摄的同一场景的图像进行对齐。
• 文档/名片校正：将透视拍摄的矩形文档，通过仿射变换拉正。
• 增强现实（AR）：当检测到平面标记（如一张图片）时，计算其四个角点在真实世界中的对应位置，通过解算单应性矩阵（透视变换，是仿射变换的更一般形式）或仿射变换，将虚拟物体准确地“贴”在标记上。
• 数据增强：在训练机器学习模型时，对图像进行随机旋转、缩放、剪切等仿射变换，以增加数据多样性。

5. 矩阵操作对比：Unity Matrix4x4 vs. OpenCV 2x3 Matrix

理解了各自领域的应用方式后，我们来一场直接的“矩阵对决”，看看它们在数据结构和操作上的具体差异。

一个具体的数值例子：假设我们要将一个点(1, 0)绕原点逆时针旋转90度。

• 数学/通用计算：旋转矩阵为[[0, -1], [1, 0]]。结果点：(0, 1)。
• 在Unity中（2D模式，Y向上）：使用Matrix4x4.Rotate(Quaternion.Euler(0,0,90))生成的4x4矩阵，其左上角2x2部分就是[[0, -1], [1, 0]]。应用后得到(0, 1)，符合预期。
• 在OpenCV中（图像坐标系，Y向下）：如果使用cv2.getRotationMatrix2D((0,0), 90, 1)，得到的2x3矩阵是[[0, 1, 0], [-1, 0, 0]]。注意看，其线性部分变成了[[0, 1], [-1, 0]]，这与通用矩阵不同。如果我们用这个矩阵去计算点(1,0)：

  x' = 0*1 + 1*0 + 0 = 0 y' = -1*1 + 0*0 + 0 = -1

  结果是(0, -1)。在Y轴向下的坐标系里，(0, -1)这个点位于原点的正下方。但从屏幕观察者的角度看，一个点从(1,0)（右边）跑到了(0,-1)（下方），这看起来像是顺时针旋转了90度。这就是坐标系差异带来的直观错觉。函数本身执行的数学变换（绕原点逆时针）是正确的，只是观察坐标系变了。

6. 实战：在Unity中实现一个OpenCV风格的图像扭曲器

理论说得再多，不如动手一试。让我们在Unity中模拟一个类似OpenCVwarpAffine的功能，对一张RawImage的纹理进行实时的仿射变换。这能帮你深刻理解矩阵数据如何在两个系统间传递。

步骤1：设置场景

1. 创建一个Unity UI Canvas。
2. 在Canvas下创建一个RawImage组件，并赋予它一张纹理。
3. 创建一个C#脚本，挂载到RawImage的游戏对象上。

步骤2：编写脚本核心逻辑

using UnityEngine; using UnityEngine.UI; [RequireComponent(typeof(RawImage))] public class AffineWarper : MonoBehaviour { private RawImage _rawImage; private Texture2D _sourceTexture; private Texture2D _warpedTexture; // 仿射变换矩阵参数 (2x3矩阵，对应 [a, b, tx; c, d, ty]) public float a = 1.0f, b = 0.0f, tx = 0.0f; public float c = 0.0f, d = 1.0f, ty = 0.0f; void Start() { _rawImage = GetComponent<RawImage>(); _sourceTexture = _rawImage.texture as Texture2D; if (_sourceTexture == null) { Debug.LogError("RawImage does not have a valid Texture2D."); return; } // 创建一张新的纹理用于存储扭曲结果 _warpedTexture = new Texture2D(_sourceTexture.width, _sourceTexture.height, TextureFormat.RGBA32, false); _warpedTexture.wrapMode = TextureWrapMode.Clamp; _rawImage.texture = _warpedTexture; ApplyAffineWarp(); } void Update() { // 可以在这里动态修改a,b,c,d,tx,ty参数，并实时更新 if (Input.GetKeyDown(KeyCode.Space)) { // 示例：做一个简单的剪切变换 b = 0.5f; c = 0.2f; ApplyAffineWarp(); } } void ApplyAffineWarp() { if (_sourceTexture == null || _warpedTexture == null) return; int width = _sourceTexture.width; int height = _sourceTexture.height; Color[] sourcePixels = _sourceTexture.GetPixels(); Color[] warpedPixels = new Color[width * height]; // 核心：对目标纹理的每一个像素，找到它在源纹理中的位置 for (int y_dst = 0; y_dst < height; y_dst++) { for (int x_dst = 0; x_dst < width; x_dst++) { // **关键步骤1：坐标系转换** // OpenCV默认原点在左上角，Y向下。 // Unity纹理采样原点在左下角，Y向上。 // 为了模拟OpenCV行为，我们先在“OpenCV坐标系”下计算。 float x_cv = x_dst; float y_cv = y_dst; // 此时原点在左上角 // 应用仿射变换（逆变换，因为我们要根据目标找源） // 注意：这里我们直接使用矩阵参数。更严谨的做法是求矩阵的逆。 // 这里为了演示，我们假设矩阵代表的变换是可逆的，且我们应用的是正向变换。 // 实际warpAffine内部做的是逆映射（Inverse Mapping）。 float x_src_cv = a * x_cv + b * y_cv + tx; float y_src_cv = c * x_cv + d * y_cv + ty; // **关键步骤2：将源坐标转换回Unity纹理坐标系** // Unity纹理坐标：原点在左下角，Y向上，范围0-1。 // 我们需要将计算得到的像素坐标转换为UV坐标。 float u = x_src_cv / width; // 转换Y： src_y_unity = height - src_y_cv float v = 1.0f - (y_src_cv / height); // 处理边界：如果源坐标超出纹理范围，则赋予一个颜色（如黑色） Color sampledColor = Color.black; if (u >= 0f && u <= 1f && v >= 0f && v <= 1f) { // 使用双线性插值进行采样（Texture2D.GetPixelBilinear） // 注意：GetPixelBilinear接受的是0-1的UV坐标。 sampledColor = _sourceTexture.GetPixelBilinear(u, v); } warpedPixels[y_dst * width + x_dst] = sampledColor; } } _warpedTexture.SetPixels(warpedPixels); _warpedTexture.Apply(); // 应用更改到GPU } // 在Inspector中提供一个按钮，方便测试 [ContextMenu("Apply Warp")] void ApplyWarpFromEditor() { ApplyAffineWarp(); } }

步骤3：原理与注意事项解析

1. 逆映射：代码中我们遍历目标图像的每个像素，计算它在源图像中对应的位置（x_src_cv, y_src_cv）。这是仿射变换在图像处理中的标准做法，称为“逆向映射”（Inverse Mapping），可以避免目标图像中出现空洞。
2. 坐标系转换：这是最易出错的部分。我们在“OpenCV图像坐标系”（左上角原点，Y向下）中进行矩阵计算，然后将得到的源像素坐标，转换为Unity纹理采样所需的“UV坐标系”（左下角原点，Y向上，范围0-1）。
3. 插值：我们使用了Texture2D.GetPixelBilinear，它实现了双线性插值，与OpenCV中cv2.INTER_LINEAR标志的效果类似。你也可以自己实现最近邻插值，性能更高但质量较差。
4. 性能：这段代码在Update中每帧调用GetPixels和SetPixels是非常耗CPU的，仅用于学习原理。实际项目中，这类像素级操作应该使用Compute Shader在GPU上并行完成，或者使用Unity的MaterialPropertyBlock和自定义Shader来实现实时扭曲。

通过这个例子，你可以清晰地看到，尽管数学公式相同，但在不同的系统和坐标系下，实现细节需要格外小心。你可以尝试修改脚本中的a, b, c, d, tx, ty参数，观察RawImage上纹理的变化，并与在Python中用OpenCV设置相同参数得到的结果进行对比，直观感受坐标系的差异。

7. 常见问题与排查技巧实录

在实际开发中混合使用Unity和OpenCV处理几何变换时，我踩过不少坑。下面是一些典型问题及其解决方案。

7.1 问题1：从OpenCV导入的变换矩阵，在Unity中应用后效果完全不对

• 现象：在Python中用OpenCV计算好了一个旋转矩阵，将数据（如[[0.707, -0.707, 100], [0.707, 0.707, 50]]）传到Unity，用Matrix4x4构造并应用后，物体飞到了奇怪的地方或旋转方向反了。
• 排查思路：
  1. 检查坐标系：这是首要怀疑对象。确认OpenCV矩阵是在什么坐标系下计算的（通常是图像左上角原点，Y向下）。而Unity的Matrix4x4默认应用于世界空间或本地空间，其坐标系是Y向上的。
  2. 检查矩阵格式：OpenCV的2x3矩阵是[[a, b, tx], [c, d, ty]]。在构建Unity的Matrix4x4时，你需要将其转换为4x4齐次矩阵。通常，你需要将a,b,c,d放入4x4矩阵的左上角2x2部分，将tx, ty放入第4列的前两行（m03,m13），并设置m33=1，其余位置为0。但这还没完。
  3. 处理Y轴翻转：由于Y轴方向相反，你可能需要对矩阵进行修正。一个常见的修正方法是：在将OpenCV矩阵的c和d（即第二行第一、二个元素）赋值给Unity矩阵的m10和m11时，取反。因为旋转/剪切在Y轴反向的坐标系中，其符号会发生变化。更系统的方法是，在应用矩阵前，先对点的Y坐标进行y_unity = -y_opencv的转换，或者将这个转换整合到一个专门的坐标系转换矩阵中，与仿射变换矩阵相乘。
• 解决方案：编写一个专门的工具函数来处理转换。

  public static Matrix4x4 ConvertOpenCvAffineToUnityMatrix(float[] cvMatrix2x3, float imageHeight) { // cvMatrix2x3 是长度为6的数组 [a, b, tx, c, d, ty] float a = cvMatrix2x3[0]; float b = cvMatrix2x3[1]; float tx = cvMatrix2x3[2]; float c = cvMatrix2x3[3]; float d = cvMatrix2x3[4]; float ty = cvMatrix2x3[5]; // 构建一个从OpenCV图像坐标系到Unity世界坐标系（假设Y向上，原点在中心）的转换矩阵 // 步骤：1. 将Y轴翻转 (y -> -y) 2. 将原点从左上角移到图像中心 Matrix4x4 toUnityCoord = Matrix4x4.identity; toUnityCoord.m11 = -1; // Y轴翻转 // 平移：先将原点平移到中心。假设图像宽高为w,h。 // 从OpenCV坐标(0,0在左上角)到Unity坐标(0,0在中心)： x_unity = x_cv - w/2, y_unity = -(y_cv - h/2) = h/2 - y_cv // 这部分平移可以合并到矩阵里，这里为了清晰，假设外部处理。 // 构建仿射变换部分（忽略平移） Matrix4x4 affinePart = new Matrix4x4(); affinePart.m00 = a; affinePart.m01 = b; affinePart.m03 = tx; affinePart.m10 = c; affinePart.m11 = d; affinePart.m13 = ty; affinePart.m22 = 1; affinePart.m33 = 1; // 组合变换：先进行仿射变换，再进行坐标系转换 // 注意顺序：对于点p，最终变换是 toUnityCoord * affinePart * p // 因为Unity是左乘，affinePart先应用，toUnityCoord后应用。 Matrix4x4 finalMatrix = toUnityCoord * affinePart; return finalMatrix; }

  注意：上面的函数是一个简化示例，实际应用中需要根据你的具体坐标系（Unity世界原点在哪里？OpenCV处理的图像对应Unity世界的哪个区域？）来调整toUnityCoord矩阵。最可靠的方法是：在OpenCV和Unity中分别用相同的几个已知点进行测试，根据结果差异来推导出正确的转换矩阵。

7.2 问题2：使用getAffineTransform时，点序错误导致扭曲异常

• 现象：用三对点计算仿射变换，结果图像扭曲成完全不可识别的样子。
• 原因：src_pts和dst_pts中的三个点必须一一对应，并且顺序一致。如果顺序错乱（比如src中是[pt1, pt2, pt3]，而dst中是[pt2, pt1, pt3]），计算出的矩阵会试图把pt1映射到pt2的位置，导致完全错误的变换。
• 解决方案：在定义点集时，务必确保顺序。对于矩形，通常按左上、右上、左下的顺序取三个点。可以使用可视化工具（如在图像上画圈）来确认你选取的点顺序是正确的。

7.3 问题3：变换后图像出现黑边或信息丢失

• 现象：应用旋转或缩放后，输出图像的角落变成黑色（填充值），或者部分图像内容被裁切掉了。
• 原因：
  1. 输出尺寸dsize设置过小：cv2.warpAffine的dsize参数决定了输出画布的大小。如果画布小于变换后的图像边界，超出的部分自然就被裁切了。
  2. 未计算新的画布大小：当进行旋转时，外接矩形会变大。如果仍使用原图尺寸，四个角就会超出画布。
• 解决方案：
  • 手动计算新尺寸：对于旋转，可以先计算原始图像四个角点变换后的新位置，然后找出所有新点的最小/最大X和Y值，从而确定新画布的宽度和高度。

  import cv2 import numpy as np def rotate_image_with_fit(image, angle, center=None, scale=1.0): (h, w) = image.shape[:2] if center is None: center = (w // 2, h // 2) M = cv2.getRotationMatrix2D(center, angle, scale) # 计算原始图像四个角点的新位置 cos = np.abs(M[0, 0]) sin = np.abs(M[0, 1]) # 计算新图像的尺寸 new_w = int((h * sin) + (w * cos)) new_h = int((h * cos) + (w * sin)) # 调整旋转矩阵的平移部分，使图像中心移动到新画布中心 M[0, 2] += (new_w / 2) - center[0] M[1, 2] += (new_h / 2) - center[1] rotated = cv2.warpAffine(image, M, (new_w, new_h)) return rotated

  • 使用borderMode和borderValue：如果允许黑边，可以忽略。如果想用其他颜色填充，可以设置borderValue=(255,255,255)为白色。如果想重复边缘像素，可以使用borderMode=cv2.BORDER_REPLICATE。

7.4 问题4：在Unity中组合变换顺序混乱

• 现象：写了多行代码分别设置平移、旋转、缩放，但最终物体的姿态和预想的不一样。
• 原因：矩阵乘法不满足交换律。Translate * Rotate和Rotate * Translate的结果完全不同。前者是“先旋转，后平移”（物体绕自身原点旋转，然后移动），后者是“先平移，后旋转”（物体先移动到新位置，再绕世界原点旋转）。
• 解决方案：牢记Unity中矩阵乘法的应用顺序是从右到左。在编写代码时，想清楚你希望的变换顺序。通常，对于单个物体，我们期望的顺序是：缩放 -> 旋转 -> 平移。Unity的Transform组件内部就是按照这个顺序来组合的。当你需要手动组合矩阵时，也应该遵循这个顺序：finalMatrix = translationMatrix * rotationMatrix * scaleMatrix。

理解仿射变换在Unity和OpenCV中的异同，本质上是理解同一套数学工具在不同应用语境下的“方言”。游戏开发关心的是物体在虚拟世界中的连续、动态关系，而计算机视觉更关注从像素数据中提取和修正静态的几何信息。当你需要打通这两个世界时——比如用OpenCV识别现实中的标记来控制Unity中的虚拟物体——坐标系转换和矩阵数据的正确解读就成了关键。我的经验是，永远不要假设，永远用最简单的点（比如一个正方形的四个角）在两个系统中分别做测试，对比输入和输出，一点点推导出那个正确的“翻译”矩阵。这个过程虽然繁琐，但一旦打通，你就会对三维空间和二维图像之间的几何关系有前所未有的透彻理解。