Comment dessiner une courbe qui passe par trois points?

Question

J'essaie de créer une courbe qui passe par trois points donnés en Java (je dessine les courbes à travers une classe qui étend JPanel). Comment puis-je le faire?

Answer 1

Vous devriez regarder dans quelque chose comme splines Catmull-Rom, qui sont essentiellement des courbes qui passent par un certain nombre de points de contrôle (dans votre cas vos trois points).

Voici un exemple que je trouve après un rapide Google: http://www.mvps.org/directx/articles/catmull/

Hope this helps :)

Answer 2

essayer une recherche Google sur splines Bézier. cela peut être une solution 2D, mais devrait être extensible à la 3D si vous en avez besoin. Fondamentalement, en utilisant les trois points comme paramètres, vous pouvez obtenir un polynôme de second ordre qui correspond aux trois points. Et son extensible, si vous avez N points, vous obtenez un polynôme d'ordre N-1 qui génère tous les points de façon paramétrique du 1er au dernier, lorsque vous «réglez» un paramètre scalaire, souvent désigné par «s».

modifier/ajouter:

comme l'a souligné (! CapBBeard de crédit), Béziers ne frappe pas vraiment les points médians. L'interpolation lagrangienne atteint réellement les points, mais devient moche encore plus rapidement à mesure que le nombre de points augmente. (quelque chose comme des fractions polynomiales O (n) chacune d'ordre N)

Answer 3

Un cercle passera par trois points sur un plan. Cette page explique la géométries: http://www.mathopenref.com/const3pointcircle.html

Answer 4

Je viens juste de passer du temps à travailler dur. Il y a quelques fonctions de support, suivies par la chose qui crée un Arc2D sur trois points d'un cercle. Pour mes buts, j'ai un point de départ et un point final, ainsi qu'un point intermédiaire (bien qu'il ne doive pas être au milieu). Son but est de me dire quel arc de cercle je veux.).

Voici les liens directs à la source:

org.six11.util.gui.shape.ShapeFactory

org.six11.util.pen.Functions

public static Pt getCircleCenter(Pt a, Pt b, Pt c) { 
    double ax = a.getX(); 
    double ay = a.getY(); 
    double bx = b.getX(); 
    double by = b.getY(); 
    double cx = c.getX(); 
    double cy = c.getY(); 

    double A = bx - ax; 
    double B = by - ay; 
    double C = cx - ax; 
    double D = cy - ay; 

    double E = A * (ax + bx) + B * (ay + by); 
    double F = C * (ax + cx) + D * (ay + cy); 

    double G = 2 * (A * (cy - by) - B * (cx - bx)); 
    if (G == 0.0) 
    return null; // a, b, c must be collinear 

    double px = (D * E - B * F)/G; 
    double py = (A * F - C * E)/G; 
    return new Pt(px, py); 
} 

public static double makeAnglePositive(double angleDegrees) { 
    double ret = angleDegrees; 
    if (angleDegrees < 0) { 
    ret = 360 + angleDegrees; 
    } 
    return ret; 
} 

public static double getNearestAnglePhase(double limitDegrees, double sourceDegrees, int dir) { 
    double value = sourceDegrees; 
    if (dir > 0) { 
    while (value < limitDegrees) { 
     value += 360.0; 
    } 
    } else if (dir < 0) { 
    while (value > limitDegrees) { 
     value -= 360.0; 
    } 
    } 
    return value; 
} 

public static Arc2D makeArc(Pt s, Pt mid, Pt e) { 
    Pt c = Functions.getCircleCenter(s, mid, e); 
    double radius = c.distance(s); 

    double startAngle = Functions.makeAnglePositive(Math.toDegrees(-Math 
     .atan2(s.y - c.y, s.x - c.x))); 
    double midAngle = Functions.makeAnglePositive(Math.toDegrees(-Math.atan2(mid.y - c.y, mid.x 
     - c.x))); 
    double endAngle = Functions 
     .makeAnglePositive(Math.toDegrees(-Math.atan2(e.y - c.y, e.x - c.x))); 

    // Now compute the phase-adjusted angles begining from startAngle, moving positive and negative. 
    double midDecreasing = Functions.getNearestAnglePhase(startAngle, midAngle, -1); 
    double midIncreasing = Functions.getNearestAnglePhase(startAngle, midAngle, 1); 
    double endDecreasing = Functions.getNearestAnglePhase(midDecreasing, endAngle, -1); 
    double endIncreasing = Functions.getNearestAnglePhase(midIncreasing, endAngle, 1); 

    // Each path from start -> mid -> end is technically, but one will wrap around the entire 
    // circle, which isn't what we want. Pick the one that with the smaller angular change. 
    double extent = 0; 
    if (Math.abs(endDecreasing - startAngle) < Math.abs(endIncreasing - startAngle)) { 
    extent = endDecreasing - startAngle; 
    } else { 
    extent = endIncreasing - startAngle; 
    } 

    return new Arc2D.Double(c.x - radius, c.y - radius, radius * 2, radius * 2, startAngle, extent, 
     Arc2D.OPEN); 
} 

Answer 5

utilisation 2 courbes
curveLine1 créé avec 3 points: P1, C1, E1.
curveLine2 créé avec 3 points: P2 = E1, C2, E2.
faites C1, E1, C2 en 1 ligne.
Voir par exemple ici: http://i.stack.imgur.com/I901q.png

QuadCurve2D.Double curveLine1 = new QuadCurve2D.Double(30, 75, 195, 23, 280, 143); 
//QuadCurve2D.Double curveLine1 = new QuadCurve2D.Double(P1.x, P1.y, C1.x, C1.y, E1.x, E1.y); 
QuadCurve2D.Double curveLine2 = new QuadCurve2D.Double(280, 143, 366, 260, 466, 193); 
//QuadCurve2D.Double curveLine2 = new QuadCurve2D.Double(E1.x, E1.y, C2.x, C2.y, E2.x, E2.y); 
Graphics2D g2 = (Graphics2D) g; 
g2.draw(curveLine1); 
g2.draw(curveLine2);