Discussion :

[guitz]

Salut !

Mon intervention va paraître de trop ici, mais as-tu pensé à développer une interface pour le design du décor (réseau routier, bâtiments etc...).
Auquel cas, il suffit de travailler en fil de fer, vue de dessus sans jamais être ennuyé par les procédures graphiques qui sont toujours très lourdes.
Cela permet aussi à l'aide de quelques fonctionnalités très simples de repositionner les objets et donc de remodeler à souhait ce qui peut et doit l'être.

Bonjour,

Jusqu'à présent je n'ai travaillé qu'en "fil de fer", les objets mathématiques de chaque segment du graphe sont des splines. Ensuite l'affichage se fait dans une autre classe.

La détection des intersections relève plus de l'urbanisation par la machine (au quel cas c'est indispensable) et moins pour un urbaniste humain.

Je ne comprends pas.

Pour info, j'utilise la fonction sinusoïdale pour tracer mes courbes.
Il suffit pour cela d'associer au segment AB un handle (comme on le ferait pour une courbe de Bezier) pour en fixer l'amplitude, le signe (localement convexe ou concave) et la symétrie (courbe d'apparence exotique)!
Donc tout ça se fait facilement à vue !

Les splines quadratiques offrent beaucoup plus de possibilités que la fonction sinusoidale

Merci pour ton post henderson

[wiwaxia]

... Les splines quadratiques offrent beaucoup plus de possibilités que la fonction sinusoidale ...

Tout dépend, comme pour les courbes de Bézier, du lot de fonctions que l'on se donne au départ (il en faudra certainement plusieurs !) ... mais c'est sûrement plus compliqué à mettre en oeuvre, et beaucoup plus lourd en calculs.
Le splines présentent effectivement, vis-à-vis des contraintes imposées, une souplesse incomparable en raison de leur simplicité.

Il se pourrait toutefois que le recours aux fonctions sinusoïdales s'avère avantageux dans certains cas particuliers ... Mais là je sors franchement du sujet .

[henderson]

Salut !

...
Il se pourrait toutefois que le recours aux fonctions sinusoïdales s'avère avantageux dans certains cas particuliers ... Mais là je sors franchement du sujet .

A ce stade, c'est juste pour me simplifier la vie au niveau de la mise en place du réseau routier avec des courbes sinusoïdales sporadiques : amplitude et symétrie modifiable grâce à un point de contrôle qui se dessine toujours sur la courbe elle-même (en pi/2 quelque soit le rapport de symétrie).
En tant qu'urbaniste, je suis à même de voir par moi-même si mon tracé intercepte ou non autre chose !
J'ai donc tendance à modeler visuellement (comme je l'ai toujours fait en imagerie 3D y compris sur SoftImage dès 1990) !
Ici c'est une question de moyen que l'on peut se donner pour attendre l'objectif ... Donc à chacun ses trucs et astuces et surtout sa manière de modéliser (organisation des données et fonctionnalités de l'objet en C++) !

Par contre ma classe jCity ... comme elle génère un objet en expansion ... la machine a besoin d'algorithmie parce qu'elle ... est aveugle !!!
Cette discussion est donc de ce point de vue très intéressante !
Et c'est pour cette raison que je ne vais pas insister d'avantage !

A plus !

[guitz]

Bonjour,

Bon alors j'ai pas réussi à implémenter cette résolution d'un polynôme de degré 4, du coup je me suis rabattu sur la méthode par dichotomie. C'est moins bien optimisé mais dans mon projet ce n'est pas grave car ce code n'est pas appelé x fois par secondes.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
bool AInfrastructureGraphManager::DichotomyStep(FVector a0, FVector a1, FVector a2, FVector b0, FVector b1, FVector b2) {
 
 
 
	if (CollisionSegSeg(GetLocationAtDistanceAlongSpline(a0, a1, a2, MinS), GetLocationAtDistanceAlongSpline(a0, a1, a2, (MinS + MaxS) / 2), GetLocationAtDistanceAlongSpline(b0, b1, b2, MinT), GetLocationAtDistanceAlongSpline(b0, b1, b2, (MinT + MaxT) / 2)) == true) {
 
		MaxS = (MinS + MaxS) / 2;
		MaxT = (MinT + MaxT) / 2;
 
		return true;
	}
 
	if (CollisionSegSeg(GetLocationAtDistanceAlongSpline(a0, a1, a2, (MinS + MaxS) / 2), GetLocationAtDistanceAlongSpline(a0, a1, a2, MaxS), GetLocationAtDistanceAlongSpline(b0, b1, b2, MinT), GetLocationAtDistanceAlongSpline(b0, b1, b2, (MinT + MaxT) / 2)) == true) {
 
		MinS = (MinS + MaxS) / 2;
		MaxT = (MinT + MaxT) / 2;
 
		return true;
	}
 
 
	if (CollisionSegSeg(GetLocationAtDistanceAlongSpline(a0, a1, a2, MinS), GetLocationAtDistanceAlongSpline(a0, a1, a2, (MinS + MaxS) / 2), GetLocationAtDistanceAlongSpline(b0, b1, b2, (MinT + MaxT) / 2), GetLocationAtDistanceAlongSpline(b0, b1, b2, MaxT)) == true) {
 
		MaxS = (MinS + MaxS) / 2;
		MinT = (MinT + MaxT) / 2;
 
		return true;
	}
 
	if (CollisionSegSeg(GetLocationAtDistanceAlongSpline(a0, a1, a2, (MinS + MaxS) / 2), GetLocationAtDistanceAlongSpline(a0, a1, a2, MaxS), GetLocationAtDistanceAlongSpline(b0, b1, b2, (MinT + MaxT) / 2), GetLocationAtDistanceAlongSpline(b0, b1, b2, MaxT)) == true) {
 
		MinS = (MinS + MaxS) / 2;
		MinT = (MinT + MaxT) / 2;
 
		return true;
	}
 
	return false;
 
}
 
 
FVector AInfrastructureGraphManager::GetLocationAtDistanceAlongSpline(FVector PointA, FVector PointB, FVector PointC, float s) {
 
	float l_X = (1 - s)*(1 - s)*PointA.X + 2 * s*(1 - s)*PointC.X + s*s*PointB.X;
	float l_Y = (1 - s)*(1 - s)*PointA.Y + 2 * s*(1 - s)*PointC.Y + s*s*PointB.Y;
 
	return FVector(l_X, l_Y, 0.f);
 
}
 
 
FVector AInfrastructureGraphManager::GetSplinesIntersection(FVector a0, FVector a1, FVector a2, FVector b0, FVector b1, FVector b2) {
 
	float l_epsilon = 0.01; //plus il est petit plus c'est précis mais couteux et inversement. 
							//TODO à optimiser et rendre proportionnel à la longueur de la spline la plus longue
	bool l_bool = true;
 
	MinS = 0; MaxS = 1; MinT = 0; MaxT = 1;
 
	while (MaxS - MinS > l_epsilon && l_bool == true) {
 
		l_bool = DichotomyStep(a0, a1, a2, b0, b1, b2);
 
	}
 
	return GetLocationAtDistanceAlongSpline(a0, a1, a2, (MinS + MaxS) / 2.0);
 
}