How to move points of a multi-segmented bezier curve to one side

Question

I am trying to move points from a multi-segmented bezier curve to one end of the curve using the following code which modified for my use from here. Only the last segment seems to give the desired behaviour. All other segments, basically just disappear or skip through briskly.

public Vector2[] MultiSegmentCubicCurveReduction(Path curve, float start, float end)
{
    List<Vector2> pointsForSubpath = new List<Vector2>();

    float oneMinusStart = 1f - start;
    float oneMinusEnd = 1f - end;

    float scale = (end - start) / (curve.NumPoints - 1);

    for (int i = 0; i < curve.NumSegments; i++)
    {

        var a =
            oneMinusStart * oneMinusStart * oneMinusStart * curve[3*i] +
           3f * oneMinusStart * oneMinusStart * start * curve[3 * i + 1] +
           3f * oneMinusStart * start * start * curve[3 * i + 2] +
                                     start * start * start * curve[3 * i + 3];

        var b = a + (3f * oneMinusStart * oneMinusStart * (curve[3 * i + 1] - curve[3 * i]) +
                     6 * start * oneMinusStart * (curve[3 * i + 2] - curve[3 * i + 1]) +
          3 * start * start * (curve[3 * i + 3] - curve[3 * i + 2])) * scale;

        ;

        var d = oneMinusEnd * oneMinusEnd * oneMinusEnd * curve[3 * i] +
            3f * oneMinusEnd * oneMinusEnd * end * curve[3 * i + 1] +
            3f * oneMinusEnd * end * end * curve[3 * i + 2] +
                                            end * end * end * curve[3 * i + 3];


        var c = d - (3f * oneMinusEnd * oneMinusEnd * (curve[3 * i + 1] - curve[3 * i]) +
                     6 * end * oneMinusEnd * (curve[3 * i + 2] - curve[3 * i + 1]) +
                                                        3 * end * end * (curve[3 * i + 3] - curve[3 * i + 2])) * scale;

        pointsForSubpath.AddRange(new List<Vector2>() { a, b, c, d });
    }

    return pointsForSubpath.Distinct().ToArray();

}

UPDATE

The brisk movement I was having earlier was actually a reduction of control points to four regardless of the number of segments. Now I am getting the following behaviour. All the points for the first segment converge to one end point whiles all the points of the remaining segments converge to the other end point, resulting in a straight line.

Answer 1

The code in the linked answer moves the endpoints of a single segment of a Bézier curve.

Using it on all segments simultaneously as you do here doesn't make sense. At most you want to be changing one segment at a time - the flaming tip of the wick as it burns down. Segments in the middle of the chain shouldn't change at all until their neighbouring segment on one side or the other is completely consumed.

So, let's sketch out how we'd solve this problem.

First, let's assume we have a BezierSpline type that provides an ordered, resize-able sequence of BezierSegment entries. Let's also associate with each segment an (approximate) arc length. We can use this to get a more uniform rate of motion as we contract the curve. (You can always translate this into a raw position array later, but talking about it in an object oriented fashion makes the description a bit clearer for this answer)

With this in hand, we can make a version of the IntevalFromTo method from the earlier answer that operates on a spline, rather than on a segment, producing a new spline. The version I show here is O(n) in the number of segments in the spline - you could make one that's O(log(n)) with binary search if you have exceptionally long splines, but I'm keeping it simple for now.

BezierSpline IntervalFromTo(BezierSpline sourceSpline, float start, float end) {
    // Ensure our start & end parameters are in a sensible range.
    Assert(start >= 0 && start <= end && end <= 1);

    // Convert our relative start & end values to absolute arc length measures.
    float lengthStart = start * sourceSpline.totalLength;
    float lengthEnd = end * sourceSpline.totalLength;

    // Scan for the first segment in our new, contracted spline, 
    // skipping over segments that have been completely consumed.
    int firstSegment = 0;
    float accumulatedLength = 0f;
    while(lengthStart >= accumulatedLength + sourceSpline.GetSegment(firstSegment).length) {
        // This is simple, but not strictly numerically stable, 
        // so you may need to exercise more care if you need high precision.
        accumulatedLength += sourceSpline.GetSegment(firstSegment).length;
        firstSegment++;
    }

    // Translate our start point into the local parameter space of the first segment.
    // (For better uniformity here, you can instead search for the point at which
    // the arc length along this curve exactly matches the residual)
    float localStart = Clamp01((lengthStart - accumulatedLength)
                     / sourceSpline.GetSegment(firstSegment).length);

    int lastSegment = firstSegment;
    while(lengthEnd < sourceSpline.segmentCount - 1 
       && lengthEnd > accumulatedLength + sourceSpline.GetSegment(lastSegment).length) {
        accumulatedLength += sourceSpline.GetSegment(lastSegment).length;
        lastSegment++;
    }

    // Translate our end point into the local parameter space of the last segment.
    // (For better uniformity here, you can instead search for the point at which
    // the arc length along this curve exactly matches the residual)
    float localEnd = Clamp01((lengthEnd - accumulatedLength)
                     / sourceSpline.GetSegment(lastSegment).length);


    int segmentCount = lastSegment - firstSegment + 1;
    var modifiedSpline = new BezierSpline(segmentCount);

    if (segmentCount == 1) {
        // We've reduced the spline to one segment!
        // Use the single-segment version of IntervalFromTo in my earlier answer.
        var segment = IntervalFromTo(
                          sourceSpline.GetSegment(firstSegment), 
                          localStart, 
                          localEnd
                      );
        modifiedSpline.SetSegment(0, segment);
    } else {
        // Form a shortened start segment, 
        // using our IntervalFromTo method for individual segments.
        var segment = IntervalFromTo(
                          sourceSpline.GetSegment(firstSegment), 
                          localStart, 
                          1f
                      );
        modifiedSpline.SetSegment(0, segment);

        // Copy all intact segments between the start and end, unchanged.
        for(int i = 1; i < segmentCount - 1; i++) {
            modifiedSpline.SetSegment(i, sourceSpline.GetSegment(firstSegment + i));
        }

        // And finally, cap it off with a shortened end segment.
        segment = IntervalFromTo(
                          sourceSpline.GetSegment(lastSegment), 
                          0f, 
                          localEnd
                      );
        modifiedSpline.SetSegment(segmentCount - 1, segment);
    }

    return modifiedSpline;
}