VisClient/org/hfbk/vis/visnode/VisStrip.java

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

import org.dronus.graph.Node;
import org.hfbk.vis.Prefs;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class VisStrip extends VisNode {

        int dl;

        float tx, ty, tz, maxx, maxz, minx, minz;

        class Poly extends LinkedList<Vector3f> {
        };

        class Frame extends LinkedList<Poly> {
        };

        List<Frame> frames = new LinkedList<Frame>();

        List<Vector3f> markers = new LinkedList<Vector3f>();

        String mapfile = "misc/salon.coord";

        public VisStrip(Node node, Vector3f dummy) {
                super(node, new Vector3f());

                // if (node.text.length()>0)
                // mapfile=node.text;

                loadWalls();

                radius = 2000;

                // add(new VisKUKA( new Vector3f(-180,30,515)));
                // add(new VisInteractive(null, new Vector3f(0, -20,0)));

                // add(new VisInteractive(null, new Vector3f(0, -20,0), new
                // Vector3f(100,0,100)));

                // add(new VisWall(new Vector3f(0,50,-50),0));
        }

        private void loadWalls() {
                float off = 0;
                File f = null;

                f = new File("misc/strip/");

                int max = f.listFiles().length;
                for (int count = 0; count < max && count < 1200; count++) {
                        try {

                                String fname = "misc/strip/so" + String.format("%1$04d", count)
                                                + ".coord";

                                if (Prefs.current.verbose)
                                        System.out.println(fname);
                                BufferedReader r = new BufferedReader(new FileReader(new File(
                                                fname)));

                                String l;
                                maxx = -100000;
                                maxz = -100000;
                                minx = 100000;
                                minz = 100000;

                                Frame currentFrame = new Frame();
                                frames.add(currentFrame);

                                do {
                                        off += .1;
                                        Poly currentWall = new Poly();
                                        currentFrame.add(currentWall);

                                        while ((l = r.readLine()) != null) {
                                                if (l.equals(""))
                                                        break;
                                                else {
                                                        String[] coords = l.split(" ");

                                                        if (coords[0].equals("M")) {
                                                                markers.add(new Vector3f(Float
                                                                                .parseFloat(coords[1]), Float
                                                                                .parseFloat(coords[2]), Float
                                                                                .parseFloat(coords[3])));
                                                        } else {
                                                                tx = Float.parseFloat(coords[0]);
                                                                ty = off;
                                                                tz = Float.parseFloat(coords[2]);

                                                                minx = Math.min(tx, minx);

                                                                maxx = Math.max(tx, maxx);

                                                                minz = Math.min(tz, minz);
                                                                maxz = Math.max(tz, maxz);

                                                                currentWall.add(new Vector3f(tx, ty, tz));

                                                        }
                                                }
                                        }
                                } while (l != null);
                                if (Prefs.current.verbose)
                                        System.out.println(minz + " " + maxz + " " + minx + " "
                                                        + maxx);
                                // add(new VisInteractive(null, new Vector3f(-(maxx-minx)/2,
                                // 0,-(maxz-minz)/2), new
                                // Vector3f((maxx-minx),0,(maxz-minz))));

                        } catch (FileNotFoundException e) {
                                // nichts machen, da rechnen wir ja mit.
                        } catch (NumberFormatException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }

                }

        }

        @Override
        void transform() {
                super.transform();
                GL11.glTranslatef(0, 0, -1000);
                GL11.glRotatef(180, 0, 1, 0);
                GL11.glScalef(.4f, .4f, .4f);
                GL11.glRotatef(-90, 1, 0, 0);
        }

        @Override
        void renderSelf() {

                if (dl == 0) {
                        dl = GL11.glGenLists(1);
                        GL11.glNewList(dl, GL11.GL_COMPILE);
                        GL11.glDisable(GL11.GL_TEXTURE_2D);
                        // GL11.glEnable(GL11.GL_CULL_FACE);
                        GL11.glColor4f(1, 1, 1, .5f);

                        // GL11.glRotatef(90,1,0,0);

                        Frame lastframe = null;

                        for (Frame frame : frames) {
                                for (List<Vector3f> wall : frame) {

                                        /*
                                         * GL11.glBegin(GL11.GL_LINE_STRIP); for (Vector3f segment:
                                         * wall) GL11.glVertex3f(segment.x, 0,segment.z);
                                         * GL11.glEnd();
                                         */
                                        if (wall.size() > 1) {
                                                GL11.glColor4f(1, 1, 1, .3f);
                                                GL11.glBegin(GL11.GL_LINE_STRIP);
                                                for (Vector3f segment : wall)
                                                        GL11.glVertex3f(segment.x, segment.y, segment.z);
                                                GL11.glEnd();

                                                double TOLERANCE = 20;
                                                GL11.glColor4f(1, 1, 1, .7f);
                                                GL11.glBegin(GL11.GL_LINES);
                                                if (lastframe != null)
                                                        for (Vector3f segment : wall) {
                                                                Vector3f match = null;
                                                                double mindist = Double.MAX_VALUE;
                                                                for (Poly pastwall : lastframe)
                                                                        for (Vector3f pastSegment : pastwall) {
                                                                                float dx = segment.x - pastSegment.x;
                                                                                float dz = segment.z - pastSegment.z;
                                                                                double dist = dx * dx + dz * dz;
                                                                                if (dist < mindist && dist < TOLERANCE) {
                                                                                        mindist = dist;
                                                                                        match = pastSegment;
                                                                                }
                                                                        }
                                                                if (match != null) {
                                                                        GL11.glVertex3f(segment.x, segment.y,
                                                                                        segment.z);
                                                                        GL11.glVertex3f(match.x, match.y, match.z);
                                                                }
                                                        }
                                                GL11.glEnd();

                                        }
                                }
                                /*
                                 * GL11.glBegin(GL11.GL_LINES);
                                 * 
                                 * 
                                 * for (Vector3f segment: wall){ GL11.glVertex3f(segment.x,
                                 * 0,segment.z); GL11.glVertex3f(segment.x,
                                 * segment.y,segment.z); } GL11.glEnd();
                                 */
                                lastframe = frame;

                        }

                        GL11.glBegin(GL11.GL_LINES);
                        for (Vector3f segment : markers) {
                                GL11.glVertex3f(segment.x, segment.y, segment.z);
                                GL11.glVertex3f(segment.x, segment.y + 50, segment.z);
                        }
                        GL11.glEnd();

                        // GL11.glDisable(GL11.GL_CULL_FACE);
                        GL11.glDisable(GL11.GL_LIGHTING);
                        GL11.glEndList();
                }
                GL11.glCallList(dl);
        }
}

---