引用别的链接学习矩阵变换
计算机图形学一：变换矩阵-Transformation Matrices-CSDN博客

矩阵参数

m_nErr = EzdKernel.E3_MarkerSetTransformMatrix(m_idMarker, ResultMatrix.Values);
 if (m_nErr != EzdKernel.E3_ERR.SUCCESS)
 {
        return false;
  }
      return true;


public class Matrix2d
{
    public const int TRANSFORM_NO = 0;

    public const int TRANSFORM_MOVE = 1;

    public const int TRANSFORM_SCALE = 2;

    public const int TRANSFORM_MIRROR = 4;

    public const int TRANSFORM_ROTATE = 8;

    public const int TRANSFORM_SHEAR = 16;

    public const int TRANSFORM_MIX = 255;

    private double x00;

    private double x01;

    private double x02;

    private double x10;

    private double x11;

    private double x12;

    private double x20;

    private double x21;

    private double x22;

    public double[] Values => new double[9] { x00, x01, x02, x10, x11, x12, x20, x21, x22 };




    // 参数先列后行
    public static Matrix2d Identity()
    {
        Matrix2d matrix2d = new Matrix2d();
        matrix2d.x00 = 1.0;
        matrix2d.x01 = 0.0;
        matrix2d.x02 = 0.0;
        matrix2d.x10 = 0.0;
        matrix2d.x11 = 1.0;
        matrix2d.x12 = 0.0;
        matrix2d.x20 = 0.0;
        matrix2d.x21 = 0.0;
        matrix2d.x22 = 1.0;
        return matrix2d;
    }

    public static Matrix2d Move(double fx, double fy)
    {
        Matrix2d matrix2d = Identity();
        matrix2d.x20 = fx;
        matrix2d.x21 = fy;
        return matrix2d;
    }

    public static Matrix2d Scale(double fScaleX, double fScaleY)
    {
        Matrix2d matrix2d = Identity();
        matrix2d.x00 = fScaleX;
        matrix2d.x11 = fScaleY;
        return matrix2d;
    }

    public static Matrix2d Scale(double ptX, double ptY, double fScaleX, double fScaleY)
    {
        Matrix2d matrix2d = Identity();
        matrix2d.x00 = fScaleX;
        matrix2d.x11 = fScaleY;
        matrix2d.x20 = (1.0 - fScaleX) * ptX;
        matrix2d.x21 = (1.0 - fScaleY) * ptY;
        return matrix2d;
    }

    public static Matrix2d Rotate(double ptX, double ptY, double fRadAngle)
    {
        Matrix2d matrix2d = Identity();
        double num = Math.Cos(fRadAngle);
        double num2 = Math.Sin(fRadAngle);
        matrix2d.x00 = num;
        matrix2d.x01 = num2;
        matrix2d.x10 = 0.0 - num2;
        matrix2d.x11 = num;
        matrix2d.x20 = (1.0 - num) * ptX + ptY * num2;
        matrix2d.x21 = (1.0 - num) * ptY - ptX * num2;
        return matrix2d;
    }

    public static Matrix2d MirrorX()
    {
        Matrix2d matrix2d = Identity();
        matrix2d.x11 = -1.0;
        return matrix2d;
    }

    public static Matrix2d MirrorY()
    {
        Matrix2d matrix2d = Identity();
        matrix2d.x00 = -1.0;
        return matrix2d;
    }

    public static Matrix2d ShearX(double xShear, double yShear, double fRadAngle)
    {
        Matrix2d matrix2d = Move(0.0 - xShear, 0.0 - yShear);
        Matrix2d matrix2d2 = Identity();
        matrix2d2.x10 = Math.Tan(fRadAngle);
        Matrix2d matrix2d3 = Move(xShear, yShear);
        return matrix2d * matrix2d2 * matrix2d3;
    }

    public static Matrix2d ShearY(double xShear, double yShear, double fRadAngle)
    {
        Matrix2d matrix2d = Move(0.0 - xShear, 0.0 - yShear);
        Matrix2d matrix2d2 = Identity();
        matrix2d2.x01 = Math.Tan(fRadAngle);
        Matrix2d matrix2d3 = Move(xShear, yShear);
        return matrix2d * matrix2d2 * matrix2d3;
    }

    public static Matrix2d Mirror(double x1, double y1, double x2, double y2)
    {
        Matrix2d matrix2d = Identity();
        double num = x2 - x1;
        double num2 = y2 - y1;
        double num3 = Math.Sqrt(num * num + num2 * num2);
        if (num3 > 1E-12)
        {
            num /= num3;
            num2 /= num3;
        }

        matrix2d.x00 = 1.0 - 2.0 * num2 * num2;
        matrix2d.x01 = 2.0 * num * num2;
        matrix2d.x10 = 2.0 * num * num2;
        matrix2d.x11 = 1.0 - 2.0 * num * num;
        matrix2d.x20 = 2.0 * x1 * num2 * num2 - 2.0 * num * num2 * y1;
        matrix2d.x21 = 2.0 * y1 * num * num - 2.0 * num * num2 * x1;
        return matrix2d;
    }

    public static Matrix2d operator *(Matrix2d A, Matrix2d B)
    {
        Matrix2d matrix2d = new Matrix2d();
        matrix2d.x00 = A.x00 * B.x00;
        matrix2d.x00 += A.x01 * B.x10;
        matrix2d.x00 += A.x02 * B.x20;
        matrix2d.x01 = A.x00 * B.x01;
        matrix2d.x01 += A.x01 * B.x11;
        matrix2d.x01 += A.x02 * B.x21;
        matrix2d.x02 = A.x00 * B.x02;
        matrix2d.x02 += A.x01 * B.x12;
        matrix2d.x02 += A.x02 * B.x22;
        matrix2d.x10 = A.x10 * B.x00;
        matrix2d.x10 += A.x11 * B.x10;
        matrix2d.x10 += A.x12 * B.x20;
        matrix2d.x11 = A.x10 * B.x01;
        matrix2d.x11 += A.x11 * B.x11;
        matrix2d.x11 += A.x12 * B.x21;
        matrix2d.x12 = A.x10 * B.x02;
        matrix2d.x12 += A.x11 * B.x12;
        matrix2d.x12 += A.x12 * B.x22;
        matrix2d.x20 = A.x20 * B.x00;
        matrix2d.x20 += A.x21 * B.x10;
        matrix2d.x20 += A.x22 * B.x20;
        matrix2d.x21 = A.x20 * B.x01;
        matrix2d.x21 += A.x21 * B.x11;
        matrix2d.x21 += A.x22 * B.x21;
        matrix2d.x22 = A.x20 * B.x02;
        matrix2d.x22 += A.x21 * B.x12;
        matrix2d.x22 += A.x22 * B.x22;
        return matrix2d;
    }

    public static Pt2d operator *(Matrix2d M, Pt2d pt)
    {
        return new Pt2d(pt.X * M.x00 + pt.Y * M.x10 + M.x20, pt.X * M.x01 + pt.Y * M.x11 + M.x21);
    }

    public static Pt2d operator *(Pt2d pt, Matrix2d M)
    {
        return new Pt2d(pt.X * M.x00 + pt.Y * M.x10 + M.x20, pt.X * M.x01 + pt.Y * M.x11 + M.x21);
    }

    public static Matrix2d TwoPointMap(Pt2d ptOld1, Pt2d ptOld2, Pt2d ptNew1, Pt2d ptNew2)
    {
        double num = ptOld1.Dist(ptOld2);
        double num2 = ptNew1.Dist(ptNew2);
        double num3 = num2 / num;
        double angle = ptOld2.GetAngle(ptOld1);
        double angle2 = ptNew2.GetAngle(ptNew1);
        Matrix2d matrix2d = Rotate(ptOld1.X, ptOld1.Y, 0.0 - angle);
        Matrix2d matrix2d2 = Scale(ptOld1.X, ptOld1.Y, num3, num3);
        Matrix2d matrix2d3 = Rotate(ptOld1.X, ptOld1.Y, angle2);
        Matrix2d matrix2d4 = Move(ptNew1.X - ptOld1.X, ptNew1.Y - ptOld1.Y);
        return matrix2d * matrix2d2 * matrix2d3 * matrix2d4;
    }

    public static Matrix2d ThreePointMap(Pt2d ptOld1, Pt2d ptOld2, Pt2d ptOld3, Pt2d ptNew1, Pt2d ptNew2, Pt2d ptNew3)
    {
        int nO = 0;
        int nX = 1;
        int nY = 2;
        Pt2d[] array = new Pt2d[3];
        Pt2d[] array2 = new Pt2d[3];
        if (JMath.Get3PtXOYCoor(ptOld1, ptOld2, ptOld3, 0.001, ref nO, ref nX, ref nY))
        {
            array[0] = ptOld1;
            array[1] = ptOld2;
            array[2] = ptOld3;
            array2[0] = ptNew1;
            array2[1] = ptNew2;
            array2[2] = ptNew3;
        }
        else
        {
            Pt2d ptGet = default(Pt2d);
            Pt2d ptGet2 = default(Pt2d);
            JMath.GetProjectPtToLine(ptOld1, ptOld2, ptOld3, ref ptGet);
            JMath.GetProjectPtToLine(ptNew1, ptNew2, ptNew3, ref ptGet2);
            array[0] = ptOld1;
            array[1] = ptGet;
            array[2] = ptOld3;
            array2[0] = ptNew1;
            array2[1] = ptGet2;
            array2[2] = ptNew3;
        }

        double num = array[nX].Dist(array[nO]);
        double num2 = array2[nX].Dist(array2[nO]);
        double num3 = array[nY].Dist(array[nO]);
        double num4 = array2[nY].Dist(array2[nO]);
        double fScaleX = num2 / num;
        double fScaleY = num4 / num3;
        double angle = array[nX].GetAngle(array[nO]);
        double angle2 = array2[nX].GetAngle(array2[nO]);
        Matrix2d matrix2d = Rotate(array[nO].X, array[nO].Y, 0.0 - angle);
        Matrix2d matrix2d2 = Scale(array[nO].X, array[nO].Y, fScaleX, fScaleY);
        Matrix2d matrix2d3 = Rotate(array[nO].X, array[nO].Y, angle2);
        Matrix2d matrix2d4 = Move(array2[nO].X - array[nO].X, array2[nO].Y - array[nO].Y);
        return matrix2d * matrix2d2 * matrix2d3 * matrix2d4;
    }
}