Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14046)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14048)
@@ -31,9 +31,9 @@
   [Item("BinPacking2D", "Represents a single-bin packing for a 2D bin-packing problem.")]
   [StorableClass]
-  public class BinPacking2D : BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
+  public class BinPacking2D : BinPacking<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
 
     public BinPacking2D(RectangularPackingShape binMeasures)
       : base(binMeasures) {
-      ExtremePoints = new SortedSet<TwoDimensionalPacking>(new EPComparer2D());
+      ExtremePoints = new SortedSet<PackingPosition>(new EPComparer2D());
       ExtremePoints.Add(binMeasures.Origin);
     }
@@ -42,5 +42,5 @@
     protected BinPacking2D(BinPacking2D original, Cloner cloner)
       : base(original, cloner) {
-      this.ExtremePoints = new SortedSet<TwoDimensionalPacking>(original.ExtremePoints, new EPComparer2D());
+      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer2D());
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -48,5 +48,5 @@
     }
 
-    protected override void GenerateNewExtremePointsForNewItem(RectangularPackingItem newItem, TwoDimensionalPacking position) {
+    protected override void GenerateNewExtremePointsForNewItem(RectangularPackingItem newItem, PackingPosition position) {
 
       int newWidth = position.Rotated ? newItem.Height : newItem.Width;
@@ -54,25 +54,25 @@
 
       //Find ExtremePoints beginning from sourcepointX
-      var sourcePointX = new TwoDimensionalPacking(0, position.X + newWidth, position.Y);
+      var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y);
       if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height) {
         //Traversing down the y-axis        
-        var newPoint = new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y - 1);
+        var newPoint = new PackingPosition(0, sourcePointX.X, sourcePointX.Y - 1);
         while (sourcePointX.Y > 0 && !IsPointOccupied(newPoint)) {
           sourcePointX = newPoint;
-          newPoint = new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y - 1);
-        }
-        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y));
+          newPoint = new PackingPosition(0, sourcePointX.X, sourcePointX.Y - 1);
+        }
+        ExtremePoints.Add(new PackingPosition(0, sourcePointX.X, sourcePointX.Y));
       }
 
       //Find ExtremePoints beginning from sourcepointY
-      var sourcePointY = new TwoDimensionalPacking(0, position.X, position.Y + newItem.Height);
+      var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height);
       if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height) {
         //Traversing down the x-axis  
-        var newPoint = new TwoDimensionalPacking(0, sourcePointY.X - 1, sourcePointY.Y);
+        var newPoint = new PackingPosition(0, sourcePointY.X - 1, sourcePointY.Y);
         while (sourcePointY.X > 0 && !IsPointOccupied(newPoint)) {
           sourcePointY = newPoint;
-          newPoint = new TwoDimensionalPacking(0, sourcePointY.X - 1, sourcePointY.Y);
-        }
-        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointY.X, sourcePointY.Y));
+          newPoint = new PackingPosition(0, sourcePointY.X - 1, sourcePointY.Y);
+        }
+        ExtremePoints.Add(new PackingPosition(0, sourcePointY.X, sourcePointY.Y));
       }
 
@@ -85,5 +85,5 @@
     }
 
-    public override TwoDimensionalPacking FindExtremePointForItem(RectangularPackingItem measures, bool rotated, bool stackingConstraints) {
+    public override PackingPosition FindExtremePointForItem(RectangularPackingItem measures, bool rotated, bool stackingConstraints) {
       RectangularPackingItem item = new RectangularPackingItem(
         rotated ? measures.Height : measures.Width,
@@ -97,22 +97,22 @@
         var currentPoint = ExtremePoints.ElementAt(epIndex);
 
-        var result = new TwoDimensionalPacking(currentPoint.AssignedBin, currentPoint.X, currentPoint.Y, rotated);
+        var result = new PackingPosition(currentPoint.AssignedBin, currentPoint.X, currentPoint.Y, rotated);
         return result;
       }
       return null;
     }
-    public override TwoDimensionalPacking FindPositionBySliding(RectangularPackingItem measures, bool rotated) {
-      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(0,
+    public override PackingPosition FindPositionBySliding(RectangularPackingItem measures, bool rotated) {
+      PackingPosition currentPosition = new PackingPosition(0,
         BinMeasures.Width - (rotated ? measures.Height : measures.Width),
         BinMeasures.Height - (rotated ? measures.Width : measures.Height), rotated);
       //Slide the item as far as possible to the left
-      while (IsPositionFeasible(measures, TwoDimensionalPacking.MoveLeft(currentPosition))
-        || IsPositionFeasible(measures, TwoDimensionalPacking.MoveDown(currentPosition))) {
+      while (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
+        || IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition))) {
         //Slide the item as far as possible to the bottom
-        while (IsPositionFeasible(measures, TwoDimensionalPacking.MoveDown(currentPosition))) {
-          currentPosition = TwoDimensionalPacking.MoveDown(currentPosition);
-        }
-        if (IsPositionFeasible(measures, TwoDimensionalPacking.MoveLeft(currentPosition)))
-          currentPosition = TwoDimensionalPacking.MoveLeft(currentPosition);
+        while (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition))) {
+          currentPosition = PackingPosition.MoveDown(currentPosition);
+        }
+        if (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition)))
+          currentPosition = PackingPosition.MoveLeft(currentPosition);
       }
 
@@ -165,5 +165,5 @@
     }
 
-    public override int ShortestPossibleSideFromPoint(TwoDimensionalPacking position) {
+    public override int ShortestPossibleSideFromPoint(PackingPosition position) {
       int shortestSide = int.MaxValue;
       int width = BinMeasures.Width;
@@ -173,12 +173,12 @@
         return shortestSide;
 
-      TwoDimensionalPacking current = new TwoDimensionalPacking(0, position.X, position.Y);
-      while (current.X < width && IsPointOccupied(current)) { current = TwoDimensionalPacking.MoveRight(current); }
+      PackingPosition current = new PackingPosition(0, position.X, position.Y);
+      while (current.X < width && IsPointOccupied(current)) { current = PackingPosition.MoveRight(current); }
       if (current.X - position.X < shortestSide)
         shortestSide = current.X - position.X;
 
 
-      current = new TwoDimensionalPacking(0, position.X, position.Y);
-      while (current.Y < height && IsPointOccupied(current)) { current = TwoDimensionalPacking.MoveUp(current); }
+      current = new PackingPosition(0, position.X, position.Y);
+      while (current.Y < height && IsPointOccupied(current)) { current = PackingPosition.MoveUp(current); }
       if (current.Y - position.Y < shortestSide)
         shortestSide = current.Y - position.Y;
@@ -186,5 +186,5 @@
       return shortestSide;
     }
-    public override bool IsStaticStable(RectangularPackingItem item, TwoDimensionalPacking position) {
+    public override bool IsStaticStable(RectangularPackingItem item, PackingPosition position) {
       throw new NotImplementedException();
     }
@@ -196,5 +196,5 @@
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, RectangularPackingItem measures, TwoDimensionalPacking position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, RectangularPackingItem measures, PackingPosition position) {
       int x1 = position.X / 10;
       int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
@@ -203,8 +203,8 @@
         OccupationLayers[i].Add(itemID);
     }
-    protected override List<int> GetLayerItemIDs(TwoDimensionalPacking position) {
+    protected override List<int> GetLayerItemIDs(PackingPosition position) {
       return OccupationLayers[position.X / 10];
     }
-    protected override List<int> GetLayerItemIDs(RectangularPackingItem measures, TwoDimensionalPacking position) {
+    protected override List<int> GetLayerItemIDs(RectangularPackingItem measures, PackingPosition position) {
       List<int> result = new List<int>();
       int x1 = position.X / 10;
@@ -217,6 +217,6 @@
     }
   }
-  public class EPComparer2D : IComparer<TwoDimensionalPacking> {
-    public int Compare(TwoDimensionalPacking a, TwoDimensionalPacking b) {
+  public class EPComparer2D : IComparer<PackingPosition> {
+    public int Compare(PackingPosition a, PackingPosition b) {
       int result = a.X.CompareTo(b.X);
       if (result == 0)
