Discussion :

[zaboug]

Bonjour,

Je suis sur un projet d'analyse d'images. Les méthodes d'analyses sont développées par un collègue mathématicien sous Scilab (équivalent libre de Matlab), et je suis chargée d'adapter ces méthodes pour en faire un logiciel Java.

Dans la chaine de traitement, il utilise les fonction lsq_spline et interp de Scilab qui calcul et récupère des splines cubiques des moindre carré.
Savez vous s'il existe des équivalents de ces fontions en Java ?
Mon collègue me dit que le calcul et le tracé de spline sont des trucs super commun, donc je serais étonnée qu'il n'existe pas des librairies qui s'en occupe. Mais je ne sais pas dans quelle direction chercher...

tout conseil seront bienvenue

merci d'avance

PS : je ne savais pas trop où mettre ce post, n'hésitez pas à le déplacer si besoin est

[bouye]

Le tracé des splines est pris en charge par Java2D et les classes GeneralPath, Path2D, Path2D.Double, Path2D.Float, CubicCurve2D, CubicCurve2D.Double, CubicCurve2D.Float, QuadCurve2D, QuadCurve2D.Double et QuadCurve2D.Float (ouf), le tout rendu dans un Graphics2D

[zaboug]

merci pour ta réponse, je vais aller fouiller par là

[zaboug]

bon, je suis allée voir la Javadoc et un tuto de sun concernant les graphique 2D et les courbes (quadratic et cubic).

Deux problèmes se posent pour moi :

• on ne peut pas spécifier plus de 2 points de contrôle avec les "cubic curve" alors que j'aurais besoin d'en avoir 4
• on ne peut pas récupérer l'ensemble des points de la courbe.

Je m'explique : mon but n'est pas de tracer une courbe dans un graphique, mais de l'inclure dans une image. En gros j'ai une image représentant une sorte de demi-disque sur le bas de l'image, et je dois dessiner son contour. J'ai une première méthode qui me donne un contour brut (que je dessine en blanchissant les pixels correspondant sur l'image), et je dois lisser ce contour avec des splines à 4 puis 6 points de control (bornes comprises, ce qui correspond à 2 puis 4 points de control tels qu'implémentés par les cubic curve).

Comme vous pouvez le voir, les CubicCurve2D et graphic2D ne répondent pas vraiment à la problèmatique.
Cela dit, je n'ai pas encore trouvé de tuto sur l'utilisation des PathIterator et je ne comprends pas encore bien leur fonctionnement. Donc peut être qu'une solution existe dans cette direction.

Dans tous les cas, si vous connaissez d'autres librairies ou si vous voyez que quelques subtilité m'ont échappées dans l'utilisation des cubicCurves2D, hésitez pas. J'explore toutes les voies !

[EDIT] j'ai trouvé sur ce post une solution proposée pour avoir plus de 2 points de controle : faire plusieurs courbes qui se suivent...
Reste le problème de la récupération des points pour pouvoir les inclure dans une image...

[bouye]

Une discussion similaire a deja eut lieu (faire une recherche), une spline de bezier a n-points de controles peut-etre modelise en utilisant une successiob de plusieurs splines de Bezier (ce que fait n'importe quel logiciel de dessin vectoriel et quasiment toutes les libs de rendu 2D ou 3D)..

Courbe de Bézier de degré supérieur à 3
Elles sont rarement utilisées. On préfère se ramener à l'utilisation de courbes cubiques que l'on raccorde. Pour cela, il faut et il suffit que le dernier point d'une courbe soit le premier d'une autre. On obtient ainsi une courbe continue.

Par exemple, pour une courbe définie par les points A, B, C, D, E, F et G, on utilise les courbes cubiques définies par A, B, C, et D, et par D, E, F, et G et la continuité est ainsi assurée. Pour avoir une courbe C1 en D, il faut que [C, D] = [D, E], et si en plus on veut qu'elle soit C2 en D, alors [B, D] = [D, F], et de même pour les dérivées successives.

Il est tout a fait possible de recuperer les points et points de controle des courbes ou des chemins, il suffit de parcourir leur PathIterator.

[zaboug]

oui, j'avais trouvé ce post.

pour ce qui est du pathIterator, je n'arrive à récupérer que les points de contrôle. Sachant que c'est moi qui les ai défini pour tracer la courbe, ça ne me sert pas à grand chose.
Je veux récupérer l'ensemble des points de la courbe, mais je n'y arrive pas...
Je commence à me demander si c'est possible

[bouye]

Qu'y a-t-il de complique dans ca ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Path2D myPath = ... // construction et ajout de toutes mes courbes dans un meme path.
 
double buffer[] = new double[6];
PathIterator it = myPath.getPathIterrator(null);
List<Point2D> pList = new LinkedList<Point2D>();
while(!it.isDone())
  int currentSegment = it.currentSegment(buffer);
  switch (currentSegment ) {
     case PathIterator.SEG_MOV:
     case PathIterator.SEG_LINETO:
       pList.add(new Point2D.Double(buffer[0], buffer[1]);
       break;
     case PathIterator.SEG_QUADTO:
       pList.add(new Point2D.Double(buffer[2], buffer[3]);
       break;
     case PathIterator.SEG_CUBICTO:
       pList.add(new Point2D.Double(buffer[4], buffer[5]);
       break;
     case PathIterator.SEG_CLOSE:
     default:
  }
}
//pList  = new ArrayList<Point2D>(pList);
Point2D[] points = new Point2D[pList.size()];
points = pList.toArray(points);

[zaboug]

Il n'y a rien de compliqué à "ça" comme tu dis, j'étais déjà arrivé à un code similaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
int num = 0;
PathIterator iter = spline.getPathIterator(null);
float[] points = new float[6];
System.out.println("spline");
while(!iter.isDone())
{
	num ++;
 
	switch ( iter.currentSegment(points) ) 
	{
		case PathIterator.SEG_MOVETO:
			System.out.println("MOVETO => Coordonnees point "+num+" : ["+points[0]+", "+points[1]+"]");
			break;
		case PathIterator.SEG_LINETO:
			System.out.println("LINETO => Coordonnees point "+num+" : ["+points[0]+", "+points[1]+"]");
			break;
		case PathIterator.SEG_CUBICTO :
			System.out.println("CUBICTO => Coordonnees point "+num+" : ["+points[0]+", "+points[1]+"]" +
					", [" + points[2]+", "+points[3]+"]"+", [" + points[4]+", "+points[5]+"]");
			break;
		case PathIterator.SEG_QUADTO :
			System.out.println("QUADTO => Coordonnees point "+num+" : ["+points[0]+", "+points[1]+"]" +
					", [" + points[2]+", "+points[3]+"]");
			break;
	}
		iter.next();
}

Mais ce que je dis, c'est que ça ne répond pas à ma problématique : je veux récupérer TOUS les points de la courbe, et ce code ne permet de récupérer que les points de contrôle ! (sache quand même que par acquis de conscience j'ai aussi testé ton code qui donne le même résultat).

Mon but n'est pas de tracer la courbe (enfin pas dans un premier temps), mais d'utiliser l'ensemble des points pour faire d'autres traitements. Donc un tableau ou une liste ne contenant que les points de control ne me sert absolument à rien.

L'autre solution serait de récupérer la fonction correspondant à la courbe tracée, mais je n'ai pas trouvé de moyen de le faire non plus.


ça fait maintenant une semaine que je suis sur cette problèmatique et j'en suis arrivée à la conclusion que les cubicCurves ne permettent que de dessiner des courbes.
Donc je cherche d'autres moyens d'arriver à mes fins, ce qui passera peut être par l'implémentation de notre propre Classe de calcul de spline, ou par l'utilisation des fonctions Scilab codées en C via JNI ou JNA...
Bref, pas que du bonheur en perspective.

Je laisse ce post ouvert, car je n'exclue pas la possibilité d'être passé à côté de quelque chose, d'avoir loupé une librairie existante ou même une méthode des cubicCurves.

[bouye]

Vu qu'il y une infinite de points entre deux extremites d'un segments de la courbe non ce n'est pas possible de recuperer tous les points d'une portion de la courbe.

Tu peux recuperer :
- ses extremites (voir code)
- ses points de controle
-- resp buffer[0], buffer[1] sur SEG_QUADTO
-- resp buffer[0], buffer[1] et buffer[2], buffer[3] sur SEG_CUBICTO

Tu veux savoir si un point x,y est sur la courbe ?
- soit tu utilises les methodes intersect() de l'interface Shape et tu verifies que le rectangle ou le cercle centre sur x, y et de rayon/cote dw et dh (la precision de la zone de test est a ta discretion) intersecte la courbe
- soit tu prend ton equation de spline comme un grand et tu verifies que le point est effectivement sur le segment de la courbe...

Tu veux un nombre discret de points permettant de dessiner la courbe ?
- Soit tu te fais une routine qui parcourt le segment droit entre les deux extremites de la courbe et tu resouds l'equation du spline au fur et a mesure ! N'importe quel lyceen peut le faire.
- Soit tu te crees un FlatteningPathIterator qui permet permet d'approximer une courbe en une suite de segments droits et tu le parcours EXACTEMENT de la meme maniere que lorsque tu as parcouru le PathIterator de base !

[zaboug]

- Soit tu te crees un FlatteningPathIterator qui permet permet d'approximer une courbe en une suite de segments droits et tu le parcours EXACTEMENT de la meme maniere que lorsque tu as parcouru le PathIterator de base !

Merci, c'est tout ce qui me manquait.