/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * All rights reserved. Check the documentation for licensing terms.
    * https://caribou.iisg.agh.edu.pl/trac/cast
    */
   package pl.edu.agh.cast.schema.layout.algorithm;
   
   import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Queue;
  import java.util.Set;
  
  import org.eclipse.core.runtime.IProgressMonitor;
  import org.eclipse.draw2d.geometry.Point;
  
  import pl.edu.agh.cast.model.visual.backward.ConnectionGroup;
  import pl.edu.agh.cast.model.visual.backward.Node;
  import pl.edu.agh.cast.schema.util.Messages;
  
  /**
   * This class represents version 3 of peacock layout algorithm.
   *
   * @author Kornel Skalkowski kornelsk@gmail.com
   * @author Jakub Fibinger jfibinger@gmail.com
   *
   */
  public class Peacock3LayoutAlgorithm extends AbstractGroupingLayoutAlgorithm {
  
      private final int STEPS_NUMBER = 5;
  
      private final int AREA_CENTER_X = 0;
  
      private final int AREA_CENTER_Y = 0;
  
      private final double RADIUS_SCALE = 40;
  
      private final double MIN_RADIUS_SCALE_FACTOR = 1;
  
      private final double MAX_RADIUS_SCALE_FACTOR = 7;
  
      private final double DISTANCE_FACTOR = 0.001;
  
      private final double ANGLE_RANGE_FACTOR = 1.4;
  
      private int maxWeight = -1;
  
      private int minWeight = -1;
  
      private int treeSize = 0;
  
      private double radius = 150;
  
      private double radiusScaleFactor = 2;
  
      private Collection<Node> nodes = null;
  
      private boolean[][] adiacentTable = null;
  
      private Map<String, Integer> distanceSums = new HashMap<String, Integer>();
  
      private Map<String, Integer> adiacentTablePositions = new HashMap<String, Integer>();
  
      private Map<String, Map<String, Integer>> distancesTable = new HashMap<String, Map<String, Integer>>();
  
      /**
       * This class represents single node in BFS tree.
       *
       * @author Jakub Fibinger jfibinger@gmail.com
       * @author Kornel Skalkowski kornelsk@gmail.com
       *
       */
      private class TreeNode {
  
          Node node;
  
          TreeNode parent;
  
          Set<TreeNode> children = new HashSet<TreeNode>();
  
          /**
           * Public constructor.
           *
           * @param node
           *            graph's node.
           */
          public TreeNode(Node node) {
              this.node = node;
          }
  
      }
  
      @Override
     /*
      * This method sets nodes positions on board.
      *
      * @param positionNodes collection of nodes to position.
      */
     protected void setNodesPositions(Collection<Node> positionNodes, IProgressMonitor monitor) {
 
         monitor.subTask(Messages.Peacock3LayoutAlgorithm_0);
 
         this.nodes = positionNodes;
         this.setRadiusScaleFactor();
         this.setRootNode(new LinkedList<Node>(positionNodes));
 
         List<Edge> edges = new LinkedList<Edge>();
         minWeight = maxWeight = -1;
         for (Node n : nodes) {
             for (Node neighbor : getNeighbors(nodes, n)) {
                 if (findEdge(edges, n, neighbor) == null) {
                     int weight = getWeight(n, neighbor);
                     edges.add(new Edge(n, neighbor, weight));
                     if (minWeight == -1) {
                         minWeight = maxWeight = weight;
                     } else if (weight > maxWeight) {
                         maxWeight = weight;
                     } else if (weight < minWeight) {
                         minWeight = weight;
                     }
                 }
             }
             monitor.worked(positionNodes.size());
         }
 
         for (int i = 0; i < this.STEPS_NUMBER; i++) {
             steepestDescent(edges);
         }
         monitor.worked(positionNodes.size());
 
     }
 
     /**
      * This method sets scale factor field.
      */
     private void setRadiusScaleFactor() {
         this.radiusScaleFactor = this.nodes.size() / this.RADIUS_SCALE;
         if (this.radiusScaleFactor < this.MIN_RADIUS_SCALE_FACTOR) {
             this.radiusScaleFactor = this.MIN_RADIUS_SCALE_FACTOR;
         }
         if (this.radiusScaleFactor > this.MAX_RADIUS_SCALE_FACTOR) {
             this.radiusScaleFactor = this.MAX_RADIUS_SCALE_FACTOR;
         }
     }
 
     /**
      * This class represents single edge in graph.
      *
      * @author Jakub Fibinger jfibinger@gmail.com
      * @author Kornel Skalkowski kornelsk@gmail.com
      *
      */
     private class Edge {
 
         Node n1, n2;
 
         int weight;
 
         /**
          * Public constructor.
          *
          * @param n1
          *            first node of edge.
          * @param n2
          *            second node of edge.
          * @param weight
          *            edge weight.
          */
         public Edge(Node n1, Node n2, int weight) {
             this.n1 = n1;
             this.n2 = n2;
             this.weight = weight;
         }
 
     }
 
     /**
      * This method looks for Edge object connecting two nodes
      *
      * @param edges
      *            list of all edges
      * @param n1
      *            first node
      * @param n2
      *            second node
      * @return found edge or null if doesn't exist
      */
     private Edge findEdge(List<Edge> edges, Node n1, Node n2) {
         for (Edge e : edges) {
             if (e.n2 == n1 && e.n1 == n2) {
                 return e;
             }
         }
         return null;
     }
 
     /**
      * This method returns number of calls between two nodes
      *
      * @param n1
      *            first node
      * @param n2
      *            second node
      * @return sum of calls in both directions
      */
     private int getWeight(Node n1, Node n2) {
         for (ConnectionGroup cg : n1.getConnectionGroups()) {
             if (cg.getTarget() == n2 || cg.getSource() == n2) {
                 int weight = cg.getConnectionCount();
                 return weight > 40 ? 40 : weight;
             }
         }
         return 0;
     }
 
     /**
      * This method calculates euclides distance between two nodes
      *
      * @param n1
      *            first node
      * @param n2
      *            second node
      * @return calculated distance
      */
     private double distance(Node n1, Node n2) {
         double length = n1.getLocation().x - n2.getLocation().x;
         double height = n1.getLocation().y - n2.getLocation().y;
         return Math.sqrt(length * length + height * height);
     }
 
     /**
      * Potential is function that is sum of potential of each edge. For edge e potential is caltulated as follows:
      * potential(e) = 1 - const_param * weight(e) * distance(e) where weight() is number of calls between two nodes
      * distance() is euclides distance between two nodes const_param is number used to scale the product of weight and
      * distance
      *
      * @param edges
      *            list of all edges between nodes
      * @return calculated potential
      */
     private double potential(List<Edge> edges) {
         double result = 0;
         for (Edge e : edges) {
             double a = 1 - DISTANCE_FACTOR * getWeight(e.n1, e.n2) * distance(e.n1, e.n2);
             result += a * a;
         }
         return result;
     }
 
     /**
      * This method calculates derivative of potential function with respect to a variable x of node n
      *
      * @param edges
      *            list of all edges between nodes
      * @param n
      *            node
      * @return calculated partial derivative
      */
     private double derivativeX(List<Edge> edges, Node n) {
         double result = 0;
         double x1 = n.getLocation().x;
         double x2 = 0;
         for (Edge e : edges) {
             if (e.n1 == n || e.n2 == n) {
                 if (e.n1 == n) {
                     x2 = e.n2.getLocation().x;
                 } else {
                     x2 = e.n1.getLocation().x;
                 }
 
                 double a = x1 - x2;
                 double b = e.n1.getLocation().y - e.n2.getLocation().y;
                 double sqrt = Math.sqrt(a * a + b * b);
                 double w = getWeight(e.n1, e.n2);
                 w *= DISTANCE_FACTOR;
                 result += -(2 * a * w * (w * sqrt - 1)) / sqrt;
             }
         }
         return result;
     }
 
     /**
      * This method calculates derivative of potential function with respect to a variable y of node n
      *
      * @param edges
      *            list of all edges between nodes
      * @param n
      *            node
      * @return calculated partial derivative
      */
     private double derivativeY(List<Edge> edges, Node n) {
         double result = 0;
         double x1 = n.getLocation().y;
         double x2 = 0;
         for (Edge e : edges) {
             if (e.n1 == n || e.n2 == n) {
                 if (e.n1 == n) {
                     x2 = e.n2.getLocation().y;
                 } else {
                     x2 = e.n1.getLocation().y;
                 }
 
                 double a = x1 - x2;
                 double b = e.n1.getLocation().x - e.n2.getLocation().x;
                 double sqrt = Math.sqrt(a * a + b * b);
                 double w = getWeight(e.n1, e.n2);
                 w *= DISTANCE_FACTOR;
 
                 result += -(2 * a * w * (w * sqrt - 1)) / sqrt;
             }
         }
         return result;
     }
 
     /**
      * This method is just a trial, it calculates potential for changed arrangement of nodes using gradient multiplied
      * by multiplier
      *
      * @param gradient
      *            vector of derivatives for all nodes, defines the directions for nodes to move
      * @param multiplier
      *            number that says how big the jump of nodes has to be
      * @param edges
      *            list of all edges between nodes
      * @return value of calculated potential
      */
     private double potentialForGradient(double[] gradient, int multiplier, List<Edge> edges) {
         int i = 0;
         Point[] oldCoords = new Point[nodes.size()];
         for (Node n : nodes) {
             int x = n.getLocation().x;
             int y = n.getLocation().y;
             oldCoords[i / 2] = n.getLocation();
 
             n.setLocation(new Point(x + gradient[i++] / multiplier, y + gradient[i++] / multiplier));
         }
         double result = potential(edges);
         i = 0;
         for (Node n : nodes) {
             n.setLocation(oldCoords[i++]);
         }
         return result;
     }
 
     /**
      * This method calculates arrangement of nodes using steepest descent algorithm. It tries to set the best distances
      * between nodes - lower distance for connection group with bigger amount of connections.
      *
      * @param edges
      *            list of all edges between nodes
      */
     private void steepestDescent(List<Edge> edges) {
         double[] gradient = new double[nodes.size() * 2];
         int i = 0;
         for (Node n : nodes) {
             gradient[i++] = derivativeX(edges, n) * 1000000;
             gradient[i++] = derivativeY(edges, n) * 1000000;
         }
 
         int multi = 8;
         double result = potentialForGradient(gradient, multi, edges);
         double resultForLess = potentialForGradient(gradient, multi / 2, edges);
         double resultForMore = potentialForGradient(gradient, multi * 2, edges);
         if (resultForLess < result) {
             result = resultForLess;
             multi /= 2;
             resultForLess = potentialForGradient(gradient, multi / 2, edges);
             while (resultForLess < result) {
                 multi /= 2;
                 result = resultForLess;
                 resultForLess = potentialForGradient(gradient, multi / 2, edges);
             }
         } else if (resultForMore < result) {
             result = resultForMore;
             multi *= 2;
             resultForMore = potentialForGradient(gradient, multi * 2, edges);
             while (resultForMore < result) {
                 multi *= 2;
                 result = resultForMore;
                 resultForMore = potentialForGradient(gradient, multi * 2, edges);
             }
         }
         int multiplier = multi;
 
         i = 0;
         for (Node n : nodes) {
             int x = n.getLocation().x;
             int y = n.getLocation().y;
             n.setLocation(new Point(x + gradient[i++] / multiplier, y + gradient[i++] / multiplier));
         }
     }
 
     /**
      * This method makes BFS.
      *
      * @param rootNode
      *            root of tree being made.
      */
     private void makeTree(TreeNode rootNode, Collection<Node> nodes, List<String> connectionNodes,
             List<String> rootNodes) {
         TreeNode nextNode = null;
         Queue<TreeNode> queue = new LinkedList<TreeNode>();
         Map<Node, TreeNode> nodeToTreeNodeMap = new HashMap<Node, TreeNode>();
 
         queue.offer(rootNode);
         nodeToTreeNodeMap.put(rootNode.node, rootNode);
 
         while (!queue.isEmpty()) {
             nextNode = queue.poll();
 
             if (connectionNodes.contains(nextNode.node.getId())) {
                 String connectionNodeID = nextNode.node.getId();
                 connectionNodes.remove(connectionNodeID);
                 Node fakeChild = this.getNodeFromID(rootNodes.remove(0), nodes);
                 TreeNode fakeTreeChild = new TreeNode(fakeChild);
                 nextNode.children.add(fakeTreeChild);
                 this.treeSize++;
                 nodes.remove(fakeChild);
                 queue.offer(fakeTreeChild);
             }
 
             for (Node neighbor : getNeighbors(nodes, nextNode.node)) {
                 if (!nodeToTreeNodeMap.containsKey(neighbor)) {
                     TreeNode treeNeighbor = new TreeNode(neighbor);
                     this.treeSize++;
                     nodes.remove(neighbor);
                     nodeToTreeNodeMap.put(neighbor, treeNeighbor);
                     treeNeighbor.parent = nextNode;
                     nextNode.children.add(treeNeighbor);
 
                     queue.offer(treeNeighbor);
                 }
             }
         }
     }
 
     /**
      * This method fills adjacent table class field. It maps graph given as parameter to adjacent table.
      *
      * @param nodes
      *            list of nodes in graph.
      */
     private void fillAdiacentTable(List<Node> nodes) {
         this.adiacentTable = new boolean[nodes.size()][nodes.size()];
 
         int position = 0;
         for (Node node : this.nodes) {
             this.adiacentTablePositions.put(node.getId(), position++);
         }
 
         for (Node node1 : nodes) {
             for (Node node2 : this.getNeighbors(nodes, node1)) {
                 this.adiacentTable[this.adiacentTablePositions.get(node1.getId())][this.adiacentTablePositions
                         .get(node2.getId())] = true;
             }
         }
     }
 
     /**
      * This method initializes nodes' distance tables. It adds to them node's neighbors with distance value set on 1. It
      * should be called after fillAdiacentTable() method call.
      *
      * @param nodes
      *            list of nodes in graph.
      */
     private void initNodesDistanceTables(List<Node> nodes) {
         for (Node node : nodes) {
             Map<String, Integer> neighbours = new HashMap<String, Integer>();
             this.distancesTable.put(node.getId(), neighbours);
             for (Node neighbour : this.getNeighbors(nodes, node)) {
                 neighbours.put(neighbour.getId(), new Integer(1));
             }
         }
     }
 
     /**
      * This method fills nodes' distance tables. It should be called after initNodesDistanceTables() method call.
      *
      * @param nodes
      *            list of nodes in graph.
      */
     private void fillNodesDistanceTables(List<Node> nodes) {
         boolean wasChange = true;
 
         while (wasChange) {
             wasChange = false;
 
             for (Node node : nodes) {
                 Map<String, Integer> distancesFromNode = this.distancesTable.get(node.getId());
                 for (Node neighbour : this.getNeighbors(nodes, node)) {
                     String neighbourID = neighbour.getId();
                     for (String nodeID : distancesFromNode.keySet()) {
                         if (nodeID.compareTo(neighbourID) != 0) {
                             if (this.distancesTable.get(neighbourID).containsKey(nodeID)) {
                                 if (this.distancesTable.get(neighbourID).get(nodeID) > distancesFromNode.get(nodeID) + 1) {
                                     this.distancesTable.get(neighbourID).put(nodeID, distancesFromNode.get(nodeID) + 1);
                                     wasChange = true;
                                 }
                             } else {
                                 this.distancesTable.get(neighbourID).put(nodeID, distancesFromNode.get(nodeID) + 1);
                                 wasChange = true;
                             }
                         }
                     }
                 }
             }
         }
     }
 
     /**
      * This method computes sums of distances from every node to others.
      */
     private void computeDistanceSums() {
         for (String nodeID : this.distancesTable.keySet()) {
             int distancesSum = 0;
 
             for (Integer distance : this.distancesTable.get(nodeID).values()) {
                 distancesSum += distance.intValue();
             }
 
             this.distanceSums.put(nodeID, new Integer(distancesSum));
         }
     }
 
     /**
      * This method returns root nodes ID numbers.
      *
      * @param positionNodes
      *            list of nodes in graph.
      * @return list of root nodes' IDs.
      */
     private List<String> getRootNodesIDs(List<Node> positionNodes) {
         int nrOfNodesInGraph = this.distancesTable.size();
         List<String> rootNodeIDs = new LinkedList<String>();
         while (nrOfNodesInGraph > 0) {
             String rootID = this.distanceSums.keySet().iterator().next();
             Map<String, Integer> rootDistancesTable = this.distancesTable.get(rootID);
             int distancesSum = this.distanceSums.remove(rootID);
 
             nrOfNodesInGraph -= (rootDistancesTable.size() + 1);
 
             for (String nodeID : rootDistancesTable.keySet()) {
                 if (distancesSum > this.distanceSums.get(nodeID).intValue()) {
                     distancesSum = this.distanceSums.get(nodeID).intValue();
                     rootID = nodeID;
                 }
                 this.distanceSums.remove(nodeID);
             }
             rootNodeIDs.add(rootID);
         }
         return rootNodeIDs;
     }
 
     /**
      * This method returns main root from root nodes given as parameter.
      *
      * @param rootNodesIDs
      *            list of possible root nodes' IDs.
      * @return ID of root node; null if no rootNodesIDs are specified
      */
     private String getMainRoot(String[] rootNodesIDs) {
         String rootNodeID = null;
         if (rootNodesIDs.length > 0) {
             rootNodeID = rootNodesIDs[0];
             int maxSum = this.distanceSums.get(rootNodeID).intValue();
             for (int i = 1; i < rootNodesIDs.length; i++) {
                 if (maxSum < this.distanceSums.get(rootNodesIDs[i]).intValue()) {
                     maxSum = this.distanceSums.get(rootNodesIDs[i]).intValue();
                     rootNodeID = rootNodesIDs[i];
                 }
             }
 
         }
         return rootNodeID;
 
     }
 
     /**
      * This method returns proper number of nodes which can be used to join with subgraphs. Number of returned nodes is
      * defined by numberOfNodesToReturn parameter. Root node of graph which is searched for connection nodes is defined
      * by rootID parameter.
      *
      * @param numberOfNodesToReturn
      *            number of connection nodes which has to be returned.
      * @param rootID
      *            id of root node in graph.
      * @return list of connection nodes.
      */
     private List<String> getRootConnectionNodes(int numberOfNodesToReturn, String rootID) {
         List<String> connectionNodesIDs = new LinkedList<String>();
         int numberOfNodesAddedToResultTable = 0;
 
         if (this.distancesTable.get(rootID).size() <= numberOfNodesToReturn) {
             while (numberOfNodesAddedToResultTable < numberOfNodesToReturn) {
                 Iterator<String> it = this.distancesTable.get(rootID).keySet().iterator();
                 while (it.hasNext()) {
                     connectionNodesIDs.add(it.next());
                     numberOfNodesAddedToResultTable++;
                     if (numberOfNodesAddedToResultTable == numberOfNodesToReturn) {
                         break;
                     }
                 }
             }
         } else {
             Integer[] distanceSumsArray = this.distancesTable.get(rootID).values().toArray(new Integer[0]);
             Arrays.sort(distanceSumsArray);
             int minimumSumValue = distanceSumsArray[distanceSumsArray.length - numberOfNodesToReturn];
 
             for (String nodeID : this.distancesTable.get(rootID).keySet()) {
                 if (this.distancesTable.get(rootID).get(nodeID).intValue() >= minimumSumValue) {
                     connectionNodesIDs.add(nodeID);
                     numberOfNodesAddedToResultTable++;
                     if (numberOfNodesAddedToResultTable == numberOfNodesToReturn) {
                         break;
                     }
                 }
             }
         }
         return connectionNodesIDs;
     }
 
     /**
      * This method returns node which has ID given as parameter.
      *
      * @param nodeID
      *            ID of searched node.
      * @param positionNodes
      *            list of nodes in graph.
      * @return node which has given ID.
      */
     private Node getNodeFromID(String nodeID, Collection<Node> positionNodes) {
         Iterator<Node> it = positionNodes.iterator();
         while (it.hasNext()) {
             Node node = it.next();
             if (node.getId().compareTo(nodeID) == 0) {
                 return node;
             }
         }
         return null;
     }
 
     /**
      * This method merge unconnected graph in one and make BTS tree.
      *
      * @param positionNodes
      *            list of nodes in graph.
      * @return root node of connected graph.
      */
     private TreeNode mergeGraphAndMakeTree(List<Node> positionNodes) {
         this.fillAdiacentTable(positionNodes);
         this.initNodesDistanceTables(positionNodes);
         this.fillNodesDistanceTables(positionNodes);
         this.computeDistanceSums();
         List<String> rootNodesIDs = this.getRootNodesIDs(positionNodes);
         this.computeDistanceSums();
         String mainRootNode = this.getMainRoot(rootNodesIDs.toArray(new String[0]));
 
         rootNodesIDs.remove(mainRootNode);
 
         List<String> connectionNodesIDs = null;
         if (rootNodesIDs.size() > 0) {
             connectionNodesIDs = this.getRootConnectionNodes(rootNodesIDs.size(), mainRootNode);
         } else {
             connectionNodesIDs = new LinkedList<String>();
         }
 
         positionNodes.remove(mainRootNode);
         TreeNode treeRoot = new TreeNode(this.getNodeFromID(mainRootNode, positionNodes));
         this.makeTree(treeRoot, positionNodes, connectionNodesIDs, rootNodesIDs);
         return treeRoot;
     }
 
     /**
      * This method sets root node and root's neighbors in proper locations.
      *
      * @param positionNodes
      *            collection of nodes to position (with or without main root). If the list is empty the method does
      *            nothing
      */
     private void setRootNode(List<Node> positionNodes) {
         if (positionNodes == null || positionNodes.isEmpty()) {
             return; // cannot set root node in there is no nodes specified
         }
 
         TreeNode treeRoot = this.mergeGraphAndMakeTree(positionNodes);
         treeRoot.node.setLocation(new Point(this.AREA_CENTER_X, this.AREA_CENTER_Y));
 
         boolean radiusFactorInvert = true;
         double alfa = 0;
         for (TreeNode treeNode : treeRoot.children) {
             Node n = treeNode.node;
             double temp = this.getAngleRange(2 * Math.PI, this.countChildren(treeRoot), this.treeSize);
             int x = (int)((this.AREA_CENTER_X - this.radius) * Math.cos(alfa + temp / 2.0));
             int y = (int)((this.AREA_CENTER_Y - this.radius) * Math.sin(alfa + temp / 2.0));
             n.setLocation(new Point(x, y));
 
             if (radiusFactorInvert) {
                 this.setNode(treeRoot, 2, countChildren(treeRoot), alfa, this.ANGLE_RANGE_FACTOR * temp,
                         (this.radiusScaleFactor + 1) * 0.8);
                 radiusFactorInvert = false;
             } else {
                 this.setNode(treeRoot, 2, countChildren(treeRoot), alfa, this.ANGLE_RANGE_FACTOR * temp,
                         this.radiusScaleFactor + 1);
                 radiusFactorInvert = true;
             }
             alfa += temp;
         }
         this.treeSize = 0;
     }
 
     /**
      * This method sets children's locations of node given as parameter.
      *
      * @param node
      *            method sets positions of this node's children.
      * @param deepLevel
      *            distance from root.
      * @param nrOfNodes
      *            number of all nodes in given angle.
      * @param angle
      *            initial angle.
      * @param angleRange
      *            angle interval.
      */
     private void setNode(TreeNode node, int deepLevel, int nrOfNodes, double angle, double angleRange,
             double radiusFactor) {
         boolean radiusFactorInvert = true;
         for (TreeNode n : node.children) {
             double temp = this.getAngleRange(angleRange, this.countChildren(n), nrOfNodes);
             int x = (int)((this.AREA_CENTER_X - this.radius * radiusFactor * deepLevel) * Math.cos(angle + temp / 2.0));
             int y = (int)((this.AREA_CENTER_Y - this.radius * radiusFactor * deepLevel) * Math.sin(angle + temp / 2.0));
             n.node.setLocation(new Point(x, y));
 
             if (radiusFactorInvert) {
                 this.setNode(n, deepLevel + 1, this.countChildren(n), angle, this.ANGLE_RANGE_FACTOR * temp,
                         this.radiusScaleFactor * 0.8);
                 radiusFactorInvert = false;
             } else {
                 this.setNode(n, deepLevel + 1, this.countChildren(n), angle, this.ANGLE_RANGE_FACTOR * temp,
                         this.radiusScaleFactor);
                 radiusFactorInvert = true;
             }
             angle += temp;
         }
     }
 
     /**
      * This method returns angle interval depends on number of node's children.
      *
      * @param angle
      *            angle to divide between node's children.
      * @param nrOfChildren
      *            number of node's children.
      * @param nrOfNodes
      *            number of all nodes in angle.
      * @return angle range for single node.
      */
     private double getAngleRange(double angle, double nrOfChildren, double nrOfNodes) {
         return angle * nrOfChildren / nrOfNodes;
     }
 
     /**
      * This method returns number of nodes children.
      *
      * @param node
      *            method counts number of this node's children.
      * @return number of node's children.
      */
     private int countChildren(TreeNode node) {
         Collection<TreeNode> children = node.children;
         int result = 0;
 
         if (children.size() == 0) {
             result = 1;
         }
 
         for (TreeNode n : children) {
             result += this.countChildren(n);
         }
 
         return result;
     }
 
     /**
      * This method returns number of working units.
      *
      * @return number of work units
      */
     @Override
     protected int getWorkUnits(int nodesCount) {
         return (nodesCount + 1) * nodesCount;
     }
 }