Edge.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2014 Andrei Stoica. 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: Andrei Stoica - initial API and implementation during Google Summer of Code 2014
 ******************************************************************************/

package edu.tum.cs.vis.model.util;

import javax.vecmath.Vector3f;

public class Edge {

        private final Vector3f  edge                    = new Vector3f();

        private final Vector3f  invertedEdge    = new Vector3f();

        private final Vertex[]  vertices                = new Vertex[2];

        private boolean                 isSharpEdge             = false;

        public Edge() {
                return;
        }

        public Edge(Vertex position1, Vertex position2) {
                this.edge.set(position1);
                this.edge.sub(position2);
                this.invertedEdge.negate(edge);
                this.vertices[0] = position1;
                this.vertices[1] = position2;
        }

        public Vector3f getEdgeValue() {
                return this.edge;
        }

        public Vector3f getInvertedEdgeValue() {
                return this.invertedEdge;
        }

        public Vertex[] getVerticesOfEdge() {
                return this.vertices;
        }

        public boolean isSharpEdge() {
                return this.isSharpEdge;
        }

        public boolean hasVertex(Vertex v) {
                if (v != null && (vertices[0].sameCoordinates(v) || vertices[1].sameCoordinates(v))) {
                        return true;
                }
                return false;
        }

        public void setEdgeValue() {
                if (this.vertices[0] == null || this.vertices[1] == null) {
                        return;
                }
                this.edge.set(this.vertices[0]);
                this.edge.sub(this.vertices[1]);
        }

        public void setInvertedEdgeValue() {
                this.invertedEdge.negate(this.edge);
        }

        public void setVerticesOfEdge(final Vertex position1, final Vertex position2) {
                this.vertices[0] = position1;
                this.vertices[1] = position2;
                this.setEdgeValue();
                this.setInvertedEdgeValue();
        }

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

        public boolean isEqualTo(Edge edge) {
                if (this.vertices[0].sameCoordinates(edge.vertices[0])
                                && this.vertices[1].sameCoordinates(edge.vertices[1])) {
                        return true;
                }
                if (this.vertices[0].sameCoordinates(edge.vertices[1])
                                && this.vertices[1].sameCoordinates(edge.vertices[0])) {
                        return true;
                }
                return false;
        }

        public boolean isCollinear(Edge edge) {
                // compute angle between the two edges in DEG (will result a value in [0,180] DEG)
                float angle = this.edge.angle(edge.edge) * 180.f / (float) Math.PI;
                // if the angle is in [0,angleTolerance] || [180-angleTolerance,180] then edges are
                // collinear
                if (angle <= Thresholds.ANGLE_TOLERANCE || angle >= (180.0f - Thresholds.ANGLE_TOLERANCE)) {
                        return true;
                }
                return false;
        }

        public boolean containsVertex(Vertex v) {
                if (vertices[0].sameCoordinates(v)) {
                        return true;
                }
                if (vertices[1].sameCoordinates(v)) {
                        return true;
                }
                Vector3f sideEdge = new Vector3f(v);
                sideEdge.sub(vertices[0]);
                sideEdge.cross(sideEdge, edge);
                if (sideEdge.length() == 0.0f) {
                        return true;
                }
                return false;
        }

        public boolean containsVertexInside(Vertex v) {
                Vector3f edgeRef = new Vector3f(invertedEdge);
                // create edge given the vertex to be compared
                Vector3f edgeCmp = new Vector3f(v);
                edgeCmp.sub(vertices[0]);
                if (edgeCmp.length() <= Thresholds.DISTANCE_TOLERANCE) {
                        return false;
                }
                // get the angle (in DEG) between the two edges (in [0,180])
                float angle = edgeRef.angle(edgeCmp) * 180.0f / (float) Math.PI;
                // check if the angle is bigger than the tolerance
                if (angle > Thresholds.ANGLE_TOLERANCE && angle < (180.f - Thresholds.ANGLE_TOLERANCE)) {
                        return false;
                }
                // now the edges are parallel so v is on the ref edge
                // check if it is inside using dot product
                float dotProd = edgeCmp.dot(edgeRef);
                // the vertex is inside if dotProd in between the edgeRef with the tolerance levels
                // discounted for the edge vertices
                if (dotProd <= Thresholds.DISTANCE_TOLERANCE) {
                        return false;
                }
                if (dotProd >= (edge.length() * (edge.length() - Thresholds.DISTANCE_TOLERANCE))) {
                        return false;
                }
                return true;
        }

        public boolean isDirectNeighbor(Edge nEdge) {
                if (this.isCollinear(nEdge)) {
                        if ((this.vertices[0].sameCoordinates(nEdge.vertices[0]) && this.vertices[1]
                                        .sameCoordinates(nEdge.vertices[1]))
                                        || (this.vertices[1].sameCoordinates(nEdge.vertices[0]) && this.vertices[0]
                                                        .sameCoordinates(nEdge.vertices[1]))) {
                                return true;
                        } else if ((this.containsVertexInside(nEdge.vertices[0]))
                                        || (this.containsVertexInside(nEdge.vertices[1]))
                                        || (nEdge.containsVertexInside(this.vertices[0]))
                                        || (nEdge.containsVertexInside(this.vertices[1]))) {
                                return true;
                        }
                }
                return false;
        }

        @Override
        public String toString() {
                String print = "Edge: " + this.edge + "\n";
                print = print + "Vertex1: " + this.vertices[0] + ", Vertex2: " + this.vertices[1];
                return print;
        }
}