projects / anneal.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
checkpoint autogen tile
[anneal.git] / src / edu / berkeley / qfat / Main.java
diff --git a/src/edu/berkeley/qfat/Main.java b/src/edu/berkeley/qfat/Main.java
index 5d86d71..2af52bf 100644 (file)
--- a/src/edu/berkeley/qfat/Main.java
+++ b/src/edu/berkeley/qfat/Main.java
@@ -57,9 +57,11 @@ public class Main extends MeshViewer {
     
     /** magnification factor */
     private static final float MAG = 1;
-    public static final float MATCHING_EPSILON = 0.0001f;
+    public static final float MATCHING_EPSILON = 0.001f;
 
+    private static boolean small(float f) { return Math.abs(f) < 0.001; }
     public void generateTile(Matrix[] matrices, Mesh mesh) {
+        mesh.coalesce = true;
         HashSet<HalfSpace> halfSpaces = new HashSet<HalfSpace>();
         HashSet<Polygon> polygons = new HashSet<Polygon>();
         for(Matrix m : matrices) {
@@ -67,7 +69,25 @@ public class Main extends MeshViewer {
             if (v.mag() < 0.0001) continue;
             v = v.times(0.5f);
             Point p = Point.ORIGIN.plus(v);
-            HalfSpace hs = new HalfSpace(p, Point.ORIGIN.minus(p).norm());
+            Vec v0 = v;
+            /*
+            if      (small(v.x) && small(v.y)) v = new Vec(0,0,1);
+            else if (small(v.y) && small(v.z)) v = new Vec(1,0,0);
+            else if (small(v.z) && small(v.x)) v = new Vec(0,1,0);
+            else if (small(v.x))               v = new Vec(0,v.y,0).minus(new Vec(0,0,v.z)).cross(new Vec(1,0,0));
+            else if (small(v.y))               v = new Vec(0,0,v.z).minus(new Vec(v.x,0,0)).cross(new Vec(0,1,0));
+            else if (small(v.z))               v = new Vec(v.x,0,0).minus(new Vec(0,v.y,0)).cross(new Vec(0,0,1));
+            else {
+                Point v1 = new Point(v.x, 0,   0);
+                Point v2 = new Point(0,   v.y, 0);
+                Point v3 = new Point(0,   0,   v.z);
+                v = v3.minus(v2).cross(v1.minus(v2));
+            }
+            */
+            if (v.dot(Point.ORIGIN.minus(p)) < 0) v = v.times(-1);
+
+            System.out.println(v);
+            HalfSpace hs = new HalfSpace(p, v.norm());
             halfSpaces.add(hs);
             polygons.add(new Polygon(hs));
         }
@@ -108,7 +128,7 @@ public class Main extends MeshViewer {
 
         // rotate to align major axis -- this probably needs to be done by a human.
         //goal.transform(Matrix.rotate(new Vec(0, 0, 1), (float)(Math.PI/2)));
-        goal.transform(Matrix.rotate(new Vec(0, 1, 0), (float)(Math.PI/2)));
+
 
         float goal_width  = goal.diagonal().dot(new Vec(1, 0, 0));
         float goal_height = goal.diagonal().dot(new Vec(0, 1, 0));
@@ -120,30 +140,48 @@ public class Main extends MeshViewer {
           float depth  = (float)0.3;
         */
         
-        float width  = (float)0.7;
+        float width  = (float)0.8;
         float depth  = (float)0.08;
         float height = (float)0.4;
 
         float rshift =   width/2;
         float lshift = -(width/2);
-
-        //float halfup = height/2;
         float halfup = 0;
-
+        //float shift = height/2;
+        //width = (width*2)/3;
+        float shift = 0;
         translations = new Matrix[] {
 
-            //Matrix.translate(new Vec(lshift,  depth,    0)),
-            //Matrix.translate(new Vec(rshift,  depth,    0)),
-            //Matrix.translate(new Vec(lshift, -depth,    0)),
-            //Matrix.translate(new Vec(rshift, -depth,    0)),
-
+            Matrix.translate(new Vec(lshift/2,  depth,    -shift)),
+            Matrix.translate(new Vec(rshift/2,  depth,    -shift)),
+            Matrix.translate(new Vec(lshift/2, -depth,    -shift)),
+            Matrix.translate(new Vec(rshift/2, -depth,    -shift)),
+
+            Matrix.translate(new Vec(lshift,  depth/2,    -shift)),
+            Matrix.translate(new Vec(rshift,  depth/2,    -shift)),
+            Matrix.translate(new Vec(lshift, -depth/2,    -shift)),
+            Matrix.translate(new Vec(rshift, -depth/2,    -shift)),
+
+
+            /*
+            Matrix.translate(new Vec(lshift,  depth,    -shift)),
+            Matrix.translate(new Vec(rshift,  depth,    -shift)),
+            Matrix.translate(new Vec(lshift, -depth,    -shift)),
+            Matrix.translate(new Vec(rshift, -depth,    -shift)),
+            */
+            /*
+            Matrix.translate(new Vec(lshift,  depth,    shift)),
+            Matrix.translate(new Vec(rshift,  depth,    shift)),
+            Matrix.translate(new Vec(lshift, -depth,    shift)),
+            Matrix.translate(new Vec(rshift, -depth,    shift)),
+            */
             //Matrix.translate(new Vec(0,  depth,    0)).times(Matrix.rotate(new Vec(0, 0, 1), (float)Math.PI)),
             //Matrix.translate(new Vec(0, -depth,    0)).times(Matrix.rotate(new Vec(0, 0, 1), (float)Math.PI)),
             //Matrix.translate(new Vec(0,   0,    height)).times(Matrix.rotate(new Vec(0, 0, 1), (float)Math.PI)),
             //Matrix.translate(new Vec(0,   0,   -height)).times(Matrix.rotate(new Vec(0, 0, 1), (float)Math.PI)),
 
-            Matrix.translate(new Vec(0,  depth, 0)),
-            Matrix.translate(new Vec(0, -depth, 0)),
+            //Matrix.translate(new Vec(0,  depth, 0)),
+            //Matrix.translate(new Vec(0, -depth, 0)),
             Matrix.translate(new Vec(0,      0,  height)),
             Matrix.translate(new Vec(0,      0, -height)),
 
@@ -157,9 +195,43 @@ public class Main extends MeshViewer {
             Matrix.translate(new Vec( width,           0,    0)),
             Matrix.translate(new Vec(-width,           0,    0)),
 
+            Matrix.ONE
+        };
+
+        float unit = 0.1f;
+        float r = unit/2;
+        float sin = (float)(unit * Math.sin(Math.PI/3));
+        float cos = (float)(unit * Math.cos(Math.PI/3));
+        float x = (float)(r*Math.tan(Math.PI/6));
+        float z = (float)(r/Math.cos(Math.PI/6));
+        height = 2*r*(float)Math.sqrt(2f/3f);
+
+
+        r *= 0.3f;
+        cos *= 0.3f;
+        unit *= 0.3f;
+
+
+        /*
+        sin *= 0.3f;
+        x *= 0.3f;
+        z *= 0.3f;
+        */
+        translations = new Matrix[] {
+            Matrix.translate(new Vec(-unit, 0, 0)),
+            Matrix.translate(new Vec( unit, 0, 0)),
+            Matrix.translate(new Vec(-cos,  0,  sin)),
+            Matrix.translate(new Vec( cos,  0,  sin)),
+            Matrix.translate(new Vec(-cos,  0, -sin)),
+            Matrix.translate(new Vec( cos,  0, -sin)),
+            Matrix.translate(new Vec( 0,  height, z)),
+            Matrix.translate(new Vec(-r,  height, -x)),
+            Matrix.translate(new Vec( r,  height, -x)),
+            Matrix.translate(new Vec( 0, -height, -z)),
+            Matrix.translate(new Vec(-r, -height, x)),
+            Matrix.translate(new Vec( r, -height, x)),
         };
 
-        generateTile(translations, tile);
 
         /*
         translations = new Matrix[] {
@@ -192,10 +264,11 @@ public class Main extends MeshViewer {
             Matrix.translate(new Vec(-width,           0,    0)),
 
         };
-
+        */
         //   
 
 
+        //generateTile(translations, tile);
 
         Point ltf = new Point(lshift,  (depth/2),  (height/2));
         Point mtf = new Point( 0.0,    (depth/2),  (height/2));
@@ -241,7 +314,7 @@ public class Main extends MeshViewer {
             mbn,
             rbn
         };
-
+        /*
 
         // top
         tile.newT(ltf, mtf, mtc, null, 1);
@@ -290,7 +363,8 @@ public class Main extends MeshViewer {
         tile.newT(mbf, ltf, lbf, null, 6);
         tile.newT(rtf, mtf, rbf, null, 6);
         tile.newT(rbf, mtf, mbf, null, 6);
-
+*/
+        /*
         HashSet<Mesh.E> es = new HashSet<Mesh.E>();
         for(Mesh.T t : tile) {
             es.add(t.e1());
@@ -305,7 +379,7 @@ public class Main extends MeshViewer {
         }
         */
 
-        /*
+
          height = 4;
          width  = 4;
          depth  = 1;
@@ -379,22 +453,32 @@ public class Main extends MeshViewer {
              new Point(-1, -1,  1),
              new Point(-1, -1, -1));
 
-        float factor = (float)Math.pow(tile.volume() / goal.volume(), 1.0/3.0);
-        goal.transform(Matrix.scale(factor/2.4f));
 
-        /*        
+
         translations = new Matrix[] {
 
             Matrix.translate(new Vec(0, 0.2f,0))
-            .times(Matrix.rotate(new Vec(0,1,0), (float)( 1*Math.PI/2))),
+            .times(Matrix.rotate(new Vec(0,1,0), (float)(1*Math.PI/2))),
 
             Matrix.translate(new Vec(0,-0.2f,0))
-            .times(Matrix.rotate(new Vec(0,1,0), (float)(-1*Math.PI/2))),
+            .times(Matrix.rotate(new Vec(0,1,0), (float)(1*Math.PI/2))),
 
-            //Matrix.translate(new Vec( 0.2f,0,0))
-            //.times(Matrix.rotate(new Vec(1,0,0), (float)( 1*Math.PI/2))),
-            //Matrix.translate(new Vec(-0.2f,0,0))
-            //.times(Matrix.rotate(new Vec(1,0,0), (float)(-1*Math.PI/2))),
+            Matrix.translate(new Vec( 0.2f,0,0))
+            .times(Matrix.rotate(new Vec(1,0,0), (float)(-1*Math.PI/2))),
+
+            Matrix.translate(new Vec(-0.2f,0,0))
+            .times(Matrix.rotate(new Vec(1,0,0), (float)(-1*Math.PI/2))),
+
+            Matrix.rotate(new Vec(0,0,1), (float)(2*Math.PI/2)),
+            /*
+            Matrix.rotate(new Vec(0,0,1), (float)(1*Math.PI/2)),
+
+            Matrix.rotate(new Vec(0,0,1), (float)(3*Math.PI/2)),
+
+            Matrix.rotate(new Vec(1,0,0), (float)(2*Math.PI/2)),
+            */
+            //Matrix.rotate(new Vec(0,0,1), (float)(2*Math.PI/2)),
+            //Matrix.scale(1,-1,1),
 
             //Matrix.translate(new Vec( 0.2f, 0,0))
             //.times(Matrix.rotate(new Vec(0,0,1), (float)( 1*Math.PI/2)))
@@ -420,37 +504,59 @@ public class Main extends MeshViewer {
 
             Matrix.ONE,
         };
-        */
-            
+
+
+           
         for(Matrix m1 : translations) {
         for(Matrix m2 : translations) {
             for(Mesh.T t1 : tile) {
                 for(Mesh.T t2 : tile) {
-                    if (t1==t2) continue;
 
                     Matrix m = m1.inverse().times(m2);
-                    if ((t1.v1().p.times(m).minus(t2.v1().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v2().p.times(m).minus(t2.v3().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v3().p.times(m).minus(t2.v2().p).mag() < MATCHING_EPSILON)) {
+                    if ((t1.v1().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v2().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON) &&
+                        (t1.v3().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON)) {
                         t2.e3().bindEdge(t1.e1(), m);
                         t2.e2().bindEdge(t1.e2(), m);
                         t2.e1().bindEdge(t1.e3(), m);
                     }
-                    if ((t1.v2().p.times(m).minus(t2.v1().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v3().p.times(m).minus(t2.v3().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v1().p.times(m).minus(t2.v2().p).mag() < MATCHING_EPSILON)) {
+                    if ((t1.v2().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v3().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON) &&
+                        (t1.v1().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON)) {
                         t2.e3().bindEdge(t1.e2(), m);
                         t2.e2().bindEdge(t1.e3(), m);
                         t2.e1().bindEdge(t1.e1(), m);
                     }
-                    if ((t1.v3().p.times(m).minus(t2.v1().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v1().p.times(m).minus(t2.v3().p).mag() < MATCHING_EPSILON) &&
-                        (t1.v2().p.times(m).minus(t2.v2().p).mag() < MATCHING_EPSILON)) {
+                    if ((t1.v3().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v1().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON) &&
+                        (t1.v2().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON)) {
                         t2.e3().bindEdge(t1.e3(), m);
                         t2.e2().bindEdge(t1.e1(), m);
                         t2.e1().bindEdge(t1.e2(), m);
                     }
 
+                    if ((t1.v1().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v2().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON) &&
+                        (t1.v3().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON)) {
+                        t2.e1().bindEdge(t1.e1().pair, m);
+                        t2.e2().bindEdge(t1.e2().pair, m);
+                        t2.e3().bindEdge(t1.e3().pair, m);
+                    }
+                    if ((t1.v2().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v3().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON) &&
+                        (t1.v1().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON)) {
+                        t2.e2().bindEdge(t1.e1().pair, m);
+                        t2.e3().bindEdge(t1.e2().pair, m);
+                        t2.e1().bindEdge(t1.e3().pair, m);
+                    }
+                    if ((t1.v3().p.times(m).distance(t2.v1().p) < MATCHING_EPSILON) &&
+                        (t1.v1().p.times(m).distance(t2.v2().p) < MATCHING_EPSILON) &&
+                        (t1.v2().p.times(m).distance(t2.v3().p) < MATCHING_EPSILON)) {
+                        t2.e3().bindEdge(t1.e1().pair, m);
+                        t2.e1().bindEdge(t1.e2().pair, m);
+                        t2.e2().bindEdge(t1.e3().pair, m);
+                    }
+
                 }
             }
         }
@@ -461,6 +567,9 @@ public class Main extends MeshViewer {
         // rescale to match volume
 
 
+        float factor = (float)Math.pow(tile.volume() / goal.volume(), 1.0/3.0);
+        goal.transform(Matrix.scale(factor/2.1f));
+        goal.transform(Matrix.rotate(new Vec(0, 1, 0), (float)(Math.PI/2)));
 
         // translate to match centroid
         goal.transform(Matrix.translate(tile.centroid().minus(goal.centroid())));
@@ -524,7 +633,7 @@ public class Main extends MeshViewer {
 
         //System.out.println(v.mag() + " " + max);
         boolean good = p.move(m, false);
-        //if (!good) { /*misses++;*/ return; }
+        if (!good) { /*misses++;*/ return; }
 
         double new_tile_error = tile.error();
         double new_goal_error = goal.error();
@@ -549,6 +658,7 @@ public class Main extends MeshViewer {
             p.move(Matrix.translate(v.times(-1)), true);
             misses++;
         }
+        p.reComputeErrorAround();
     }
 
     float hits = 0;
@@ -638,7 +748,10 @@ public class Main extends MeshViewer {
                 System.out.println("temp="+temp + " ratio="+(Math.ceil(acceptance*100)) + " " +
                                    "points_per_second=" +
                                    (count*1000)/((double)(System.currentTimeMillis()-then)));
-                for(Mesh.Vertex p : goal.vertices()) p.recomputeFundamentalQuadricIfNeighborChanged();
+                for(Mesh.Vertex p : goal.vertices()) {
+                    p.quadricStale = true;
+                    p.recomputeFundamentalQuadricIfNeighborChanged();
+                }
 
                 synchronized(safeTriangles) {
                     safeTriangles.clear();
Space Annealer