From: adam <adam@megacz.com>
Date: Sun, 16 Dec 2007 03:06:01 +0000 (-0800)
Subject: checkpoint
X-Git-Url: http://git.megacz.com/?p=anneal.git;a=commitdiff_plain;h=485efa58c987b9a4b5155b36ae7c64eff4251142

checkpoint

darcs-hash:20071216030601-5007d-a5afd28f585c268de50bd774784725870ec1353b.gz
---

diff --git a/src/edu/berkeley/qfat/Main.java b/src/edu/berkeley/qfat/Main.java
index ee44e4d..44a8312 100644
--- a/src/edu/berkeley/qfat/Main.java
+++ b/src/edu/berkeley/qfat/Main.java
@@ -391,6 +391,7 @@ public class Main extends MeshViewer {
                         count++;
                         Mesh.Vertex v = pts[Math.abs(random.nextInt()) % pts.length];
                         rand(temp,v);
+                        v.recomputeFundamentalQuadricIfStale();
                         v.recomputeFundamentalQuadricIfNeighborChanged();
                     }
                     Thread.yield();
diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index bbb419a..8a46c73 100644
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -74,33 +74,19 @@ 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 float oldscore = 0;
+
 
-        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();
@@ -112,14 +98,6 @@ public class Mesh implements Iterable<Mesh.T> {
             gl.glNormal3f(norm.x, norm.y, norm.z);
         }
 
-        public void recomputeFundamentalQuadricIfNeighborChanged() {
-            Vertex oldv = nearest_in_other_mesh;
-            Vertex newv = score_against.nearest(p);
-            if (oldv==newv) return;
-            recomputeFundamentalQuadric();
-            if (oldv!=null) oldv.recomputeFundamentalQuadricIfNeighborChanged();
-            //if (newv!=null) newv.recomputeFundamentalQuadricIfNeighborChanged();
-        }
         public void recomputeFundamentalQuadric() {
             unApplyQuadricToNeighbor();
             if (quadricStale || fundamentalQuadric==null) {
@@ -160,7 +138,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();
@@ -185,6 +163,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
diff --git a/src/edu/berkeley/qfat/geom/HasQuadric.java b/src/edu/berkeley/qfat/geom/HasQuadric.java
new file mode 100644
index 0000000..825bda9
--- /dev/null
+++ b/src/edu/berkeley/qfat/geom/HasQuadric.java
@@ -0,0 +1,45 @@
+package edu.berkeley.qfat.geom;
+import javax.media.opengl.*;
+
+/** any object associated with a specific point in 3D space */
+public abstract class HasQuadric extends HasPoint {
+
+    public Matrix errorQuadric() { return quadric; }
+    public boolean quadricStale = false;
+    /** the nearest vertex in the "score_against" mesh */
+    public HasQuadric nearest_in_other_mesh;
+
+    /** the number of vertices in the other mesh for which this is the nearest_in_other_mesh */
+    public int    quadric_count;
+
+    /** the total error quadric (contributions from all vertices in other mesh for which this is nearest) */
+    public Matrix quadric = Matrix.ZERO;
+
+    public Matrix fundamentalQuadric = null;
+
+        public void recomputeFundamentalQuadricIfNeighborChanged() {
+            HasQuadric oldv = nearest_in_other_mesh;
+            HasQuadric newv = nearest();
+            if (oldv==newv) return;
+            recomputeFundamentalQuadric();
+            if (oldv!=null) oldv.recomputeFundamentalQuadricIfNeighborChanged();
+            // for some reason this causes an infinite loop
+            //if (newv!=null) newv.recomputeFundamentalQuadricIfNeighborChanged();
+        }
+        public void recomputeFundamentalQuadricIfStale() {
+            if (quadricStale || fundamentalQuadric==null) 
+                recomputeFundamentalQuadric();
+        }
+    public abstract void recomputeFundamentalQuadric();
+    public abstract void unApplyQuadricToNeighbor();
+    public abstract void applyQuadricToNeighbor();
+    public abstract void reComputeErrorAround();
+    public abstract void reComputeError();
+    public abstract void unComputeError();
+    public abstract void computeError();
+    public abstract HasQuadric nearest();
+        public Matrix fundamentalQuadric() {
+            if (fundamentalQuadric == null) recomputeFundamentalQuadric();
+            return fundamentalQuadric;
+        }
+}