$search

Group.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2012 Stefan Profanter. All rights reserved. This program and the accompanying
 * materials are made available under the terms of the GNU Public License v3.0 which accompanies
 * this distribution, and is available at http://www.gnu.org/licenses/gpl.html
 * 
 * Contributors: Stefan Profanter - initial API and implementation, Year: 2012
 ******************************************************************************/
package edu.tum.cs.vis.model.util;

import java.awt.Color;
import java.io.Serializable;
import java.util.ArrayList;

import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;

import processing.core.PGraphics;
import edu.tum.cs.vis.model.Model;

public class Group implements Serializable {

        private final Model                     model;

        private static final long       serialVersionUID        = -3347910663268579041L;
        protected Float                         minX                            = null;
        protected Float                         maxX                            = null;
        protected Float                         minY                            = null;
        protected Float                         maxY                            = null;
        protected Float                         minZ                            = null;
        protected Float                         maxZ                            = null;

        private Mesh                            mesh                            = new Mesh();

        private String                          name;

        private ArrayList<Group>        children                        = new ArrayList<Group>();

        public Group(Model parent) {
                model = parent;
        }

        public void addChild(Group g) {
                children.add(g);
        }

        public void draw(PGraphics g, Color overrideColor) {
                mesh.drawLines(g, overrideColor);
                mesh.drawTriangles(g, overrideColor);
                for (Group gr : children) {
                        gr.draw(g, overrideColor);
                }
        }

        public boolean removeTriangle(Triangle t) {
                if (mesh.getTriangles().remove(t))
                        return true;
                for (Group gr : children) {
                        boolean ret = gr.removeTriangle(t);
                        if (ret)
                                return ret;
                }
                return false;
        }

        public void drawBoundingBox(PGraphics gr, boolean recursive) {
                mesh.drawBoundingBox(gr);
                if (recursive) {
                        for (Group g : children) {
                                g.drawBoundingBox(gr, recursive);
                        }
                }
        }

        public void addTriangle(Triangle t) {
                synchronized (mesh.getTriangles()) {
                        mesh.getTriangles().add(t);
                }
                synchronized (model.getTriangles()) {
                        model.getTriangles().add(t);
                }
        }

        public ArrayList<Group> getChildren() {
                return children;
        }

        public void getIntersectedTriangles(final Point3f rayStart, final Point3f rayEnd,
                        final ArrayList<IntersectedTriangle> intersectedTriangles) {
                mesh.getIntersectedTriangles(rayStart, rayEnd, intersectedTriangles);

                for (Group g : children) {
                        g.getIntersectedTriangles(rayStart, rayEnd, intersectedTriangles);
                }

        }

        public Float getMaxX() {
                if (maxX == null)
                        getTotalWidth();
                return maxX;
        }

        public Float getMaxY() {
                if (maxY == null)
                        getTotalHeight();
                return maxY;
        }

        public Float getMaxZ() {
                if (maxZ == null)
                        getTotalDepth();
                return maxZ;
        }

        public Mesh getMesh() {
                return mesh;
        }

        public Float getMinX() {
                if (minX == null)
                        getTotalWidth();
                return minX;
        }

        public Float getMinY() {
                if (minY == null)
                        getTotalHeight();
                return minY;
        }

        public Float getMinZ() {
                if (minZ == null)
                        getTotalDepth();
                return minZ;
        }

        public Model getModel() {
                return model;
        }

        public String getName() {
                return name;
        }

        public float getTotalDepth() {
                if (minZ == null || maxZ == null) {
                        minZ = mesh.getMinZ();
                        maxZ = mesh.getMaxZ();

                        for (Group g : children) {
                                minZ = Math.min(minZ, g.getMinZ());
                                maxZ = Math.max(maxZ, g.getMaxZ());

                        }
                }
                return maxZ - minZ;
        }

        public float getTotalHeight() {
                if (minY == null || maxY == null) {
                        minY = mesh.getMinY();
                        maxY = mesh.getMaxY();

                        for (Group g : children) {
                                minY = Math.min(minY, g.getMinY());
                                maxY = Math.max(maxY, g.getMaxY());

                        }
                }
                return maxY - minY;
        }

        public float getTotalWidth() {
                if (minX == null || maxX == null) {
                        minX = mesh.getMinX();
                        maxX = mesh.getMaxX();

                        for (Group g : children) {
                                minX = Math.min(minX, g.getMinX());
                                maxX = Math.max(maxX, g.getMaxX());

                        }
                }
                return maxX - minX;
        }

        public void initialize(String textureBasePath) {
                initialize(textureBasePath, true);
        }

        private void initialize(String textureBasePath, boolean isRoot) {
                // Initialize min and max values of mesh
                mesh.setTextureBasePath(textureBasePath);
                mesh.getWidth();
                mesh.getHeight();
                mesh.getDepth();
                for (Group g : children) {
                        g.initialize(textureBasePath, false);
                }
                getTotalWidth();
                getTotalHeight();
                getTotalDepth();
                if (isRoot) {
                        Vector3f translation = new Vector3f((minX + (getTotalWidth() / 2)) * (-1),
                                        (minY + (getTotalHeight() / 2)) * (-1), (minZ + (getTotalDepth() / 2)) * (-1));
                        for (Vertex v : model.getVertices())
                                v.add(translation);
                }
        }

        public void resetMinMaxValues() {
                mesh.resetMinMaxValues();

                minX = maxX = minY = maxY = minZ = maxZ = null;

                for (Group g : children) {
                        g.resetMinMaxValues();
                }
        }

        public void setChildren(ArrayList<Group> children) {
                this.children = children;
        }

        public void setMesh(Mesh mesh) {
                this.mesh = mesh;
        }

        public void setName(String name) {
                this.name = name;
        }

}

---

knowrob_cad_parser
Author(s): Stefan Profanter
autogenerated on Tue Mar 5 12:15:33 2013