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 da10ac9..46c2200 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -37,11 +37,15 @@ public class Mesh implements Iterable<Mesh.T> {
     }
 
     public Iterator<T> iterator() {
+        /*
         for(Vert v : pointset)
             if (v.e != null && v.e.t != null)
                 return new FaceIterator(v);
         return new FaceIterator();
+        */
+        return ts.iterator();
     }
+    public HashSet<T> ts = new HashSet<T>();
 
     public Mesh score_against = null;
     public double score = 0;
@@ -164,12 +168,14 @@ public class Mesh implements Iterable<Mesh.T> {
             unApplyQuadricToNeighbor();
             Matrix m = Matrix.ZERO;
             E e = this.e;
+            int count = 0;
             do {
                 T t = e.t;
                 m = m.plus(t.norm().fundamentalQuadric(t.centroid()));
+                count++;
                 e = e.pair.next;
             } while(e != this.e);
-            fundamentalQuadric = m;
+            fundamentalQuadric = m.times(1/(float)count);
             applyQuadricToNeighbor();
         }
 
@@ -208,6 +214,15 @@ public class Mesh implements Iterable<Mesh.T> {
             reComputeError();
         }
 
+        public void reComputeErrorAround() {
+            reComputeError();
+            if (nearest_in_other_mesh != null) nearest_in_other_mesh.reComputeError();
+            E e = this.e;
+            do {
+                e.p2.reComputeError();
+                e = e.pair.next;
+            } while (e != this.e);
+        }
         public void reComputeError() {
             unComputeError();
             computeError();
@@ -217,11 +232,43 @@ public class Mesh implements Iterable<Mesh.T> {
             oldscore = 0;
         }
         public void computeError() {
-            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;
+            if (quadric_count == 0) {
+                if (nearest_in_other_mesh == null) {
+                    if (score_against != null) {
+                        Vert ne = score_against.nearest(p);
+                        oldscore = ne.fundamentalQuadric().preAndPostMultiply(p) * 100 * 3;
+                    } else {
+                        oldscore = 0;
+                    }
+                } else {
+                    oldscore = nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p) * 100 * 3;
+                }
+            } else {
+                oldscore = (quadric.preAndPostMultiply(p) * 100) / quadric_count;
+            }
+
+            oldscore = oldscore*oldscore;
+
+            int numaspects = 0;
+            float aspects = 0;
+            E e = this.e;
+            do {
+                double ang = Math.abs(e.crossAngle());
+                if (ang > Math.PI) throw new Error();
+                if (e.t != null) {
+                    numaspects++;
+                    aspects += e.t.aspect()*e.t.aspect();
+                }
+
+                if (ang > Math.PI * 0.8)
+                    oldscore += (ang - (Math.PI*0.8)) * 10;
+
+                e = e.pair.next;
+            } while (e != this.e);
+            if (numaspects > 0) oldscore += (aspects / numaspects);
+
             //System.out.println(oldscore);
+            //oldscore = oldscore*oldscore;
             score += oldscore;
         }
 
@@ -257,14 +304,15 @@ public class Mesh implements Iterable<Mesh.T> {
                 do {
                     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; }
+                        //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);
             }
-*/
+            */
+            reComputeErrorAround();
             return good;
         }
 
@@ -394,7 +442,15 @@ public class Mesh implements Iterable<Mesh.T> {
         public BindingGroup bind_to     = bind_peers.other();
         boolean shattered = false;
 
-        public int compareTo(E e) { return e.length() > length() ? 1 : -1; }
+        public float comparator() {
+            if (t==null) return length();
+            if ((length() * length()) / t.area() > 10)
+                return (float)(length()*Math.sqrt(t.area()));
+            return length()*t.area();
+        }
+        public int compareTo(E e) {
+            return e.comparator() > comparator() ? 1 : -1;
+        }
         public void bindEdge(E e) { bind_to.add(e); }
         public void dobind() { bind_to.dobind(this); }
 
@@ -428,12 +484,23 @@ public class Mesh implements Iterable<Mesh.T> {
             if (destroyed) return;
             destroyed = true;
             pair.destroyed = true;
+
+            if (t != null) t.destroy();
+            t = null;
+
+            if (pair.t != null) pair.t.destroy();
+            pair.t = null;
+
             if (next.t != null) next.t.destroy();
             if (prev.t != null) prev.t.destroy();
             next.t = null;
             prev.t = null;
+
+            if (pair.next.t != null) pair.next.t.destroy();
+            if (pair.prev.t != null) pair.next.t.destroy();
             pair.next.t = null;
             pair.prev.t = null;
+
             this.bind_to = null;
             pair.bind_to = null;
             this.bind_peers = null;
@@ -685,6 +752,7 @@ public class Mesh implements Iterable<Mesh.T> {
         public final int colorclass;
 
         public void destroy() {
+            ts.remove(this);
         }
 
         T(E e1, int colorclass) {
@@ -710,6 +778,7 @@ public class Mesh implements Iterable<Mesh.T> {
             }
             this.color = color;
             this.colorclass = colorclass;
+            ts.add(this);
         }
         public E e1() { return e1; }
         public E e2() { return e1.next; }
@@ -724,9 +793,11 @@ public class Mesh implements Iterable<Mesh.T> {
         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);