X-Git-Url: http://git.megacz.com/?p=anneal.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fqfat%2FMesh.java;h=6048110b74f9cc7690d69c2d0c84ad40c5bfaadf;hp=fd73795255f4915d2c1eff3c8d4e2ac1b80ea99f;hb=e32bd0376c8c859f51920674c84e6599ef7aeb18;hpb=0e80eb500d944f8ad1f3a9e2d296d9a4cbcd7e25

diff --git a/src/edu/berkeley/qfat/Mesh.java b/src/edu/berkeley/qfat/Mesh.java
index fd73795..6048110 100644
--- a/src/edu/berkeley/qfat/Mesh.java
+++ b/src/edu/berkeley/qfat/Mesh.java
@@ -19,6 +19,47 @@ public class Mesh implements Iterable<Mesh.T> {
     private RTree<T>         triangles = new RTree<T>();
     private PointSet<Vertex> vertices  = new PointSet<Vertex>();
 
+    public boolean option_wireframe    = false;
+    public boolean option_errorNormals = false;
+    public boolean option_selectable   = true;
+
+    public void render(GL gl, Matrix m) {
+        if (option_wireframe) {
+            gl.glDisable(GL.GL_LIGHTING);
+            gl.glBegin(GL.GL_LINES);
+            gl.glColor3f(1, 1, 1);
+            for (T t : this) {
+                m.times(t.e1().p1.goodp).glVertex(gl);
+                m.times(t.e1().p2.goodp).glVertex(gl);
+                m.times(t.e2().p1.goodp).glVertex(gl);
+                m.times(t.e2().p2.goodp).glVertex(gl);
+                m.times(t.e3().p1.goodp).glVertex(gl);
+                m.times(t.e3().p2.goodp).glVertex(gl);
+            }
+            gl.glEnd();
+            gl.glEnable(GL.GL_LIGHTING);
+            return;
+        }
+        for(T t : this) {
+            gl.glColor4f((float)(0.25+(0.05*t.color)),
+                         (float)(0.25+(0.05*t.color)),
+                         (float)(0.75+(0.05*t.color)),
+                         (float)0.3); 
+            t.glTriangle(gl, m);
+        }
+        if (option_errorNormals)
+            for(T t : this)
+                for(Mesh.Vertex p : new Mesh.Vertex[] { t.v1(), t.v2(), t.v3() }) {
+                    if (p.ok) {
+                        gl.glBegin(GL.GL_LINES);
+                        gl.glColor3f(1, 1, 1);
+                        p.p.glVertex(gl);
+                        p.p.plus(p.norm().times((float)p.error()*10)).glVertex(gl);
+                        gl.glEnd();
+                    }
+                }
+    }
+
     public boolean immutableVertices;
     public Mesh    error_against      = null;
     public double  error              = 0;
@@ -74,6 +115,53 @@ public class Mesh implements Iterable<Mesh.T> {
     }
 
 
+    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) { 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 //////////////////////////////////////////////////////////////////////////////
 
     /** a vertex in the mesh */
@@ -82,6 +170,9 @@ public class Mesh implements Iterable<Mesh.T> {
         public Point oldp;
         E e;                // some edge *leaving* this point
 
+        public boolean original = false;
+        public boolean edge = false;
+
         private boolean illegal = false;
 
         public boolean visible = false;
@@ -162,6 +253,7 @@ public class Mesh implements Iterable<Mesh.T> {
         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)
@@ -206,7 +298,7 @@ public class Mesh implements Iterable<Mesh.T> {
             setError(nerror);
         }
 
-        public boolean move(Matrix m, boolean ignoreProblems) {
+        public boolean move(Vec vv, boolean ignoreProblems) {
 
             boolean good = true;
 
@@ -217,21 +309,26 @@ public class Mesh implements Iterable<Mesh.T> {
             // M * t1 = M * t1.getMatrix(t2) * t2
 
             if (bindingGroup!=null && this != bindingGroup.getMaster()) {
-                Matrix v = getBindingMatrix(bindingGroup.getMaster());
-                return ((Vertex)bindingGroup.getMaster()).move(v.inverse().times(m).times(v), ignoreProblems);
+                Matrix m2 = getBindingMatrix(bindingGroup.getMaster());
+                Vec v2 = m2.times(vv.plus(getPoint())).minus(m2.times(getPoint()));
+                return ((Vertex)bindingGroup.getMaster()).move(v2, ignoreProblems);
             }
 
+            Point op = this.p;
+            Point pp = vv.plus(getPoint());
             if (bindingGroup != null) {
-                Matrix m2 = null;
-                for(int i=0; i<20 && !m.equals(m2); i++) {
-                    m2 = m.times(getConstraint());
+                /*
+                for(int i=0; i<20 ; i++) {
+                    Point p2 = getConstraint().times(pp);
+                    pp = pp.midpoint(p2);
                     //System.out.println(m.minus(m2));
                 }
-                if (!m.equals(m2)) return true;
+            */
+                    pp = getConstraint().times(pp);
             }
+            pp = pp.minus(op).norm().times(vv.mag()).plus(op);
             ok = false;
-            Point op = this.p;
-            Point pt = m.times(this.p);
+            Point pt = pp;
             for(Vertex v : (Iterable<Vertex>)getBoundPeers()) {
                 Point pt2 = v.getBindingMatrix(this).times(pt);
                 /*
@@ -263,7 +360,6 @@ public class Mesh implements Iterable<Mesh.T> {
 
             unApplyQuadricToNeighbor();
 
-
             boolean illegalbefore = illegal;
             illegal = false;
             /*
@@ -667,6 +763,9 @@ public class Mesh implements Iterable<Mesh.T> {
     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) {
 
@@ -707,9 +806,114 @@ public class Mesh implements Iterable<Mesh.T> {
         public final int color;
         public final int colorclass;
 
+        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;
@@ -747,11 +951,30 @@ public class Mesh implements Iterable<Mesh.T> {
         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;