public void subdivide() {
for (T t : this) t.old = true;
for (Vertex v : vertices()) v.original = true;
+ Queue<T> q = new LinkedList<T>();
OUTER: while(true) {
- for (T t : this)
- if (t.old) {
- Point p = t.e1.midpoint();
- System.out.println("shatter " + t.e1);
- t.e1.shatter();
- nearest(p).edge = true;
- continue OUTER;
- }
+ for (T t : this) {
+ if (t.old) { t.shatter(); continue OUTER; }
+ }
break;
}
+ /*
+ while(q.size()>0) {
+ T t = q.remove();
+ if (!t.old || t.destroyed()) continue;
+ E te = t.e1;
+ T to = t.e1.pair.t;
+ if (!t
+ q.add(t.e1().pair.t);
+ q.add(t.e2().pair.t);
+ q.add(t.e3().pair.t);
+ q.add(to.e1().pair.t);
+ q.add(to.e2().pair.t);
+ q.add(to.e3().pair.t);
+ Point p = te.midpoint();
+ Point c = t.centroid();
+ Vertex v1 = t.getOtherVertex(te);
+ Vertex v2 = te.pair.t.getOtherVertex(te.pair);
+ System.out.println("shatter " + te);
+ te.shatter();
+ Vertex v = nearest(p);
+ v.move(c.minus(v.getPoint()), false);
+ v.edge = true;
+ v1.getE(p).shatter();
+ v2.getE(p).shatter();
+ }
+ */
+ /*
+ for (Vertex v : vertices())
+ clearWish();
+ for (Vertex v : vertices()) {
+
+ }
+ for (Vertex v : vertices())
+ grantWish();
+ */
}
// Vertexices //////////////////////////////////////////////////////////////////////////////
public HasQuadric nearest() { return error_against==null ? null : error_against.vertices.nearest(p, this); }
public void computeError() {
if (error_against==null) return;
+ if (nearest_in_other_mesh == null && nearest()==null) return;
float nerror =
nearest_in_other_mesh != null
? nearest_in_other_mesh.fundamentalQuadric().preAndPostMultiply(p)
private static float round(float f) {
return Math.round(f*1000)/1000f;
}
+ public T newT(HasPoint p1, HasPoint p2, HasPoint p3) {
+ return newT(p1.getPoint(), p2.getPoint(), p3.getPoint(), null, 0);
+ }
public T newT(Point p1, Point p2, Point p3, Vec norm, int colorclass) {
if (coalesce) {
public final int color;
public final int colorclass;
- public boolean old;
+ public boolean old = false;
public final int serial = max_serial++;
public boolean occluded;
+ public Point shatter() {
+ if (destroyed) return null;
+ E e = e1();
+
+ HashSet<E> forward = new HashSet<E>();
+ HashSet<E> backward = new HashSet<E>();
+ HashSet<E> both = new HashSet<E>();
+
+ for(E eb : (Iterable<E>)e.getBoundPeers()) {
+ if (eb==e) continue;
+ if (eb.next.isBoundTo(e.next) && eb.prev.isBoundTo(e.prev)) {
+ forward.add(eb);
+ both.add(eb);
+ }
+ if (eb.pair.next.pair.isBoundTo(e.prev) && eb.pair.prev.pair.isBoundTo(e.next)) {
+ backward.add(eb.pair);
+ both.add(eb.pair);
+ }
+ }
+
+ Vertex v1 = e.t.v1();
+ Vertex v2 = e.t.v2();
+ Vertex v3 = e.t.v3();
+ Point c = e.t.centroid();
+ E e_next = e.next;
+ E e_prev = e.prev;
+ e.t.destroy();
+ newT(v1, v2, c);
+ newT(c, v2, v3);
+ newT(v3, v1, c);
+
+ // FIXME: forward too
+ for(E ex : backward) {
+ Vertex v1x = ex.t.v1();
+ Vertex v2x = ex.t.v2();
+ Vertex v3x = ex.t.v3();
+ Point cx = ex.t.centroid();
+ E ex_next = ex.next;
+ E ex_prev = ex.prev;
+ ex.t.destroy();
+ newT(v1x, v2x, cx);
+ newT(cx, v2x, v3x);
+ newT(v3x, v1x, cx);
+
+ // FIXME: i have no idea if this is right
+ e.next.bindTo(e.getBindingMatrix(ex.pair), ex.prev);
+ e.prev.bindTo(e.getBindingMatrix(ex.pair), ex.next);
+ e.next.pair.bindTo(e.getBindingMatrix(ex.pair), ex.prev.pair);
+ e.prev.pair.bindTo(e.getBindingMatrix(ex.pair), ex.next.pair);
+
+ e_next.next.bindTo(e_next.getBindingMatrix(ex_prev.pair), ex_prev.prev.pair);
+ e_next.prev.bindTo(e_next.getBindingMatrix(ex_prev.pair), ex_prev.next.pair);
+
+ e_prev.next.bindTo(e_prev.getBindingMatrix(ex_next.pair), ex_next.prev.pair);
+ e_prev.prev.bindTo(e_prev.getBindingMatrix(ex_next.pair), ex_next.next.pair);
+ }
+
+ /*
+
+ E first = null;
+ E firste = null;
+ E firstx = null;
+ E firstq = null;
+ for(E e : (Iterable<E>)getBoundPeers()) {
+ E enext = e.next;
+ E eprev = e.prev;
+ E pnext = e.pair.next;
+ E pprev = e.pair.prev;
+ Point mid = e.midpoint();
+ Vertex r = e.next.p2;
+ Vertex l = e.pair.next.p2;
+ if (!e.destroyed) {
+ e.destroy();
+ e.pair.destroy();
+ newT(r.p, e.p1.p, mid, null, 0);
+ newT(r.p, mid, e.p2.p, null, 0);
+ newT(l.p, mid, e.p1.p, null, 0);
+ newT(l.p, e.p2.p, mid, null, 0);
+ }
+ }
+ for(E e : (Iterable<E>)getBoundPeers()) {
+ Point mid = e.midpoint();
+ if (first==null) {
+ first = e.p1.getE(mid);
+ firste = e;
+ firstx = e.pair;
+ firstq = e.p2.getE(mid).pair;
+ continue;
+ }
+ e.p1.getE(mid). bindTo(e.getBindingMatrix(firste), first);
+ e.p1.getE(mid).pair. bindTo(e.getBindingMatrix(firste), first.pair);
+ e.p2.getE(mid).pair. bindTo(e.getBindingMatrix(firste), firstq);
+ e.p2.getE(mid).pair.pair.bindTo(e.getBindingMatrix(firste), firstq.pair);
+ }
+ */
+ /*
+ first.setConstraint(firste.getConstraint());
+ firstq.setConstraint(firste.getConstraint());
+ */
+ return null;
+ }
+
+
T(E e1, int colorclass) {
this.e1 = e1;
E e2 = e1.next;
public boolean hasE(E e) { return e1==e || e1.next==e || e1.prev==e; }
public boolean has(Vertex v) { return v1()==v || v2()==v || v3()==v; }
+ public Vertex getOtherVertex(E e) {
+ if (!hasE(e)) throw new RuntimeException();
+ if (!e.has(v1())) return v1();
+ if (!e.has(v2())) return v2();
+ if (!e.has(v3())) return v3();
+ throw new RuntimeException();
+ }
+
public void removeFromRTree() { triangles.remove(this); }
public void addToRTree() { triangles.insert(this); }
- public void destroy() { triangles.remove(this); }
+ public void destroy() {
+ if (e1 != null) {
+ e1.t = null;
+ e1.next.t = null;
+ e1.prev.t = null;
+ }
+ triangles.remove(this);
+ destroyed = true;
+ }
public void reinsert() { triangles.remove(this); triangles.add(this); }
+ private boolean destroyed = false;
+ public boolean destroyed() { return destroyed; }
+
public boolean shouldBeDrawn() {
if (e1().bindingGroupSize() <= 1) return false;
projects / anneal.git / commitdiff