Edge.java

import java.util.ArrayList;

import org.jdelaunay.delaunay.geometries.DEdge;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.LineSegment;

public class Edge {
    
    private ArrayList<Node> subNodes;
    private Node endNode;
    private Node startNode;
    
    public Edge(Node startNode, Node endNode){
        if(startNode.getX() <= endNode.getX()){
            this.startNode = startNode;
            this.endNode = endNode;
        } else{
            this.endNode = startNode;
            this.startNode = endNode;
        }
        subNodes = new ArrayList<Node>();
    }
    
    public Edge(Node startNode, double angleXAxis){
        this.startNode = startNode;
        double x = Math.cos(Math.toRadians(angleXAxis));
        double y = -Math.sin(Math.toRadians(angleXAxis));
        endNode = new Node(startNode.getX()+x, startNode.getY()+y);
        subNodes = new ArrayList<Node>();
    }
    
    public Edge(DEdge dEdge){
        this(new Node(dEdge.getStartPoint()), new Node(dEdge.getEndPoint()));
        subNodes = new ArrayList<Node>();
    }

    public Node getEndNode() {
        return endNode;
    }

    public void setEndNode(Node endNode) {
        this.endNode = endNode;
    }
    
    public Node getStartNode() {
        return startNode;
    }

    public void setStartNode(Node startNode) {
        this.startNode = startNode;
    }
    
    public ArrayList<Node> getSubNodes(){
        return subNodes;
    }
    
    public void addSubNode(Node node){
        subNodes.add(node);
    }
    
    public boolean isIncident(Node node){
        return (node.equals(startNode) || node.equals(endNode));
    }
    
    public double angleXAxis(){
        double angle = Math.toDegrees(Math.acos(dx()/magnitude()));
        while(angle >= 180)
            angle -= 180;
        return angle;
    }
    
    public double dx(){
        return endNode.getX()-startNode.getX();
    }
    
    public double dy(){
        return endNode.getY()-startNode.getY();
    }
    
    public double magnitude(){
        return Math.sqrt(dx()*dx()+dy()*dy());
    }
    
    public int[] subNodesXInt(){
        int[] subX = new int[subNodes.size()];
        for(int i=0; i < subNodes.size(); i++){
            subX[i] = subNodes.get(i).getXInt();
        }
        return subX;
    }
    
    public int[] subNodesYInt(){
        int[] subY = new int[subNodes.size()];
        for(int i=0; i < subNodes.size(); i++){
            subY[i] = subNodes.get(i).getYInt();
        }
        return subY;
    }
    
    public DEdge toDEdge(){
        return new DEdge(startNode.toDPoint(), endNode.toDPoint());
    }
    
    public LineSegment toLineSegment(){
        return new LineSegment(startNode.toCoordinate(), endNode.toCoordinate());
    }
    
    public Node intersection(Edge other){
        Coordinate s = toLineSegment().intersection(other.toLineSegment());
        if(s != null)
            return new Node(toLineSegment().intersection(other.toLineSegment()));
        else
            return null;
    }
    
    public void deleteSubNodes(){
        subNodes.clear();
    }
}