WIP TP

tp/tp_master.cpp

@@ -184,17 +184,34 @@ public:
 	// Touche c
 	// utiliser:
 	// - phi2
-	// - phi2unsew(d) decoudre par phi2
-	// - phi2sew(d,e) couture phi2 d avec e
+    // - phi2_unsew(d) decoudre par phi2
+    // - phi2_sew(d,e) couture phi2 d avec e
 	// - add_dart() renvoit un nouveau brin (phi1 et phi2 sont en point fixe)
-	// - phi1sew(d,e) fusion de cycle
+    // - phi1_sew(d,e) fusion de cycle
 	//		le phi1 de d devient le phi1 de e et inversement
 	// - newVertexOrbitEmbedding(d) creer le plongement de sommet
 	void coupeArete(Dart d)
 	{
+        Dart e = phi2(d);
+        phi2_unsew(d);
 
+        Dart d2 = add_dart();
+        Dart e2 = add_dart();
+
+        newVertexOrbitEmbedding(d2);
+        position[d2] = (position[d]+position[phi1(d)])/2;
+
+        newVertexOrbitEmbedding(e2);
+        position[e2] = (position[e]+position[phi1(e)])/2;
+
+        phi2_sew(d,e2);
+        phi2_sew(e,d2);
+
+        phi1_sew(d,d2);
+        phi1_sew(e,e2);
 	}
 
+
 	// Touche m
 	// fusionne 2 arêtes consécutive (sommet commun de valence 2)
 	//			definies par d et phi1(d)
@@ -206,7 +223,23 @@ public:
 	//
 	void mergeAretes(Dart d)
 	{
+        if( vertexValence(phi1(d)) == 2 )
+        {
+            Dart d2 = phi1(d);
+            Dart e = phi2(d2);
+            Dart e2 = phi2(d);
 
+            phi2_unsew(d);
+            phi2_unsew(e);
+
+            phi1_sew(d,d2);
+            phi1_sew(e,e2);
+
+            remove_dart(e2);
+            remove_dart(d2);
+
+            phi2_sew(d,e);
+        }
 	}
 
 
@@ -222,7 +255,48 @@ public:
 	// - getVertexEmbedding(d)  renvoit l'indice de plongement de sommet de d
 	void coupeFace(Dart d, Dart e)
 	{
+        int e_find = 0;
+        unsigned int res = 0;
+        Dart tmp = d;
+
+        // Test if d & e are on the same face
+        do
+        {
+            tmp = phi1(tmp);
+            res++;
+
+            if(tmp == e)
+                e_find = 1;
+        } while (tmp != d);
+
+        // d & e on the same face
+        if(e_find && res > 3)
+        {
+            printf("Nous sommes sur la meme face et valence superieur a 3\n");
+            fflush(stdout);
+
+            // d & e not consecutive
+            if( (phi1(d) != e) && (phi_1(d) != e) )
+            {
+                printf("Les brins selectionné ne sont pas consecutif\n");
+                fflush(stdout);
+
+                Dart d_1 = phi_1(d);
+                Dart e_1 = phi_1(e);
+
+
+                Dart f = add_dart();
+                setVertexOrbitEmbedding(f, getVertexEmbedding(e));
+                Dart g = add_dart();
+                setVertexOrbitEmbedding(g, getVertexEmbedding(d));
+                phi1_sew(f,g);
 
+                phi1_sew(d_1, f);
+                phi1_sew(e_1, g);
+
+                phi2_sew(f, g);
+            }
+        }
 	}
 
 
@@ -231,10 +305,19 @@ public:
 	// Utiliser:
 	// - phi1_sew
 	// - remove_face(d)
-	//
 	void mergeFaces(Dart d)
 	{
+        Dart e = phi2(d);
+        Dart d_1 = phi_1(d);
+        Dart e_1 = phi_1(e);
+
+        phi2_unsew(d);
 
+        phi1_sew(d_1, e);
+        phi1_sew(e_1, d);
+
+        remove_dart(d);
+        remove_dart(e);
 	}
 
 
@@ -247,7 +330,44 @@ public:
 	//
 	void basculeArete(Dart d)
 	{
+        Dart e = phi2(d);
 
+        if( (faceValence(d)%2 == 1) && (faceValence(e)%2 == 1) )
+        {
+            Dart d_1 = phi_1(d);
+            Dart d1 = phi1(d);
+            Dart e_1 = phi_1(e);
+            Dart e1 = phi1(e);
+
+            // Search where to flip
+            int nb_phi1_d =faceValence(d)/2;
+            int nb_phi1_e =faceValence(e)/2;
+            printf("nb_phi1_d : %d & nb_phi1_e : %d\n", nb_phi1_d, nb_phi1_e);
+            fflush(stdout);
+            int i;
+            Dart new_pos_d = d;
+            Dart new_pos_e = e;
+
+            for(i=0; i<nb_phi1_d; i++)
+            {
+                new_pos_d = phi_1(new_pos_d);
+            }
+
+            for(i=0; i<nb_phi1_e; i++)
+            {
+                new_pos_e = phi_1(new_pos_e);
+            }
+
+            phi1_sew(d_1, e);
+            phi1_sew(e_1, d);
+
+
+            setVertexOrbitEmbedding( d, getVertexEmbedding(new_pos_d) );
+            setVertexOrbitEmbedding( e, getVertexEmbedding(new_pos_e) );
+
+            phi1_sew(phi_1(new_pos_d), e);
+            phi1_sew(phi_1(new_pos_e), d);
+        }
 	}
 
 
@@ -255,13 +375,70 @@ public:
 
 	// Triangule une face avec un point central
 	// Touche t
+    /*
+     * Coupe face de deux brins consécutif
+     * Coupé l'arete en deux
+     * Place au milieu et relié avec les autres point
+     */
 	void trianguleFace(Dart d)
 	{
+        unsigned int val_face = faceValence(d);
+        Dart init_face[val_face];
+        Dart dart_in[val_face];
+        Dart dart_out[val_face];
+
+        Dart tmp = d;
+
+        Vec3 pos_res = {0, 0, 0};
+        int i=0;
+
+        // Fill init face table
+        do
+        {
+            init_face[i] = tmp;
+            i++;
+            tmp = phi1(tmp);
 
+        } while (tmp != d);
+
+
+        for(i=0; i<val_face; i++)
+        {
+            pos_res += position[init_face[i]];
+            fflush(stdout);
+
+            Dart in = add_dart();
+            Dart out = add_dart();
+            phi1_sew(in, out);
+            phi2_sew(in, out);
+            phi1_sew(init_face[i], out);
+
+            dart_in[i] = in;
+            dart_out[i] = out;
+        }
+
+        for(i=val_face-1; i>0; i--)
+        {
+            phi1_sew(dart_in[i], dart_in[i-1]);
+        }
+
+        newVertexOrbitEmbedding(dart_out[0]);
+        position[dart_out[0]] = pos_res / val_face;
+
+        for(i=0; i<val_face; i++)
+        {
+            setVertexOrbitEmbedding( dart_in[i], getVertexEmbedding(init_face[(i+1)%val_face]) );
+        }
 	}
 
+
 	// Quandrangule une face (les arêtes) sont déjà coupée
 	// Touche q
+    /*
+     * Coupé en carré
+     * Rajout d'un point au milieu de la face
+     * Coupe les aretes au milieu
+     */
 	void quadranguleFace(Dart d)
 	{