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);
+ 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;
}
} 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) {