fehler behoben

save.graph

@@ -1 +1 @@
-{"layers":[[{"layers":[],"edges":[],"name":"0"},{"layers":[],"edges":[],"name":"1"},{"layers":[],"edges":[],"name":"2"},{"layers":[],"edges":[],"name":"3"},{"layers":[],"edges":[],"name":"4"}],[{"layers":[],"edges":[],"name":"5"},{"layers":[],"edges":[],"name":"6"},{"layers":[],"edges":[],"name":"7"},{"layers":[],"edges":[],"name":"8"},{"layers":[],"edges":[],"name":"9"}],[{"layers":[],"edges":[],"name":"10"},{"layers":[],"edges":[],"name":"11"},{"layers":[],"edges":[],"name":"12"},{"layers":[],"edges":[],"name":"13"},{"layers":[],"edges":[],"name":"14"}],[{"layers":[],"edges":[],"name":"15"},{"layers":[],"edges":[],"name":"16"},{"layers":[],"edges":[],"name":"17"},{"layers":[],"edges":[],"name":"18"},{"layers":[],"edges":[],"name":"19"}],[{"layers":[],"edges":[],"name":"20"},{"layers":[],"edges":[],"name":"21"},{"layers":[],"edges":[],"name":"22"},{"layers":[],"edges":[],"name":"23"},{"layers":[],"edges":[],"name":"24"}]],"edges":[{"source":"4","target":"6"},{"source":"1","target":"5"},{"source":"8","target":"13"},{"source":"9","target":"13"},{"source":"8","target":"11"},{"source":"8","target":"12"},{"source":"6","target":"10"},{"source":"10","target":"15"},{"source":"12","target":"18"},{"source":"16","target":"21"}]}
+{"layers":[[{"layers":[],"edges":[],"name":"0"},{"layers":[],"edges":[],"name":"1"},{"layers":[],"edges":[],"name":"2"},{"layers":[],"edges":[],"name":"3"},{"layers":[],"edges":[],"name":"4"}],[{"layers":[],"edges":[],"name":"5"},{"layers":[],"edges":[],"name":"6"},{"layers":[],"edges":[],"name":"7"},{"layers":[],"edges":[],"name":"8"},{"layers":[],"edges":[],"name":"9"}],[{"layers":[],"edges":[],"name":"10"},{"layers":[],"edges":[],"name":"11"},{"layers":[],"edges":[],"name":"12"},{"layers":[],"edges":[],"name":"13"},{"layers":[],"edges":[],"name":"14"}],[{"layers":[],"edges":[],"name":"15"},{"layers":[],"edges":[],"name":"16"},{"layers":[],"edges":[],"name":"17"},{"layers":[],"edges":[],"name":"18"},{"layers":[],"edges":[],"name":"19"}],[{"layers":[],"edges":[],"name":"20"},{"layers":[],"edges":[],"name":"21"},{"layers":[],"edges":[],"name":"22"},{"layers":[],"edges":[],"name":"23"},{"layers":[],"edges":[],"name":"24"}]],"edges":[{"source":"1","target":"8"},{"source":"3","target":"8"},{"source":"0","target":"7"},{"source":"0","target":"6"},{"source":"5","target":"13"},{"source":"6","target":"13"},{"source":"7","target":"14"},{"source":"13","target":"17"},{"source":"10","target":"16"},{"source":"13","target":"16"},{"source":"12","target":"16"},{"source":"19","target":"23"},{"source":"15","target":"22"}]}

save_err1.graph

@@ -0,0 +1 @@
+{"layers":[[{"layers":[],"edges":[],"name":"0"},{"layers":[],"edges":[],"name":"1"},{"layers":[],"edges":[],"name":"2"},{"layers":[],"edges":[],"name":"3"},{"layers":[],"edges":[],"name":"4"}],[{"layers":[],"edges":[],"name":"5"},{"layers":[],"edges":[],"name":"6"},{"layers":[],"edges":[],"name":"7"},{"layers":[],"edges":[],"name":"8"},{"layers":[],"edges":[],"name":"9"}],[{"layers":[],"edges":[],"name":"10"},{"layers":[],"edges":[],"name":"11"},{"layers":[],"edges":[],"name":"12"},{"layers":[],"edges":[],"name":"13"},{"layers":[],"edges":[],"name":"14"}],[{"layers":[],"edges":[],"name":"15"},{"layers":[],"edges":[],"name":"16"},{"layers":[],"edges":[],"name":"17"},{"layers":[],"edges":[],"name":"18"},{"layers":[],"edges":[],"name":"19"}],[{"layers":[],"edges":[],"name":"20"},{"layers":[],"edges":[],"name":"21"},{"layers":[],"edges":[],"name":"22"},{"layers":[],"edges":[],"name":"23"},{"layers":[],"edges":[],"name":"24"}]],"edges":[{"source":"0","target":"7"},{"source":"1","target":"7"},{"source":"2","target":"9"},{"source":"7","target":"10"},{"source":"7","target":"13"},{"source":"13","target":"17"},{"source":"12","target":"16"},{"source":"19","target":"23"},{"source":"19","target":"24"},{"source":"15","target":"20"},{"source":"18","target":"22"},{"source":"17","target":"21"}]}

src/Algorithms/Animated/BK/BlockCalc.java

@@ -62,15 +62,24 @@ public class BlockCalc implements AlgorithmStage {
         return -1;
 	}
 	
+	private int calcNodeIndex( int index )
+	{
+        if( layout == LayoutType.TOP_BOTTOM_LEFT || layout == LayoutType.TOP_BOTTOM_RIGHT )
+            return index;
+        //if( layout == LayoutType.BOTTOM_TOP_LEFT || layout == LayoutType.BOTTOM_TOP_RIGHT )
+        //    return graph.getContainedLayers().get( calcLayerIndex() ).size() - index - 1;
+        return index;
+	}
+	
 	@Override
 	public StageStatus forwardStep() {
-		LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
+		LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) );
 		current.setSelected( layout );
 		if( current.getContainedNodes().size() > 0 )
 		{
-			if( subgraphAlgs.get( calcLayerIndex() ).get( nodeIndex ) == null )
-				subgraphAlgs.get( calcLayerIndex() ).set( nodeIndex, new BKNodePlacement( null, current ) );
-			if( subgraphAlgs.get( calcLayerIndex() ).get( nodeIndex ).forwardStep() == StageStatus.UNFINISHED )
+			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ) == null )
+				subgraphAlgs.get( calcLayerIndex() ).set( calcNodeIndex( nodeIndex ), new BKNodePlacement( null, current ) );
+			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).forwardStep() == StageStatus.UNFINISHED )
 				return StageStatus.UNFINISHED;
 		}
 		ArrayList< LayeredGraphEdge > incommingEdges = null;
@@ -101,14 +110,14 @@ public class BlockCalc implements AlgorithmStage {
                 if( layout == LayoutType.BOTTOM_TOP_LEFT || layout == LayoutType.BOTTOM_TOP_RIGHT )
                     u = incommingEdges.get( m - 1 ).getTargets().get( 0 );
                 ArrayList<LayeredGraphEdge> conflicts = incommingEdges.get( m - 1 ).calcConflictedEdges();
-		        if( !incommingEdges.get( m - 1 ).isConflicted() && r < graph.getContainedLayers().get( calcBeforeLayerIndex() ).indexOf( u ) + 1 )
+		        if( !incommingEdges.get( m - 1 ).isConflicted( layout ) && calcNodeIndex( r ) < calcNodeIndex( graph.getContainedLayers().get( calcBeforeLayerIndex() ).indexOf( u ) + 1 ) )
 		        {
 		        	System.out.println( "" );
 		        	ArrayList< Boolean > oldConflicts = new ArrayList<>();
 		        	for( LayeredGraphEdge e : conflicts )
 		        	{
-		        		oldConflicts.add( e.isConflicted() );
-		        		e.setConflicted( true );
+		        		oldConflicts.add( e.isConflicted( layout ) );
+		        		e.setConflicted( true, layout );
 		        	}
 		            LayeredGraphNode oldAlignU = u.getAlignedTo( layout );
 		            Color oldColorCurrent = current.getColor( layout );
@@ -125,7 +134,7 @@ public class BlockCalc implements AlgorithmStage {
 		            backwards.add( 0, () -> {
 		                System.out.println( "Stepping Backwards... (Step " + oldStep + ")" );
 			        	for( int i = 0; i < conflicts.size(); i++ )
-			        		conflicts.get( i ).setConflicted( oldConflicts.get( i ) );
+			        		conflicts.get( i ).setConflicted( oldConflicts.get( i ), layout );
 			        	uf.setAlignTo( oldAlignU, layout );
 		                current.setColor( oldColorCurrent, layout );
 		                current.setRoot( oldRootCurrent, layout );
@@ -169,9 +178,9 @@ public class BlockCalc implements AlgorithmStage {
 
 	@Override
 	public StageStatus backwardStep() {
-		if( subgraphAlgs.get( calcLayerIndex() ).get( nodeIndex ) != null )
+		if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ) != null )
 		{
-			if( subgraphAlgs.get( calcLayerIndex() ).get( nodeIndex ).backwardStep() == StageStatus.UNFINISHED )
+			if( subgraphAlgs.get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) ).backwardStep() == StageStatus.UNFINISHED )
 			{
 				LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
 				current.setSelected( layout );
@@ -182,7 +191,7 @@ public class BlockCalc implements AlgorithmStage {
 		StageStatus status = calcBeforeState();
 		if( status == StageStatus.FINISHED )
 			return status;
-		LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( nodeIndex );
+		LayeredGraphNode current = graph.getContainedLayers().get( calcLayerIndex() ).get( calcNodeIndex( nodeIndex ) );
 		current.setSelected( layout );
 		//current.update();
 		if( !backwards.isEmpty() )

src/Algorithms/Animated/BK/Compaction.java

@@ -50,7 +50,20 @@ public class Compaction implements AlgorithmStage{
 		double max = 0;
 		for( LayeredGraphNode n : graph.getContainedNodes() )
 			max = Math.max( max, n.getWidth( layout ) );
-		return max + 50;
+		//return max + 25;
+		return max;
+	}
+	
+	private LayeredGraphNode getNodeFromIndex( int index )
+	{
+	    for( ArrayList< LayeredGraphNode > l : graph.getContainedLayers() )
+	    {
+	        if( index >= l.size() )
+	            index -= l.size();
+	        else
+	            return l.get( index );
+	    }
+	    return null;
 	}
 	
 	@Override
@@ -65,7 +78,7 @@ public class Compaction implements AlgorithmStage{
 				int oldVIndex = vIndex;
 				for( ; vIndex < nodes.size(); vIndex++ )
 				{
-					if( nodes.get( vIndex ).isXUndefined( layout ) && nodes.get( vIndex ) == nodes.get( vIndex ).getRoot( layout ) )
+					if( getNodeFromIndex( vIndex ).isXUndefined( layout ) && getNodeFromIndex( vIndex ) == getNodeFromIndex( vIndex ).getRoot( layout ) )
 					{
 						found = true;
 						break;
@@ -83,11 +96,12 @@ public class Compaction implements AlgorithmStage{
 				else
 				{
 					StackFrame f = new StackFrame();
-					f.v = nodes.get( vIndex );
+					f.v = getNodeFromIndex( vIndex );
 					double oldX = f.v.getX( layout );
 					f.v.setX( 0, true, layout );
 					f.v.setSelected( layout );
 					f.w = f.v;
+                    System.out.println( "call place_block( " + f.v + " )" );
 					stack.add( 0, f );
 					actions.add( 0, ()-> {
 						stack.get( 0 ).v.setX( oldX, false, layout );
@@ -103,9 +117,10 @@ public class Compaction implements AlgorithmStage{
 				StackFrame sf = stack.get( 0 );
 				if( sf.u == null )
 				{
-					if( graph.getContainedLayers().get( sf.w.getLayer() ).indexOf( sf.w ) >= 1 )
+				    int posW = graph.getContainedLayers().get( sf.w.getLayer() ).indexOf( sf.w );
+					if( posW >= 1 )
 					{
-						sf.u = graph.getContainedLayers().get( sf.w.getLayer() ).get( graph.getContainedLayers().get( sf.w.getLayer() ).indexOf( sf.w ) - 1 ).getRoot( layout );
+						sf.u = graph.getContainedLayers().get( sf.w.getLayer() ).get( posW - 1 ).getRoot( layout );
 						if( sf.u.isXUndefined( layout ) )
 						{
 							StackFrame nsf = new StackFrame();
@@ -114,6 +129,7 @@ public class Compaction implements AlgorithmStage{
 							nsf.v.setX( 0, true, layout );
 							nsf.v.setSelected( layout );
 							nsf.w = nsf.v;
+		                    System.out.println( "call place_block( " + nsf.v + " )" );
 							stack.add( 0, nsf );
 							actions.add( 0, ()-> {
 								stack.get( 0 ).v.setX( oldX, false, layout );
@@ -137,6 +153,7 @@ public class Compaction implements AlgorithmStage{
 						sf.w = sf.w.getAlignedTo( layout );
 						if( sf.w == sf.v )
 						{
+		                    System.out.println( "return place_block( " + sf.v + " )" );
 							stack.remove( 0 );
 							actions.add( 0, ()-> {
 								stack.add( 0, sf );
@@ -156,13 +173,13 @@ public class Compaction implements AlgorithmStage{
 				else
 				{
 					LayeredGraphNode oldSink = sf.v.getSink( layout );
-					if( sf.v.getSink( layout ) == sf.v )
-						sf.v.setSink( sf.u.getSink( layout ), layout );
 					LayeredGraphNode sinkOfU = sf.u.getSink( layout );
 					double oldShift = sinkOfU.getShift( layout );
 					double oldX = sf.v.getX( layout );
 					boolean oldDef = !sf.v.isXUndefined( layout );
 					sf.v.setSelected( layout );
+                    if( sf.v.getSink( layout ) == sf.v )
+                        sf.v.setSink( sf.u.getSink( layout ), layout );
 					if( sf.v.getSink( layout ) != sf.u.getSink( layout ) )
 						sf.u.getSink( layout ).setShift( Math.min( sf.u.getSink( layout ).getShift( layout ), sf.v.getX( layout ) - sf.u.getX( layout ) - calcSpacing() ), layout );
 					else
@@ -173,6 +190,7 @@ public class Compaction implements AlgorithmStage{
 					sf.u = null;
 					if( sf.w == sf.v )
 					{
+                        System.out.println( "return place_block( " + sf.v + " )" );
 						stack.remove( 0 );
 						actions.add( 0, ()-> {
 							stack.add( 0, sf );
@@ -205,8 +223,8 @@ public class Compaction implements AlgorithmStage{
 			boolean oldDef = !v.isXUndefined( layout );
 			v.setSelected( layout );
 			v.setX( v.getRoot( layout ).getX( layout ), true, layout );
-			if( v == v.getRoot( layout ) && v.getSink( layout ).getShift( layout ) < Double.POSITIVE_INFINITY )
-				v.setX( v.getX( layout ) + v.getSink( layout ).getShift( layout ), true, layout );
+			if( v == v.getRoot( layout ) && v.getRoot( layout ).getSink( layout ).getShift( layout ) < Double.POSITIVE_INFINITY )
+				v.setX( v.getX( layout ) + v.getRoot( layout ).getSink( layout ).getShift( layout ), true, layout );
 			actions.add( 0, ()-> {
 				v.setX( oldX, oldDef, layout );
 				v.setSelected( layout );

src/Main.java

@@ -15,7 +15,7 @@ public class Main {
 	public static void main(String[] args) {
 		Reader r = new Reader( "save.graph" );
 		LayeredGraphNode graph = r.readInputGraph();
-	    //RandomGraphGenerator r = new RandomGraphGenerator( 0.1, 0.1, 5,5, 5, 5, 1 );
+	    //RandomGraphGenerator r = new RandomGraphGenerator( 0.1, 0.2, 5,5, 5, 5, 1 );
 	    //LayeredGraphNode graph = r.createRandomNode( null, 0 );
 	    //SweepCrossingMinimizer cminzer = new SweepCrossingMinimizer();
 	    //for( int i = 0; i < 10; i++ )

src/Model/LayeredEdge.java

@@ -23,7 +23,7 @@ public class LayeredEdge implements LayeredGraphEdge {
     boolean reversed;
     boolean dummy;
     ArrayList< Point >[] bindPoints;
-    boolean conflicted;
+    boolean[] conflicted;
     
     @SuppressWarnings("unchecked")
     public LayeredEdge( ElkEdge original, ArrayList< LayeredGraphNode > sources, ArrayList< LayeredGraphNode > targets, LayeredGraphNode graph )
@@ -35,6 +35,7 @@ public class LayeredEdge implements LayeredGraphEdge {
         reversed = false;
         dummy = false;
         bindPoints = new ArrayList[ 4 ];
+        conflicted = new boolean[ 4 ];
         for( int i = 0; i < 4; i++ )
             bindPoints[ i ] = new ArrayList<>();
         for( ArrayList<Point> bps : bindPoints )
@@ -42,13 +43,20 @@ public class LayeredEdge implements LayeredGraphEdge {
             bps.add( null );
             bps.add( null );
         }
-        conflicted = false;
     }
 
     @Override
-    public boolean isConflicted()
+    public boolean isConflicted( LayoutType layout )
     {
-    	return conflicted;
+        if( layout == LayoutType.TOP_BOTTOM_LEFT )
+            return conflicted[ 0 ];
+        if( layout == LayoutType.TOP_BOTTOM_RIGHT )
+            return conflicted[ 1 ];
+        if( layout == LayoutType.BOTTOM_TOP_LEFT )
+            return conflicted[ 2 ];
+        if( layout == LayoutType.BOTTOM_TOP_RIGHT )
+            return conflicted[ 3 ];
+        return false;
     }
     
     @Override
@@ -76,9 +84,23 @@ public class LayeredEdge implements LayeredGraphEdge {
     };
     
     @Override
-    public void setConflicted( boolean conflicted )
+    public void setConflicted( boolean conflicted, LayoutType layout )
     {
-    	this.conflicted = conflicted;
+        if( layout == null )
+        {
+            this.conflicted[ 0 ] = conflicted;
+            this.conflicted[ 1 ] = conflicted;
+            this.conflicted[ 2 ] = conflicted;
+            this.conflicted[ 3 ] = conflicted;
+        }
+        if( layout == LayoutType.TOP_BOTTOM_LEFT )
+            this.conflicted[ 0 ] = conflicted;
+        if( layout == LayoutType.TOP_BOTTOM_RIGHT )
+            this.conflicted[ 1 ] = conflicted;
+        if( layout == LayoutType.BOTTOM_TOP_LEFT )
+            this.conflicted[ 2 ] = conflicted;
+        if( layout == LayoutType.BOTTOM_TOP_RIGHT )
+            this.conflicted[ 3 ] = conflicted;
     }
     
     @Override

src/Model/LayeredGraphEdge.java

@@ -20,9 +20,9 @@ public interface LayeredGraphEdge {
     ElkEdge getOriginalEdge();
     
     
-    public boolean isConflicted();
+    public boolean isConflicted( LayoutType layout );
     public ArrayList<LayeredGraphEdge> calcConflictedEdges();
-    public void setConflicted( boolean conflicted );
+    public void setConflicted( boolean conflicted, LayoutType layout );
     /**
      * Entfernt diese Kante vom Graphen
      */

src/Model/LayeredNode.java

@@ -440,19 +440,21 @@ public class LayeredNode implements LayeredGraphNode {
         if( nodes.size() > 0 )
         {
             double max = 0;
+            double min = Double.POSITIVE_INFINITY;
             for( LayeredGraphNode n : nodes )
             {
                 if( max < n.getX(layout) + n.getWidth(layout) + 50 )
                     max = n.getX(layout) + n.getWidth(layout) + 50;
+                min = Math.min( n.getX(layout), min);
             }
             if( layout == LayoutType.TOP_BOTTOM_LEFT )
-                return Math.max( max, layouts[ 0 ].w );
+                return Math.max( max - min, layouts[ 0 ].w );
             if( layout == LayoutType.TOP_BOTTOM_RIGHT )
-                return Math.max( max, layouts[ 1 ].w );
+                return Math.max( max - min, layouts[ 1 ].w );
             if( layout == LayoutType.BOTTOM_TOP_LEFT )
-                return Math.max( max, layouts[ 2 ].w );
+                return Math.max( max - min, layouts[ 2 ].w );
             if( layout == LayoutType.BOTTOM_TOP_RIGHT )
-                return Math.max( max, layouts[ 3 ].w );
+                return Math.max( max - min, layouts[ 3 ].w );
         }
         if( layout == LayoutType.TOP_BOTTOM_LEFT )
             return layouts[ 0 ].w;

src/View/MainView.java

@@ -33,7 +33,7 @@ public class MainView {
 	public MainView( LayeredGraphNode graph )
 	{
 		controller = new AnimationController();
-		controller.setTimeBetween( 100 );
+		controller.setTimeBetween( 10 );
 		frame = new JFrame();
         frame.setSize( Math.min( (int)graph.getWidth( LayoutType.TOP_BOTTOM_LEFT ) * 2 + 200, 1700 ), Math.min( (int)graph.getHeight( LayoutType.TOP_BOTTOM_LEFT ) * 2 + 200, 900 ) );
 		frame.setLocation( 100, 100 );

src/View/NodeView.java

@@ -48,13 +48,20 @@ public class NodeView extends JPanel {
         double scale = Math.min( (double)super.getWidth() / (int)model.getWidth( layout ), (double)super.getHeight() / (int)model.getHeight( layout ));
         ((Graphics2D)g).scale( scale, scale );
         paintComponent( g );
+        double minX = Double.POSITIVE_INFINITY;
         for( Component c : getComponents() )
         {
+            minX = Math.min( c.getLocation().x, minX);
+        }
+        for( Component c : getComponents() )
+        {
+            if( c.getLocation().x < 0 )
+                System.out.println( "x: " + c.getLocation().x + " y: " + c.getLocation().y );
             c.paint( g.create( 
-                    c.getLocation().x + 25, 
+                    c.getLocation().x + 25 - (int)minX, 
                     c.getLocation().y + 25, 
-                    Math.min( (int)model.getWidth( layout ) - 25, c.getPreferredSize().width + c.getLocation().x + 25 ), 
-                    Math.min( (int)model.getHeight( layout ) - 25, c.getPreferredSize().height + c.getLocation().y + 25 ) ) );
+                    Math.min( (int)model.getWidth( layout ) - 25, c.getPreferredSize().width + Math.abs(c.getLocation().x) + 25 ), 
+                    Math.min( (int)model.getHeight( layout ) - 25, c.getPreferredSize().height + Math.abs(c.getLocation().y) + 25 ) ) );
         }
     }
 
@@ -73,5 +80,10 @@ public class NodeView extends JPanel {
 		}
 		Border linebor = BorderFactory.createLineBorder(model.getColor( layout ), 5);
 		linebor.paintBorder( this, g2, 0, 0, (int)model.getWidth( layout )-1, (int)model.getHeight( layout )-1 );
+		if( model.getRoot( layout ).getSink( layout ).getColor( layout ) != model.getColor( layout ) )
+		{
+    		g.setColor( model.getRoot( layout ).getSink( layout ).getColor( layout ) );
+    		g.fillOval( (int)model.getWidth( layout ) / 2 - (int)model.getWidth( layout ) / 3, (int)model.getHeight( layout ) / 2 - (int)model.getHeight( layout ) / 3, (int)model.getWidth( layout ) / 3 * 2, (int)model.getHeight( layout ) / 3 * 2 );
+		}
 	}
 }