}
}
+ public void unscore() {
+ HashSet<Vert> done = new HashSet<Vert>();
+ for(T t : this)
+ for(Vert p : new Vert[] { t.v1(), t.v2(), t.v3() }) {
+ if (done.contains(p)) continue;
+ done.add(p);
+ p.unscore();
+ }
+ }
+ public void fundamental() {
+ HashSet<Vert> done = new HashSet<Vert>();
+ 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 rescore() {
int num = 0;
double dist = 0;
if (done.contains(p)) continue;
done.add(p);
p.rescore();
+
}
return (float)(dist/num);
}
E e; // some edge *leaving* this point
Vert bound_to = this;
- int nearest_vert_in_other_mesh_count;
- float nearest_vert_in_other_mesh_x;
- float nearest_vert_in_other_mesh_y;
- float nearest_vert_in_other_mesh_z;
- Vert nearest_vert_in_other_mesh;
+
+ /** 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 quadric() {
- Matrix m = new Matrix(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
- 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);
- return m;
+ public Matrix errorQuadric() { return quadric; }
+
+ private Matrix fundamentalQuadric = null;
+ public Matrix fundamentalQuadric() {
+ if (fundamentalQuadric == null) recomputeFundamentalQuadric();
+ return fundamentalQuadric;
}
public Point getPoint() { return p; }
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 (nearest_vert_in_other_mesh == null) return;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_x -= p.x;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_y -= p.y;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_z -= p.z;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_count--;
- if (nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_count==0) {
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_x = 0;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_y = 0;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_z = 0;
- }
- nearest_vert_in_other_mesh = 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 nearest_vert_in_other_mesh==null ? this : nearest_vert_in_other_mesh; }
- public Point nearest_vert_in_other_mesh() { return nearest_vert_in_other_mesh_count==0 ? partner().p :
- new Point(nearest_vert_in_other_mesh_x/nearest_vert_in_other_mesh_count, nearest_vert_in_other_mesh_y/nearest_vert_in_other_mesh_count, nearest_vert_in_other_mesh_z/nearest_vert_in_other_mesh_count); }
+
public void rescore() {
if (score_against == null) return;
score -= oldscore;
oldscore = 0;
- if (nearest_vert_in_other_mesh != null) unscore();
- Vert po = this;
- if (nearest_vert_in_other_mesh == null) {
- nearest_vert_in_other_mesh = 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 (nearest_vert_in_other_mesh.e == null || nearest_vert_in_other_mesh.norm().dot(norm()) < 0) {
- nearest_vert_in_other_mesh = null;
+ if (nearest_in_other_mesh.e == null || nearest_in_other_mesh.norm().dot(norm()) < 0) {
+ nearest_in_other_mesh = null;
} else {
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_x += po.p.x;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_y += po.p.y;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_z += po.p.z;
- nearest_vert_in_other_mesh.nearest_vert_in_other_mesh_count++;
+ nearest_in_other_mesh.quadric = nearest_in_other_mesh.quadric.plus(fundamentalQuadric());
+ nearest_in_other_mesh.quadric_count++;
}
}
- double s1, s2;
- if (nearest_vert_in_other_mesh_count==0) s1 = 0;
- else s1 = p.distance(nearest_vert_in_other_mesh_x/nearest_vert_in_other_mesh_count, nearest_vert_in_other_mesh_y/nearest_vert_in_other_mesh_count, nearest_vert_in_other_mesh_z/nearest_vert_in_other_mesh_count);
- s2 = nearest_vert_in_other_mesh==null ? 0 : po.p.distance(nearest_vert_in_other_mesh.p);
- oldscore = (float)(s1 + s2);
+ oldscore = quadric_count == 0 ? 0 : (quadric.preAndPostMultiply(p) / quadric_count);
score += oldscore;
}
throw new RuntimeException(e);
}
rescore();
- boolean good = true;
- /*
- for(T t : this) {
- for(E e = this.e; ;) {
- if (e.intersects(t)) { good = false; break; }
- e = e.pair.next;
- if (e == this.e) break;
- }
- }
- */
- /*
- if (t==this.t) continue;
- if (this.intersects(t)) good = false;
- }
- */
- return good;
+
+ // should recompute fundamental quadrics of all vertices sharing a face, but we defer...
+ // FIXME: intersection test needed?
+ return true;
}
public boolean move(Vec v) {
Matrix m = new Matrix(v);
projects / anneal.git / blobdiff