checkpoint before triforce

[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 a2e175b..02f589e 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -75,7 +75,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
     /** a vertex in the mesh */
     public final class Vertex extends HasQuadric implements Visitor {
-        public Point p, oldp;
+        public Point p, oldp, goodp;
         E e;                // some edge *leaving* this point
 
         Matrix binding = Matrix.ONE;
@@ -87,6 +87,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
         private Vertex(Point p) {
             this.p = p;
+            this.goodp = p;
             if (vertices.get(p) != null) throw new Error();
             vertices.add(this);
         }
@@ -137,25 +138,37 @@ public class Mesh implements Iterable<Mesh.T> {
         public void computeError() {
             if (error_against==null) return;
             float nerror =
-                quadric_count != 0
-                ? (quadric.preAndPostMultiply(p) * 100)/quadric_count
-                : nearest_in_other_mesh != null
-                ? nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p) * 100
-                : nearest().fundamentalQuadric().preAndPostMultiply(p) * 100;
+                nearest_in_other_mesh != null
+                ? nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p)
+                : nearest().fundamentalQuadric().preAndPostMultiply(p);
+            if (quadric_count != 0)
+                nerror = (nerror + quadric.preAndPostMultiply(p))/(quadric_count+1);
+
             for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next) {
-                double ang = Math.abs(e.crossAngle());
+                double ang = Math.abs(e.dihedralAngle());
                 if (ang > Math.PI) throw new Error();
                 float minangle = (float)(Math.PI * 0.8);
                 if (ang > minangle) nerror += (ang - minangle);
                 /*
                 if (e.t.aspect() < 0.2) {
-                    nerror += (0.2-e.t.aspect()) * 300;
+                    nerror += (0.2-e.t.aspect()) * 10;
                 }
                 */
             }
+
             setError(nerror);
         }
 
+        public boolean move(Matrix m, boolean ignoreProblems) {
+            boolean good = true;
+            for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
+                good &= p.transform(m.times(p.p), ignoreProblems);
+            for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
+                if (good || ignoreProblems)  p.reComputeErrorAround();
+                else                         p.transform(p.oldp, true);
+            return good;
+        }
+
         /** does NOT update bound pairs! */
         private boolean transform(Point newp, boolean ignoreProblems) {
             this.oldp = this.p;
@@ -177,8 +190,8 @@ public class Mesh implements Iterable<Mesh.T> {
         public void checkLegality() {
             /*
             for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next) {
-                if (Math.abs(e.crossAngle()) > (Math.PI * 0.9) ||
-                    Math.abs(e.next.crossAngle()) > (Math.PI * 0.9)) illegal = true;
+                if (Math.abs(e.dihedralAngle()) > (Math.PI * 0.9) ||
+                    Math.abs(e.next.dihedralAngle()) > (Math.PI * 0.9)) illegal = true;
                 if (e.t.aspect() < 0.1) illegal = true;
             }
             */
@@ -209,16 +222,6 @@ public class Mesh implements Iterable<Mesh.T> {
             return !illegal;
         }
 
-        public boolean move(Matrix m, boolean ignoreProblems) {
-            boolean good = true;
-            for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
-                good &= p.transform(m.times(p.p), ignoreProblems);
-            for(Vertex p = this; p != null; p = (p.bound_to==this)?null:p.bound_to)
-                if (good || ignoreProblems)  p.reComputeErrorAround();
-                else                         p.transform(p.oldp, true);
-            return good;
-        }
-
         public E getFreeIncident() {
             E ret = getFreeIncident(e, e);
             if (ret != null) return ret;
@@ -330,17 +333,18 @@ public class Mesh implements Iterable<Mesh.T> {
         boolean shattered = false;
 
         public boolean intersects(T t) { return t.intersects(p1.p, p2.p); }
-        public float comparator() {
-            /*
+
+        public float stretchRatio() {
             Vertex nearest = error_against.nearest(midpoint());
-            //return (float)Math.max(length(), midpoint().distance(nearest.p));
-            //return length();
             float nearest_distance = midpoint().distance(nearest.p);
             float other_distance =
                 (p1.p.distance(error_against.nearest(p1.p).p)+
                  p2.p.distance(error_against.nearest(p2.p).p))/2;
             return nearest_distance/other_distance;
-            */
+        }
+        public float comparator() {
+            
+
             return length();
             //return t==null?0:(1/t.aspect());
         }
@@ -423,7 +427,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public T makeT(int colorclass) { return t==null ? (t = new T(this, colorclass)) : t; }
 
-        public double crossAngle() {
+        public double dihedralAngle() {
             Vec v1 = t.norm().times(-1);
             Vec v2 = pair.t.norm().times(-1);
             return Math.acos(v1.norm().dot(v2.norm()));
@@ -597,5 +601,17 @@ public class Mesh implements Iterable<Mesh.T> {
             return true;
         }
 
+        /** issue gl.glVertex() for each of the triangle's points */
+        public void glVertices(GL gl) {
+            if (!shouldBeDrawn()) return;
+            norm().glNormal(gl);
+            Point p1 = v1().goodp;
+            Point p2 = v2().goodp;
+            Point p3 = v3().goodp;
+            p1.glVertex(gl);
+            p2.glVertex(gl);
+            p3.glVertex(gl);
+        }
+
     }
 }