Vertex.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; Andrei Stoica -
 * refactored implementation during Google Summer of Code 2014
 ******************************************************************************/
package edu.tum.cs.vis.model.util;

import java.awt.Color;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

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

public class Vertex extends Point3f {

        private static final long       serialVersionUID        = 4454667509075960402L;

        private Vector3f                        normalVector            = new Vector3f();

        private float                           pointarea                       = 0f;

        public Color                            color;

        public Color                            overrideColor           = null;

        private int                                     clusterLabel            = -1;

        private final float[]           clusterCurvatureVal     = { 0.0f, 0.0f, 0.0f };

        private boolean                         isSharpVertex           = false;

        private final Set<Vertex>       neighbors                       = new HashSet<Vertex>();

        public Vertex(float x, float y, float z) {
                super(x, y, z);
        }

        public Vertex(Tuple3f p) {
                super(p);
        }

        public Vertex(Tuple3f p, Vector3f norm) {
                super(p);
                this.normalVector = (Vector3f) norm.clone();
        }

        /*
         * (non-Javadoc)
         * @see javax.vecmath.Tuple3f#clone()
         */
        @Override
        public Object clone() {
                Vertex v = new Vertex(this);
                v.normalVector = (Vector3f) normalVector.clone();
                v.color = color == null ? null : new Color(color.getRed(), color.getGreen(),
                                color.getBlue(), color.getAlpha());
                v.overrideColor = overrideColor == null ? null : new Color(overrideColor.getRed(),
                                overrideColor.getGreen(), overrideColor.getBlue(), overrideColor.getAlpha());
                return v;
        }

        /*
         * (non-Javadoc)
         * @see javax.vecmath.Tuple3f#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object o) {
                if (o == this) {
                        return true;
                }

                return false;
        }

        public boolean sameCoordinates(Point3f p) {
                // if exact coordinates return true
                if (p.x == x && p.y == y && p.z == z) {
                        return true;
                }
                // else check if vertices have different coordinates
                // but within the tolerance level
                float distanceTolerance = Thresholds.DISTANCE_TOLERANCE;
                Vector3f diff = new Vector3f(x, y, z);
                diff.sub(p);
                return (diff.length() <= distanceTolerance);
        }

        public Vector3f getNormalVector() {
                return normalVector;
        }

        public float getPointarea() {
                return pointarea;
        }

        /*
         * (non-Javadoc)
         * @see javax.vecmath.Tuple3f#hashCode()
         */
        @Override
        public int hashCode() {
                return Float.valueOf(x).hashCode() ^ Float.valueOf(y).hashCode()
                                ^ Float.valueOf(z).hashCode() ^ Double.valueOf(pointarea).hashCode()
                                ^ normalVector.hashCode();
        }

        public void setNormalVector(Vector3f normalVector) {
                this.normalVector = normalVector;
        }

        public void setPointarea(float pointarea) {

                this.pointarea = pointarea;
        }

        public void transform(float[][] matrix) {

                float[] newPos = new float[4];
                for (int row = 0; row < 4; row++) {
                        newPos[row] = x * matrix[row][0] + y * matrix[row][1] + z * matrix[row][2]
                                        + matrix[row][3];
                }
                x = newPos[0] / newPos[3];
                y = newPos[1] / newPos[3];
                z = newPos[2] / newPos[3];
        }

        public Set<Vertex> getNeighbors() {
                return neighbors;
        }

        public void addNeighbor(Vertex v) {
                if (v == this)
                        return;
                synchronized (neighbors) {
                        neighbors.add(v);
                }
        }

        public void addNeighbor(Collection<Vertex> neig) {
                synchronized (neighbors) {
                        synchronized (neig) {
                                neighbors.addAll(neig);
                        }
                        // make sure we didn't add ourself as neighbor
                        if (neighbors.contains(this))
                                neighbors.remove(this);
                }
        }

        public void addNeighbor(Vertex[] neig) {
                synchronized (neighbors) {
                        synchronized (neig) {
                                for (Vertex v : neig) {
                                        if (v == this)
                                                continue;
                                        neighbors.add(v);
                                }
                        }
                }
        }

        public boolean isSharpVertex() {
                return isSharpVertex;
        }

        public void isSharpVertex(final boolean value) {
                this.isSharpVertex = value;
        }

        public int getClusterLabel() {
                return clusterLabel;
        }

        public void setClusterLabel(final int newLabel) {
                this.clusterLabel = newLabel;
        }

        public float[] getClusterCurvatureVal() {
                return clusterCurvatureVal;
        }

        public void setClusterCurvatureVal(final float newKMin, final float newKMax,
                        final float newKMinKMax) {
                this.clusterCurvatureVal[0] = newKMin;
                this.clusterCurvatureVal[1] = newKMax;
                this.clusterCurvatureVal[2] = newKMinKMax;
        }
}