Warp GraphicsPath along a Bézier Spline

/*
 *
 * Transform GraphicsPath points along a cubic Bézier Spline
 *  http://csharpcodewhisperer.blogspot.com
 *
 *
 * Made using SharpDevelop
 *
 *
 */
GraphicsPath BezierWarp(GraphicsPath text,Size size)
{
    // Control points for a cubic Bézier spline
    PointF P0 = new PointF();
    PointF P1 = new PointF();
    PointF P2 = new PointF();
    PointF P3 = new PointF();

    float shrink = 20;
    float shift = 0;

    P0.X = shrink;
    P0.Y = shrink+shift;
    P1.X = size.Width-shrink;
    P1.Y = shrink;
    P2.X = shrink;
    P2.Y = size.Height-shrink;
    P3.X = size.Width-shrink;
    P3.Y = size.Height-shrink-shift;

    // Calculate coefficients A thru H from the control points
    float A = P3.X - 3 * P2.X + 3 * P1.X - P0.X;
    float B = 3 * P2.X - 6 * P1.X + 3 * P0.X;
    float C = 3 * P1.X - 3 * P0.X;
    float D = P0.X;

    float E = P3.Y - 3 * P2.Y + 3 * P1.Y - P0.Y;
    float F = 3 * P2.Y - 6 * P1.Y + 3 * P0.Y;
    float G = 3 * P1.Y - 3 * P0.Y;
    float H = P0.Y;

    PointF[] pathPoints = text.PathPoints;
    RectangleF textBounds = text.GetBounds();

    for (int i =0; i < pathPoints.Length; i++)
    {
        PointF pt = pathPoints[i];
        float textX = pt.X;
        float textY = pt.Y;

        // Normalize the x coordinate into the parameterized value
        // with a domain between 0 and 1.
        float t  =  textX / textBounds.Width;
        float t2 = (t * t);
        float t3 = (t * t * t);

        // Calculate spline point for parameter t
        float Sx = A * t3 + B * t2 + C * t + D;
        float Sy = E * t3 + F * t2 + G * t + H;

        // Calculate the tangent vector for the point
        float Tx = 3 * A * t2 + 2 * B * t + C;
        float Ty = 3 * E * t2 + 2 * F * t + G;
        // Rotate 90 or 270 degrees to make it a perpendicular
        float Px = - Ty;
        float Py =   Tx;

        // Normalize the perpendicular into a unit vector
        float magnitude = (float)Math.Sqrt((Px*Px) + (Py*Py));
        Px /= magnitude;
        Py /= magnitude;

        // Assume that input text point y coord is the "height" or
        // distance from the spline. Multiply the perpendicular vector
        // with y. It becomes the new magnitude of the vector.
        Px *= textY;
        Py *= textY;

        // Translate the spline point using the resultant vector
        float finalX = Px + Sx;
        float finalY = Py + Sy;

        pathPoints[i] = new PointF(finalX, finalY);
    }

    return new GraphicsPath(pathPoints,text.PathTypes);
}