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 42f03d2..0e2c1d6 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -20,13 +20,13 @@ public class Mesh implements Iterable<Mesh.T> {
 
     public boolean immutableVertices;
     public boolean ignorecollision    = false;
-    public Mesh    score_against      = null;
-    public double  score              = 0;
+    public Mesh    error_against      = null;
+    public double  error              = 0;
 
     public Mesh(boolean immutableVertices) { this.immutableVertices = immutableVertices; }
 
     public void makeVerticesImmutable() { this.immutableVertices = true; }
-    public float score() { return (float)score; }
+    public float error() { return (float)error; }
 
     public int size() { return vertices.size(); }
     public Iterable<Vertex> vertices() { return vertices; }
@@ -76,15 +76,15 @@ public class Mesh implements Iterable<Mesh.T> {
 
     /** a vertex in the mesh */
     public final class Vertex extends HasQuadric implements Visitor {
-        public String toString() { return p.toString(); }
         public Point p;
         E e;                // some edge *leaving* this point
 
         Matrix binding = Matrix.ONE;
         Vertex bound_to = this;
+        private boolean good;
 
         public Point getPoint() { return p; }
-        public float score() { return oldscore; }
+        public float error() { return olderror; }
 
         private Vertex(Point p) {
             this.p = p;
@@ -92,60 +92,44 @@ public class Mesh implements Iterable<Mesh.T> {
             vertices.add(this);
         }
 
-        private void glNormal(GL gl) {
-            Vec norm = norm();
-            gl.glNormal3f(norm.x, norm.y, norm.z);
+        public float olderror = 0;
+        public void setError(float nerror) {
+            error -= olderror;
+            olderror = nerror;
+            error += olderror;
         }
 
-        public void _recomputeFundamentalQuadric() {
+        public Matrix _recomputeFundamentalQuadric() {
             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()));
+                m = m.plus(e.t.norm().fundamentalQuadric(e.t.centroid()));
                 count++;
             }
-            quadricStale = false;
-            fundamentalQuadric = m.times(1/(float)count);
+            return m.times(1/(float)count);
         }
 
-        public void reComputeErrorAround() {
-            reComputeError();
-            if (nearest_in_other_mesh != null) nearest_in_other_mesh.reComputeError();
-            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
-                e.p2.reComputeError();
-        }
-        public void reComputeError() {
-            unComputeError();
-            computeError();
-        }
-        public void unComputeError() {
-            score -= oldscore;
-            oldscore = 0;
-        }
         public HasQuadric nearest() {
-            if (score_against==null) return null;
-            return score_against.vertices.nearest(p, this);
+            if (error_against==null) return null;
+            return error_against.vertices.nearest(p, this);
         }
+
         public void computeError() {
-            oldscore =
+            float nerror =
                 quadric_count != 0
                 ? (quadric.preAndPostMultiply(p) * 100) / quadric_count
-                : immutableVertices
-                ? oldscore
                 : nearest_in_other_mesh != null
                 ? nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p) * 100 * 10
-                : score_against != null
+                : error_against != null
                 ? nearest().fundamentalQuadric().preAndPostMultiply(p) * 100 * 10
                 : 0;
             for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next) {
                 double ang = Math.abs(e.crossAngle());
                 if (ang > Math.PI) throw new Error();
                 float minangle = (float)(Math.PI * 0.8);
-                if (ang > minangle)
-                    oldscore += (ang - minangle);
+                if (ang > minangle) nerror += (ang - minangle);
             }
-            score += oldscore;
+            setError(nerror);
         }
 
         private void removeTrianglesFromRTree() {
@@ -186,10 +170,16 @@ public class Mesh implements Iterable<Mesh.T> {
 
             if (!ignorecollision && good) triangles.range(oldp, this.p, (Visitor<T>)this);
 
-            reComputeErrorAround();
             return good;
         }
 
+        public void reComputeErrorAround() {
+            reComputeError();
+            if (nearest_in_other_mesh != null) nearest_in_other_mesh.reComputeError();
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
+                e.p2.reComputeError();
+        }
+
         public boolean visit(Object o) {
             if (o instanceof T) {
                 T t = (T)o;
@@ -210,16 +200,21 @@ public class Mesh implements Iterable<Mesh.T> {
                 return true;
             }
         }
-        private boolean good;
 
         public boolean move(Vec v) {
             Matrix m = Matrix.translate(v);
-            Vertex p = this;
+
             boolean good = true;
-            do {
+            for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
                 good &= p.transform(m);
-                p = p.bound_to;
-            } while (p != this);
+
+            if (good) {
+                for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
+                    p.reComputeErrorAround();
+            } else {
+                for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
+                    p.transform(Matrix.translate(v.times(-1)));
+            }
             return good;
         }
 
@@ -249,6 +244,10 @@ public class Mesh implements Iterable<Mesh.T> {
             return null;
         }
 
+        private void glNormal(GL gl) {
+            Vec norm = norm();
+            gl.glNormal3f(norm.x, norm.y, norm.z);
+        }
         public Vec norm() {
             Vec norm = new Vec(0, 0, 0);
             for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
@@ -331,7 +330,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public boolean intersects(T t) { return t.intersects(p1.p, p2.p); }
         public float comparator() {
-            Vertex nearest = score_against.nearest(midpoint());
+            Vertex nearest = error_against.nearest(midpoint());
             return (float)Math.max(length(), midpoint().distance(nearest.p));
         }
         public int compareTo(E e) {