Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14047)
+++ 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)
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
+  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
     public BottomLeftGroupingVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
+  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition,RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
     public BottomLeftMultiComponentVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
+  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
 
     public BottomLeftPackingSequenceDecoder(): base() { }
@@ -44,5 +44,5 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
+  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
     public ExtremePointGroupingVectorDecoder2D () : base() {}
     [StorableConstructor]
@@ -43,5 +43,5 @@
     }
 
-    public static PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public static PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       Solution result = new Solution(binMeasures, true, false);
       result.Pack(solution, itemMeasures);
@@ -49,5 +49,5 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] // TODO
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
+  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
     public ExtremePointMultiComponentVectorDecoder2D () : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public static PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       Solution result = new Solution(binMeasures, true, false);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] // TODO
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
+  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
     public ExtremePointPackingSequenceDecoder2D () : base() {}
     [StorableConstructor]
@@ -44,5 +44,5 @@
 
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14048)
@@ -172,4 +172,5 @@
     <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
+    <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Plugin.cs" />
@@ -179,5 +180,4 @@
     <Compile Include="RectangularPackingShape.cs" />
     <Compile Include="Solution.cs" />
-    <Compile Include="TwoDimensionalPacking.cs" />
   </ItemGroup>
   <ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14048)
@@ -29,5 +29,5 @@
   [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14048)
@@ -29,5 +29,5 @@
   [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14048)
@@ -29,5 +29,5 @@
   [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPosition.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPosition.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPosition.cs	(revision 14048)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Packing Position (2d)", "Represents a packing-position associated with a two dimensional packing-problem.")]
+  [StorableClass]
+  // PackingPosition is an immutable class (and handled as value type concerning Equals and GetHashCode())
+  public class PackingPosition : BinPacking.PackingPosition {
+    [Storable]
+    private readonly int x;
+    public int X { get { return x; } }
+
+    [Storable]
+    private readonly int y;
+    public int Y { get { return y; } }
+
+    [StorableConstructor]
+    protected PackingPosition(bool deserializing) : base(deserializing) { }
+    protected PackingPosition(PackingPosition original, Cloner cloner)
+      : base(original, cloner) {
+      x = original.X;
+      y = original.Y;
+    }
+
+    public PackingPosition(int assignedBin, int x, int y, bool rotated = false)
+      : base(assignedBin, rotated) {
+      this.x = x;
+      this.y = y;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPosition(this, cloner);
+    }
+    
+    public override string ToString() {
+      return string.Format("[AssignedBin: {0}; ({1},{2})]", AssignedBin, x, y);
+    }
+
+    public override bool Equals(object obj) {
+      var other = obj as PackingPosition;
+      if (other != null)
+        return (other.X == this.X && other.Y == this.Y && base.Equals(other));
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return base.GetHashCode() + 13 * X + 17 * Y;
+    }
+
+    public static PackingPosition MoveLeft(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X - 1, original.Y, original.Rotated);
+    }
+    public static PackingPosition MoveDown(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y - 1, original.Rotated);
+    }
+
+    public static PackingPosition MoveRight(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X + 1, original.Y, original.Rotated);
+    }
+    public static PackingPosition MoveUp(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y + 1, original.Rotated);
+    }
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 14048)
@@ -29,5 +29,5 @@
   [Item("Packing-Ratio Rectangular Identical-Bin Evaluator", "Represents an evaluation-algorithm for rectangular-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
   [StorableClass]
-  public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
+  public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
 
     [StorableConstructor]
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs	(revision 14048)
@@ -38,5 +38,5 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
   // TODO: only support 2d BPPData
-  public class RectangularIdenticalBinPackingProblem : BinPackingProblem<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+  public class RectangularIdenticalBinPackingProblem : BinPackingProblem<PackingPosition, RectangularPackingShape, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
 
     #region Default Instance
@@ -97,5 +97,5 @@
     }
     public RectangularIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>()) {
+      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, RectangularPackingShape, RectangularPackingItem>()) {
     }
 
@@ -174,6 +174,6 @@
     protected override void RemoveTooBigItems() {
       PackingItemMeasures.RemoveAll(pi =>
-        !PackingBinMeasures.Encloses(new TwoDimensionalPacking(0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new TwoDimensionalPacking(0, 0, 0, true), pi));
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, true), pi));
     }
     #endregion
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [Item("RectangularPackingShape", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
   [StorableClass]
-  public class RectangularPackingShape : PackingShape<TwoDimensionalPacking>, IComparable<RectangularPackingShape> {
+  public class RectangularPackingShape : PackingShape<PackingPosition>, IComparable<RectangularPackingShape> {
     public int Height {
       get { return ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value; }
@@ -86,8 +86,8 @@
 
     #region Helpers
-    public override TwoDimensionalPacking Origin { get { return new TwoDimensionalPacking(0, 0, 0); } }
+    public override PackingPosition Origin { get { return new PackingPosition(0, 0, 0); } }
     public override int Volume { get { return Height * Width; } }
 
-    public override bool EnclosesPoint(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPoint) {
+    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition checkedPoint) {
       return (myPosition.X <= checkedPoint.X &&
                 (myPosition.X + (myPosition.Rotated ? Height : Width) - 1) >= checkedPoint.X &&
@@ -95,8 +95,8 @@
                 (myPosition.Y + (myPosition.Rotated ? Width : Height) - 1) >= checkedPoint.Y);
     }
-    public override bool Encloses(TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
+    public override bool Encloses(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
       return Encloses(checkedPosition, (RectangularPackingShape)checkedShape);
     }
-    private bool Encloses(TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
+    private bool Encloses(PackingPosition checkedPosition, RectangularPackingShape checkedShape) {
       return Encloses(new RectangleDiagonal(this), new RectangleDiagonal(checkedPosition, checkedShape));
     }
@@ -108,8 +108,8 @@
     }
 
-    public override bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
+    public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
       return Overlaps(myPosition, checkedPosition, (RectangularPackingShape)checkedShape);
     }
-    private bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
+    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, RectangularPackingShape checkedShape) {
       return Overlaps(new RectangleDiagonal(myPosition, this), new RectangleDiagonal(checkedPosition, checkedShape));
     }
@@ -136,6 +136,6 @@
       public int x2;
       public int y2;
-      public RectangleDiagonal(RectangularPackingShape myShape) : this(new TwoDimensionalPacking(0, 0, 0), myShape) { }
-      public RectangleDiagonal(TwoDimensionalPacking myPosition, RectangularPackingShape myShape) {
+      public RectangleDiagonal(RectangularPackingShape myShape) : this(new PackingPosition(0, 0, 0), myShape) { }
+      public RectangleDiagonal(PackingPosition myPosition, RectangularPackingShape myShape) {
         x1 = myPosition.X;
         y1 = myPosition.Y;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14048)
@@ -28,5 +28,5 @@
   [Item("Bin Packing Solution (2d)", "Represents a solution for a 2D bin packing problem.")]
   [StorableClass]
-  public class Solution : PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> {
+  public class Solution : PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
     public Solution(RectangularPackingShape binMeasures) : this(binMeasures, false, false) { }
     public Solution(RectangularPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
@@ -39,5 +39,5 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> NewBinPacking() {
+    public override BinPacking<PackingPosition, RectangularPackingShape, RectangularPackingItem> NewBinPacking() {
       return new BinPacking2D(BinMeasures);
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/TwoDimensionalPacking.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/TwoDimensionalPacking.cs	(revision 14047)
+++ 	(revision )
@@ -1,89 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking2D {
-  [Item("Two Dimensional Packing", "Represents a packing-position associated with a two dimensional packing-problem.")]
-  [StorableClass]
-  // TwoDimensionalPacking is an immutable class (and handled as value type concerning Equals and GetHashCode())
-  public class TwoDimensionalPacking : PackingDimensions {
-    [Storable]
-    private readonly int x;
-    public int X { get { return x; } }
-
-    [Storable]
-    private readonly int y;
-    public int Y { get { return y; } }
-
-    [StorableConstructor]
-    protected TwoDimensionalPacking(bool deserializing) : base(deserializing) { }
-    protected TwoDimensionalPacking(TwoDimensionalPacking original, Cloner cloner)
-      : base(original, cloner) {
-      x = original.X;
-      y = original.Y;
-    }
-
-    public TwoDimensionalPacking(int assignedBin, int x, int y, bool rotated = false)
-      : base(assignedBin, rotated) {
-      this.x = x;
-      this.y = y;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TwoDimensionalPacking(this, cloner);
-    }
-    
-    public override string ToString() {
-      return string.Format("[AssignedBin: {0}; ({1},{2})]", AssignedBin, x, y);
-    }
-
-    public override bool Equals(object obj) {
-      var other = obj as TwoDimensionalPacking;
-      if (other != null)
-        return (other.X == this.X && other.Y == this.Y && base.Equals(other));
-      else return false;
-    }
-
-    public override int GetHashCode() {
-      return base.GetHashCode() + 13 * X + 17 * Y;
-    }
-
-    public static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Rotated);
-    }
-    public static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Rotated);
-    }
-
-    public static TwoDimensionalPacking MoveRight(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X + 1, original.Y, original.Rotated);
-    }
-    public static TwoDimensionalPacking MoveUp(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y + 1, original.Rotated);
-    }
-
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14048)
@@ -30,9 +30,9 @@
   [Item("BinPacking3D", "Represents a single-bin packing for a 3D bin-packing problem.")]
   [StorableClass]
-  public class BinPacking3D : BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
+  public class BinPacking3D : BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
 
     public BinPacking3D(CuboidPackingShape binMeasures)
       : base(binMeasures) {
-      ExtremePoints = new SortedSet<ThreeDimensionalPacking>(new EPComparer3D());
+      ExtremePoints = new SortedSet<PackingPosition>(new EPComparer3D());
       ExtremePoints.Add(binMeasures.Origin);
     }
@@ -42,5 +42,5 @@
       : base(original, cloner) {
       this.depthWasDoubled = original.depthWasDoubled;
-      this.ExtremePoints = new SortedSet<ThreeDimensionalPacking>(original.ExtremePoints, new EPComparer3D());
+      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer3D());
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -48,30 +48,30 @@
     }
 
-    protected override void GenerateNewExtremePointsForNewItem(CuboidPackingItem newItem, ThreeDimensionalPacking position) {
+    protected override void GenerateNewExtremePointsForNewItem(CuboidPackingItem newItem, PackingPosition position) {
       int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
       int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
 
       //Find ExtremePoints beginning from sourcepointX
-      var sourcePointX = new ThreeDimensionalPacking(0, position.X + newWidth, position.Y, position.Z);
+      var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y, position.Z);
       if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height && sourcePointX.Z < BinMeasures.Depth) {
         //Traversing down the y-axis  
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
+        PackingPosition current = new PackingPosition(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current))) {
+          current = PackingPosition.MoveLeft(current);
         }
         ExtremePoints.Add(current);
 
         //Traversing down the z-axis
-        current = new ThreeDimensionalPacking(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
-        while (current.Z > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveBack(current))) {
-          current = ThreeDimensionalPacking.MoveBack(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
+        current = new PackingPosition(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
+        while (current.Z > 0 && !IsPointOccupied(PackingPosition.MoveBack(current))) {
+          current = PackingPosition.MoveBack(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
         }
         ExtremePoints.Add(current);
@@ -82,25 +82,25 @@
 
       //Find ExtremePoints beginning from sourcepointY
-      var sourcePointY = new ThreeDimensionalPacking(0, position.X, position.Y + newItem.Height, position.Z);
+      var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height, position.Z);
       if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height && sourcePointY.Z < BinMeasures.Depth) {
         //Traversing down the x-axis          
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
+        PackingPosition current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
+        while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current))) {
+          current = PackingPosition.MoveLeft(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
         }
         ExtremePoints.Add(current);
 
         //Traversing down the z-axis                                                                   
-        current = new ThreeDimensionalPacking(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
-        while (current.Z > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveBack(current))) {
-          current = ThreeDimensionalPacking.MoveBack(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
+        current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
+        while (current.Z > 0 && !IsPointOccupied(PackingPosition.MoveBack(current))) {
+          current = PackingPosition.MoveBack(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
         }
         ExtremePoints.Add(current);
@@ -112,25 +112,25 @@
 
       //Find ExtremePoints beginning from sourcepointZ
-      var sourcePointZ = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z + newDepth);
+      var sourcePointZ = new PackingPosition(0, position.X, position.Y, position.Z + newDepth);
       if (sourcePointZ.X < BinMeasures.Width && sourcePointZ.Y < BinMeasures.Height && sourcePointZ.Z < BinMeasures.Depth) {
         //Traversing down the x-axis                                                                             
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
+        PackingPosition current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
+        while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current))) {
+          current = PackingPosition.MoveLeft(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
         }
         ExtremePoints.Add(current);
 
         //Traversing down the y-axis                                                                     
-        current = new ThreeDimensionalPacking(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
+        current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
+        while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
+          current = PackingPosition.MoveDown(current);
+        }
+        ExtremePoints.Add((PackingPosition)current.Clone());
+        while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current))) {
+          current = PackingPosition.MoveLeft(current);
         }
         ExtremePoints.Add(current);
@@ -146,5 +146,5 @@
     }
 
-    public override ThreeDimensionalPacking FindExtremePointForItem(CuboidPackingItem measures, bool rotated, bool stackingConstraints) {
+    public override PackingPosition FindExtremePointForItem(CuboidPackingItem measures, bool rotated, bool stackingConstraints) {
 
       CuboidPackingItem item = new CuboidPackingItem(
@@ -164,5 +164,5 @@
       if (epIndex < ExtremePoints.Count) {
         var origPoint = ExtremePoints.ElementAt(epIndex);
-        var result = new ThreeDimensionalPacking(origPoint.AssignedBin, origPoint.X, origPoint.Y, origPoint.Z, rotated);
+        var result = new PackingPosition(origPoint.AssignedBin, origPoint.X, origPoint.Y, origPoint.Z, rotated);
         return result;
       }
@@ -170,26 +170,26 @@
     }
 
-    public override ThreeDimensionalPacking FindPositionBySliding(CuboidPackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(CuboidPackingItem measures, bool rotated) {
       //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(0,
+      PackingPosition currentPosition = new PackingPosition(0,
         BinMeasures.Width - (rotated ? measures.Depth : measures.Width),
         BinMeasures.Height - measures.Height,
         BinMeasures.Depth - (rotated ? measures.Width : measures.Depth), rotated);
       //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveDown(currentPosition))
-        || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition))
-        || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
+      while (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition))
+        || IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
+        || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
         //Slide the item as far as possible to the left
-        while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition))
-      || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
+        while (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
+      || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
           //Slide the item as far as possible to the back
-          while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
-            currentPosition = ThreeDimensionalPacking.MoveBack(currentPosition);
+          while (IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+            currentPosition = PackingPosition.MoveBack(currentPosition);
           }
-          if (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition)))
-            currentPosition = ThreeDimensionalPacking.MoveLeft(currentPosition);
-        }
-        if (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveDown(currentPosition)))
-          currentPosition = ThreeDimensionalPacking.MoveDown(currentPosition);
+          if (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition)))
+            currentPosition = PackingPosition.MoveLeft(currentPosition);
+        }
+        if (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition)))
+          currentPosition = PackingPosition.MoveDown(currentPosition);
       }
 
@@ -242,5 +242,5 @@
     }
 
-    public override int ShortestPossibleSideFromPoint(ThreeDimensionalPacking position) {
+    public override int ShortestPossibleSideFromPoint(PackingPosition position) {
 
       int shortestSide = int.MaxValue;
@@ -252,18 +252,18 @@
         return shortestSide;
 
-      ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.X < width && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveRight(current); }
+      PackingPosition current = new PackingPosition(0, position.X, position.Y, position.Z);
+      while (current.X < width && IsPointOccupied(current)) { current = PackingPosition.MoveRight(current); }
       if (current.X - position.X < shortestSide)
         shortestSide = current.X - position.X;
 
 
-      current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.Y < height && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveUp(current); }
+      current = new PackingPosition(0, position.X, position.Y, position.Z);
+      while (current.Y < height && IsPointOccupied(current)) { current = PackingPosition.MoveUp(current); }
       if (current.Y - position.Y < shortestSide)
         shortestSide = current.Y - position.Y;
 
 
-      current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.Z < depth && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveFront(current); }
+      current = new PackingPosition(0, position.X, position.Y, position.Z);
+      while (current.Z < depth && IsPointOccupied(current)) { current = PackingPosition.MoveFront(current); }
       if (current.Z - position.Z < shortestSide)
         shortestSide = current.Z - position.Z;
@@ -271,13 +271,13 @@
       return shortestSide;
     }
-    public override bool IsStaticStable(CuboidPackingItem item, ThreeDimensionalPacking position) {
+    public override bool IsStaticStable(CuboidPackingItem item, PackingPosition position) {
       //Static stability is given, if item is placed on the ground
       if (position.Y == 0)
         return true;
 
-      if (IsPointOccupied(new ThreeDimensionalPacking(0, position.X, position.Y - 1, position.Z))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X + item.Width - 1, position.Y - 1, position.Z))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X, position.Y - 1, position.Z + item.Depth - 1))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X + item.Width - 1, position.Y - 1, position.Z + item.Depth - 1)))
+      if (IsPointOccupied(new PackingPosition(0, position.X, position.Y - 1, position.Z))
+        && IsPointOccupied(new PackingPosition(0, position.X + item.Width - 1, position.Y - 1, position.Z))
+        && IsPointOccupied(new PackingPosition(0, position.X, position.Y - 1, position.Z + item.Depth - 1))
+        && IsPointOccupied(new PackingPosition(0, position.X + item.Width - 1, position.Y - 1, position.Z + item.Depth - 1)))
         return true;
 
@@ -304,5 +304,5 @@
 
     [Storable]
-    private bool depthWasDoubled = false;
+    private bool depthWasDoubled = false; // TODO ???
     public void DoubleDepth() {
       if (!depthWasDoubled) {
@@ -314,5 +314,5 @@
     }
 
-    public bool IsSupportedByAtLeastOnePoint(CuboidPackingItem item, ThreeDimensionalPacking position) {
+    public bool IsSupportedByAtLeastOnePoint(CuboidPackingItem item, PackingPosition position) {
       if (position.Y == 0)
         return true;
@@ -321,17 +321,17 @@
       for (int x = position.X; x < position.X + item.Width; x++)
         for (int z = position.Z; z < position.Z + item.Depth; z++)
-          if (IsPointOccupied(new ThreeDimensionalPacking(0, x, y, z)))
+          if (IsPointOccupied(new PackingPosition(0, x, y, z)))
             return true;
 
       return false;
     }
-    public bool IsWeightSupported(CuboidPackingItem item, ThreeDimensionalPacking ep) {
+    public bool IsWeightSupported(CuboidPackingItem item, PackingPosition ep) {
       if (ep.Y == 0)
         return true;
 
-      if (ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
+      if (ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
+        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
         return true;
 
@@ -345,5 +345,5 @@
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, CuboidPackingItem measures, ThreeDimensionalPacking position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, CuboidPackingItem measures, PackingPosition position) {
       int z1 = position.Z / 10;
       int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
@@ -352,8 +352,8 @@
         OccupationLayers[i].Add(itemID);
     }
-    protected override List<int> GetLayerItemIDs(ThreeDimensionalPacking position) {
+    protected override List<int> GetLayerItemIDs(PackingPosition position) {
       return OccupationLayers[position.Z / 10];
     }
-    protected override List<int> GetLayerItemIDs(CuboidPackingItem measures, ThreeDimensionalPacking position) {
+    protected override List<int> GetLayerItemIDs(CuboidPackingItem measures, PackingPosition position) {
       List<int> result = new List<int>();
       int z1 = position.Z / 10;
@@ -366,6 +366,6 @@
     }
   }
-  public class EPComparer3D : IComparer<ThreeDimensionalPacking> {
-    public int Compare(ThreeDimensionalPacking a, ThreeDimensionalPacking b) {
+  public class EPComparer3D : IComparer<PackingPosition> {
+    public int Compare(PackingPosition a, PackingPosition b) {
       int result = a.Z.CompareTo(b.Z);
       if (result == 0)
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs	(revision 14048)
@@ -38,5 +38,5 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
   // TODO don't support generic BPPData but only 3d BPPData
-  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<PackingPosition, CuboidPackingShape, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
 
 
@@ -102,5 +102,5 @@
     }
     public CuboidIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>()) {
+      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, CuboidPackingShape, CuboidPackingItem>()) {
     }
 
@@ -178,6 +178,6 @@
     protected override void RemoveTooBigItems() {
       PackingItemMeasures.RemoveAll(pi =>
-        !PackingBinMeasures.Encloses(new ThreeDimensionalPacking(0, 0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new ThreeDimensionalPacking(0, 0, 0, 0, true), pi));
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, true), pi));
     }
     #endregion
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("CuboidPackingShape", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
   [StorableClass]
-  public class CuboidPackingShape : PackingShape<ThreeDimensionalPacking>, IComparable<CuboidPackingShape> {
+  public class CuboidPackingShape : PackingShape<PackingPosition>, IComparable<CuboidPackingShape> {
     public IFixedValueParameter<IntValue> HeightParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
@@ -128,6 +128,6 @@
       public int y2;
       public int z2;
-      public CuboidDiagonal(CuboidPackingShape myShape) : this(new ThreeDimensionalPacking(0, 0, 0, 0), myShape) { }
-      public CuboidDiagonal(ThreeDimensionalPacking myPosition, CuboidPackingShape myShape) {
+      public CuboidDiagonal(CuboidPackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
+      public CuboidDiagonal(PackingPosition myPosition, CuboidPackingShape myShape) {
         x1 = myPosition.X;
         y1 = myPosition.Y;
@@ -141,8 +141,8 @@
 
     #region Helpers
-    public override ThreeDimensionalPacking Origin { get { return new ThreeDimensionalPacking(0, 0, 0, 0); } }
+    public override PackingPosition Origin { get { return new PackingPosition(0, 0, 0, 0); } }
     public override int Volume { get { return Width * Height * Depth; } }
 
-    public override bool EnclosesPoint(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPoint) {
+    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition checkedPoint) {
       return (myPosition.X <= checkedPoint.X &&
                 (myPosition.X + (myPosition.Rotated ? Depth : Width) - 1) >= checkedPoint.X &&
@@ -152,8 +152,8 @@
                 (myPosition.Z + (myPosition.Rotated ? Width : Depth) - 1) >= checkedPoint.Z);
     }
-    public override bool Encloses(ThreeDimensionalPacking checkedPosition, PackingShape<ThreeDimensionalPacking> checkedShape) {
+    public override bool Encloses(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
       return Encloses(checkedPosition, (CuboidPackingShape)checkedShape);
     }
-    private bool Encloses(ThreeDimensionalPacking checkedPosition, CuboidPackingShape checkedShape) {
+    private bool Encloses(PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
       return Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape));
     }
@@ -167,8 +167,8 @@
     }
 
-    public override bool Overlaps(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPosition, PackingShape<ThreeDimensionalPacking> checkedShape) {
+    public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
       return Overlaps(myPosition, checkedPosition, (CuboidPackingShape)checkedShape);
     }
-    private bool Overlaps(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPosition, CuboidPackingShape checkedShape) {
+    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
       return Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape));
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, GroupingVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
     public DeepestBottomLeftGroupingVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, MultiComponentVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
     public DeepestBottomLeftMultiComponentVectorDecoder() : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, PackingSequence-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
     public DeepestBottomLeftPackingSequenceDecoder(): base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
     public ExtremePointGroupingVectorDecoder3D() : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
     public ExtremePointMultiComponentVectorDecoder3D () : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
     public ExtremePointPackingSequenceDecoder3D () : base() {}
     [StorableConstructor]
@@ -44,5 +44,5 @@
 
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14048)
@@ -175,9 +175,9 @@
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
+    <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioCuboidIdenticalBinEvaluator.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />
-    <Compile Include="ThreeDimensionalPacking.cs" />
   </ItemGroup>
   <ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14048)
@@ -30,5 +30,5 @@
   [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14048)
@@ -30,5 +30,5 @@
   [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14048)
@@ -30,5 +30,5 @@
   [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingPosition.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingPosition.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingPosition.cs	(revision 14048)
@@ -0,0 +1,98 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Packing Position (3d)", "Represents a packing-position associated with a three dimensional packing-problem.")]
+  [StorableClass]
+  // PackingPosition is immutable (and handled as value type concerning Equals and GetHashCode)
+  public class PackingPosition : BinPacking.PackingPosition {
+    [Storable]
+    private readonly int x;
+    [Storable]
+    private readonly int y;
+    [Storable]
+    private readonly int z;
+
+    public int X { get { return x; } }
+    public int Y { get { return y; } }
+    public int Z { get { return z; } }
+
+    [StorableConstructor]
+    protected PackingPosition(bool deserializing) : base(deserializing) { }
+    protected PackingPosition(PackingPosition original, Cloner cloner)
+      : base(original, cloner) {
+      x = original.X;
+      y = original.Y;
+      z = original.Z;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPosition(this, cloner);
+    }
+
+    public PackingPosition(int assignedBin, int x, int y, int z, bool rotated = false)
+      : base(assignedBin, rotated) {
+      this.x = x;
+      this.y = y;
+      this.z = z;
+    }
+
+    public override string ToString() {
+      return string.Format("[AssignedBin: {0}; ({1},{2},{3})]", AssignedBin, X, Y, Z);
+    }
+
+
+    public override bool Equals(object obj) {
+      var tdp = obj as PackingPosition;
+      if (tdp != null)
+        return (tdp.X == this.X && tdp.Y == this.Y && tdp.Z == this.Z);
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return base.GetHashCode() + 13 * X + 17 * Y + 23 * Z;
+    }
+
+    public static PackingPosition MoveLeft(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
+    }
+    public static PackingPosition MoveDown(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
+    }
+    public static PackingPosition MoveBack(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
+    }
+
+    public static PackingPosition MoveRight(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X + 1, original.Y, original.Z, original.Rotated);
+    }
+    public static PackingPosition MoveUp(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y + 1, original.Z, original.Rotated);
+    }
+    public static PackingPosition MoveFront(PackingPosition original) {
+      return new PackingPosition(original.AssignedBin, original.X, original.Y, original.Z + 1, original.Rotated);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 14048)
@@ -28,5 +28,5 @@
   [Item("Packing-Ratio Cuboid Identical-Bin Evaluator", "Represents an evaluation-algorithm for cuboid-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
   [StorableClass]
-  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
+  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
 
     [StorableConstructor]
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs	(revision 14048)
@@ -7,5 +7,5 @@
   [Item("Bin Packing Solution (3d)", "Represents a solution for a 3D bin packing problem.")]
   [StorableClass]
-  public class Solution : PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> {
+  public class Solution : PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
     public Solution(CuboidPackingShape binMeasures) : this(binMeasures, false, false) { }
     public Solution(CuboidPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
@@ -18,5 +18,5 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> NewBinPacking() {
+    public override BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> NewBinPacking() {
       return new BinPacking3D(BinMeasures);
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/ThreeDimensionalPacking.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/ThreeDimensionalPacking.cs	(revision 14047)
+++ 	(revision )
@@ -1,99 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("Three Dimensional Packing", "Represents a packing-position associated with a three dimensional packing-problem.")]
-  [StorableClass]
-  // ThreeDimensionalPacking is immutable (and handled as value type concerning Equals and GetHashCode)
-  public class ThreeDimensionalPacking : PackingDimensions {
-    [Storable]
-    private readonly int x;
-    [Storable]
-    private readonly int y;
-    [Storable]
-    private readonly int z;
-
-    public int X { get { return x; } }
-    public int Y { get { return y; } }
-    public int Z { get { return z; } }
-
-    [StorableConstructor]
-    protected ThreeDimensionalPacking(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalPacking(ThreeDimensionalPacking original, Cloner cloner)
-      : base(original, cloner) {
-      x = original.X;
-      y = original.Y;
-      z = original.Z;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalPacking(this, cloner);
-    }
-
-    public ThreeDimensionalPacking(int assignedBin, int x, int y, int z, bool rotated = false)
-      : base(assignedBin, rotated) {
-      this.x = x;
-      this.y = y;
-      this.z = z;
-    }
-
-    public override string ToString() {
-      return string.Format("[AssignedBin: {0}; ({1},{2},{3})]", AssignedBin, X, Y, Z);
-    }
-
-
-    public override bool Equals(object obj) {
-      var tdp = obj as ThreeDimensionalPacking;
-      if (tdp != null)
-        return (tdp.X == this.X && tdp.Y == this.Y && tdp.Z == this.Z);
-      else return false;
-    }
-
-    public override int GetHashCode() {
-      return base.GetHashCode() + 13 * X + 17 * Y + 23 * Z;
-    }
-
-    public static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
-    }
-
-    public static ThreeDimensionalPacking MoveRight(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X + 1, original.Y, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveUp(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y + 1, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveFront(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z + 1, original.Rotated);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs	(revision 14048)
@@ -33,6 +33,6 @@
     private int selectedItemKey;
     private Size renderSize;
-    private BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> packing;
-    public BinPacking<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Packing {
+    private BinPacking<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> packing;
+    public BinPacking<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> Packing {
       get { return packing; }
       set {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs	(revision 14048)
@@ -35,6 +35,6 @@
     private int selectedItemKey;
 
-    private BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> packing;
-    public BinPacking<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Packing {
+    private BinPacking<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> packing;
+    public BinPacking<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> Packing {
       get { return packing; }
       set {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs	(revision 14048)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("2-dimensional packing plan view")]
-  [Content(typeof(PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>), true)]
+  [Content(typeof(PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem>), true)]
   public partial class PackingPlan2DView : ItemView {
 
@@ -35,6 +35,6 @@
     }
 
-    public new PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> Content {
-      get { return (PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem>)base.Content; }
+    public new PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> Content {
+      get { return (PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem>)base.Content; }
       set { base.Content = value; }
     }
@@ -56,5 +56,5 @@
     }
 
-    private void UpdateState(PackingPlan<TwoDimensionalPacking, RectangularPackingShape, RectangularPackingItem> plan) {
+    private void UpdateState(PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> plan) {
       int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
       container2DView.Packing = plan.BinPackings[currentBin];
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14048)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("3-dimensional packing plan View")]
-  [Content(typeof(PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>), true)]
+  [Content(typeof(PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem>), true)]
   public partial class PackingPlan3DView : ItemView {
 
@@ -35,6 +35,6 @@
     }
 
-    public new PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem> Content {
-      get { return (PackingPlan<ThreeDimensionalPacking, CuboidPackingShape, CuboidPackingItem>)base.Content; }
+    public new PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> Content {
+      get { return (PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem>)base.Content; }
       set { base.Content = value; }
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 14048)
@@ -34,5 +34,5 @@
   [StorableClass]
   public class BestBinPackingSolutionAnalyzer<D, B, I> : BinPackingAnalyzer<D, B, I>, IStochasticOperator
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs	(revision 14048)
@@ -33,5 +33,5 @@
   [StorableClass]
   public abstract class BinPackingAnalyzer<D, B, I> : SingleSuccessorOperator, IAnalyzer
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 14048)
@@ -38,5 +38,5 @@
   [StorableClass]
   public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
-    where D : class, IPackingDimensions 
+    where D : class, IPackingPosition 
     where B : PackingShape<D>, new()
     where I : PackingShape<D>, IPackingItem, new () {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [StorableClass]
   public abstract class BinPacking<D,B,I>  : Item
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14048)
@@ -38,5 +38,5 @@
   [StorableClass]
   public abstract class PackingPlan<D, B, I> :Item, IPackingPlan
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [StorableClass]
   public abstract class BinUtilizationRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs	(revision 14048)
@@ -34,5 +34,5 @@
   public class PackingPlanEvaluationAlgorithm<E, D, B, I> : SingleSuccessorOperator, IPackingPlanEvaluationAlgorithm
     where E : Item //E defines the used Encoding
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs	(revision 14048)
@@ -33,5 +33,5 @@
   [StorableClass]
   public abstract class PackingPlanEvaluator<D,B,I> : SingleSuccessorOperator, IPackingPlanEvaluator
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 14048)
@@ -31,5 +31,5 @@
   [StorableClass]
   public abstract class PackingRatioRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 14048)
@@ -30,5 +30,5 @@
   [StorableClass]
   public abstract class RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I> : PackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14048)
@@ -262,4 +262,5 @@
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
     <Compile Include="Instances\RealBPPData.cs" />
+    <Compile Include="Interfaces\IPackingPosition.cs" />
     <Compile Include="Interfaces\IPackingSequenceMoveOperator.cs" />
     <Compile Include="Interfaces\IPackingMove.cs" />
@@ -279,5 +280,4 @@
     <Compile Include="Interfaces\IPackingPlanEvaluator.cs" />
     <Compile Include="Interfaces\IPackingShape.cs" />
-    <Compile Include="Interfaces\IPackingDimensions.cs" />
     <Compile Include="PackingDimensions.cs" />
     <Compile Include="PackingMoveEvaluator.cs" />
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingDimensions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingDimensions.cs	(revision 14047)
+++ 	(revision )
@@ -1,30 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Problems.BinPacking {
-  // TODO: this interface should contain positions 
-  public interface IPackingDimensions : IItem {
-    int AssignedBin { get; }
-    bool Rotated { get; }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingPosition.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingPosition.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingPosition.cs	(revision 14048)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking {
+  
+  public interface IPackingPosition : IItem {
+    int AssignedBin { get; }
+    bool Rotated { get; }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs	(revision 14048)
@@ -29,5 +29,5 @@
   [StorableClass]
   // PackingDimensions is immutable (and handled as value types concerning Equals and GetHashCode)
-  public abstract class PackingDimensions : Item, IPackingDimensions {
+  public abstract class PackingPosition : Item, IPackingPosition {
     /// <summary>
     /// The number of the bin to which the current item is assigned is stored in this variable. Counting starts at 0 !!!
@@ -49,6 +49,6 @@
 
     [StorableConstructor]
-    protected PackingDimensions(bool deserializing) : base(deserializing) { }
-    protected PackingDimensions(PackingDimensions original, Cloner cloner)
+    protected PackingPosition(bool deserializing) : base(deserializing) { }
+    protected PackingPosition(PackingPosition original, Cloner cloner)
       : base(original, cloner) {
       assignedBin = original.AssignedBin;
@@ -56,5 +56,5 @@
     }
 
-    protected PackingDimensions(int assignedBin, bool rotated) {
+    protected PackingPosition(int assignedBin, bool rotated) {
       this.assignedBin = assignedBin;
       this.rotated = rotated;
@@ -66,5 +66,5 @@
 
     public override bool Equals(object obj) {
-      var other = obj as PackingDimensions;
+      var other = obj as PackingPosition;
       if (other != null)
         return (other.AssignedBin == this.AssignedBin && other.Rotated == this.Rotated);
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14048)
@@ -33,5 +33,5 @@
   [StorableClass]
   public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {     
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 14048)
@@ -32,5 +32,5 @@
   [StorableClass]
   public abstract class PackingShape<T> : Item, IPackingShape, IParameterizedItem
-    where T : class, IPackingDimensions {
+    where T : class, IPackingPosition {
     public static Type PositionType {
       get { return typeof(T); }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs	(revision 14047)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs	(revision 14048)
@@ -34,5 +34,5 @@
   [StorableClass]
   public abstract class PackingSolutionDecoder<D, B, I> : SingleSuccessorOperator, IPackingSolutionDecoder
-    where D : class, IPackingDimensions
+    where D : class, IPackingPosition
     where B : PackingShape<D>
     where I : PackingShape<D>, IPackingItem {
