Discussion :

[iroquoise rosa]

bonjour a tous
voila j'ai trouver un code de détection de collision triangle triangle http://www.cs.clemson.edu/~malloy/co...Collision.html
je l'ai modifié pour l'adapter à ce que je veux faire


J'ai une interface haptique (phantom omni) (un genre de souris 3D) elle a des bibliothèques et dispose de fonctions ou je peux récupérer les positons de l'effecteur

J’utilise osg pour crée la scène (boule+ une dent) ,une fois que j'ai récupéré les positions de cette interface je les affecte à la boule ce qui me donne une boule qui bouge suivant le mouvement de l'interface haptique

Le problème avec le code c'est oui il détecte la collision, mais je voudrais une réponse a cette collision que la boule ne pénètre pas la dent elle reste en surface quand y a détection de collision

voila ce que j'ai essayé

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
HDdouble pos[3];
hdGetDoublev(HD_CURRENT_POSITION, pos);	// la fonction qui recupére la  postion de l'interface haptique
 
//création de l'objet mobile avec sa transformation
 
osg::ref_ptr < osg::Group > modele3D = dynamic_cast < osg::Group * >(osgDB::readNodeFile("boule.obj"));	//boule
 
osg::PositionAttitudeTransform * movingPAT = new osg::PositionAttitudeTransform;
 
movingPAT->setPosition(osg::Vec3d(pos[0] / 10, -pos[2] / 10, pos[1] / 10));	//c'est la ou j'associe la positon de l'interface haptique a mon objet ( la boule)
 
movingPAT->addChild(modele3D.get());
root->addChild(movingPAT);
 
MovableObject *movingObject = new MovableObject(modele3D.get(), movingPAT);
 
//creation de l'objet statique avec sa transformation
 
osg::ref_ptr < osg::Group > modele3DD = dynamic_cast < osg::Group * >(osgDB::readNodeFile("dent.obj"));
 
osg::PositionAttitudeTransform * stationaryPAT = new osg::PositionAttitudeTransform;
 
stationaryPAT->addChild(modele3DD.get());
root->addChild(stationaryPAT);
 
MovableObject *stationaryObject = new MovableObject(modele3DD.get(), stationaryPAT);
 
//premier teste de la collison 
 
if (movingObject->collidesWith(stationaryObject)) {
    cout << "collision BOOOOOOMMMMMM" << endl;
    compt = 1;
 
} else {
    cout << "pas de collision " << endl;
    compt = 0;
 
}
 
//des fonctions liée a l'affichage 
osgViewer::Viewer viewer;
viewer.setUpViewInWindow(100, 100, 512, 512);
viewer.setCameraManipulator(new osgGA::TrackballManipulator());
viewer.setSceneData(root);
viewer.realize();
 
//la je rentre dans la boucle =>genre l’équivalent de glmainloop de opengl
 
while (!viewer.done()) {
 
    viewer.frame();
 
    hdGetDoublev(HD_CURRENT_POSITION, pos);
 
    if (compt == 1)		// y'a collision 
    {
 
	MovableObject *movingObject = new MovableObject(modele3D.get(), movingPAT);	//en ecrivant ça j'ai gardé la postion (movingPAT qu'il avait au moment de la collision)
 
    } else			//y'a pas collision
    {
 
	movingPAT->setPosition(osg::Vec3d(pos[0] / 10, -pos[2] / 10, pos[1] / 10);	//movingPAT prend les positions de l'interface haptique );      
			       MovableObject * movingObject = new MovableObject(modele3D.get(), movingPAT);}

le problème avec ce code c'est que des qu'il y a collision la boule garde la positon au moment du contacte et elle ne bouge plus même si je fais bouger l'interface c'est a dire une fois que (compt=1) c'est bon compt ne reprend plus la valeur 0....

j’espère que j'ai été explicite je sais que c'est pas vraiment évidement de comprendre la chose quand elle est pas devant nous ...
mais merci d'avance pour votre aide

L'algorithme marche assez bien quand il s'agit d'objets ou ya pas beaucoup de triangle

mais des que j’introduis mes modèles (boule ,dent) il devient très lourd et le rendu visuel n'est pas correcte (malgré qu'il utilise la méthode des sphères englobante pour limiter les tests )

je voudrais savoir ou je pourrais agir pour limiter encore les tests sur les triangles

[LittleWhite]

Bonjour,

je ne suis pas sur d'avoir compris, mais une solution est d'appliquer un "rebond". Le rebond consiste à appliquer un déplacement proportionnel à la vitesse de départ. Cela est possible lorsque l'on a le vecteur de vitesse (direction) et la normale de l'objet que l'on touche.

Il suffit de faire un cross product et vous aurez la vitesse à prendre après avoir touché le mur.
D'ailleurs, votre gestion de collision devrait être géré avec un vecteur de vitesse et la détection se ferait à t+1 (ce qui veut dire que vous calculer s'il y a une détection pour la prochaine position, et s'il y a, alors vous ne bougez pas votre boule (ou vous faites un rebond)).

De toute façon, une collision d'une boule avec le reste du monde se limite principalement à faire un calcul de distance entre le sphère de la boule est un point (ou une droite). Si la distance est plus petite que le rayon de la boule, alors, c'est qu'il y a collision.

[iroquoise rosa]

bonjour ,merci d'avoir répondu...

ce que je voudrais c'est pas une détection grossière mais plutôt précise c'est a dire que quand les primitives des deux objets se touche que je dirais que y a collision le code que j'ai trouvé ( http://www.cs.clemson.edu/~malloy/co...Collision.html) est précis certes mais très lent quand les deux objets se compose de plusieurs triangle

la boule pourrais être autre chose j'ai juste pris exemple d'objet simple boule.

Ça dépend vraiment des mouvements de ma main ces positions je les récupère je les affecte grace a "setposition "
a ma boule

je voudrais que quand y a collision l'objet garde la position ou ya eu contact même si j'essaye de faire pénétrer

je sais pas si c'est clair ou pas ...!!!


en tout cas merci beaucoup

[LittleWhite]

Avant de faire le setPosition() vous devez tester si la nouvelle position est correcte.
Et oui, certes la boule bouge selon votre main, mais en fait, cela ne change rien, vous devriez utiliser un vecteur vitesse, qui lui, varie selon votre main

[iroquoise rosa]

ooooow la tester la nouvelle position si elle est correcte ??? j'ai pas compris !! correcte par rapport a quoi ??


comment introduire le vecteur vitesse ,(moi qui voulait faire simple :s)
je pourrais avoir un algorithme que je puisse voir a peu près comment m'y prendre ??

merci d'avance

[LittleWhite]

Correct == si l'objet ne rentre en collision avec aucun autre.

Et pour les collisions, tout objet peut être englober par une sphère ou une boite rectangulaire, simplifiant énormément tout les calcul de collision. Donc, même si vous avez un éléphant comme objet, celui-ci étant mis dans une boite rectangulaire l'englobant permettra de faire en sorte que la collision soit facile à détecter.

Pour l'histoire du vecteur vitesse, certes cela est un peu plus compliqué, mais au final, cela simplifie la vie, lorsque l'on doit faire la gestion d'un rebond (par exemple).
L'algorithme :

Code :

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

1
2
 
nouvelle_position = vitesse + position

La vitesse est calculé par rapport aux données de votre accéléromètre (de l'inclinaison et autre données de vos capteurs).

[iroquoise rosa]

encore merci de prendre le temps de me répondre

pour la détection de collision j'ai lu dans certains document qu'il y avait deux étapes dans la détection de collision une détection non précise ou on utilise comme vous dites des boites englobante ceci permet de limiter les objets qui seront tester .
puis vient la détection précise c'est ce que je cherche une fois qu'on sait qu'elle objet rentre en collision ,je dois faire les tests sur les primitives de ces objets(test triangle-triangle).

c'est ce qui est fait dans le code que j'ai trouvé dans http://www.cs.clemson.edu/~malloy/co...Collision.html)
(il utilise les boundingsphere)

malgré cela ce code marche que pour un certain nombre de triangles quand l'objet a un maillage important ça devient lent puisque il test tout les triangles

je voudrais limiter encore les tests (une façon de sélectionner quelque triangles pour le test )

[iroquoise rosa]

bonjour

en fin de compte j'ai réussi a résoudre le problème pour éviter qu'un objet pénètre dans l'autre lors de la collision

Je fais le test de la collision avec un 3eme objet crée, les positions de ce dernier sont toujours mis a jour

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

	osg::ref_ptr<osg::Group> root = new osg::Group;
	
	osg::ref_ptr<osg::Group> modele3D = 
	dynamic_cast<osg::Group*>(osgDB::readNodeFile("boule_repere.obj"));   //boule
	
	osg::ref_ptr<osg::Group> modele3DD = 
	dynamic_cast<osg::Group*>(osgDB::readNodeFile("boule_repere.obj"));
		

	HDdouble  pos[3];
    hdGetDoublev(HD_CURRENT_POSITION,pos);//position de l'interface haptique

	osg::PositionAttitudeTransform* movingPAT = new osg::PositionAttitudeTransform;
    
    movingPAT->setPosition( osg::Vec3d(pos[0]/10,-pos[2]/10,pos[1]/10 )); //associer les positions de l'interface haptique a la boule

        movingPAT->addChild(modele3D.get());
	root->addChild(movingPAT);
	MovableObject* movingObject = new MovableObject(modele3D.get(), movingPAT);//crée un objet de la classe MovableObject
 
////////creation de l'objet statique 
	osg::PositionAttitudeTransform* stationaryPAT = new osg::PositionAttitudeTransform;
	const osg::BoundingSphere& bb2=modele3DD->getBound();
     
	stationaryPAT->addChild(modele3DD.get());
	root->addChild(stationaryPAT);
	MovableObject* stationaryObject = new MovableObject(modele3DD.get(), stationaryPAT);


	////////// la partie ajouter 
	osg::PositionAttitudeTransform* tempPAT = new osg::PositionAttitudeTransform;

	 tempPAT->setPosition( osg::Vec3d(pos[0]/10,-pos[2]/10,pos[1]/10 )); 
	MovableObject* temp = new MovableObject(modele3D.get(),tempPAT);
   //////////
	osgViewer::Viewer viewer;
	viewer.setUpViewInWindow( 100,100, 512, 512 );
	viewer.setCameraManipulator(new osgGA::TrackballManipulator());
	viewer.setSceneData(root);
	viewer.realize();

	while( !viewer.done() )
	{
		
	viewer.frame();
	
	HDdouble  pos[3];
    hdGetDoublev(HD_CURRENT_POSITION,pos);
	osg::PositionAttitudeTransform* tempPAT = new osg::PositionAttitudeTransform;

	 tempPAT->setPosition( osg::Vec3d(pos[0]/10,-pos[2]/10,pos[1]/10 ));
	 tempPAT->addChild(modele3D);
	 MovableObject* temp = new MovableObject(modele3D.get(),tempPAT);//crée un objet de la classe MovableObject




	///teste de collision//// je teste temp non pas movableObject comme je faisais 

	if( temp->collidesWith(stationaryObject) )
	{
     //cout<<"collision boooooooooooooooooom"<<endl;
		compt=1;
	
	  
    }
    else{
	  //cout<<"pas de collision "<<endl;
	   compt=0;
    
    }
	
if(compt==1)
{
   


		
	MovableObject* movingObject = new MovableObject(modele3D.get(), movingPAT);

}
else
{
	    movingPAT->setPosition( osg::Vec3d(pos[0]/10,-pos[2]/10,pos[1]/10 )); 

	MovableObject* movingObject = new MovableObject(modele3D.get(),movingPAT);

}



	}

}

et merci pour votre aide

[iroquoise rosa]

bonjour
pour accélérer la détection de collision j'ai lu qu'on utilisait une hiérarchie accélératrice c'est a dire que dans mon cas je dois subdiviser ma dent en petites sphères ....le problème est comment positionner mes petites sphères (c-a-d comment obtenir le centre et le rayon adéquat )...


merci d'avance pour votre aide ...

[saturn1]

Tu peux regarder du coté des QuadTree si je ne dis pas de betise...

Tu peux regarder ce tutoriel illustre pour la theorie

http://www.kyleschouviller.com/wsuxn...urce-included/

[LittleWhite]

En 3D, ce n'est pas des QuadTree, mais des OctTree (le principe reste le même). Sinon, il existe les BSP (pour Binary Space Partitionning) ou encore d'autres structures.
Par contre, normalement, c'est pour une multitude d'objet et non un seul objet. C'est pour cela que je me demande si votre code n'a pas un autre problème. À moins que votre dents soit composé de centaine de milliers de triangles ?

[iroquoise rosa]

RE
ma dent est composé de plus de 12000 triangles
j'aurais aimé les subdiviser en petites sphères c-a-d mettre les triangles dans des petites sphères pour réduire les tests de collision (triangle-triangle),mais je sais pas comment m'y prendre en C++ combiner avec osg

ce que je peux avoir avec osg est le centre et le rayon de la grande sphère qui englobe ma dent
comment exploiter tout ça pour avoir ce que je veux !

[LittleWhite]

Je continue à croire qu'il y a un problème dans votre programme (comme si vous faisiez trop de vérification de collision à chaque fois ...)

Sinon, pour la sphère, je pense que ce n'est pas du tout la peine de faire une détection triangle / triangle. Il faut mieux faire, je pense une détection sphère / triangle.