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 1d842f7..1a210cd 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -46,19 +46,6 @@ public class Mesh implements Iterable<Mesh.T> {
         }
     }
 
-    public void unApplyQuadricToNeighborAll() {
-        for(Vertex p : vertices)
-            p.unApplyQuadricToNeighbor();
-    }
-    public void recomputeAllFundamentalQuadrics() {
-        for(Vertex p : vertices)
-            p.recomputeFundamentalQuadric();
-    }
-    public void applyQuadricToNeighborAll() {
-        for(Vertex p : vertices)
-            p.applyQuadricToNeighbor();
-    }
-
     public void transform(Matrix m) {
         ArrayList<Vertex> set = new ArrayList<Vertex>();
         for(Vertex v : vertices) set.add(v);
@@ -87,33 +74,17 @@ public class Mesh implements Iterable<Mesh.T> {
     // Vertexices //////////////////////////////////////////////////////////////////////////////
 
     /** a vertex in the mesh */
-    public final class Vertex extends HasPoint implements Visitor<T> {
+    public final class Vertex extends HasQuadric implements Visitor<T> {
         public String toString() { return p.toString(); }
         public Point p;
         E e;                // some edge *leaving* this point
 
-        /** the nearest vertex in the "score_against" mesh */
-        Vertex   nearest_in_other_mesh;
-        /** the number of vertices in the other mesh for which this is the nearest_in_other_mesh */
-        int    quadric_count;
-        /** the total error quadric (contributions from all vertices in other mesh for which this is nearest) */
-        Matrix quadric = Matrix.ZERO;
-
         Matrix binding = Matrix.ONE;
         Vertex bound_to = this;
-        float oldscore = 0;
-        boolean quadricStale = false;
 
-        public Matrix errorQuadric() { return quadric; }
         public Point getPoint() { return p; }
         public float score() { return oldscore; }
 
-        private Matrix fundamentalQuadric = null;
-        public Matrix fundamentalQuadric() {
-            if (fundamentalQuadric == null) recomputeFundamentalQuadric();
-            return fundamentalQuadric;
-        }
-
         private Vertex(Point p) {
             this.p = p;
             if (vertices.get(p) != null) throw new Error();
@@ -126,32 +97,21 @@ public class Mesh implements Iterable<Mesh.T> {
         }
 
         public void recomputeFundamentalQuadric() {
-            if (!quadricStale && fundamentalQuadric != null) return;
-            quadricStale = false;
             unApplyQuadricToNeighbor();
-            Matrix m = Matrix.ZERO;
-            int count = 0;
-            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next) {
-                T t = e.t;
-                m = m.plus(t.norm().fundamentalQuadric(t.centroid()));
-                count++;
+            if (quadricStale || fundamentalQuadric==null) {
+                Matrix m = Matrix.ZERO;
+                int count = 0;
+                for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next) {
+                    T t = e.t;
+                    m = m.plus(t.norm().fundamentalQuadric(t.centroid()));
+                    count++;
+                }
+                quadricStale = false;
+                fundamentalQuadric = m.times(1/(float)count);
             }
-            fundamentalQuadric = m.times(1/(float)count);
             applyQuadricToNeighbor();
         }
 
-        public void unApplyQuadricToNeighbor() {
-            if (nearest_in_other_mesh == null) return;
-            if (fundamentalQuadric == null) return;
-            nearest_in_other_mesh.unComputeError();
-            nearest_in_other_mesh.quadric = nearest_in_other_mesh.quadric.minus(fundamentalQuadric);
-            nearest_in_other_mesh.quadric_count--;
-            if (nearest_in_other_mesh.quadric_count==0)
-                nearest_in_other_mesh.quadric = Matrix.ZERO;
-            nearest_in_other_mesh.computeError();
-            nearest_in_other_mesh = null;
-        }
-
         public void applyQuadricToNeighbor() {
             if (score_against == null) return;
 
@@ -164,7 +124,7 @@ public class Mesh implements Iterable<Mesh.T> {
             nearest_in_other_mesh = new_nearest;
                 
             // don't attract to vertices that face the other way
-            if (nearest_in_other_mesh.e == null || nearest_in_other_mesh.norm().dot(norm()) < 0) {
+            if (((Vertex)nearest_in_other_mesh).e == null || ((Vertex)nearest_in_other_mesh).norm().dot(norm()) < 0) {
                 nearest_in_other_mesh = null;
             } else {
                 nearest_in_other_mesh.unComputeError();
@@ -189,6 +149,7 @@ public class Mesh implements Iterable<Mesh.T> {
             score -= oldscore;
             oldscore = 0;
         }
+        public HasQuadric nearest() { return score_against.nearest(p); }
         public void computeError() {
             oldscore =
                 quadric_count != 0