Edge.java

import java.util.ArrayList;

public class Edge {
    
    private ArrayList<Node> subNodes;
    private ArrayList<Node> tempSubNodes;
    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;
        }
    }

    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 ArrayList<Node> getTempSubNodes(){
        return tempSubNodes;
    }
    
    public void setTempSubNodes(ArrayList<Node> subNodes){
        tempSubNodes = subNodes;
    }
    
    public boolean isIncident(Node node){
        return (node.equals(startNode) || node.equals(endNode));
    }
    
    public double dx(){
        return endNode.getX()-startNode.getX();
    }
    
    public double dy(){
        return endNode.getY()-startNode.getY();
    }
    
    public double compatibility(Edge other){
        return angleComp(other)*posComp(other)*scaleComp(other)*visComp(other);
    }
    
    public double magnitude(){
        return Math.sqrt(dx()*dx()+dy()*dy());
    }
    
    public double visibility(Edge other){
        Node ds = new Node(other.getStartNode().getX()+dy(), other.getStartNode().getY()-dx());
        Node de = new Node(other.getEndNode().getX()+dy(), other.getEndNode().getY()-dx());
        Node is = lineIntersection(new Edge(other.getStartNode(), ds));
        Node ie = lineIntersection(new Edge(other.getEndNode(), de));
        Node im = new Edge(is, ie).midPoint();
        if(is == null || im == null || ie == null)
            return 0;
        return Math.max(0, 1-(2*midPoint().distance(im))/is.distance(ie));
    }
    
    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 Node midPoint(){
        double x = (startNode.getX()+endNode.getX())/2;
        double y = (startNode.getY()+endNode.getY())/2;
        return new Node(x,y);
    }
    
    public void deleteSubNodes(){
        subNodes = null;
    }
    
    public void finalizeSubNodes(){
        subNodes = tempSubNodes;
        tempSubNodes = null;
    }
    
    public void increaseSubNodes(){
        if (subNodes == null){
            subNodes = new ArrayList<Node>();
            subNodes.add(startNode);
            subNodes.add(midPoint());
            subNodes.add(endNode);
        } else{
            ArrayList<Node> tempList = new ArrayList<Node>();
            for(int i=0; i < subNodes.size()-1; i++){
                tempList.add(subNodes.get(i));
                tempList.add(new Node((subNodes.get(i).getX()+subNodes.get(i+1).getX())/2,
                        (subNodes.get(i).getY()+subNodes.get(i+1).getY())/2));
            }
            tempList.add(endNode);
            subNodes = tempList;
        }
    }
    
    private double angleComp(Edge other){
        double angle = Math.cos(Math.acos(Math.abs((dx()*other.dx()+dy()*other.dy())
                / (magnitude()*other.magnitude()))));
        return angle;
    }
    
    private double posComp(Edge other){
        Edge bridge = new Edge(midPoint(), other.midPoint());
        double lavg = (magnitude()+other.magnitude())/2;
        double pos = lavg/(lavg+bridge.magnitude());
        return pos;
    }
    
    private double scaleComp(Edge other){
        double lavg = (magnitude()+other.magnitude())/2;
        double scale = 2/(lavg/Math.min(magnitude(), other.magnitude()) 
                + Math.max(magnitude(), other.magnitude())/lavg);
        return scale;
    }
    
    private double visComp(Edge other){
        return Math.min(visibility(other), other.visibility(this));
    }
    
    private Node lineIntersection(Edge other){
        double x1 = startNode.getX();
        double y1 = startNode.getY();
        double x2 = endNode.getX();
        double y2 = endNode.getY();
        double x3 = other.getStartNode().getX();
        double y3 = other.getStartNode().getY();
        double x4 = other.getEndNode().getX();
        double y4 = other.getEndNode().getY();
        
        if((x1-x2)*(y3-y4)-(y1-y2)*(x3-x4) == 0)
            return null;
        double px = ((x1*y2-y1*x2)*(x3-x4)-(x1-x2)*(x3*y4-y3*x4))/((x1-x2)*(y3-y4)-(y1-y2)*(x3-x4));
        double py = ((x1*y2-y1*x2)*(y3-y4)-(y1-y2)*(x3*y4-y3*x4))/((x1-x2)*(y3-y4)-(y1-y2)*(x3-x4));
        return new Node(px, py);
    }
}