work on javadoc

src/Algorithms/InitializeNodePositions.java

@@ -12,7 +12,10 @@ import Model.LayeredGraphNode;
  *
  */
 public class InitializeNodePositions {
-
+    /**
+     * the actual algorithm
+     * @param graph the graph where the node positions are to be set.
+     */
     public static void placeNodes( LayeredGraphNode graph ) {
         
     	RandomColorGenerator cGen = new RandomColorGenerator();

src/Algorithms/RandomColorGenerator.java

@@ -3,15 +3,24 @@ package Algorithms;
 import java.awt.Color;
 import java.util.Random;
 
+/**
+ * generates random colors
+ * @author kolja
+ *
+ */
 public class RandomColorGenerator {
 
-	Random rand;
+	private Random rand;
 	
 	public RandomColorGenerator()
 	{
 		rand = new Random();
 	}
 	
+	/**
+	 * generate a color with random RGB values
+	 * @return the color
+	 */
 	public Color generateColor()
 	{
 		float r = rand.nextFloat();

src/Algorithms/RandomGraphGenerator.java

@@ -3,6 +3,11 @@ package Algorithms;
 import Model.LayeredGraphNode;
 import Model.LayeredNode;
 
+/**
+ * creates random {@link LayeredGraphNode}s for testing purposes
+ * @author kolja
+ *
+ */
 public class RandomGraphGenerator {
 
     private double pSubgraph;
@@ -13,6 +18,16 @@ public class RandomGraphGenerator {
     private int maxNodePerLayer;
     private int maxDepth;
     
+    /**
+     * sets the parameters for the random graph
+     * @param pSubgraph the probability that a node contains a graph
+     * @param pEdge the probability that there is an edge between two nodes in subsequent layers
+     * @param minLayer the minimum number of layers in each graph
+     * @param maxLayer the maximum number of layers in each graph
+     * @param minNodePerLayer the minimum number of layers in each layer
+     * @param maxNodePerLayer the maximum number of layers in each layer
+     * @param maxDepth the maximum hierarchy depth
+     */
     public RandomGraphGenerator( double pSubgraph, double pEdge, int minLayer, int maxLayer, int minNodePerLayer, int maxNodePerLayer, int maxDepth )
     {
         this.pSubgraph = pSubgraph;
@@ -24,6 +39,12 @@ public class RandomGraphGenerator {
         this.maxDepth = maxDepth;
     }
     
+    /**
+     * creates a random {@link LayeredGraphNode} using the parameters given to the constructor of the {@link RandomGraphGenerator}
+     * @param parent the parent node of the nodes in the graph
+     * @param depth the current depth of the graph (used to check if the maximum depth is reached)
+     * @return the generated {@link LayeredGraphNode}
+     */
     public LayeredGraphNode createRandomNode( LayeredGraphNode parent, int depth )
     {
         LayeredGraphNode node = new LayeredNode( null, null );

src/Algorithms/SweepCrossingMinimizer.java

@@ -7,8 +7,8 @@ import Model.LayeredGraphNode;
 
 
 /**
- * Der aus der Vorlesung bekannte Sweep Algorithmus zur Minnimierung von Kantenkreuzungen
- * Es wird immer genau ein sweep durchgeführt
+ * Der aus der Vorlesung bekannte Sweep Algorithmus zur Minimierung von Kantenkreuzungen
+ * Es wird immer genau ein sweep durchgef�hrt
  * @author kolja
  *
  */
@@ -25,7 +25,7 @@ public class SweepCrossingMinimizer {
             graph.setOrderedLayer( reduceCrossingsBetweenLayers( l1, l2, false ), i ); // minnimiere die Kreuzungen zwischen den letzten beiden Layern
         }
         for( int i = layers.size() - 2; i >= 0; i-- )
-        { // Gehe alle Layer rückwärts durch
+        { // Gehe alle Layer r�ckw�rts durch
             ArrayList<LayeredGraphNode> l1 = layers.get( i + 1 );
             ArrayList<LayeredGraphNode> l2 = layers.get( i );
             graph.setOrderedLayer( reduceCrossingsBetweenLayers( l1, l2, true ), i );  // minnimiere die Kreuzungen zwischen den letzten beiden Layern
@@ -38,13 +38,13 @@ public class SweepCrossingMinimizer {
      * @param l1 Eine geordnete Liste mit Knoten aus dem ersten Layer
      * @param l2 Eine geordnete Liste mit Knoten aus dem zweiten Layer
      * @param rev Gibt an, in welche Richtung die Kanten verlaufen (true, falls von l2 nach l1)
-     * @return Gibt eine Liste mit Gewichten zurück, nach denen die Knoten sortiert werden sollen
+     * @return Gibt eine Liste mit Gewichten zur�ck, nach denen die Knoten sortiert werden sollen
      */
     private ArrayList<Double> reduceCrossingsBetweenLayers( ArrayList<LayeredGraphNode> l1, ArrayList<LayeredGraphNode> l2, boolean rev)
     {
         ArrayList< Double > gewicht = new ArrayList< Double >();
         for( LayeredGraphNode n : l2 )
-        { // Für jeden Knoten in Layer 2
+        { // F�r jeden Knoten in Layer 2
             ArrayList< LayeredGraphEdge > edges = null;
             if( rev )
                 edges = n.getOutgoingEdges();
@@ -65,7 +65,7 @@ public class SweepCrossingMinimizer {
     }
     
     /**
-     * Zählt die Anzahl der Kantenkreuzungen in einem Graph
+     * Z�hlt die Anzahl der Kantenkreuzungen in einem Graph
      * @param layers Eine Liste mit Sortierten Layern
      * @return Die Anzahl der Kreuzungen
      */
@@ -83,7 +83,7 @@ public class SweepCrossingMinimizer {
     }
     
     /**
-     * Zählt die Anzahl der Kantenkreuzungen zwischen zwei Layern (Es wird angenommen dass alle Kanten von l1 nach l2 verlaufen)
+     * Z�hlt die Anzahl der Kantenkreuzungen zwischen zwei Layern (Es wird angenommen dass alle Kanten von l1 nach l2 verlaufen)
      * @param l1 Der erste Layer
      * @param l2 Der zweite Layer
      * @return Die Anzahl der Kreuzungen