有个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. 这个位置的介绍，就可以做出边角定位