X-Git-Url: http://git.megacz.com/?p=anneal.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fqfat%2FMesh.java;h=fb994880da734591fb6fefa0ec560273087f4e1b;hp=15cd3fc2e4accd62aac6efc0d1df814b956f3a64;hb=6fe08d5c50c341f47ded8ce9acd670aad9362614;hpb=57f53f050333a8168f51b48d028a276214837a2d

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index 15cd3fc..fb99488 100644
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -18,9 +18,9 @@ public class Mesh implements Iterable<Mesh.T> {
     private PointSet<Vertex> vertices  = new PointSet<Vertex>();
 
     public boolean immutableVertices;
-    public boolean ignorecollision = false;
-    public Mesh    score_against = null;
-    public double  score = 0;
+    public boolean ignorecollision    = false;
+    public Mesh    score_against      = null;
+    public double  score              = 0;
 
     public Mesh(boolean immutableVertices) { this.immutableVertices = immutableVertices; }
 
@@ -46,38 +46,6 @@ public class Mesh implements Iterable<Mesh.T> {
         }
     }
 
-    public void unApplyQuadricToNeighborAll() {
-        HashSet<Vertex> done = new HashSet<Vertex>();
-        for(T t : this)
-            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {
-                if (done.contains(p)) continue;
-                done.add(p);
-                p.unApplyQuadricToNeighbor();
-            }
-    }
-    public void recomputeAllFundamentalQuadrics() {
-        HashSet<Vertex> done = new HashSet<Vertex>();
-        for(T t : this)
-            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {
-                if (done.contains(p)) continue;
-                done.add(p);
-                p.recomputeFundamentalQuadric();
-            }
-    }
-    public float applyQuadricToNeighborAll() {
-        int num = 0;
-        double dist = 0;
-        HashSet<Vertex> done = new HashSet<Vertex>();
-        for(T t : this)
-            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {
-                if (done.contains(p)) continue;
-                done.add(p);
-                p.applyQuadricToNeighbor();
-                
-            }
-        return (float)(dist/num);
-    }
-
     public void transform(Matrix m) {
         ArrayList<Vertex> set = new ArrayList<Vertex>();
         for(Vertex v : vertices) set.add(v);
@@ -118,8 +86,8 @@ public class Mesh implements Iterable<Mesh.T> {
         /** the total error quadric (contributions from all vertices in other mesh for which this is nearest) */
         Matrix quadric = Matrix.ZERO;
 
-        Vertex bound_to = this;
         Matrix binding = Matrix.ONE;
+        Vertex bound_to = this;
         float oldscore = 0;
         boolean quadricStale = false;
 
@@ -145,19 +113,18 @@ public class Mesh implements Iterable<Mesh.T> {
         }
 
         public void recomputeFundamentalQuadric() {
-            if (!quadricStale && fundamentalQuadric != null) return;
-            quadricStale = false;
             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.times(1/(float)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);
+            }
             applyQuadricToNeighbor();
         }
 
@@ -199,11 +166,8 @@ public class Mesh implements Iterable<Mesh.T> {
         public void reComputeErrorAround() {
             reComputeError();
             if (nearest_in_other_mesh != null) nearest_in_other_mesh.reComputeError();
-            E e = this.e;
-            do {
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
                 e.p2.reComputeError();
-                e = e.pair.next;
-            } while (e != this.e);
         }
         public void reComputeError() {
             unComputeError();
@@ -214,64 +178,33 @@ public class Mesh implements Iterable<Mesh.T> {
             oldscore = 0;
         }
         public void computeError() {
-            if (quadric_count == 0) {
-                if (immutableVertices) {
-                } else if (nearest_in_other_mesh == null) {
-                    if (score_against != null) {
-                        Vertex ne = score_against.nearest(p);
-                        oldscore = ne.fundamentalQuadric().preAndPostMultiply(p) * 100 * 10;
-                    } else {
-                        oldscore = 0;
-                    }
-                } else {
-                    oldscore = nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p) * 100 * 10;
-                }
-            } else {
-                oldscore = (quadric.preAndPostMultiply(p) * 100) / quadric_count;
-            }
-
-            oldscore = oldscore;
-
-            int numaspects = 0;
-            float aspects = 0;
-            E e = this.e;
-            do {
-                //double ang = Math.abs(e.crossAngle());
+            oldscore =
+                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
+                ? score_against.nearest(p).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();
-                /*
-                  if (e.t != null) {
-                  numaspects++;
-                  aspects += e.t.aspect()*e.t.aspect();
-                  }
-                */
-
                 float minangle = (float)(Math.PI * 0.8);
                 if (ang > minangle)
                     oldscore += (ang - minangle);
-
-                e = e.pair.next;
-            } while (e != this.e);
-            if (numaspects > 0) oldscore += (aspects / numaspects);
-
-            //System.out.println(oldscore);
-            //oldscore = oldscore*oldscore;
+            }
             score += oldscore;
         }
 
         private void removeTrianglesFromRTree() {
-            E e = this.e;
-            do {
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
                 if (e.t != null) e.t.removeFromRTree();
-                e = e.pair.next;
-            } while(e != this.e);
         }
         private void addTrianglesToRTree() {
-            E e = this.e;
-            do {
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
                 if (e.t != null) e.t.addToRTree();
-                e = e.pair.next;
-            } while(e != this.e);
         }
 
         /** does NOT update bound pairs! */
@@ -295,12 +228,10 @@ public class Mesh implements Iterable<Mesh.T> {
 
             good = true;
 
-            for(E e = this.e; ;) {
+            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)) good = false;
                 if (e.t.aspect() < 0.1) good = false;
                 e.p2.quadricStale = true;
-                e = e.pair.next;
-                if (e==this.e) break;
             }
 
             if (!ignorecollision && good) triangles.range(oldp, this.p, (Visitor<T>)this);
@@ -311,16 +242,14 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public void visit(T t) {
             if (!good) return;
-            E e = Vertex.this.e;
-            do {
+            for(E e = Vertex.this.e; e!=null; e=e.pair.next==Vertex.this.e?null:e.pair.next) {
                 if (!t.has(e.p1) && !t.has(e.p2) && e.intersects(t)) { good = false; }
                 if (e.t != null) {
                     if (!e.t.has(t.e1().p1) && !e.t.has(t.e1().p2) && t.e1().intersects(e.t)) { good = false; }
                     if (!e.t.has(t.e2().p1) && !e.t.has(t.e2().p2) && t.e2().intersects(e.t)) { good = false; }
                     if (!e.t.has(t.e3().p1) && !e.t.has(t.e3().p2) && t.e3().intersects(e.t)) { good = false; }
                 }
-                e = e.pair.next;
-            } while(e != Vertex.this.e);
+            }
         }
         private boolean good;
 
@@ -338,24 +267,15 @@ public class Mesh implements Iterable<Mesh.T> {
         public E getFreeIncident() {
             E ret = getFreeIncident(e, e);
             if (ret != null) return ret;
-            ret = getFreeIncident(e.pair.next, e.pair.next);
-            if (ret == null) {
-                E ex = e;
-                do {
-                    System.out.println(ex + " " + ex.t);
-                    ex = ex.pair.next;
-                } while (ex != e);
-                throw new Error("unable to find free incident to " + this);
-            }
-            return ret;
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
+                System.out.println(e + " " + e.t);
+            throw new Error("unable to find free incident to " + this);
         }
 
         public E getFreeIncident(E start, E before) {
-            E e = start;
-            do {
-                if (e.pair.p2 == this && e.pair.t == null && e.pair.next.t == null) return e.pair;
-                e = e.pair.next;
-            } while(e != before);
+            for(E e = start; e!=null; e=e.pair.next==before?null:e.pair.next)
+                if (e.pair.p2 == this && e.pair.t == null && e.pair.next.t == null)
+                    return e.pair;
             return null;
         }
 
@@ -365,33 +285,26 @@ public class Mesh implements Iterable<Mesh.T> {
             return getE(v);
         }
         public E getE(Vertex p2) {
-            E e = this.e;
-            do {
-                if (e==null) return null;
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
                 if (e.p1 == this && e.p2 == p2) return e;
-                e = e.pair.next;
-            } while (e!=this.e);
             return null;
         }
 
         public Vec norm() {
             Vec norm = new Vec(0, 0, 0);
-            E e = this.e;
-            do {
-                if (e.t != null) norm = norm.plus(e.t.norm().times((float)e.prev.angle()));
-                e = e.pair.next;
-            } while(e != this.e);
+            for(E e = this.e; e!=null; e=e.pair.next==this.e?null:e.pair.next)
+                if (e.t != null)
+                    norm = norm.plus(e.t.norm().times((float)e.prev.angle()));
             return norm.norm();
         }
 
         public boolean isBoundTo(Vertex p) {
-            Vertex px = p;
-            do {
-                if (px==this) return true;
-                px = px.bound_to;
-            } while(px != p);
+            for(Vertex px = p; px!=null; px=(px.bound_to==p?null:px.bound_to))
+                if (px==this)
+                    return true;
             return false;
         }
+
         public void unbind() { bound_to = this; binding = Matrix.ONE; }
         public void bind(Vertex p) { bind(p, Matrix.ONE); }
         public void bind(Vertex p, Matrix binding) {
@@ -460,20 +373,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());
-            //if (t==null) return length();
-            /*
-              double ang = Math.abs(crossAngle());
-              float minangle = (float)(Math.PI * 0.9);
-              if (ang > minangle)
-              return 300;
-            */
-            /*
-              if ((length() * length()) / t.area() > 10)
-              return (float)(length()*Math.sqrt(t.area()));
-              return length()*t.area();
-            */
             return (float)Math.max(length(), midpoint().distance(nearest.p));
-            //return length();
         }
         public int compareTo(E e) {
             return e.comparator() > comparator() ? 1 : -1;