CanvasPanel.java

import javax.swing.JPanel;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Line2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;

public class CanvasPanel extends JPanel {
    
    private boolean bundlingActive;
    private int mousePosX, mousePosY;
    private int radius = 5;
    private ArrayList<Edge> edges;
    private ArrayList<Node> nodes;
    private MainWindow window;
    private Node selectedNode;

    public CanvasPanel(MainWindow window) {
        this.window = window;
        setBackground(Color.WHITE);
        
        edges = new ArrayList<Edge>();
        nodes = new ArrayList<Node>();
        bundlingActive = false;
        addListeners();
    }
    
    private void addListeners(){
        addMouseListener(new MouseListener() {
            
            @Override
            public void mouseReleased(MouseEvent e) {
                // Create or move a Node of the graph.
                if(window.getMouseMode() == MouseMode.NODE){
                    if(selectedNode != null){
                        boolean occupied = false;
                        for(Node node : nodes){
                            if(clickedNode(e, node) && !node.equals(selectedNode)){
                                occupied = true;
                                break;
                            }
                        }
                        if(!occupied)
                            selectedNode.setCoords(mousePosX, mousePosY);
                        selectedNode = null;
                    }
                    else
                        nodes.add(new Node(e.getX(), e.getY()));
                }
                // Create an Edge of the graph.
                if(window.getMouseMode() == MouseMode.EDGE){
                    for(Node node : nodes){
                        if(clickedNode(e, node)){
                            if(!node.equals(selectedNode)){
                                edges.add(new Edge(selectedNode, node));
                                break;
                            }
                        }
                    }
                    selectedNode = null;
                }
                // Delete a Node or Edge of the graph.
                if(window.getMouseMode() == MouseMode.DELETE){
                    for(Node node : nodes){
                        if(clickedNode(e, node)){
                            nodes.remove(node);
                            ArrayList<Edge> edgesToDelete = new ArrayList<Edge>();
                            for(Edge edge : edges){
                                if(edge.isIncident(node))
                                    edgesToDelete.add(edge);
                            }
                            edges.removeAll(edgesToDelete);
                            break;
                        }
                    }
                    for(Edge edge : edges){
                        if(clickedEdge(e, edge)){
                            edges.remove(edge);
                            break;
                        }
                    }
                }
                paintComponent(getGraphics());
            }
            
            @Override
            public void mousePressed(MouseEvent e) {
                // Let the user create an Edge of the graph.
                if(window.getMouseMode() == MouseMode.EDGE){
                    for(Node node : nodes){
                        if(clickedNode(e, node)){
                            selectedNode = node;
                            break;
                        }
                    }
                }
                // Let the user move a Node of the graph.
                if(window.getMouseMode() == MouseMode.NODE){
                    for(Node node : nodes){
                        if(clickedNode(e, node)){
                            selectedNode = node;
                            break;
                        }
                    }
                }
            }
            
            @Override
            public void mouseExited(MouseEvent e) {
            }
            
            @Override
            public void mouseEntered(MouseEvent e) {
            }
            
            @Override
            public void mouseClicked(MouseEvent e) {
            }
        });
        
        addMouseMotionListener(new MouseMotionListener() {
            
            @Override
            public void mouseMoved(MouseEvent e) {
            }
            
            @Override
            // Draw the Edge or Node that the user is holding.
            public void mouseDragged(MouseEvent e) {
                if(selectedNode != null){
                    mousePosX = e.getX();
                    mousePosY = e.getY();
                    paintComponent(getGraphics());
                }
            }
        });
    }
    
    @Override
    public void paintComponent(Graphics g){
        super.paintComponent(g);
        BufferedImage bimg = new BufferedImage(getSize().width, getSize().width, 
                BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bimg.createGraphics();

        // Draw the Edges of the graph.
        g2d.setColor(new Color(0, 0, 0, 0.10f));
        g2d.setStroke(new BasicStroke(3));
        for(Edge edge : edges){
            if(bundlingActive){
                g2d.drawPolyline(edge.subNodesXInt(), edge.subNodesYInt(), edge.getSubNodes().size());
            }
            else
                g2d.drawLine(edge.getStartNode().getXInt(), edge.getStartNode().getYInt(), 
                        edge.getEndNode().getXInt(), edge.getEndNode().getYInt());
        }
        
        // Color the Edges of the graph.
        int[] pixels = bimg.getRGB(0, 0, getSize().width, getSize().height, null, 0, getSize().width);
        for(int p=0; p < getSize().width*getSize().height; p++){
            int alpha = pixels[p]>>24 & 255;
            if(alpha > 0)
                pixels[p] = alpha<<24 | alpha<<16 | (255-alpha);
        }
        bimg.setRGB(0, 0, getSize().width, getSize().height, pixels, 0, getSize().width);
        
        // Draw the Nodes of the graph.
        g2d.setColor(Color.BLACK);
        for(Node node : nodes){
            if(node.equals(selectedNode)){
                if(window.getMouseMode() == MouseMode.NODE)
                    g2d.fillOval(mousePosX-radius, mousePosY-radius, radius*2, radius*2);
                else{
                    g2d.fillOval(node.getXInt()-radius, node.getYInt()-radius, radius*2, radius*2);
                    g2d.drawLine(node.getXInt(), node.getYInt(), mousePosX, mousePosY);
                }
            }
            else
                g2d.fillOval(node.getXInt()-radius, node.getYInt()-radius, radius*2, radius*2);
        }
        this.getGraphics().drawImage(bimg, 0, 0, null);
    }
    
    public void addEdge(int startNodeIndex, int endNodeIndex){
        edges.add(new Edge(nodes.get(startNodeIndex), nodes.get(endNodeIndex)));
    }
    
    public void addNode(int x, int y){
        nodes.add(new Node(x, y));
    }
    
    public ArrayList<Edge> getEdges(){
        return edges;
    }
    
    public ArrayList<Node> getNodes(){
        return nodes;
    }

    public void bundleEdges(int stiffness, boolean animate){
        int cycles = 5;
        int iterations = 50;
        double stepSize = 0.4;
        double progress = 0;
        for(int c=0; c < cycles; c++){
            for(Edge e : edges)
                e.increaseSubNodes();
            for(int i=0; i < iterations; i++){
                for(Edge e : edges){
                    double kp = stiffness/e.magnitude()*(e.getSubNodes().size()-1);
                    ArrayList<Node> tempSubNodes = new ArrayList<Node>();
                    tempSubNodes.add(e.getStartNode());
                    for(int n=1; n < e.getSubNodes().size()-1; n++){
                        double esForceX = 0;
                        double esForceY = 0;
                        Node s = e.getSubNodes().get(n);
                        Node pre = e.getSubNodes().get(n-1);
                        Node suc = e.getSubNodes().get(n+1);
                        
                        // Calculate electrostatic force
                        for(Edge f : edges){
                            if(e != f){
                                double comp = e.compatibility(f);
                                if(comp > 0.1){
                                    Node t = f.getSubNodes().get(n);
                                    double nDist = Double.POSITIVE_INFINITY;
                                    for(Node u : f.getSubNodes()){
                                        if(s.distance(u) < nDist){
                                            nDist = s.distance(u);
                                            t = u;
                                        }
                                    }
                                    if(s.distance(t) > 0){
                                        esForceX += comp * ((t.getX()-s.getX()) / s.distance(t));
                                        esForceY += comp * ((t.getY()-s.getY()) / s.distance(t));
                                    }
                                }
                            }
                        }
                        // Calculate spring force and move sub-Nodes
                        double springForceX = kp * ((pre.getX()-s.getX())) 
                                + kp * ((suc.getX()-s.getX()));
                        double springForceY = kp * ((pre.getY()-s.getY())) 
                                + kp * ((suc.getY()-s.getY()));
                        tempSubNodes.add(new Node(s.getX()+esForceX*stepSize+springForceX*stepSize,
                                s.getY()+esForceY*stepSize+springForceY*stepSize));
                    }
                    tempSubNodes.add(e.getEndNode());
                    e.setTempSubNodes(tempSubNodes);
                }
                for(Edge e : edges)
                    e.finalizeSubNodes();
                bundlingActive = true;
                progress += (100.0/cycles)/iterations;
                window.updateProgress((int)progress);
                if(animate)
                    paintComponent(getGraphics());
            }
            // Decrease iterations and stepSize for next cycle
            iterations = (int)Math.round(iterations*2/3);
            stepSize = stepSize/2;
        }
        bundlingActive = true;
        window.updateProgress(0);
        paintComponent(getGraphics());
    }
    
    public void clearAll(){
        nodes.clear();
        edges.clear();
        paintComponent(getGraphics());
    }
    
    public void connectAll(){
        edges.clear();
        for(int i=0; i<nodes.size(); i++)
            for(int j=i+1; j<nodes.size(); j++)
                edges.add(new Edge(nodes.get(i), nodes.get(j)));
        paintComponent(getGraphics());
    }
    
    public void unbundleEdges(){
        bundlingActive = false;
        for(Edge edge: edges)
            edge.deleteSubNodes();
        paintComponent(getGraphics());
    }
    
    private boolean clickedEdge(MouseEvent e, Edge edge){
        return (Line2D.ptSegDist(edge.getStartNode().getX(), edge.getStartNode().getY(), 
                edge.getEndNode().getX(), edge.getEndNode().getY(), e.getX(), e.getY()) < 2.0);
    }

    private boolean clickedNode(MouseEvent e, Node node){
        return (e.getX() >= node.getX()-radius && e.getX() <= node.getX()+radius &&
                e.getY() >= node.getY()-radius && e.getY() <= node.getY()+radius);
    }
}