X-Git-Url: http://git.megacz.com/?p=anneal.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fqfat%2FMeshViewer.java;h=73f22fb51c0fd7f5561a79c7379aa6d5722eafe5;hp=3799ab5a042bb7bfc11b711b8aa8d6b1a1048337;hb=f8763e1d5c2936537f981b840e9487ae22ed9ee7;hpb=ebf227e9a3373f74682716dedc9ba4c3e5882f6e

diff --git a/src/edu/berkeley/qfat/MeshViewer.java b/src/edu/berkeley/qfat/MeshViewer.java
index 3799ab5..73f22fb 100644
--- a/src/edu/berkeley/qfat/MeshViewer.java
+++ b/src/edu/berkeley/qfat/MeshViewer.java
@@ -13,6 +13,257 @@ import edu.berkeley.qfat.geom.Point;
 
 public class MeshViewer extends Viewer {
 
+    public int whichNeighbor = 1;
+
+    public double temp;
+    public boolean tileon = true;
+    public boolean tilemeshon = false;
+    public boolean goalon = true;
+    public boolean anneal = false;
+    public boolean hillclimb = false;
+    public boolean neighbors = false;
+    public boolean neighborsWire = false;
+    public boolean neighborsWireOne = false;
+    public boolean errorNormals = false;
+
+    public boolean force = false;
+    public Matrix[] transforms;
+    public Mesh.Vertex[] points;
+    public int breaks = 0;
+
+    public int temps;
+    public int accepts;
+    public    int vertss;
+    protected HashSet<Mesh.T> safeTriangles = new HashSet<Mesh.T>();
+
     public MeshViewer(JFrame f) { super(f); }
 
+
+    public void _display(GLAutoDrawable drawable, GL gl) {
+
+        if (transforms==null) return;
+        glcanvas.setSize(f.getWidth(), f.getHeight() - 100);
+        Graphics2D g = (Graphics2D)f.getGraphics();
+        g.setColor(Color.black);
+        g.fillRect(0, f.getHeight()-100, f.getWidth(), f.getHeight());
+        g.setColor(Color.red);
+        int top = f.getHeight()-70;
+        g.drawString("temperature: "+temps, 10, 30+top);
+        g.drawString("acceptance: "+accepts, 10, 50+top);
+        g.drawString("vertices: "+vertss, 10, 70+top);
+        g.fillRect(140, 25+top, temps, 10);
+        g.fillRect(140, 45+top, accepts, 10);
+        g.fillRect(140, 65+top, vertss, 10);
+
+        GLU glu = new GLU();
+        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        gl.glPointSize(5.0f);
+        gl.glLoadIdentity();
+        glu.gluPerspective(50, ((float)drawable.getWidth())/drawable.getHeight(), 0.5, 10);
+        glu.gluLookAt(0, 0, -((tz/10)-1), 0, 0, 0, 0, 1, 0);
+        gl.glRotatef(anglex/3, 0, 1, 0);
+        gl.glRotatef(-(angley/3), 1, 0, 0);
+
+
+        gl.glDisable(GL.GL_LIGHTING);
+        gl.glColor4f(1, 0, 0, 1);
+        gl.glBegin(GL.GL_LINES);
+        gl.glVertex3f(0,0,0);
+        gl.glVertex3f(.3f,0,0);
+        gl.glEnd();
+        gl.glColor4f(0, 1, 0, 1);
+        gl.glBegin(GL.GL_LINES);
+        gl.glVertex3f(0,0,0);
+        gl.glVertex3f(0,.3f,0);
+        gl.glEnd();
+        gl.glColor4f(0, 0, 1, 1);
+        gl.glBegin(GL.GL_LINES);
+        gl.glVertex3f(0,0,0);
+        gl.glVertex3f(0,0,.3f);
+        gl.glEnd();
+        gl.glEnable(GL.GL_LIGHTING);
+
+
+        gl.glBegin(GL.GL_TRIANGLES);
+        if (tileon)
+            draw(gl, true, safeTriangles);
+        if (tilemeshon)
+            draw(gl, false, safeTriangles);
+        gl.glEnd();
+
+        //draw(gl, false, tile);
+
+        gl.glBegin(GL.GL_TRIANGLES);
+        gl.glColor4f((float)0.5, (float)0.5, (float)0.5, (float)0.8);
+        if (goalon)
+            draw(gl, false, goal);
+        gl.glEnd();
+
+
+        int i = 0;
+        gl.glColor4f(1,1,1,1);
+        for(Matrix m : transforms) {
+            i++;
+            if (neighborsWireOne && i!=whichNeighbor) continue;
+            if (neighbors) draw(gl, true, safeTriangles, m);
+            else if (neighborsWire || neighborsWireOne) draw(gl, false, safeTriangles, m);
+        }
+
+        gl.glDisable(GL.GL_LIGHTING);
+        gl.glShadeModel(GL.GL_FLAT);
+        if (closest != null) {
+            gl.glColor3f(1,1,1);
+            gl.glBegin(gl.GL_POINTS);
+            closest.getPoint().glVertex(gl);
+            gl.glEnd();
+        }
+
+        gl.glFlush();
+        gl.glDrawBuffer(GL.GL_BACK);
+        gl.glReadBuffer( GL.GL_BACK );
+        gl.glPixelStorei( GL.GL_PACK_ALIGNMENT, 1);
+        gl.glFlush();
+        gl.glDisable(GL.GL_LIGHTING);
+        gl.glShadeModel(GL.GL_FLAT);
+
+
+        updateVisibility(gl, tile);
+
+        Matrix projection = Matrix.getProjectionMatrix(gl);
+        double dist = Double.MAX_VALUE;
+        if (clickPoint != null) return;
+        closest = null;
+        for(Mesh.Vertex v : tile.vertices()) {
+            if (!v.visible) continue;
+            Point p = projection.times(v.getPoint());
+            int x = (int)p.x;
+            int y = (int)p.y;
+            y = glcanvas.getHeight()-y;
+            if (closest==null || (x-mousex)*(x-mousex)+(y-mousey)*(y-mousey) < dist) {
+                dist = (x-mousex)*(x-mousex)+(y-mousey)*(y-mousey);
+                closest = v;
+            }
+        }
+    }
+
+
+    private void draw(GL gl, boolean triangles, Iterable<Mesh.T> tris) { draw(gl, triangles, tris, Matrix.ONE); }
+    private void draw(GL gl, boolean triangles, Iterable<Mesh.T> tris, Matrix m) {
+        float red = 0.0f;
+        float green = 0.0f;
+        float blue = 0.0f;
+        synchronized(this) {
+        for(Mesh.T t : tris) {
+            if (red < 0.15) red = 1.0f;
+            if (green < 0.15) green = 1.0f;
+            if (blue < 0.15) blue = 1.0f;
+            red -= .09f;
+            green -= .12f;
+            blue -= .15f;
+
+            /*
+            if (triangles) switch(t.color) {
+                case 0: gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3); break;
+                case 1: gl.glColor4f((float)0.25, (float)0.75, (float)0.25, (float)0.3); break;
+                case 2: gl.glColor4f((float)0.75, (float)0.25, (float)0.25, (float)0.3); break;
+                case 3: gl.glColor4f((float)0.50, (float)0.50, (float)0.50, (float)0.3); break;
+                case 4: gl.glColor4f((float)0.25, (float)0.75, (float)0.75, (float)0.3); break;
+                case 5: gl.glColor4f((float)0.25, (float)0.75, (float)0.75, (float)0.3); break;
+                case 6: gl.glColor4f((float)0.75, (float)0.25, (float)0.75, (float)0.3); break;
+            }
+            */
+            
+            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); 
+            //if (t.v1().visible && t.v2().visible && t.v3().visible) continue;
+
+            /*
+            if (t.e1().pair.t==null) gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3);
+            else if (t.e2().pair.t==null) gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3);
+            else if (t.e3().pair.t==null) gl.glColor4f((float)0.25, (float)0.25, (float)0.75, (float)0.3);
+            else  gl.glColor4f((float)0.75, (float)0.25, (float)0.25, (float)0.3);
+            */
+            //gl.glBegin(GL.GL_LINES);
+
+            if (triangles) {
+                t.glTriangle(gl, m);
+            } else {
+                gl.glDisable(GL.GL_LIGHTING);
+                gl.glBegin(GL.GL_LINES);
+                gl.glColor3f(1, 1, 1);
+                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);
+            }
+
+            Point centroid = t.centroid();
+            gl.glBegin(GL.GL_LINES);
+            gl.glColor3f(1, 1, 1);
+
+            if (triangles && errorNormals)
+                for(Mesh.Vertex p : new Mesh.Vertex[] { t.v1(), t.v2(), t.v3() }) {
+                    if (p.ok) {
+                        //gl.glDisable(GL.GL_LIGHTING);
+                        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);
+                        //if (p.nearest_in_other_mesh != null) p.nearest_in_other_mesh.p.glVertex(gl);
+                        //tile.nearest(p).centroid().glVertex(gl);
+                        gl.glEnd();
+                        //gl.glEnable(GL.GL_LIGHTING);
+                    }
+                }
+            gl.glEnd();
+            
+        }
+        }
+    }
+
+    public synchronized void dump() {
+        try {
+        PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("dump.stl")));
+        pw.println("solid dump");
+        for(Mesh.T t : tile) {
+            Vec normal = t.norm();
+            pw.println("facet normal " + normal.x + " " + normal.y + " " + normal.z);
+            pw.println("  outer loop");
+            for(Mesh.Vertex v : new Mesh.Vertex[] { t.v1(), t.v2(), t.v3() }) {
+                pw.println("    vertex " + v.p.x + " " + v.p.y + " " + v.p.z);
+            }
+            pw.println("  endloop");
+            pw.println("endfacet");
+        }
+        pw.println("endsolid dump");
+        pw.flush();
+        pw.close();
+        } catch (Exception e) { throw new RuntimeException(e); }
+    }
+
+    public void keyPressed(KeyEvent e)  {
+        super.keyPressed(e);
+        switch(e.getKeyCode()) {
+            case KeyEvent.VK_SPACE: breaks++; force = true; break;
+            case KeyEvent.VK_UP: temp = temp * 2; break;
+            case KeyEvent.VK_ENTER: temp = 10; break;
+            case KeyEvent.VK_LEFT: whichNeighbor--; break;
+            case KeyEvent.VK_RIGHT: whichNeighbor++; break;
+            case KeyEvent.VK_D: dump(); break;
+            case KeyEvent.VK_E: errorNormals = !errorNormals; break;
+            case KeyEvent.VK_A: hillclimb = false; anneal = !anneal; break;
+            case KeyEvent.VK_H: anneal = true; hillclimb = !hillclimb; break;
+            case KeyEvent.VK_N: neighbors = !neighbors; break;
+            case KeyEvent.VK_T: tileon = !tileon; break;
+            case KeyEvent.VK_G: goalon = !goalon; break;
+            case KeyEvent.VK_M: tilemeshon = !tilemeshon; break;
+        }
+    }
+
 }
\ No newline at end of file