How to make a move relative to a straight line ax + by + c = 0, affine transformations

Here's how I figured out my task, maybe someone will need it.

To perform the reflection of a triangle relative to an arbitrary straight line, you need to perform specific actions:

• move the line and triangle so that the line passes through the origin;
• rotation of the line and triangle around the origin point to coincide with the X coordinate axis;
• reflection relative to the coordinate axis;
• reverse rotation around the origin;
• move to the starting position.

In matrix form, this transformation has the representation
[T] = [T'] [R] [R'] [R^(-1)] [T'^(-1)], where T' is the displacement matrix, R is the rotation matrix around the origin, and R' is the reflection matrix.

The equation ax + by + c = 0, can be reduced to the form:

by = -ax - c
y = -a/b x - c/b

From it we find two points of the line A, B:

Point A = new Point( -width, -(a / b) * -width - c / b );
Point B = new Point( width, -(a / b) * width - c / b );

Where a, b, c - coefficients read from the fields on the form, width is the distance from the beginning of the canvas to the middle (width = Canvas.Width / 2), where x = 0.

As a result, there is a straight line L passing through the entire coordinate system.
Let's write it in matrix form:

float[,] L = new float[2, 3] {
    { A.X, A.Y, 1 },
    { B.X, B.Y, 1 }
};

We also write the matrix X from the array of points of the triangle points:

float[,] X = new float[3, 3] {
    { points[0].X, points[0].Y, 1 },
    { points[1].X, points[1].Y, 1 },
    { points[2].X, points[2].Y, 1 }
};

Now we do affine transformations using matrix multiplication.
For multiplication, we will use the method MultiplyMatrix

private static float[,] MultiplyMatrix(float[,] a, float[,] b)
{
    float[,] product = new float[a.GetLength(0), b.GetLength(1)];

    for (int row = 0; row  product.GetLength(0); row++)
        for (int col = 0; col  product.GetLength(1); col++)
            // Multiply the row of A by the column of B
            for (int inner = 0; inner  a.GetLength(1); inner++)
                product[row, col] += a[row, inner] * b[inner, col];

    return product;
}

1) To move the line and the triangle so that the line passes through the origin, we find the position y at x = 0:

float ys = -(a / b) * 0 - c / b;

Moving the line and triangle to the origin using the displacement matrix:

float[,] T = new float[3, 3] {
    { 1, 0, 0 },
    { 0, 1, 0 },
    { 0, -ys, 1 }
};

L = MultiplyMatrix(L, T);
X = MultiplyMatrix(X, T);

2) Rotate the line and triangle around the origin point until it coincides with the coordinate axis X. To do this, we find the angle at which the line is located relative to the X axis:

double radians = Math.Atan(-(a / b));

And rotate using the rotation matrix around the beginning coordinates:

float[,] R = new float[3, 3] {
    { Math.Cos(radians), -Math.Sin(radians), 0 }, 
    { Math.Sin(radians), Math.Cos(radians), 0 },
    { 0, 0, 1 }
};

L = MultiplyMatrix(L, R);
X = MultiplyMatrix(X, R);

3) We reflect the triangle relative to the coordinate axis using the reflection matrix:

float[,] Rr = new float[3, 3] {
    { 1, 0, 0 },
    { 0, -1, 0 },
    { 0, 0, 1 }
};

X = MultiplyMatrix(X, Rr);

4) Make a reverse rotation around the origin:

float[,] Rh = new float[3, 3] {
    { Math.Cos(radians), Math.Sin(radians), 0 },
    { -Math.Sin(radians), Math.Cos(radians), 0 },
    { 0, 0, 1 }
};

L = MultiplyMatrix(L, Rh);
X = MultiplyMatrix(X, Rh);

5) Move to the starting position:

float[,] Th = new float[3, 3] {
    { 1, 0, 0 },
    { 0, 1, 0 },
    { 0, ys, 1 }
};

L = MultiplyMatrix(L, Th);
X = MultiplyMatrix(X, Th);

Assigning new values for the array points:

for (int i = 0; i  p.Length; i++)
{
    points[i].X = X[i, 0];
    points[i].Y = X[i, 1];
}

Draw a triangle with the new coordinates:

graph.FillPolygon(Brushes.RoyalBlue, points);