X-Git-Url: http://git.megacz.com/?p=anneal.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fqfat%2FMain.java;h=2af52bf8a6b8da1d2b73a870510d3d643e3ce0a9;hp=0246692022dbb42ad6c479dbf69b7e720aeed264;hb=3fa3102dca9b7eee00ea28a63cc906951c26053b;hpb=0f91cadcd5a273c8c312c1d054fe9de1a82ebf8e diff --git a/src/edu/berkeley/qfat/Main.java b/src/edu/berkeley/qfat/Main.java index 0246692..2af52bf 100644 --- a/src/edu/berkeley/qfat/Main.java +++ b/src/edu/berkeley/qfat/Main.java @@ -7,15 +7,113 @@ import javax.media.opengl.glu.*; import java.util.*; import edu.berkeley.qfat.geom.*; import edu.berkeley.qfat.geom.Point; +import edu.berkeley.qfat.geom.Polygon; + +// TO DO: +// - real anneal +// - solve self-intersection problem +// - get a better test model? +// - symmetry constraints withing the tile +// - rotation matrices +// - overbinding results in forced equational constraints on the leader +// - shatter in invertd-triforce pattern brian mentioned +// - aspect ratio? non-uniform deformation? +// - rotational alignment + +// - movie-style user interface like +// http://www.coleran.com/markcoleranreell.html ? + +// - consider recasting the Shewchuk predicates in Java? +// http://www.cs.cmu.edu/afs/cs/project/quake/public/code/predicates.c + +/* + blender keys + - middle mouse = option+click + - right mouse = command+click + + 3,7,1 = view along axes (control for opp direction) + 4, 8, 7, 2 = rotate in discrete increments (+control to translate) + middle trag: rotate space + shift+middle drag: translate space + wheel: zoom + home: home view: take current angle, zoom to whole scnee + 5 = ortho vs non-ortho + +*/ + +/* + + + */ + // FIXME: re-orient goal (how?) public class Main extends MeshViewer { + public static int verts = 1; + public static final Random random = new Random(); /** magnification factor */ private static final float MAG = 1; + 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 halfSpaces = new HashSet(); + HashSet polygons = new HashSet(); + for(Matrix m : matrices) { + Vec v = m.getTranslationalComponent(); + if (v.mag() < 0.0001) continue; + v = v.times(0.5f); + Point p = Point.ORIGIN.plus(v); + 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)); + } + for(Polygon p : polygons) { + System.out.println(p.plane.norm + " " + p.plane.dvalue); + for(HalfSpace hs : halfSpaces) { + if (p.plane==hs) continue; + p = p.intersect(hs); + } + p.tesselate(mesh); + } + } + + private void quad(Mesh mesh, Matrix m, Point p1_, Point p2_, Point p3_, Point p4_) { + Point p1 = m.times(p1_); + Point p2 = m.times(p2_); + Point p3 = m.times(p3_); + Point p4 = m.times(p4_); + Point c = new Point((p1.x+p2.x+p3.x+p4.x)/4, + (p1.y+p2.y+p3.y+p4.y)/4, + (p1.z+p2.z+p3.z+p4.z)/4); + mesh.newT(p1, p2, c, null, 0); + mesh.newT(p2, p3, c, null, 0); + mesh.newT(p3, p4, c, null, 0); + mesh.newT(p4, p1, c, null, 0); + } public Main(StlFile stlf, Frame f) { super(f); @@ -25,144 +123,463 @@ public class Main extends MeshViewer { Point p1 = new Point(stlf.coordArray[i+1].x * MAG, stlf.coordArray[i+1].y * MAG, stlf.coordArray[i+1].z * MAG); Point p2 = new Point(stlf.coordArray[i+2].x * MAG, stlf.coordArray[i+2].y * MAG, stlf.coordArray[i+2].z * MAG); Vec n = new Vec(stlf.normArray[i/3].x * MAG, stlf.normArray[i/3].y * MAG, stlf.normArray[i/3].z * MAG); - Mesh.T t = goal.newT(p0, p1, p2, n); + Mesh.T t = goal.newT(p0, p1, p2, n, 0); } // rotate to align major axis -- this probably needs to be done by a human. - goal.transform(new Matrix(new Vec(0, 0, 1), (float)(Math.PI/2))); + //goal.transform(Matrix.rotate(new Vec(0, 0, 1), (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)); float goal_depth = goal.diagonal().dot(new Vec(0, 0, 1)); - float width = (float)0.6; - float height = (float)0.08; - float depth = (float)0.3; + /* + float width = (float)0.6; + float height = (float)0.08; + float depth = (float)0.3; + */ + + 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 = 0; + //float shift = height/2; + //width = (width*2)/3; + float shift = 0; translations = new Matrix[] { - new Matrix(new Vec(-(width/2), height, 0)), - new Matrix(new Vec( (width/2), height, 0)), - new Matrix(new Vec(-(width/2), -height, 0)), - new Matrix(new Vec( (width/2), -height, 0)), - new Matrix(new Vec(-(width/2), 0, depth)), - new Matrix(new Vec( (width/2), 0, depth)), - new Matrix(new Vec(-(width/2), 0, -depth)), - new Matrix(new Vec( (width/2), 0, -depth)), - - new Matrix(new Vec( width, 0, 0)), - new Matrix(new Vec(-width, 0, 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)), + */ /* - new Matrix(new Vec( 0, 0, depth)), - new Matrix(new Vec( 0, 0, -depth)), + 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, 0, height)), + Matrix.translate(new Vec(0, 0, -height)), + + //Matrix.translate(new Vec(lshift, depth, height/2)), + //Matrix.translate(new Vec(lshift, depth, -height/2)), + //Matrix.translate(new Vec(rshift, -depth, height/2)), + //Matrix.translate(new Vec(rshift, -depth, -height/2)), + //Matrix.translate(new Vec(rshift, 0, height)), + //Matrix.translate(new Vec(rshift, 0, -height)), + + 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)), + }; + + + /* + translations = new Matrix[] { + + //Matrix.translate(new Vec(lshift, depth, halfup)), + //Matrix.translate(new Vec(rshift, depth, halfup)), + //Matrix.translate(new Vec(lshift, -depth, halfup)), + //Matrix.translate(new Vec(rshift, -depth, halfup)), + + + //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, 0, height)), + //Matrix.translate(new Vec(0, 0, -height)), + + //Matrix.translate(new Vec(lshift, depth, height/2)), + //Matrix.translate(new Vec(lshift, depth, -height/2)), + //Matrix.translate(new Vec(rshift, -depth, height/2)), + //Matrix.translate(new Vec(rshift, -depth, -height/2)), + //Matrix.translate(new Vec(rshift, 0, height)), + //Matrix.translate(new Vec(rshift, 0, -height)), + + Matrix.translate(new Vec( width, 0, 0)), + 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)); + Point rtf = new Point(rshift, (depth/2), (height/2)); + Point lbf = new Point(lshift, -(depth/2), (height/2)); + Point mbf = new Point( 0.0, -(depth/2), (height/2)); + Point rbf = new Point(rshift, -(depth/2), (height/2)); + + Point ltc = new Point(lshift, (depth/2), 0); + Point mtc = new Point( 0.0, (depth/2), 0); + Point rtc = new Point(rshift, (depth/2), 0); + Point lbc = new Point(lshift, -(depth/2), 0); + Point mbc = new Point( 0.0, -(depth/2), 0); + Point rbc = new Point(rshift, -(depth/2), 0); + + Point ltn = new Point(lshift, (depth/2), -(height/2)); + Point mtn = new Point( 0.0, (depth/2), -(height/2)); + Point rtn = new Point(rshift, (depth/2), -(height/2)); + Point lbn = new Point(lshift, -(depth/2), -(height/2)); + Point mbn = new Point( 0.0, -(depth/2), -(height/2)); + Point rbn = new Point(rshift, -(depth/2), -(height/2)); - Point ltf = new Point(-(width/2), (height/2), (depth/2)); - Point mtf = new Point( 0.0, (height/2), (depth/2)); - Point rtf = new Point( (width/2), (height/2), (depth/2)); - Point ltn = new Point(-(width/2), (height/2), -(depth/2)); - Point mtn = new Point( 0.0, (height/2), -(depth/2)); - Point rtn = new Point( (width/2), (height/2), -(depth/2)); - Point lbf = new Point(-(width/2), -(height/2), (depth/2)); - Point mbf = new Point( 0.0, -(height/2), (depth/2)); - Point rbf = new Point( (width/2), -(height/2), (depth/2)); - Point lbn = new Point(-(width/2), -(height/2), -(depth/2)); - Point mbn = new Point( 0.0, -(height/2), -(depth/2)); - Point rbn = new Point( (width/2), -(height/2), -(depth/2)); Point[] points = new Point[] { ltf, mtf, rtf, - ltn, - mtn, - rtn, lbf, mbf, rbf, + + ltc, + mtc, + rtc, + lbc, + mbc, + rbc, + + ltn, + mtn, + rtn, lbn, mbn, rbn }; - + /* // top - tile.newT(ltf, mtf, mtn, null); - tile.newT(mtn, ltn, ltf, null); - tile.newT(mtf, rtf, rtn, null); - tile.newT(rtn, mtn, mtf, null); + tile.newT(ltf, mtf, mtc, null, 1); + tile.newT(mtc, ltc, ltf, null, 1); + tile.newT(mtf, rtf, rtc, null, 1); + tile.newT(rtc, mtc, mtf, null, 1); + + tile.newT(ltc, mtc, mtn, null, 1); + tile.newT(mtn, ltn, ltc, null, 1); + tile.newT(mtc, rtc, rtn, null, 1); + tile.newT(rtn, mtn, mtc, null, 1); // bottom (swap normals) - tile.newT(mbf, lbf, mbn, null); - tile.newT(lbn, mbn, lbf, null); - tile.newT(rbf, mbf, rbn, null); - tile.newT(mbn, rbn, mbf, null); - + tile.newT(mbf, lbf, mbc, null, 2); + tile.newT(lbc, mbc, lbf, null, 2); + tile.newT(rbf, mbf, rbc, null, 2); + tile.newT(mbc, rbc, mbf, null, 2); + + tile.newT(mbc, lbc, mbn, null, 2); + tile.newT(lbn, mbn, lbc, null, 2); + + tile.newT(rbc, mbc, rbn, null, 2); + tile.newT(mbn, rbn, mbc, null, 2); + + // left - tile.newT(ltf, ltn, lbn, null); - tile.newT(lbn, lbf, ltf, null); + tile.newT(ltf, ltc, lbc, null, 3); + tile.newT(lbc, lbf, ltf, null, 3); + tile.newT(ltc, ltn, lbn, null, 3); + tile.newT(lbn, lbc, ltc, null, 3); // right (swap normals) - tile.newT(rtn, rtf, rbn, null); - tile.newT(rbf, rbn, rtf, null); + tile.newT(rtc, rtf, rbc, null, 4); + tile.newT(rbf, rbc, rtf, null, 4); + tile.newT(rtn, rtc, rbn, null, 4); + tile.newT(rbc, rbn, rtc, null, 4); // front - tile.newT(ltn, mtn, mbn, null); - tile.newT(ltn, mbn, lbn, null); - tile.newT(mtn, rtn, rbn, null); - tile.newT(mtn, rbn, mbn, null); + tile.newT(ltn, mtn, mbn, null, 5); + tile.newT(ltn, mbn, lbn, null, 5); + tile.newT(mtn, rtn, rbn, null, 5); + tile.newT(mtn, rbn, mbn, null, 5); // back - tile.newT(mtf, ltf, mbf, null); - tile.newT(mbf, ltf, lbf, null); - tile.newT(rtf, mtf, rbf, null); - tile.newT(rbf, mtf, mbf, null); + tile.newT(mtf, ltf, mbf, null, 6); + tile.newT(mbf, ltf, lbf, null, 6); + tile.newT(rtf, mtf, rbf, null, 6); + tile.newT(rbf, mtf, mbf, null, 6); +*/ + /* + HashSet es = new HashSet(); + for(Mesh.T t : tile) { + es.add(t.e1()); + es.add(t.e2()); + es.add(t.e3()); + } + for(Mesh.E e : es) { + if (e.p1.p.x == e.p2.p.x && e.p1.p.y == e.p2.p.y) continue; + if (e.p1.p.z == e.p2.p.z && e.p1.p.y == e.p2.p.y) continue; + if (e.p1.p.x == e.p2.p.x && e.p1.p.z == e.p2.p.z) continue; + e.shatter(); + } + */ + + + height = 4; + width = 4; + depth = 1; + + Matrix mm = Matrix.scale(0.1f); + // top + quad(tile, mm, + new Point( 2, 2, 0), + new Point( 1, 1, -1), + new Point(-1, 1, -1), + new Point(-2, 2, 0)); + quad(tile, mm, + new Point(-2, 2, 0), + new Point(-1, 1, 1), + new Point( 1, 1, 1), + new Point( 2, 2, 0)); + quad(tile, mm, + new Point( 1, 1, -1), + new Point( 1, 1, 1), + new Point(-1, 1, 1), + new Point(-1, 1, -1)); + + // bottom + quad(tile, mm, + new Point(-2, -2, 0), + new Point(-1, -1, -1), + new Point( 1, -1, -1), + new Point( 2, -2, 0)); + quad(tile, mm, + new Point( 2, -2, 0), + new Point( 1, -1, 1), + new Point(-1, -1, 1), + new Point(-2, -2, 0)); + quad(tile, mm, + new Point(-1, -1, -1), + new Point(-1, -1, 1), + new Point( 1, -1, 1), + new Point( 1, -1, -1)); + + // left + quad(tile, mm, + new Point( 2, -2, 0), + new Point( 1, -1, -1), + new Point( 1, 1, -1), + new Point( 2, 2, 0)); + quad(tile, mm, + new Point( 2, 2, 0), + new Point( 1, 1, 1), + new Point( 1, -1, 1), + new Point( 2, -2, 0)); + quad(tile, mm, + new Point( 1, -1, -1), + new Point( 1, -1, 1), + new Point( 1, 1, 1), + new Point( 1, 1, -1)); + + // bottom + quad(tile, mm, + new Point(-2, 2, 0), + new Point(-1, 1, -1), + new Point(-1, -1, -1), + new Point(-2, -2, 0)); + quad(tile, mm, + new Point(-2, -2, 0), + new Point(-1, -1, 1), + new Point(-1, 1, 1), + new Point(-2, 2, 0)); + quad(tile, mm, + new Point(-1, 1, -1), + new Point(-1, 1, 1), + new Point(-1, -1, 1), + new Point(-1, -1, -1)); + + + + translations = new Matrix[] { + + Matrix.translate(new Vec(0, 0.2f,0)) + .times(Matrix.rotate(new Vec(0,1,0), (float)(1*Math.PI/2))), - for(Matrix m : translations) { + Matrix.translate(new Vec(0,-0.2f,0)) + .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.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))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 3*Math.PI/2))), + + //Matrix.translate(new Vec(-0.2f, 0,0)) + //.times(Matrix.rotate(new Vec(0,0,1), (float)( 3*Math.PI/2))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 3*Math.PI/2))), + + //Matrix.rotate(new Vec(0,0,1), (float)( 0*Math.PI/2)) + //.times(Matrix.translate(new Vec(0, -0.2f, 0))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 1*Math.PI/2))), + //Matrix.rotate(new Vec(0,0,1), (float)( 1*Math.PI/2)) + //.times(Matrix.translate(new Vec(0, -0.2f, 0))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 1*Math.PI/2))), + + //Matrix.rotate(new Vec(0,0,1), (float)( 0*Math.PI/2)) + //.times(Matrix.translate(new Vec(0, -0.2f, 0))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 1*Math.PI/2))), + //Matrix.rotate(new Vec(0,0,1), (float)( 0*Math.PI/2)) + //.times(Matrix.translate(new Vec(0, -0.2f, 0))) + //.times(Matrix.rotate(new Vec(0,1,0), (float)( 1*Math.PI/2))), + + Matrix.ONE, + }; + + + + for(Matrix m1 : translations) { + for(Matrix m2 : translations) { for(Mesh.T t1 : tile) { for(Mesh.T t2 : tile) { - if (t1==t2) continue; - - if ((t1.v1().p.times(m).minus(t2.v1().p).mag() < Mesh.EPSILON) && - (t1.v2().p.times(m).minus(t2.v3().p).mag() < Mesh.EPSILON) && - (t1.v3().p.times(m).minus(t2.v2().p).mag() < Mesh.EPSILON)) { - t1.e1().bind(t2.e3().pair); - t1.e2().bind(t2.e2().pair); - t1.e3().bind(t2.e1().pair); + + Matrix m = m1.inverse().times(m2); + 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).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.v2().p.times(m).minus(t2.v1().p).mag() < Mesh.EPSILON) && - (t1.v3().p.times(m).minus(t2.v3().p).mag() < Mesh.EPSILON) && - (t1.v1().p.times(m).minus(t2.v2().p).mag() < Mesh.EPSILON)) { - t1.e2().bind(t2.e3().pair); - t1.e3().bind(t2.e2().pair); - t1.e1().bind(t2.e1().pair); + 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.v3().p.times(m).minus(t2.v1().p).mag() < Mesh.EPSILON) && - (t1.v1().p.times(m).minus(t2.v3().p).mag() < Mesh.EPSILON) && - (t1.v2().p.times(m).minus(t2.v2().p).mag() < Mesh.EPSILON)) { - t1.e3().bind(t2.e3().pair); - t1.e1().bind(t2.e2().pair); - t1.e2().bind(t2.e1().pair); + + 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); + } + } } } + } - //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); - goal.transform(new Matrix(factor)); + 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(new Matrix(tile.centroid().minus(goal.centroid()))); + goal.transform(Matrix.translate(tile.centroid().minus(goal.centroid()))); + goal.makeVerticesImmutable(); //tx.e2.shatter(); //tx.e3.shatter(); - tile.bind(); + tile.rebindPoints(); //mid.move(new Vec((float)0,0,(float)-0.05)); //ltn.move(new Vec((float)0,0,(float)-0.05)); @@ -173,81 +590,192 @@ public class Main extends MeshViewer { System.out.println("tile volume: " + tile.volume()); System.out.println("goal volume: " + goal.volume()); - tile.score_against = goal; - goal.score_against = tile; + tile.error_against = goal; + goal.error_against = tile; } - public synchronized void breakit() { - if (verts > 200) return; + public void breakit() { + int oldverts = verts; + System.out.println("doubling vertices."); PriorityQueue es = new PriorityQueue(); - for(Mesh.E e : tile.edges()) es.add(e); - for(int i=0; i<10; i++) { + for(Mesh.T t : tile) { + es.add(t.e1()); + es.add(t.e2()); + es.add(t.e3()); + Thread.yield(); + repaint(); + } + for(int i=0; i 0) { + while (breaks>0) { + breaks--; + breakit(); + } + seek_upward = true; + } else if (acceptance > 0.96) gamma = 0.1f; + else if (acceptance > 0.9) gamma = 0.2f; + else if (acceptance > 0.8) gamma = 0.3f; + else if (acceptance > 0.6) gamma = 0.4f; + else if (acceptance > 0.3) gamma = 0.6f; + else if (acceptance > 0.15) gamma = 0.9f; + else if (acceptance > 0.05) gamma = 0.94f; + else if (acceptance > 0.01) gamma = 0.98f; + else { /*breaks++;*/ } + + /* + if (seek_upward) { + if (acceptance > 0.2) seek_upward = false; + else gamma = 2-gamma; + } + */ + + if (anneal) + temp = temp * gamma; + + + HashSet hs = new HashSet(); + 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<400; i++) { + if (anneal) { + count++; + Mesh.Vertex v = pts[Math.abs(random.nextInt()) % pts.length]; + rand(temp,v); + v.recomputeFundamentalQuadricIfStale(); + v.recomputeFundamentalQuadricIfNeighborChanged(); + } + Thread.yield(); + repaint(); + } + + /* + PriorityQueue es = new PriorityQueue(); + for(Mesh.T t : tile) { + float max = 5; + for(Mesh.E e : new Mesh.E[] { t.e1(), t.e2(), t.e3() }) { + if (e==null) continue; + if (e.stretchRatio() > max) es.add(e); + if (t.aspect() < 0.1 && e.length()>e.next.length() && e.length()>e.prev.length()) es.add(e); } - goal.unscore(); - tile.unscore(); - goal.fundamental(); - tile.fundamental(); - goal.rescore(); - tile.rescore(); + } + for(int i=0; i<5; i++) { + Mesh.E e = es.poll(); + if (e==null) break; + e.shatter(); + } + + + tile.rebindPoints(); + */ + + + 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.quadricStale = true; + p.recomputeFundamentalQuadricIfNeighborChanged(); + } + + synchronized(safeTriangles) { + safeTriangles.clear(); + for(Mesh.T t : tile) + //if (t.shouldBeDrawn()) + safeTriangles.add(t); + } } - breakit(); - } + } } + public static void main(String[] s) throws Exception { StlFile stlf = new StlFile(); - stlf.load("simplefish.stl"); + stlf.load("torus.stl"); + //stlf.load("fish.stl"); + //stlf.load("monkey.stl"); Frame f = new Frame(); Main main = new Main(stlf, f); + f.pack(); + f.show(); + f.setSize(900, 900); + f.doLayout(); main.anneal(); } + } \ No newline at end of file