X-Git-Url: http://git.megacz.com/?p=anneal.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fqfat%2FMesh.java;h=da10ac99a225e95d672fbf0c5c3a7394c9959cda;hp=219da71afdc52c46e0889412574c0832d15f8dd5;hb=8333b6805df84244a7524fbdc58e9a6820fb0b6c;hpb=3a566fdd09e751b7901edc4d22060032f96fe438 diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java index 219da71..da10ac9 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(); @@ -50,15 +50,14 @@ public class Mesh implements Iterable { public int numedges = 0; public float avgedge = 0; - public void unbind() { + public void rebindPoints() { + // unbind all points for(Mesh.T t : this) { t.v1().unbind(); t.v2().unbind(); t.v3().unbind(); } - } - - public void bind() { + // ask edges to re-implement their bindings for(Mesh.T t : this) { t.e1().dobind(); t.e2().dobind(); @@ -66,7 +65,25 @@ public class Mesh implements Iterable { } } - public float rescore() { + public void unApplyQuadricToNeighborAll() { + HashSet done = new HashSet(); + for(T t : this) + for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) { + if (done.contains(p)) continue; + done.add(p); + p.unApplyQuadricToNeighbor(); + } + } + public void recomputeAllFundamentalQuadrics() { + HashSet done = new HashSet(); + for(T t : this) + for(Vert p : new Vert[] { 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 done = new HashSet(); @@ -74,7 +91,8 @@ public class Mesh implements Iterable { for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) { if (done.contains(p)) continue; done.add(p); - p.rescore(); + p.applyQuadricToNeighbor(); + } return (float)(dist/num); } @@ -98,90 +116,118 @@ public class Mesh implements Iterable { return (float)total; } - - public class BindingGroup { - public HashSet es = new HashSet(); - public BindingGroup() { } - public BindingGroup(E e) { - es.add(e); - } - public void add(E e) { - if (e.bg != null) { merge(e.bg); return; } - es.add(e); - e.bg = this; - } - public void merge(BindingGroup bg) { - for(E e : bg.es) { - e.bg = null; - add(e); - } - } - } - + public void rebuildPointSet() { pointset.rebuild(); } public Vec diagonal() { return pointset.diagonal(); } public Point centroid() { return pointset.centroid(); } public Vert nearest(Point p) { return pointset.nearest(p); } public final class Vert extends HasPoint { public Point p; + E e; // some edge *leaving* this point + + /** 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; + + Vert bound_to = this; + Matrix binding = new Matrix(); + float oldscore = 0; + boolean quadricStale = false; + + public Matrix errorQuadric() { return quadric; } public Point getPoint() { return p; } + public float score() { return oldscore; } + + private Matrix fundamentalQuadric = null; + public Matrix fundamentalQuadric() { + if (fundamentalQuadric == null) recomputeFundamentalQuadric(); + return fundamentalQuadric; + } + private Vert(Point p) { this.p = p; if (pointset.get(p) != null) throw new Error(); pointset.add(this); } - public float score() { return oldscore; } - 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; + + private void glNormal(GL gl) { + Vec norm = norm(); + gl.glNormal3f(norm.x, norm.y, norm.z); } - public Vert partner() { return watch==null ? this : watch; } - public Point watchback() { return watch_count==0 ? partner().p : - new Point(watch_x/watch_count, watch_y/watch_count, watch_z/watch_count); } - public void rescore() { + + public void recomputeFundamentalQuadric() { + //if (!quadricStale && fundamentalQuadric != null) return; + quadricStale = false; + unApplyQuadricToNeighbor(); + 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; + applyQuadricToNeighbor(); + } + + public void unApplyQuadricToNeighbor() { + if (nearest_in_other_mesh == null) return; + if (fundamentalQuadric == null) return; + nearest_in_other_mesh.unComputeError(); + 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.computeError(); + nearest_in_other_mesh = null; + } + + public void applyQuadricToNeighbor() { if (score_against == null) return; - score -= oldscore; - oldscore = 0; + Vert new_nearest = score_against.nearest(p); + if (nearest_in_other_mesh != null && new_nearest == nearest_in_other_mesh) return; - if (watch != null) unscore(); - Vert po = this; - if (watch == null) { - watch = score_against.nearest(po.p); - - // don't attract to vertices that face the other way - if (watch.e == null || watch.norm().dot(norm()) < 0) { - watch = null; - } else { - watch.watch_x += po.p.x; - watch.watch_y += po.p.y; - watch.watch_z += po.p.z; - watch.watch_count++; - } + if (nearest_in_other_mesh != null) unApplyQuadricToNeighbor(); + if (nearest_in_other_mesh != null) throw new Error(); + + nearest_in_other_mesh = new_nearest; + + // don't attract to vertices that face the other way + if (nearest_in_other_mesh.e == null || nearest_in_other_mesh.norm().dot(norm()) < 0) { + nearest_in_other_mesh = null; + } else { + nearest_in_other_mesh.unComputeError(); + nearest_in_other_mesh.quadric = nearest_in_other_mesh.quadric.plus(fundamentalQuadric()); + nearest_in_other_mesh.quadric_count++; + nearest_in_other_mesh.computeError(); } + reComputeError(); + } - 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); - oldscore = (float)(s1 + s2); + public void reComputeError() { + unComputeError(); + computeError(); + } + public void unComputeError() { + score -= oldscore; + oldscore = 0; + } + public void computeError() { + oldscore = quadric_count == 0 ? 0 : ((quadric.preAndPostMultiply(p) * 100) / quadric_count); + double ang = Math.abs(e.crossAngle()); + if (ang < Math.PI * 0.2) + oldscore += ((Math.PI*0.2) - ang) * 10; + //System.out.println(oldscore); score += oldscore; } /** does NOT update bound pairs! */ public boolean transform(Matrix m) { - // FIXME: screws up kdtree - // FIXME: screws up hashmap - unscore(); + unApplyQuadricToNeighbor(); try { if (pointset.get(this.p)==null) throw new Error(); pointset.remove(this); @@ -189,36 +235,45 @@ 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); } - rescore(); + applyQuadricToNeighbor(); + + // should recompute fundamental quadrics of all vertices sharing a face, but we defer... + E e = this.e; + do { + e.p2.quadricStale = true; + e = e.pair.next; + } while(e != this.e); + + // FIXME: intersection test needed? boolean good = true; /* - for(T t : this) { - for(E e = this.e; ;) { - if (e.intersects(t)) { good = false; break; } + for(T t : Mesh.this) { + if (!good) break; + e = this.e; + do { + if (!t.has(e.p1) && !t.has(e.p2) && e.intersects(t)) { good = false; break; } + if (e.t != null) { + if (!e.t.has(t.e1().p1) && !e.t.has(t.e1().p2) && t.e1().intersects(e.t)) { good = false; break; } + if (!e.t.has(t.e2().p1) && !e.t.has(t.e2().p2) && t.e2().intersects(e.t)) { good = false; break; } + if (!e.t.has(t.e3().p1) && !e.t.has(t.e3().p2) && t.e3().intersects(e.t)) { good = false; break; } + } e = e.pair.next; - if (e == this.e) break; - } - } - */ - /* - if (t==this.t) continue; - if (this.intersects(t)) good = false; + } while(e != this.e); } - */ +*/ return good; } + public boolean move(Vec v) { Matrix m = new Matrix(v); Vert p = this; boolean good = true; do { good &= p.transform(m); - v = v.times(binding); // bleh wrong p = p.bound_to; } while (p != this); return good; @@ -241,6 +296,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 { @@ -251,6 +311,16 @@ public class Mesh implements Iterable { 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); + return norm.norm(); + } + public boolean isBoundTo(Vert p) { Vert px = p; do { @@ -259,7 +329,6 @@ public class Mesh implements Iterable { } while(px != p); return false; } - public void unbind() { bound_to = this; binding = new Matrix(); } public void bind(Vert p) { bind(p, new Matrix()); } public void bind(Vert p, Matrix binding) { @@ -271,26 +340,46 @@ public class Mesh implements Iterable { this.bound_to = temp_bound_to; this.binding = temp_binding.times(temp_binding); // FIXME: may have order wrong here } - 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); - 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; + public class BindingGroup { + private HashSet set = new HashSet(); + public BindingGroup bind_others; + public BindingGroup other() { return bind_others; } + public BindingGroup(BindingGroup bind_others) { this.bind_others = bind_others; } + public BindingGroup() { this.bind_others = new BindingGroup(this); } + public BindingGroup(E e) { this(); set.add(e); } + public void add(E e) { + if (set.contains(e)) return; + set.add(e); + BindingGroup e_bind_peers = e.bind_peers; + BindingGroup e_bind_to = e.bind_to; + e.bind_peers = this; + e.bind_to = bind_others; + for (E epeer : e_bind_peers.set) add(epeer); + for (E eother : e_bind_to.set) bind_others.add(eother); + + for(E eother : bind_others.set) { + if (e.next.bind_to.set.contains(eother.prev)) { + e.next.next.bindEdge(eother.prev.prev); + } + if (e.prev.bind_to.set.contains(eother.next)) { + e.prev.prev.bindEdge(eother.next.next); + } + } + + } + public void dobind(E e) { + for(E ebound : set) { + e.p1.bind(ebound.p2); + e.p2.bind(ebound.p1); + } + } + public void shatter(BindingGroup bg1, BindingGroup bg2) { + for(E e : set) { + e.shatter(e.midpoint(), bg1, bg2); + } + } } /** [UNIQUE] an edge */ @@ -301,42 +390,36 @@ public class Mesh implements Iterable { E prev; // previous half-edge E next; // next half-edge E pair; // partner half-edge - public BindingGroup bg = new BindingGroup(this); + public BindingGroup bind_peers = new BindingGroup(this); + public BindingGroup bind_to = bind_peers.other(); + boolean shattered = false; public int compareTo(E e) { return e.length() > length() ? 1 : -1; } + public void bindEdge(E e) { bind_to.add(e); } + public void dobind() { bind_to.dobind(this); } - public void bind(E e) { bind(e, new Matrix()); } - public void bind(E e, Matrix m) { e.bg.add(this); } - - public void dobind() { - if (bg==null) return; - for(E ex : bg.es) { - if (ex==this) continue; - p1.bind(ex.p1); - p2.bind(ex.p2); - } - } - - boolean shattered = false; - public Vert shatter() { return shatter(register(midpoint()), null, null); } - public Vert shatter(Vert mid, BindingGroup bg1, BindingGroup bg2) { - if (shattered) return mid; + public Point shatter() { return shatter(midpoint(), null, null); } + public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2) { + if (shattered || destroyed) return mid; shattered = true; Vert r = next.p2; E next = this.next; E prev = this.prev; + int old_colorclass = t==null ? 0 : t.colorclass; if (bg1==null) bg1 = new BindingGroup(); if (bg2==null) bg2 = new BindingGroup(); - for(E e : bg.es) e.shatter(register(e.midpoint()), bg1, bg2); + BindingGroup old_bind_to = bind_to; + bind_peers.shatter(bg1, bg2); + old_bind_to.shatter(bg2.other(), bg1.other()); pair.shatter(); destroy(); - newT(r.p, p1.p, mid.p, null); - newT(r.p, mid.p, p2.p, null); + newT(r.p, p1.p, mid, null, old_colorclass); + newT(r.p, mid, p2.p, null, old_colorclass); bg1.add(p1.getE(mid)); - bg2.add(mid.getE(p2)); + bg2.add(p2.getE(mid).pair); return mid; } @@ -351,8 +434,10 @@ public class Mesh implements Iterable { prev.t = null; pair.next.t = null; pair.prev.t = null; - this.bg = null; - pair.bg = null; + this.bind_to = null; + pair.bind_to = null; + this.bind_peers = null; + pair.bind_peers = null; pair.prev.next = next; next.prev = pair.prev; prev.next = pair.next; @@ -369,6 +454,7 @@ public class Mesh implements Iterable { this.prev.next = this; this.next.prev = this; this.pair.pair = this; + bind_peers.add(this); if (this.next.p1 != p2) throw new Error(); if (this.prev.p2 != p1) throw new Error(); if (this.p1.e == null) this.p1.e = this; @@ -380,7 +466,13 @@ public class Mesh implements Iterable { } private boolean added = false; - public T makeT() { return t==null ? (t = new T(this)) : t; } + public T makeT(int colorclass) { return t==null ? (t = new T(this, colorclass)) : t; } + + public double crossAngle() { + Vec v1 = t.norm().times(-1); + Vec v2 = pair.t.norm().times(-1); + return Math.acos(v1.norm().dot(v2.norm())); + } /** angle between this half-edge and the next */ public double angle() { @@ -410,16 +502,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; @@ -434,6 +532,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(); } @@ -522,10 +621,6 @@ public class Mesh implements Iterable { } } - private Vert register(Point p) { - Vert v = pointset.get(p); - return v==null ? new Vert(p) : v; - } public E makeE(Point p1, Point p2) { Vert v1 = pointset.get(p1); Vert v2 = pointset.get(p2); @@ -535,11 +630,11 @@ public class Mesh implements Iterable { e = v2.getE(v1); if (e != null) return e; } - if (v1 != null) return new E(v1.getFreeIncident(), register(p2)); - if (v2 != null) return new E(v2.getFreeIncident(), register(p1)).pair; - return new E(register(p1), register(p2)); + 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) { + public T newT(Point p1, Point p2, Point p3, Vec norm, int colorclass) { if (norm != null) { Vec norm2 = p3.minus(p1).cross(p2.minus(p1)); float dot = norm.dot(norm2); @@ -554,7 +649,7 @@ public class Mesh implements Iterable { e23.makeAdjacent(e31); e31.makeAdjacent(e12); } - T ret = e12.makeT(); + T ret = e12.makeT(colorclass); if (e12.t == null) throw new Error(); if (e23.t == null) throw new Error(); if (e31.t == null) throw new Error(); @@ -587,11 +682,12 @@ public class Mesh implements Iterable { public final class T extends Triangle { public final E e1; public final int color; + public final int colorclass; public void destroy() { } - T(E e1) { + T(E e1, int colorclass) { this.e1 = e1; E e2 = e1.next; E e3 = e2.next; @@ -613,6 +709,7 @@ public class Mesh implements Iterable { break; } this.color = color; + this.colorclass = colorclass; } public E e1() { return e1; } public E e2() { return e1.next; } @@ -625,6 +722,16 @@ public class Mesh implements Iterable { 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 void glVertices(GL gl) { + if (e1().bind_to.set.size() == 0) return; + if (e2().bind_to.set.size() == 0) return; + if (e3().bind_to.set.size() == 0) return; + norm().glNormal(gl); + p1().glVertex(gl); + p2().glVertex(gl); + p3().glVertex(gl); + } } }