checkpoint

[anneal.git] / src / edu / berkeley / qfat / Mesh.java

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index 747599c..da10ac9 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -153,8 +153,13 @@ public class Mesh implements Iterable<Mesh.T> {
             pointset.add(this);
         }
 
             pointset.add(this);
         }
 

+        private void glNormal(GL gl) {
+            Vec norm = norm();
+            gl.glNormal3f(norm.x, norm.y, norm.z);
+        }
+

         public void recomputeFundamentalQuadric() {
         public void recomputeFundamentalQuadric() {

-            if (!quadricStale && fundamentalQuadric != null) return;
+            //if (!quadricStale && fundamentalQuadric != null) return;

             quadricStale = false;
             unApplyQuadricToNeighbor();
             Matrix m = Matrix.ZERO;
             quadricStale = false;
             unApplyQuadricToNeighbor();
             Matrix m = Matrix.ZERO;

@@ -212,7 +217,11 @@ public class Mesh implements Iterable<Mesh.T> {
             oldscore = 0;
         }
         public void computeError() {
             oldscore = 0;
         }
         public void computeError() {

-            oldscore = quadric_count == 0 ? 0 : (quadric.preAndPostMultiply(p) / quadric_count);
+            oldscore = quadric_count == 0 ? 0 : ((quadric.preAndPostMultiply(p) * 100) / quadric_count);
+            double ang = Math.abs(e.crossAngle());
+            if (ang < Math.PI * 0.2)
+                oldscore += ((Math.PI*0.2) - ang) * 10;
+            //System.out.println(oldscore);

             score += oldscore;
         }
 
             score += oldscore;
         }
 

@@ -241,14 +250,21 @@ public class Mesh implements Iterable<Mesh.T> {
 
             // FIXME: intersection test needed?
             boolean good = true;
 
             // FIXME: intersection test needed?
             boolean good = true;

+            /*

             for(T t : Mesh.this) {
                 if (!good) break;
                 e = this.e;
                 do {
             for(T t : Mesh.this) {
                 if (!good) break;
                 e = this.e;
                 do {

-                    if (!t.has(e.p1) && !t.has(e.p2) && e.t != null && e.intersects(t)) { good = false; break; }
+                    if (!t.has(e.p1) && !t.has(e.p2) && e.intersects(t)) { good = false; break; }
+                    if (e.t != null) {
+                        if (!e.t.has(t.e1().p1) && !e.t.has(t.e1().p2) && t.e1().intersects(e.t)) { good = false; break; }
+                        if (!e.t.has(t.e2().p1) && !e.t.has(t.e2().p2) && t.e2().intersects(e.t)) { good = false; break; }
+                        if (!e.t.has(t.e3().p1) && !e.t.has(t.e3().p2) && t.e3().intersects(e.t)) { good = false; break; }
+                    }

                     e = e.pair.next;
                 } while(e != this.e);
             }
                     e = e.pair.next;
                 } while(e != this.e);
             }

+*/

             return good;
         }
 
             return good;
         }
 

@@ -335,19 +351,21 @@ public class Mesh implements Iterable<Mesh.T> {
         public BindingGroup(E e) { this(); set.add(e); }
         public void add(E e) {
             if (set.contains(e)) return;
         public BindingGroup(E e) { this(); set.add(e); }
         public void add(E e) {
             if (set.contains(e)) return;

-            for (E epeer : e.bind_peers.set) {
-                epeer.bind_peers = this;
-                epeer.bind_to    = bind_others;
-                set.add(epeer);
-            }
-            for (E eother : e.bind_to.set) {
-                bind_others.add(eother);
-            }
+            set.add(e);
+            BindingGroup e_bind_peers = e.bind_peers;
+            BindingGroup e_bind_to    = e.bind_to;
+            e.bind_peers = this;
+            e.bind_to    = bind_others;
+            for (E epeer  : e_bind_peers.set) add(epeer);
+            for (E eother : e_bind_to.set)    bind_others.add(eother);

 
             for(E eother : bind_others.set) {
                 if (e.next.bind_to.set.contains(eother.prev)) {
                     e.next.next.bindEdge(eother.prev.prev);
                 }
 
             for(E eother : bind_others.set) {
                 if (e.next.bind_to.set.contains(eother.prev)) {
                     e.next.next.bindEdge(eother.prev.prev);
                 }

+                if (e.prev.bind_to.set.contains(eother.next)) {
+                    e.prev.prev.bindEdge(eother.next.next);
+                }

             }
 
         }
             }
 
         }

@@ -382,22 +400,24 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public Point shatter() { return shatter(midpoint(), null, null); }
         public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2) {
 
         public Point shatter() { return shatter(midpoint(), null, null); }
         public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2) {

-            if (shattered) return mid;
+            if (shattered || destroyed) return mid;

             shattered = true;
 
             Vert r = next.p2;
             E next = this.next;
             E prev = this.prev;
 
             shattered = true;
 
             Vert r = next.p2;
             E next = this.next;
             E prev = this.prev;
 

+            int old_colorclass = t==null ? 0 : t.colorclass;

             if (bg1==null) bg1 = new BindingGroup();
             if (bg2==null) bg2 = new BindingGroup();
             if (bg1==null) bg1 = new BindingGroup();
             if (bg2==null) bg2 = new BindingGroup();

+            BindingGroup old_bind_to = bind_to;

             bind_peers.shatter(bg1, bg2);
             bind_peers.shatter(bg1, bg2);

-            bind_to.shatter(bg2.other(), bg1.other());
+            old_bind_to.shatter(bg2.other(), bg1.other());

             pair.shatter();
             destroy();
 
             pair.shatter();
             destroy();
 

-            newT(r.p, p1.p, mid, null);
-            newT(r.p, mid, p2.p, null);
+            newT(r.p, p1.p, mid, null, old_colorclass);
+            newT(r.p, mid, p2.p, null, old_colorclass);

             bg1.add(p1.getE(mid));
             bg2.add(p2.getE(mid).pair);
             return mid;
             bg1.add(p1.getE(mid));
             bg2.add(p2.getE(mid).pair);
             return mid;

@@ -414,12 +434,10 @@ public class Mesh implements Iterable<Mesh.T> {
             prev.t = null;
             pair.next.t = null;
             pair.prev.t = null;
             prev.t = null;
             pair.next.t = null;
             pair.prev.t = null;

-            /*

             this.bind_to = null;
             pair.bind_to = null;
             this.bind_peers = null;
             pair.bind_peers = null;
             this.bind_to = null;
             pair.bind_to = null;
             this.bind_peers = null;
             pair.bind_peers = null;

-            */

             pair.prev.next = next;
             next.prev = pair.prev;
             prev.next = pair.next;
             pair.prev.next = next;
             next.prev = pair.prev;
             prev.next = pair.next;

@@ -448,7 +466,13 @@ public class Mesh implements Iterable<Mesh.T> {
         }
         private boolean added = false;
 
         }
         private boolean added = false;
 

-        public T makeT() { return t==null ? (t = new T(this)) : t; }
+        public T makeT(int colorclass) { return t==null ? (t = new T(this, colorclass)) : t; }
+
+        public double crossAngle() {
+            Vec v1 = t.norm().times(-1);
+            Vec v2 = pair.t.norm().times(-1);
+            return Math.acos(v1.norm().dot(v2.norm()));
+        }

 
         /** angle between this half-edge and the next */
         public double angle() {
 
         /** angle between this half-edge and the next */
         public double angle() {

@@ -610,7 +634,7 @@ public class Mesh implements Iterable<Mesh.T> {
         if (v2 != null) return new E(v2.getFreeIncident(), p1).pair;
         return new E(p1, p2);
     }
         if (v2 != null) return new E(v2.getFreeIncident(), p1).pair;
         return new E(p1, p2);
     }

-    public T newT(Point p1, Point p2, Point p3, Vec norm) {
+    public T newT(Point p1, Point p2, Point p3, Vec norm, int colorclass) {

         if (norm != null) {
             Vec norm2 = p3.minus(p1).cross(p2.minus(p1));
             float dot = norm.dot(norm2);
         if (norm != null) {
             Vec norm2 = p3.minus(p1).cross(p2.minus(p1));
             float dot = norm.dot(norm2);

@@ -625,7 +649,7 @@ public class Mesh implements Iterable<Mesh.T> {
             e23.makeAdjacent(e31);
             e31.makeAdjacent(e12);
         }
             e23.makeAdjacent(e31);
             e31.makeAdjacent(e12);
         }

-        T ret = e12.makeT();
+        T ret = e12.makeT(colorclass);

         if (e12.t == null) throw new Error();
         if (e23.t == null) throw new Error();
         if (e31.t == null) throw new Error();
         if (e12.t == null) throw new Error();
         if (e23.t == null) throw new Error();
         if (e31.t == null) throw new Error();

@@ -658,11 +682,12 @@ public class Mesh implements Iterable<Mesh.T> {
     public final class T extends Triangle {
         public final E e1;
         public final int color;
     public final class T extends Triangle {
         public final E e1;
         public final int color;

+        public final int colorclass;

 
         public void destroy() {
         }
 
 
         public void destroy() {
         }
 

-        T(E e1) {
+        T(E e1, int colorclass) {

             this.e1 = e1;
             E e2 = e1.next;
             E e3 = e2.next;
             this.e1 = e1;
             E e2 = e1.next;
             E e3 = e2.next;

@@ -684,6 +709,7 @@ public class Mesh implements Iterable<Mesh.T> {
                 break;
             }
             this.color = color;
                 break;
             }
             this.color = color;

+            this.colorclass = colorclass;

         }
         public E e1() { return e1; }
         public E e2() { return e1.next; }
         }
         public E e1() { return e1; }
         public E e2() { return e1.next; }

@@ -696,6 +722,16 @@ public class Mesh implements Iterable<Mesh.T> {
         public Point p3() { return e1.next.p2.p; }
         public boolean hasE(E e) { return e1==e || e1.next==e || e1.prev==e; }
         public boolean has(Vert v) { return v1()==v || v2()==v || v3()==v; }
         public Point p3() { return e1.next.p2.p; }
         public boolean hasE(E e) { return e1==e || e1.next==e || e1.prev==e; }
         public boolean has(Vert v) { return v1()==v || v2()==v || v3()==v; }

+
+        public void glVertices(GL gl) {
+            if (e1().bind_to.set.size() == 0) return;
+            if (e2().bind_to.set.size() == 0) return;
+            if (e3().bind_to.set.size() == 0) return;
+            norm().glNormal(gl);
+            p1().glVertex(gl);
+            p2().glVertex(gl);
+            p3().glVertex(gl);
+        }

     }
 
 }
     }
 
 }