checkpoint

[anneal.git] / src / edu / berkeley / qfat / Mesh.java

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index 3a0d72c..0e59461 100644 (file)
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -319,32 +319,66 @@ public class Mesh implements Iterable<Mesh.T> {
     }
 
     public class BindingGroup {
-        private HashSet<E> ess = new HashSet<E>();
+        private HashSet<E> left = new HashSet<E>();
+        private HashSet<E> right = new HashSet<E>();
         public BindingGroup() { }
-        public BindingGroup(E e) {
-            ess.add(e);
-        }
-        public void add(E e) {
-            if (e.bg != null) { merge(e.bg); return; }
-            ess.add(e);
-            e.bg = this;
-        }
-        public void merge(BindingGroup bg) {
-            for(E e : bg.ess) {
-                e.bg = null;
-                add(e);
+        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;
+            }
+            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) {
-            for(E ex : ess) {
+            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;
-                e.p1.bind(ex.p1);
-                e.p2.bind(ex.p2);
+                v1.bind(ex.p2);
+                v2.bind(ex.p1);
             }
         }
         public void shatter(BindingGroup bg1, BindingGroup bg2) {
-            for(E e : ess) {
-                e.shatter(e.midpoint(), bg1, bg2);
+            for(E e : left) {
+                e.shatter(e.midpoint(), bg1, bg2, false);
+            }
+            for(E e : right) {
+                e.shatter(e.midpoint(), bg1, bg2, true);  // swap correct? 
             }
         }
     }
@@ -360,15 +394,15 @@ public class Mesh implements Iterable<Mesh.T> {
         public BindingGroup bg = new BindingGroup(this);
         boolean shattered = false;
 
-        public int compareTo(E e) { return e.length() > length() ? 1 : -1; }
+        public boolean isBoundTo(E e) { return bg.isBoundTo(this, e); }
 
-        public void bindEdge(E e) {
-            e.pair.bg.add(this);
-        }
+
+        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 Point shatter() { return shatter(midpoint(), null, null); }
-        public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2) {
+        public Point shatter() { return shatter(midpoint(), null, null, false); }
+        public Point shatter(Point mid, BindingGroup bg1, BindingGroup bg2, boolean swap) {
             if (shattered) return mid;
             shattered = true;
 
@@ -384,8 +418,8 @@ public class Mesh implements Iterable<Mesh.T> {
 
             newT(r.p, p1.p, mid, null);
             newT(r.p, mid, p2.p, null);
-            bg1.add(p1.getE(mid));
-            bg2.add(p2.getE(mid).pair);
+            (swap ? bg1 : bg2).add(null, p1.getE(mid), swap);
+            (swap ? bg2 : bg1).add(null, p2.getE(mid).pair, swap);
             return mid;
         }