checkpoint

darcs-hash:20071216015356-5007d-0d69b681fded2ca05d2611cb20ed15d1b8dd9a94.gz

diff --git a/src/edu/berkeley/qfat/Main.java b/src/edu/berkeley/qfat/Main.java
index f32258d..82ca36c 100644 (file)
--- a/src/edu/berkeley/qfat/Main.java
+++ b/src/edu/berkeley/qfat/Main.java
@@ -239,7 +239,7 @@ public class Main extends MeshViewer {
             }
         }
 
             }
         }
 

-        //xMesh.Vert mid = lbf.getE(mbn).shatter();
+        //xMesh.Vertex mid = lbf.getE(mbn).shatter();

 
         // rescale to match volume
         float factor = (float)Math.pow(tile.volume() / goal.volume(), 1.0/3.0);
 
         // rescale to match volume
         float factor = (float)Math.pow(tile.volume() / goal.volume(), 1.0/3.0);

@@ -286,7 +286,7 @@ public class Main extends MeshViewer {
         tile.rebindPoints();
     }
 
         tile.rebindPoints();
     }
 

-    public synchronized void rand(float temp, Mesh.Vert p) {
+    public synchronized void rand(float temp, Mesh.Vertex p) {

 
         //p.reComputeError();
         p.reComputeErrorAround();
 
         //p.reComputeError();
         p.reComputeErrorAround();

@@ -380,16 +380,16 @@ public class Main extends MeshViewer {
             temp = temp * gamma;
 
 
             temp = temp * gamma;
 
 

-            HashSet<Mesh.Vert> hs = new HashSet<Mesh.Vert>();
-            for(Mesh.Vert p : tile.vertices()) hs.add(p);
-            Mesh.Vert[] pts = (Mesh.Vert[])hs.toArray(new Mesh.Vert[0]);
+            HashSet<Mesh.Vertex> hs = new HashSet<Mesh.Vertex>();
+            for(Mesh.Vertex p : tile.vertices()) hs.add(p);
+            Mesh.Vertex[] pts = (Mesh.Vertex[])hs.toArray(new Mesh.Vertex[0]);

 
             int count = 0;
             long then = System.currentTimeMillis();
             for(int i=0; i<100; i++) {
                 if (anneal) {
                     count++;
 
             int count = 0;
             long then = System.currentTimeMillis();
             for(int i=0; i<100; i++) {
                 if (anneal) {
                     count++;

-                    Mesh.Vert v = pts[Math.abs(random.nextInt()) % pts.length];
+                    Mesh.Vertex v = pts[Math.abs(random.nextInt()) % pts.length];

                     rand(temp,v);
                 }
                 Thread.yield();
                     rand(temp,v);
                 }
                 Thread.yield();

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index ff48f42..c057f33 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -15,7 +15,7 @@ public class Mesh implements Iterable<Mesh.T> {
     public static final Random random = new Random();
 
     private RTree<T> tris = new RTree<T>();
     public static final Random random = new Random();
 
     private RTree<T> tris = new RTree<T>();

-    private PointSet<Vert> vertices = new PointSet<Vert>();
+    private PointSet<Vertex> vertices = new PointSet<Vertex>();

 
     public boolean tilemesh = false;
     public boolean ignorecollision = false;
 
     public boolean tilemesh = false;
     public boolean ignorecollision = false;

@@ -24,7 +24,7 @@ public class Mesh implements Iterable<Mesh.T> {
     public float score() { return (float)score; }
 
     public int size() { return vertices.size(); }
     public float score() { return (float)score; }
 
     public int size() { return vertices.size(); }

-    public Iterable<Vert> vertices() { return vertices; }
+    public Iterable<Vertex> vertices() { return vertices; }

 
     public Iterator<T> iterator() {
         return tris.iterator();
 
     public Iterator<T> iterator() {
         return tris.iterator();

@@ -46,18 +46,18 @@ public class Mesh implements Iterable<Mesh.T> {
     }
 
     public void unApplyQuadricToNeighborAll() {
     }
 
     public void unApplyQuadricToNeighborAll() {

-        HashSet<Vert> done = new HashSet<Vert>();
+        HashSet<Vertex> done = new HashSet<Vertex>();

         for(T t : this)
         for(T t : this)

-            for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) {
+            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {

                 if (done.contains(p)) continue;
                 done.add(p);
                 p.unApplyQuadricToNeighbor();
             }
     }
     public void recomputeAllFundamentalQuadrics() {
                 if (done.contains(p)) continue;
                 done.add(p);
                 p.unApplyQuadricToNeighbor();
             }
     }
     public void recomputeAllFundamentalQuadrics() {

-        HashSet<Vert> done = new HashSet<Vert>();
+        HashSet<Vertex> done = new HashSet<Vertex>();

         for(T t : this)
         for(T t : this)

-            for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) {
+            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {

                 if (done.contains(p)) continue;
                 done.add(p);
                 p.recomputeFundamentalQuadric();
                 if (done.contains(p)) continue;
                 done.add(p);
                 p.recomputeFundamentalQuadric();

@@ -66,9 +66,9 @@ public class Mesh implements Iterable<Mesh.T> {
     public float applyQuadricToNeighborAll() {
         int num = 0;
         double dist = 0;
     public float applyQuadricToNeighborAll() {
         int num = 0;
         double dist = 0;

-        HashSet<Vert> done = new HashSet<Vert>();
+        HashSet<Vertex> done = new HashSet<Vertex>();

         for(T t : this)
         for(T t : this)

-            for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) {
+            for(Vertex p : new Vertex[] { t.v1(), t.v2(), t.v3() }) {

                 if (done.contains(p)) continue;
                 done.add(p);
                 p.applyQuadricToNeighbor();
                 if (done.contains(p)) continue;
                 done.add(p);
                 p.applyQuadricToNeighbor();

@@ -78,12 +78,17 @@ public class Mesh implements Iterable<Mesh.T> {
     }
 
     public void transform(Matrix m) {
     }
 
     public void transform(Matrix m) {

-        ArrayList<Vert> set = new ArrayList<Vert>();
-        for (Vert v : vertices)
-            set.add(v);
-        for(Vert v : set) v.transform(m);
+        ArrayList<Vertex> set = new ArrayList<Vertex>();
+        for(Vertex v : vertices) set.add(v);
+        for(Vertex v : set) v.transform(m);

     }
 
     }
 

+    public void rebuild() { /*vertices.rebuild();*/ }
+    public Vec diagonal() { return vertices.diagonal(); }
+    public Point centroid() { return vertices.centroid(); }
+    public Vertex nearest(Point p) { return vertices.nearest(p); }
+
+    /** compute the volume of the mesh */

     public float volume() {
         double total = 0;
         for(T t : this) {
     public float volume() {
         double total = 0;
         for(T t : this) {

@@ -96,24 +101,22 @@ public class Mesh implements Iterable<Mesh.T> {
         return (float)total;
     }
 
         return (float)total;
     }
 

-    public void rebuild() { /*vertices.rebuild();*/ }
-    public Vec diagonal() { return vertices.diagonal(); }
-    public Point centroid() { return vertices.centroid(); }
-    public Vert nearest(Point p) { return vertices.nearest(p); }

 
 

-    public final class Vert extends HasPoint {
+    // Vertexices //////////////////////////////////////////////////////////////////////////////
+
+    public final class Vertex extends HasPoint {

         public String toString() { return p.toString(); }
         public Point p;
         E e;                // some edge *leaving* this point
 
         /** the nearest vertex in the "score_against" mesh */
         public String toString() { return p.toString(); }
         public Point p;
         E e;                // some edge *leaving* this point
 
         /** the nearest vertex in the "score_against" mesh */

-        Vert   nearest_in_other_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;
 
         /** 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;
 

-        Vert bound_to = this;
+        Vertex bound_to = this;

         Matrix binding = Matrix.ONE;
         float oldscore = 0;
         boolean quadricStale = false;
         Matrix binding = Matrix.ONE;
         float oldscore = 0;
         boolean quadricStale = false;

@@ -128,7 +131,7 @@ public class Mesh implements Iterable<Mesh.T> {
             return fundamentalQuadric;
         }
 
             return fundamentalQuadric;
         }
 

-        private Vert(Point p) {
+        private Vertex(Point p) {

             this.p = p;
             if (vertices.get(p) != null) throw new Error();
             vertices.add(this);
             this.p = p;
             if (vertices.get(p) != null) throw new Error();
             vertices.add(this);

@@ -171,7 +174,7 @@ public class Mesh implements Iterable<Mesh.T> {
         public void applyQuadricToNeighbor() {
             if (score_against == null) return;
 
         public void applyQuadricToNeighbor() {
             if (score_against == null) return;
 

-            Vert new_nearest = score_against.nearest(p);
+            Vertex new_nearest = score_against.nearest(p);

             if (nearest_in_other_mesh != null && new_nearest == nearest_in_other_mesh) return;
 
             if (nearest_in_other_mesh != null) unApplyQuadricToNeighbor();
             if (nearest_in_other_mesh != null && new_nearest == nearest_in_other_mesh) return;
 
             if (nearest_in_other_mesh != null) unApplyQuadricToNeighbor();

@@ -211,10 +214,9 @@ public class Mesh implements Iterable<Mesh.T> {
         public void computeError() {
             if (quadric_count == 0) {
                 if (!tilemesh) {
         public void computeError() {
             if (quadric_count == 0) {
                 if (!tilemesh) {

-                }
-                else if (nearest_in_other_mesh == null) {
+                } else if (nearest_in_other_mesh == null) {

                     if (score_against != null) {
                     if (score_against != null) {

-                        Vert ne = score_against.nearest(p);
+                        Vertex ne = score_against.nearest(p);

                         oldscore = ne.fundamentalQuadric().preAndPostMultiply(p) * 100 * 10;
                     } else {
                         oldscore = 0;
                         oldscore = ne.fundamentalQuadric().preAndPostMultiply(p) * 100 * 10;
                     } else {
                         oldscore = 0;

@@ -315,7 +317,7 @@ public class Mesh implements Iterable<Mesh.T> {
                             new Visitor<T>() {
                                 public void visit(T t) {
                                     if (!good) return;
                             new Visitor<T>() {
                                 public void visit(T t) {
                                     if (!good) return;

-                                    E e = Vert.this.e;
+                                    E e = Vertex.this.e;

                                     do {
                                         if (!t.has(e.p1) && !t.has(e.p2) && e.intersects(t)) { good = false; }
                                         if (e.t != null) {
                                     do {
                                         if (!t.has(e.p1) && !t.has(e.p2) && e.intersects(t)) { good = false; }
                                         if (e.t != null) {

@@ -324,7 +326,7 @@ public class Mesh implements Iterable<Mesh.T> {
                                             if (!e.t.has(t.e3().p1) && !e.t.has(t.e3().p2) && t.e3().intersects(e.t)) { good = false; }
                                         }
                                         e = e.pair.next;
                                             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 != Vert.this.e);
+                                    } while(e != Vertex.this.e);

                                 }
                             });
 
                                 }
                             });
 

@@ -353,7 +355,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public boolean move(Vec v) {
             Matrix m = Matrix.translate(v);
 
         public boolean move(Vec v) {
             Matrix m = Matrix.translate(v);

-            Vert p = this;
+            Vertex p = this;

             boolean good = true;
             do {
                 good &= p.transform(m);
             boolean good = true;
             do {
                 good &= p.transform(m);

@@ -387,11 +389,11 @@ public class Mesh implements Iterable<Mesh.T> {
         }
 
         public E getE(Point p2) {
         }
 
         public E getE(Point p2) {

-            Vert v = vertices.get(p2);
+            Vertex v = vertices.get(p2);

             if (v==null) return null;
             return getE(v);
         }
             if (v==null) return null;
             return getE(v);
         }

-        public E getE(Vert p2) {
+        public E getE(Vertex p2) {

             E e = this.e;
             do {
                 if (e==null) return null;
             E e = this.e;
             do {
                 if (e==null) return null;

@@ -411,8 +413,8 @@ public class Mesh implements Iterable<Mesh.T> {
             return norm.norm();
         }
 
             return norm.norm();
         }
 

-        public boolean isBoundTo(Vert p) {
-            Vert px = p;
+        public boolean isBoundTo(Vertex p) {
+            Vertex px = p;

             do {
                 if (px==this) return true;
                 px = px.bound_to;
             do {
                 if (px==this) return true;
                 px = px.bound_to;

@@ -420,10 +422,10 @@ public class Mesh implements Iterable<Mesh.T> {
             return false;
         }
         public void unbind() { bound_to = this; binding = Matrix.ONE; }
             return false;
         }
         public void unbind() { bound_to = this; binding = Matrix.ONE; }

-        public void bind(Vert p) { bind(p, Matrix.ONE); }
-        public void bind(Vert p, Matrix binding) {
+        public void bind(Vertex p) { bind(p, Matrix.ONE); }
+        public void bind(Vertex p, Matrix binding) {

             if (isBoundTo(p)) return;
             if (isBoundTo(p)) return;

-            Vert temp_bound_to = p.bound_to;
+            Vertex temp_bound_to = p.bound_to;

             Matrix temp_binding = p.binding;
             p.bound_to = this.bound_to;
             p.binding = binding.times(this.binding); // FIXME: may have order wrong here
             Matrix temp_binding = p.binding;
             p.bound_to = this.bound_to;
             p.binding = binding.times(this.binding); // FIXME: may have order wrong here

@@ -475,7 +477,7 @@ public class Mesh implements Iterable<Mesh.T> {
     /** [UNIQUE] an edge */
     public final class E implements Comparable<E> {
 
     /** [UNIQUE] an edge */
     public final class E implements Comparable<E> {
 

-        public final Vert p1, p2;
+        public final Vertex p1, p2;

         T t;     // triangle to our "left"
         E prev;  // previous half-edge
         E next;  // next half-edge
         T t;     // triangle to our "left"
         E prev;  // previous half-edge
         E next;  // next half-edge

@@ -486,7 +488,7 @@ public class Mesh implements Iterable<Mesh.T> {
 
         public boolean intersects(T t) { return t.intersects(p1.p, p2.p); }
         public float comparator() {
 
         public boolean intersects(T t) { return t.intersects(p1.p, p2.p); }
         public float comparator() {

-            Vert nearest = score_against.nearest(midpoint());
+            Vertex nearest = score_against.nearest(midpoint());

             //if (t==null) return length();
             /*
             double ang = Math.abs(crossAngle());
             //if (t==null) return length();
             /*
             double ang = Math.abs(crossAngle());

@@ -513,7 +515,7 @@ public class Mesh implements Iterable<Mesh.T> {
             if (shattered || destroyed) return mid;
             shattered = true;
 
             if (shattered || destroyed) return mid;
             shattered = true;
 

-            Vert r = next.p2;
+            Vertex r = next.p2;

             E next = this.next;
             E prev = this.prev;
 
             E next = this.next;
             E prev = this.prev;
 

@@ -618,8 +620,8 @@ public class Mesh implements Iterable<Mesh.T> {
         public E(Point p1, Point p2) {
             if (vertices.get(p1) != null) throw new Error();
             if (vertices.get(p2) != null) throw new Error();
         public E(Point p1, Point p2) {
             if (vertices.get(p1) != null) throw new Error();
             if (vertices.get(p2) != null) throw new Error();

-            this.p1 = new Vert(p1);
-            this.p2 = new Vert(p2);
+            this.p1 = new Vertex(p1);
+            this.p2 = new Vertex(p2);

             this.prev = this.next = this.pair = new E(this, this, this);
             this.p1.e = this;
             this.p2.e = this.pair;
             this.prev = this.next = this.pair = new E(this, this, this);
             this.p1.e = this;
             this.p2.e = this.pair;

@@ -628,9 +630,9 @@ public class Mesh implements Iterable<Mesh.T> {
 
         /** adds a new half-edge from prev.p2 to p2 */
         public E(E prev, Point p) {
 
         /** adds a new half-edge from prev.p2 to p2 */
         public E(E prev, Point p) {

-            Vert p2;
+            Vertex p2;

             p2 = vertices.get(p);
             p2 = vertices.get(p);

-            if (p2 == null) p2 = new Vert(p);
+            if (p2 == null) p2 = new Vertex(p);

             this.p1 = prev.p2;
             this.p2 = p2;
             this.prev = prev;
             this.p1 = prev.p2;
             this.p2 = p2;
             this.prev = prev;

@@ -659,15 +661,15 @@ public class Mesh implements Iterable<Mesh.T> {
             sync();
         }
         public Point midpoint() { return new Point((p1.p.x+p2.p.x)/2, (p1.p.y+p2.p.y)/2, (p1.p.z+p2.p.z)/2); }
             sync();
         }
         public Point midpoint() { return new Point((p1.p.x+p2.p.x)/2, (p1.p.y+p2.p.y)/2, (p1.p.z+p2.p.z)/2); }

-        public boolean has(Vert v) { return v==p1 || v==p2; }
+        public boolean has(Vertex v) { return v==p1 || v==p2; }

         public float length() { return p1.p.minus(p2.p).mag(); }
         public String toString() { return p1+"->"+p2; }
 
     }
 
     public E makeE(Point p1, Point p2) {
         public float length() { return p1.p.minus(p2.p).mag(); }
         public String toString() { return p1+"->"+p2; }
 
     }
 
     public E makeE(Point p1, Point p2) {

-        Vert v1 = vertices.get(p1);
-        Vert v2 = vertices.get(p2);
+        Vertex v1 = vertices.get(p1);
+        Vertex v2 = vertices.get(p2);

         if (v1 != null && v2 != null) {
             E e = v1.getE(v2);
             if (e != null) return e;
         if (v1 != null && v2 != null) {
             E e = v1.getE(v2);
             if (e != null) return e;

@@ -740,14 +742,14 @@ public class Mesh implements Iterable<Mesh.T> {
         public E e1() { return e1; }
         public E e2() { return e1.next; }
         public E e3() { return e1.prev; }
         public E e1() { return e1; }
         public E e2() { return e1.next; }
         public E e3() { return e1.prev; }

-        public Vert v1() { return e1.p1; }
-        public Vert v2() { return e1.p2; }
-        public Vert v3() { return e1.next.p2; }
+        public Vertex v1() { return e1.p1; }
+        public Vertex v2() { return e1.p2; }
+        public Vertex v3() { return e1.next.p2; }

         public Point p1() { return e1.p1.p; }
         public Point p2() { return e1.p2.p; }
         public Point p3() { return e1.next.p2.p; }
         public boolean hasE(E e) { return e1==e || e1.next==e || e1.prev==e; }
         public Point p1() { return e1.p1.p; }
         public Point p2() { return e1.p2.p; }
         public Point p3() { return e1.next.p2.p; }
         public boolean hasE(E e) { return e1==e || e1.next==e || e1.prev==e; }

-        public boolean has(Vert v) { return v1()==v || v2()==v || v3()==v; }
+        public boolean has(Vertex v) { return v1()==v || v2()==v || v3()==v; }

 
         public boolean shouldBeDrawn() {
             if (e1().bind_to.set.size() == 0) return false;
 
         public boolean shouldBeDrawn() {
             if (e1().bind_to.set.size() == 0) return false;

diff --git a/src/edu/berkeley/qfat/MeshViewer.java b/src/edu/berkeley/qfat/MeshViewer.java
index b1f0e52..9bed900 100644 (file)
--- a/src/edu/berkeley/qfat/MeshViewer.java
+++ b/src/edu/berkeley/qfat/MeshViewer.java
@@ -15,7 +15,7 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
     public Mesh tile = new Mesh();
     public Mesh goal = new Mesh();
     public Matrix[] translations;
     public Mesh tile = new Mesh();
     public Mesh goal = new Mesh();
     public Matrix[] translations;

-    public Mesh.Vert[] points;
+    public Mesh.Vertex[] points;

 
 
     public boolean tileon = true;
 
 
     public boolean tileon = true;

@@ -54,7 +54,7 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
             Vec normal = t.norm();
             pw.println("facet normal " + normal.x + " " + normal.y + " " + normal.z);
             pw.println("  outer loop");
             Vec normal = t.norm();
             pw.println("facet normal " + normal.x + " " + normal.y + " " + normal.z);
             pw.println("  outer loop");

-            for(Mesh.Vert v : new Mesh.Vert[] { t.v1(), t.v2(), t.v3() }) {
+            for(Mesh.Vertex v : new Mesh.Vertex[] { t.v1(), t.v2(), t.v3() }) {

                 pw.println("    vertex " + v.p.x + " " + v.p.y + " " + v.p.z);
             }
             pw.println("  endloop");
                 pw.println("    vertex " + v.p.x + " " + v.p.y + " " + v.p.z);
             }
             pw.println("  endloop");

@@ -266,7 +266,7 @@ public class MeshViewer implements GLEventListener, MouseListener, MouseMotionLi
             */
             /*
             if (mesh==goal)
             */
             /*
             if (mesh==goal)

-                for(Mesh.Vert p : new Mesh.Vert[] { t.v1(), t.v2(), t.v3() }) {
+                for(Mesh.Vertex p : new Mesh.Vertex[] { t.v1(), t.v2(), t.v3() }) {

                 gl.glDisable(GL.GL_LIGHTING);
                 gl.glBegin(GL.GL_LINES);
                 gl.glColor3f(1, 1, 1);
                 gl.glDisable(GL.GL_LIGHTING);
                 gl.glBegin(GL.GL_LINES);
                 gl.glColor3f(1, 1, 1);