}
public class BindingGroup {
- private HashSet<E> left = new HashSet<E>();
- private HashSet<E> right = new HashSet<E>();
- public BindingGroup() { }
- public BindingGroup(E e) { add(null, e, false); }
- public void add(E ethis, E e, boolean swap) {
- if (ethis==null) { }
- else if (right.contains(ethis)) swap = !swap;
- else if (!left.contains(ethis)) throw new Error();
-
- if (e.bg != null) {
- if (e.bg == this) {
- if ((!swap ? right : left).contains(e)) throw new Error("double bind!");
- return;
- }
- for(E ex : (!swap ? e.bg.left : e.bg.right)) {
- ex.bg = this;
- left.add(ex);
- }
- for(E ex : (!swap ? e.bg.right : e.bg.left)) {
- ex.bg = this;
- right.add(ex);
- }
-
- } else {
- (!swap ? left : right).add(e);
- e.bg = this;
+ private HashSet<E> set = new HashSet<E>();
+ 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 void add(E e) {
+ if (set.contains(e)) return;
+ for (E epeer : e.bind_peers.set) {
+ epeer.bind_peers = this;
+ set.add(epeer);
+ }
+ for (E eother : e.bind_to.set) {
+ eother.bind_to = bind_others;
+ bind_others.add(eother);
}
+
for(E ex : (!swap ? right : left)) {
if (e.prev.isBoundTo(ex.prev)) {
System.out.println("hit!");
}
}
- }
- public boolean isBoundTo(E e1, E e2) {
- if (left.contains(e1) && right.contains(e2)) return true;
- if (left.contains(e2) && right.contains(e1)) return true;
- return false;
+
}
public void dobind(E e) {
- Vert v1 = null;
- Vert v2 = null;
- if (left.contains(e)) { v1 = e.p1; v2 = e.p2; }
- if (right.contains(e)) { v1 = e.p2; v2 = e.p1; }
- for(E ex : left) {
- if (ex==e) continue;
- v1.bind(ex.p1);
- v2.bind(ex.p2);
- }
- for(E ex : right) {
- if (ex==e) continue;
- v1.bind(ex.p2);
- v2.bind(ex.p1);
+ for(E ebound : set) {
+ e.p1.bind(ebound.p2);
+ e.p2.bind(ebound.p1);
}
}
public void shatter(BindingGroup bg1, BindingGroup bg2) {
- for(E e : left) {
+ for(E e : set) {
e.shatter(e.midpoint(), bg1, bg2, false);
}
- for(E e : right) {
- e.shatter(e.midpoint(), bg1, bg2, true); // swap correct?
- }
}
}
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();
+ public BindingGroup bind_to = bind_peers.other();
boolean shattered = false;
- public boolean isBoundTo(E e) { return bg.isBoundTo(this, e); }
-
-
public int compareTo(E e) { return e.length() > length() ? 1 : -1; }
- public void bindEdge(E e) { bg.add(this, e, true); }
- public void dobind() { if (bg != null) bg.dobind(this); }
+ public void bindEdge(E e) { bind_to.add(e); }
+ public void dobind() { bind_to.dobind(this); }
public Point shatter() { return shatter(midpoint(), null, null, false); }
public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2, boolean swap) {
if (bg1==null) bg1 = new BindingGroup();
if (bg2==null) bg2 = new BindingGroup();
- bg.shatter(bg1, bg2);
+ bind_peers.shatter(bg1, bg2);
+ bind_to.shatter(bg2.other(), bg1.other());
pair.shatter();
destroy();
newT(r.p, p1.p, mid, null);
newT(r.p, mid, p2.p, null);
- (swap ? bg1 : bg2).add(null, p1.getE(mid), swap);
- (swap ? bg2 : bg1).add(null, p2.getE(mid).pair, swap);
+ bg1.add(p1.getE(mid));
+ bg2.add(p2.getE(mid).pair);
return mid;
}
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;
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;