有个AE 效果叫 边角定位，需要去实现（或者叫CC Power Pin）
首先对这方面理解很少，所以开始在网上查各种资料了
比如有：
[【图像处理】透视变换 Perspective Transformation]https://blog.csdn.net/xiaowei_cqu/article/details/26471527
https://markdowner.net/article/160652341966934016
[Shader入门（5）矩阵的基础概念]https://blog.csdn.net/jiumaol/article/details/104008460
[矩阵形式下的最小二乘法推导]https://zhuanlan.zhihu.com/p/87582571
1.总结一下，用python来实现：
# python3.9
import cv2
import numpy as np
image = cv2.imread(path) # 一张 1080的图 （1920x1080像素）
point1 = np.float32([[0, 0], [1920, 0], [1920, 1080], [0, 1080]])
point2 = np.float32([[900, 0], [1000, 0], [1920, 1080], [0, 1080]])
M = cv2.getPerspectiveTransform(point1, point2) # 这个透视矩阵是第一步，通过4个点的变换关系求的
img = cv2.warpPerspective(image, M, (1920, 1080)) # 这个是应用矩阵
2.不过要移植到shader上，需要再做工作
import cv2
import numpy as np
image = cv2.imread(path) # 一张 1080的图 （1920x1080像素）
point1 = np.float32([[0, 0], [1920, 0], [1920, 1080], [0, 1080]]) # 从哪个位置
point2 = np.float32([[900, 0], [1000, 0], [1920, 1080], [0, 1080]]) # 移动到哪个位置
# 以上都不变，这里会模拟当原始像素位置为0，0时，计算出新位置是 x、y
u = 0 # w位置
v = 0 # h位置
x = (M[0][0] * u + M[0][1] * v + M[0][2]) / (M[2][0] * u + M[2][1] * v + M[2][2]) # 900
y = (M[1][0] * u + M[1][1] * v + M[1][2]) / (M[2][0] * u + M[2][1] * v + M[2][2]) # 0
这里多测试几个值都能匹配上。分别是 (0, 0), (1920, 0), (1920, 1080), (0, 1080)
然后就是遍历原始图每一个位置（u，v），然后把这个位置的RGB放到 （x, y）上，这样做完后，有可能有些像素没有赋值，然后会差值一下。
但是这里主要给shader用，那么就得反过来 使用，知道x、y，要推导出u、v 然后采样。
x = (M[0][0] * u + M[0][1] * v + M[0][2]) / (M[2][0] * u + M[2][1] * v + M[2][2])
y = (M[1][0] * u + M[1][1] * v + M[1][2]) / (M[2][0] * u + M[2][1] * v + M[2][2])
3.现在假设了 M这个矩阵已经求得了，再看 这2个式子可以解出 u、v来，公式为：
/**
* shader 代码
* ｜a b｜ ｜c｜
* ｜d e｜ ｜f｜
*/
float4x4 _Matrix; // 需要外部传入
flaot u = 片元给的x
flaot v = 片元给的y
float M00 = _Matrix[0][0]; // 第一行一列
float M01 = _Matrix[0][1]; // 第一行二列
float M02 = _Matrix[0][2]; // 第一行三列
float M10 = _Matrix[1][0]; // 第二行一列
float M11 = _Matrix[1][1]; // 第二行二列
float M12 = _Matrix[1][2]; // 第二行三列
float M20 = _Matrix[2][0]; // 第三行一列
float M21 = _Matrix[2][1]; // 第三行二列
float M22 = _Matrix[2][2]; // 第三行三列
float a00 = u * M20 - M00;
float a01 = u * M21 - M01;
float a10 = v * M20 - M10;
float a11 = v * M21 - M11;
float b00 = -u * M22 + M02;
float b10 = -v * M22 + M12;
/**
* 想办法把上面的2个式子 改编成 aX + bY = c 形式
* 然后通过解 2元一次方程 本办法消元
*/
float X = (b00 * a11 - b10 * a01) / (a00 * a11 - a01 * a10);
float Y = (b00 * a10 - b10 * a00) / (a01 * a10 - a00 * a11);
// 计算出了需要采样的点
float2 nUV = float2(X, Y);
fixed4 col = tex2D(_InputTex, nUV); // 采样显示
这里介绍一个方法是 矩阵形式下的最小二乘法推导, 它可以举一反三了，比如3元1次方程，给一个3x3 矩阵和 1x3 矩阵来求解。
⚠️：需要注意的是，M矩阵的精度很重要，之前我使用了5位精度，结果在大图中（1080P）出现了偏差，改用8位好了很多
接下来就是计算矩阵了
def np_linalg_inv(matrix):
n = len(matrix)
A = [row[:] for row in matrix]
I = [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
# 前向消元
for i in range(n):
# 如果主对角线元素为0，则交换该行与下面的某一行
if A[i][i] == 0:
for j in range(i + 1, n):
if A[j][i] != 0:
A[i], A[j] = A[j], A[i]
I[i], I[j] = I[j], I[i]
break
else:
raise ValueError("Matrix is singular.")
# 将第i行的第i个元素变成1
f = A[i][i]
for j in range(i, n):
A[i][j] /= f
for j in range(n):
I[i][j] /= f
# 用第i行消去下面所有行的第i个元素
for j in range(i + 1, n):
f = A[j][i]
for k in range(i, n):
A[j][k] -= f * A[i][k]
for k in range(n):
I[j][k] -= f * I[i][k]
# 回代求解逆矩阵
for i in range(n - 1, -1, -1):
for j in range(i - 1, -1, -1):
f = A[j][i]
for k in range(n):
I[j][k] -= f * I[i][k]
return I
def cv2_getPerspectiveTransform(src, dst):
src = np.array(src, dtype=np.float32)
dst = np.array(dst, dtype=np.float32)
mat1 = np.zeros((8, 8), dtype=np.float32)
mat2 = np.zeros((8, 1), dtype=np.float32)
# 组成矩阵
for i in range(4):
x_src, y_src = src[i][0], src[i][1]
x_dst, y_dst = dst[i][0], dst[i][1]
mat1[2 * i][0] = x_src
mat1[2 * i][1] = y_src
mat1[2 * i][2] = 1
mat1[2 * i][6] = -x_dst * x_src
mat1[2 * i][7] = -x_dst * y_src
mat1[2 * i + 1][3] = x_src
mat1[2 * i + 1][4] = y_src
mat1[2 * i + 1][5] = 1
mat1[2 * i + 1][6] = -y_dst * x_src
mat1[2 * i + 1][7] = -y_dst * y_src
mat2[2 * i][0] = x_dst
mat2[2 * i + 1][0] = y_dst
# 求逆
mat1_inv = np.linalg.inv(mat1)
mat2_inv = np_linalg_inv(mat1)
# mat1_inv 使用的 np， mat2_inv 是自行实现
res = np.dot(mat1_inv, mat2)
mat = np.zeros((3, 3), dtype=np.float32)
mat[0][0] = res[0][0]
mat[0][1] = res[1][0]
mat[0][2] = res[2][0]
mat[1][0] = res[3][0]
mat[1][1] = res[4][0]
mat[1][2] = res[5][0]
mat[2][0] = res[6][0]
mat[2][1] = res[7][0]
mat[2][2] = 1
return mat
# 使用
point11 = np.float32([[0, 0], [1, 0], [1, 1], [0, 1]])
point22 = np.float32([[0.25, 0.25], [1, 0], [1, 1], [0, 1]])
MM = cv2.getPerspectiveTransform(point11, point22)
NN = cv2_getPerspectiveTransform(point11, point22)
# MM 和 NN 一致
具体见 【图像处理】透视变换 Perspective Transformation 基本可以确定的是，这个矩阵不需要每一个像素点都算一遍，所以我们写到shader外，计算好后，传入到shader当中去使用
还有一个就是 透视变换矩阵求解推导（通俗易懂），也是讲这个 求解过程
另一个高斯消元法，推荐一个网址 https://matrix.reshish.com/zh/gauss-jordanElimination.php
当我们有了这个矩阵后，传入到shader当中，看 3. 这个位置的介绍，就可以做出边角定位
网友评论