'Moving' a circle along a line

[Harold Lime]

I am tinkering with a bit of Java and would like to 'move' a circle along a curved line to simulate a free-kick in football (soccer).

I know how to draw a curve based on three sets of coordinates and I know how to draw a circle and I can make a circle 'move' by re-drawing it in a slightly different position.

But I can't figure out a way of making the circle move along the line.

The only way I can think of doing it is to get the coordinates of each pixel on the line and then use those to repeatedly draw a circle.

Is there a way to get this information without being a maths genius? Or is there a better way?

[Craig Wood]

There are two fairly straightforward ways:
1 — use a FlatteningPathIterator with a suitably small flatness, say 0.01 to start, to get the coordinates along the curve. You can get a PathIterator from both the QuadCurve2D and CubicCurve2D classes.
2 — use the parametric form of the curve to get (x,y) for [0<= t <= 1.0]
These equations are given in the Field Detail section of the PathIterator interface for the SEG_QUADTO and SEG_CUBICTO fields.

[Harold Lime]

I've no idea what 2 means... but the first one works perfectly.

Thanks

[Harold Lime]

Is it possible to get a set of equally spaced coordinates along curve?

[Craig Wood]

I would try to get points closer together than the distance increment along the curve that you want for your animation. Then you can move along the curve and collect points that are close to your desired distance increment.
In the example here it looks like the parametric form is more amenable to this.

import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;

public class CloseUp extends JPanel {
    Point2D.Double[] points;
    CubicCurve2D.Double curve;
    boolean firstTime = true;

    public CloseUp() {
        points = new Point2D.Double[4];
        points[0] = new Point2D.Double(355.0, 268.0);
        points[1] = new Point2D.Double( 20.0, 179.0);
        points[2] = new Point2D.Double( 77.0, 158.0);
        points[3] = new Point2D.Double(288.0,  32.0);
        curve = new CubicCurve2D.Double();
        curve.setCurve(points, 0);
    }

    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setPaint(Color.blue);
        g2.draw(curve);
        g2.setPaint(Color.red);
        for(int i = 0; i < points.length; i++) {
            g2.fill(new Ellipse2D.Double(points[i].x-1.5,
                                         points[i].y-1.5, 4, 4));
        }
        if(firstTime) {
            exploreCurve();
            exploreBezier();
            firstTime = false;
        }
    }

    private void exploreCurve() {
        double flatness = 0.0001;
        PathIterator pit = curve.getPathIterator(null, flatness);
        double[] coords = new double[2];
        double max = -Double.MAX_VALUE;
        double min = Double.MAX_VALUE;
        Point2D.Double lastPoint = new Point2D.Double();
        while(!pit.isDone()) {
            int type = pit.currentSegment(coords);
            switch(type) {
                case PathIterator.SEG_MOVETO:
                    break;
                case PathIterator.SEG_LINETO:
                    double dist = lastPoint.distance(coords[0], coords[1]);
                    if(dist < min) min = dist;
                    if(dist > max) max = dist;
                    break;
                default:
                    System.out.println("Unexpected type: " + type);
            }
            lastPoint.setLocation(coords[0], coords[1]);
            pit.next();
        }
        System.out.printf("PathIterator: min = %f  max = %f%n", min, max);
    }

    /**
     *  P(t) = B(n,0)*P0 + B(n,1)*P1 + ... B(n,n)*Pn
     *      0 <= t <= 1
     *
     *  B(n,m) = mth coefficient of nth degree Bernstein polynomial
     *         = C(n,m) * t^(m) * (1 - t)^(n-m)
     *  C(n,m) = Combinations of n things, taken m at a time
     *         = n! / (m! * (n-m)!)
     */
    private void exploreBezier() {
        double max = -Double.MAX_VALUE;
        double min = Double.MAX_VALUE;
        Point2D.Double lastPoint = new Point2D.Double();
        int n = points.length;
        // Usually use component width for calculating t.
        // Choose a multiplier (3) to get desired min/max ranges.
        int w = 3*getWidth();
        for(int j = 0; j <= w; j++) {
            double t = (double)j/w;          // [0 <= t <= 1.0]
            double x = 0;
            double y = 0;
            for(int k = 0; k < n; k++) {
                x += B(n-1, k, t)*points[k].x;
                y += B(n-1, k, t)*points[k].y;
            }
            if(j > 0) {
                double dist = lastPoint.distance(x, y);
                if(dist > max) max = dist;
                if(dist < min) min = dist;
            }
            lastPoint.setLocation(x, y);
        }
        System.out.printf("Parametric:   min = %f  max = %f%n", min, max);
    }

    private double B(int n, int m, double t) {
        return C(n, m) * Math.pow(t, m) * Math.pow(1.0-t, n-m);
    }

    private long C(long n, long m) {
        if(m > n/2) {
            m = n - m;
        }
        if(m <= 0 || n <= 0) {
            return 1;
        } else {
            return C(n-1, m-1)*n/m;
        }
    }

    public static void main(String[] args) {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(new CloseUp());
        f.setSize(400,400);
        f.setLocation(100,100);
        f.setVisible(true);
    }
}