X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Fedu%2Fberkeley%2Fqfat%2FMesh.java;h=efeb89b484b9115f10f53ad0d6682b64090cef04;hb=5d34d8a30db663c0d3a6e6ebaa05744e79cc5be8;hp=13c00da4f86c943ed3cf14f0ef23fd4883114a52;hpb=facb9d3f3606b4d410b758cd031d6235237b389a;p=anneal.git diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java index 13c00da..efeb89b 100644 --- a/src/edu/berkeley/qfat/Mesh.java +++ b/src/edu/berkeley/qfat/Mesh.java @@ -11,8 +11,8 @@ import edu.berkeley.qfat.geom.Point; public class Mesh implements Iterable { - public static float EPSILON = (float)0.0001; - public static Random random = new Random(); + public static final float EPSILON = (float)0.0001; + public static final Random random = new Random(); private PointSet pointset = new PointSet(); @@ -98,7 +98,6 @@ public class Mesh implements Iterable { return (float)total; } - public class BindingGroup { public HashSet es = new HashSet(); public BindingGroup() { } @@ -122,9 +121,31 @@ public class Mesh implements Iterable { public Point centroid() { return pointset.centroid(); } public Vert nearest(Point p) { return pointset.nearest(p); } - public Vert register(Point p) { Vert v = pointset.get(p); return v==null ? new Vert(p) : v; } public final class Vert extends HasPoint { public Point p; + E e; // some edge *leaving* this point + + Vert bound_to = this; + + /** the nearest vertex in the "score_against" mesh */ + Vert 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; + + Matrix binding = new Matrix(); + float oldscore = 0; + boolean inserted = false; + + public Matrix errorQuadric() { return quadric; } + + private Matrix fundamentalQuadric = null; + public Matrix fundamentalQuadric() { + if (fundamentalQuadric == null) recomputeFundamentalQuadric(); + return fundamentalQuadric; + } + public Point getPoint() { return p; } private Vert(Point p) { this.p = p; @@ -132,56 +153,63 @@ public class Mesh implements Iterable { pointset.add(this); } public float score() { return oldscore; } + + public void recomputeFundamentalQuadric() { + unscore(); + Matrix m = Matrix.ZERO; + E e = this.e; + do { + T t = e.t; + m = m.plus(t.norm().fundamentalQuadric(t.centroid())); + e = e.pair.next; + } while(e != this.e); + fundamentalQuadric = m; + rescore(); + } + public void unscore() { - if (watch == null) return; - watch.watch_x -= p.x; - watch.watch_y -= p.y; - watch.watch_z -= p.z; - watch.watch_count--; - if (watch.watch_count==0) { - watch.watch_x = 0; - watch.watch_y = 0; - watch.watch_z = 0; - } - watch = null; + if (nearest_in_other_mesh == null) return; + if (fundamentalQuadric == null) return; + nearest_in_other_mesh.quadric = nearest_in_other_mesh.quadric.minus(fundamentalQuadric); + nearest_in_other_mesh.quadric_count--; + if (nearest_in_other_mesh.quadric_count==0) + nearest_in_other_mesh.quadric = Matrix.ZERO; + nearest_in_other_mesh = null; } - public Vert partner() { return watch==null ? this : watch; } - public Vert watchback() { return watch_count==0 ? partner() : - register(new Point(watch_x/watch_count, watch_y/watch_count, watch_z/watch_count)); } + public void rescore() { if (score_against == null) return; score -= oldscore; oldscore = 0; - if (watch != null) unscore(); - Vert po = this; - if (watch == null) { - watch = score_against.nearest(po.p); + if (nearest_in_other_mesh != null) unscore(); + if (nearest_in_other_mesh == null) { + nearest_in_other_mesh = score_against.nearest(p); // don't attract to vertices that face the other way - if (watch.e == null || watch.norm().dot(norm()) < 0) { - watch = null; + if (nearest_in_other_mesh.e == null || nearest_in_other_mesh.norm().dot(norm()) < 0) { + nearest_in_other_mesh = null; } else { - watch.watch_x += po.p.x; - watch.watch_y += po.p.y; - watch.watch_z += po.p.z; - watch.watch_count++; + nearest_in_other_mesh.quadric = nearest_in_other_mesh.quadric.plus(fundamentalQuadric()); + nearest_in_other_mesh.quadric_count++; } } + /* double s1, s2; - if (watch_count==0) s1 = 0; - else s1 = p.distance(watch_x/watch_count, watch_y/watch_count, watch_z/watch_count); - s2 = watch==null ? 0 : po.p.distance(watch.p); + if (quadric_count==0) s1 = 0; + else s1 = p.distance(quadric_x/quadric_count, quadric_y/quadric_count, quadric_z/quadric_count); + s2 = quadric==null ? 0 : po.p.distance(quadric.p); oldscore = (float)(s1 + s2); + */ + oldscore = quadric.preAndPostMultiply(p); + score += oldscore; } /** does NOT update bound pairs! */ public boolean transform(Matrix m) { - // FIXME: screws up kdtree - // FIXME: screws up hashmap unscore(); try { if (pointset.get(this.p)==null) throw new Error(); @@ -190,12 +218,22 @@ public class Mesh implements Iterable { float newy = m.e*p.x + m.f*p.y + m.g*p.z + m.h; float newz = m.i*p.x + m.j*p.y + m.k*p.z + m.l; this.p = new Point(newx, newy, newz); - // FIXME: what if we move onto exactly where another point is? pointset.add(this); } catch (Exception e) { throw new RuntimeException(e); } + fundamentalQuadric = fundamentalQuadric(); rescore(); + + // recompute fundamental quadrics of all vertices sharing a face + E e = this.e; + do { + e.t.v1().recomputeFundamentalQuadric(); + e.t.v2().recomputeFundamentalQuadric(); + e.t.v3().recomputeFundamentalQuadric(); + e = e.pair.next; + } while(e != this.e); + boolean good = true; /* for(T t : this) { @@ -225,15 +263,6 @@ public class Mesh implements Iterable { return good; } - public E makeE(Vert p2) { - E e = getE(p2); - if (e != null) return e; - e = p2.getE(this); - if (this.e == null && p2.e == null) return this.e = new E(this, p2); - if (this.e == null && p2.e != null) return p2.makeE(this).pair; - return new E(getFreeIncident(), p2); - } - public E getFreeIncident() { E ret = getFreeIncident(e, e); if (ret != null) return ret; @@ -251,6 +280,11 @@ public class Mesh implements Iterable { return null; } + public E getE(Point p2) { + Vert v = pointset.get(p2); + if (v==null) return null; + return getE(v); + } public E getE(Vert p2) { E e = this.e; do { @@ -290,17 +324,6 @@ public class Mesh implements Iterable { } while(e != this.e); return norm.norm(); } - - Vert bound_to = this; - int watch_count; - float watch_x; - float watch_y; - float watch_z; - Vert watch; - E e; // some edge *leaving* this point - Matrix binding = new Matrix(); - float oldscore = 0; - boolean inserted = false; } /** [UNIQUE] an edge */ @@ -312,6 +335,7 @@ public class Mesh implements Iterable { E next; // next half-edge E pair; // partner half-edge public BindingGroup bg = new BindingGroup(this); + boolean shattered = false; public int compareTo(E e) { return e.length() > length() ? 1 : -1; } @@ -327,9 +351,8 @@ public class Mesh implements Iterable { } } - boolean shattered = false; - public Vert shatter() { return shatter(register(midpoint()), null, null); } - public Vert shatter(Vert mid, BindingGroup bg1, BindingGroup bg2) { + public Point shatter() { return shatter(midpoint(), null, null); } + public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2) { if (shattered) return mid; shattered = true; @@ -339,14 +362,14 @@ public class Mesh implements Iterable { if (bg1==null) bg1 = new BindingGroup(); if (bg2==null) bg2 = new BindingGroup(); - for(E e : bg.es) e.shatter(register(e.midpoint()), bg1, bg2); + for(E e : bg.es) e.shatter(e.midpoint(), bg1, bg2); pair.shatter(); destroy(); - newT(r, p1, mid, null); - newT(r, mid, p2, null); + newT(r.p, p1.p, mid, null); + newT(r.p, mid, p2.p, null); bg1.add(p1.getE(mid)); - bg2.add(mid.getE(p2)); + bg2.add(p2.getE(mid).pair); return mid; } @@ -420,16 +443,22 @@ public class Mesh implements Iterable { } /** creates an isolated edge out in the middle of space */ - public E(Vert p1, Vert p2) { - if (p1==p2) throw new Error("attempt to create edge with single vertex: " + p1); - this.p1 = p1; - this.p2 = p2; + public E(Point p1, Point p2) { + if (pointset.get(p1) != null) throw new Error(); + if (pointset.get(p2) != null) throw new Error(); + this.p1 = new Vert(p1); + this.p2 = new Vert(p2); this.prev = this.next = this.pair = new E(this, this, this); + this.p1.e = this; + this.p2.e = this.pair; sync(); } /** adds a new half-edge from prev.p2 to p2 */ - public E(E prev, Vert p2) { + public E(E prev, Point p) { + Vert p2; + p2 = pointset.get(p); + if (p2 == null) p2 = new Vert(p); this.p1 = prev.p2; this.p2 = p2; this.prev = prev; @@ -444,6 +473,7 @@ public class Mesh implements Iterable { this.prev.next = this; this.pair = new E(q, this, z); } + if (p2.e==null) p2.e = this.pair; sync(); } @@ -532,17 +562,29 @@ public class Mesh implements Iterable { } } - public T newT(Point p1, Point p2, Point p3, Vec norm) { return newT(register(p1), register(p2), register(p3), norm); } - public T newT(Vert p1, Vert p2, Vert p3, Vec norm) { + public E makeE(Point p1, Point p2) { + Vert v1 = pointset.get(p1); + Vert v2 = pointset.get(p2); + if (v1 != null && v2 != null) { + E e = v1.getE(v2); + if (e != null) return e; + e = v2.getE(v1); + if (e != null) return e; + } + if (v1 != null) return new E(v1.getFreeIncident(), p2); + if (v2 != null) return new E(v2.getFreeIncident(), p1).pair; + return new E(p1, p2); + } + public T newT(Point p1, Point p2, Point p3, Vec norm) { if (norm != null) { - Vec norm2 = p3.p.minus(p1.p).cross(p2.p.minus(p1.p)); + Vec norm2 = p3.minus(p1).cross(p2.minus(p1)); float dot = norm.dot(norm2); //if (Math.abs(dot) < EPointSILON) throw new Error("dot products within evertsilon of each other: "+norm+" "+norm2); - if (dot < 0) { Vert p = p1; p1=p2; p2 = p; } + if (dot < 0) { Point p = p1; p1=p2; p2 = p; } } - E e12 = p1.makeE(p2); - E e23 = p2.makeE(p3); - E e31 = p3.makeE(p1); + E e12 = makeE(p1, p2); + E e23 = makeE(p2, p3); + E e31 = makeE(p3, p1); while(e12.next != e23 || e23.next != e31 || e31.next != e12) { e12.makeAdjacent(e23); e23.makeAdjacent(e31);