Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 13606)
@@ -0,0 +1,229 @@
+﻿#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;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
+  [Item("BinPacking2D", "Represents a single-bin packing for a 2D bin-packing problem.")]
+  [StorableClass]
+  public class BinPacking2D : BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
+
+    public BinPacking2D(RectangularPackingBin binMeasures)
+      : base(binMeasures) {
+      //ExtremePoints = new HashSet<TwoDimensionalPacking>();
+      ExtremePoints = new SortedSet<TwoDimensionalPacking>(new EPComparer2D());
+      ExtremePoints.Add(binMeasures.Origin);
+    }
+    [StorableConstructor]
+    protected BinPacking2D(bool deserializing) : base(deserializing) { }
+    protected BinPacking2D(BinPacking2D original, Cloner cloner)
+      : base(original, cloner) {
+      this.ExtremePoints = new SortedSet<TwoDimensionalPacking>(original.ExtremePoints, new EPComparer2D());
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BinPacking2D(this, cloner);
+    }
+                      
+    protected override void GenerateNewExtremePointsForNewItem(RectangularPackingItem newItem, TwoDimensionalPacking position) {
+
+      int newWidth = position.Rotated ? newItem.Height : newItem.Width;
+      int newHeight = position.Rotated ? newItem.Width : newItem.Height;
+
+      //Find ExtremePoints beginning from sourcepointX
+      var sourcePointX = new TwoDimensionalPacking(0, position.X + newWidth, position.Y);
+      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height) {
+        //Traversing down the y-axis        
+        while (sourcePointX.Y > 0 && !IsPointOccupied(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y - 1))) {
+          sourcePointX.Y--;
+        }
+        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y));
+      }
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointY
+      var sourcePointY = new TwoDimensionalPacking(0, position.X, position.Y + newItem.Height);
+      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height) {
+        //Traversing down the x-axis  
+        while (sourcePointY.X > 0 && !IsPointOccupied(new TwoDimensionalPacking (0,sourcePointY.X - 1, sourcePointY.Y))) {
+          sourcePointY.X--;
+        }
+        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointY.X, sourcePointY.Y));
+      }
+
+      //ExtremePoints.RemoveWhere(ep => IsPointOccupied(ep));
+
+      //ExtremePoints = new HashSet<TwoDimensionalPacking>(ExtremePoints.
+      //  OrderBy(ep => ep.X).
+      //  ThenBy(ep => ep.Y).
+      //  ThenBy(ep => ShortestPossibleSideFromPoint(ep)));
+    }
+
+    public override TwoDimensionalPacking FindExtremePointForItem(RectangularPackingItem measures, bool rotated, bool stackingConstraints) {
+      RectangularPackingItem item = new RectangularPackingItem(
+        rotated ? measures.Height : measures.Width,
+        rotated ? measures.Width : measures.Height,
+        measures.TargetBin);
+
+      int epIndex = 0;
+      while (epIndex < ExtremePoints.Count && (!IsPositionFeasible(item, ExtremePoints.ElementAt(epIndex)))) { epIndex++; }
+
+      if (epIndex < ExtremePoints.Count) {
+        var result = ExtremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      }
+      return null;
+    }
+    public override TwoDimensionalPacking FindPositionBySliding(RectangularPackingItem measures, bool rotated) {
+      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(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))) {
+        //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);
+      }
+
+      return IsPositionFeasible(measures, currentPosition) ? currentPosition : null;
+    }
+    
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures) {
+      var temp = new List<int>(sequence);
+      for (int i = 0; i < temp.Count; i++) {
+        var item = itemMeasures[temp[i]];
+        var position = FindPositionBySliding(item, false);
+        if (position != null) {
+          PackItem(temp[i], item, position);
+          sequence.Remove(temp[i]);
+        }
+      }
+    }
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+      var temp = new List<int>(sequence);
+      for (int i = 0; i < temp.Count; i++) {
+        var item = itemMeasures[temp[i]];
+        var position = FindPositionBySliding(item, rotationArray[temp[i]]);
+        if (position != null) {
+          PackItem(temp[i], item, position);
+          sequence.Remove(temp[i]);
+        }
+      }
+    }
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints) {
+      var temp = new List<int>(sequence);
+      foreach (int itemID in temp) {
+        var item = itemMeasures[itemID];
+        var positionFound = FindExtremePointForItem(item, false, false);
+        if (positionFound != null) {
+          PackItem(itemID, item, positionFound);
+          sequence.Remove(itemID);
+        }
+      }
+    }
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+      var temp = new List<int>(sequence);
+      foreach (int itemID in temp) {
+        var item = itemMeasures[itemID];
+        var positionFound = FindExtremePointForItem(item, rotationArray[itemID], false);
+        if (positionFound != null) {
+          PackItem(itemID, item, positionFound);
+          sequence.Remove(itemID);
+        }
+      }
+    }
+
+    public override int ShortestPossibleSideFromPoint(TwoDimensionalPacking position) {
+      int shortestSide = int.MaxValue;
+      int width = BinMeasures.Width;
+      int height = BinMeasures.Height;
+
+      if (position.X >= width || position.Y >= height)
+        return shortestSide;
+
+      TwoDimensionalPacking current = new TwoDimensionalPacking(0, position.X, position.Y);
+      while (current.X < width && IsPointOccupied(current)) { current = TwoDimensionalPacking.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); }
+      if (current.Y - position.Y < shortestSide)
+        shortestSide = current.Y - position.Y;
+
+      return shortestSide;
+    }
+    public override bool IsStaticStable(RectangularPackingItem item, TwoDimensionalPacking position) {
+      throw new NotImplementedException();
+    }
+
+
+    protected override void InitializeOccupationLayers() {
+      for (int i = 0; i*10 <= BinMeasures.Width; i += 1 ) {
+        OccupationLayers[i] = new List<int>();
+      }
+    }
+    protected override void AddNewItemToOccupationLayers(int itemID, RectangularPackingItem measures, TwoDimensionalPacking position) {
+      int x1 = position.X / 10;
+      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
+
+      for (int i = x1; i <= x2; i++)
+        OccupationLayers[i].Add(itemID);
+    }
+    protected override List<int> GetLayerItemIDs(TwoDimensionalPacking position) {
+      return OccupationLayers[position.X / 10];
+    }
+    protected override List<int> GetLayerItemIDs(RectangularPackingItem measures, TwoDimensionalPacking position) { 
+      List<int> result = new List<int> ();
+      int x1 = position.X / 10;
+      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
+
+      for (int i = x1; i <= x2; i++)
+        result.AddRange(OccupationLayers[i]);
+
+      return result;
+    }
+  }
+  public class EPComparer2D : IComparer<TwoDimensionalPacking> {
+    public int Compare(TwoDimensionalPacking a, TwoDimensionalPacking b) {
+      int result = a.X.CompareTo(b.X);
+      if (result == 0)
+        result = a.Y.CompareTo(b.Y);
+
+      return result;
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs	(revision 13606)
@@ -0,0 +1,55 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin,RectangularPackingItem>, I2DGVDecoder {
+    public BottomLeftGroupingVectorDecoder() : base() {}
+    [StorableConstructor]
+    protected BottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftGroupingVectorDecoder(BottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      PackingPlan2D result = new PackingPlan2D(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 13606)
@@ -0,0 +1,56 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking2D;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingBin, RectangularPackingItem>, I2DMCVDecoder {
+    public BottomLeftMultiComponentVectorDecoder() : base() {}
+    [StorableConstructor]
+    protected BottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftMultiComponentVectorDecoder(BottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+      PackingPlan2D result = new PackingPlan2D(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 13606)
@@ -0,0 +1,57 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DPSDecoder {
+
+    public BottomLeftPackingSequenceDecoder(): base() { }
+    [StorableConstructor]
+    protected BottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftPackingSequenceDecoder(BottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      PackingPlan2D result = new PackingPlan2D(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 13606)
@@ -0,0 +1,60 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DGVDecoder {
+    public ExtremePointGroupingVectorDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder2D(ExtremePointGroupingVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan2D result = new PackingPlan2D(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      return Decode(solution, binMeasures, itemMeasures);
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 13606)
@@ -0,0 +1,59 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] // TODO
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking,RectangularPackingBin, RectangularPackingItem>, I2DMCVDecoder {
+    public ExtremePointMultiComponentVectorDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder2D(ExtremePointMultiComponentVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan2D result = new PackingPlan2D(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+      return Decode(solution, binMeasures, itemMeasures);
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 13606)
@@ -0,0 +1,57 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] // TODO
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, I2DPSDecoder {
+    public ExtremePointPackingSequenceDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder2D(ExtremePointPackingSequenceDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder2D(this, cloner);
+    }
+
+
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      PackingPlan2D result = new PackingPlan2D(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
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 13605)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 13606)
@@ -158,6 +158,25 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Decoders\BL\BottomLeftGroupingVectorDecoder.cs" />
+    <Compile Include="Decoders\BL\BottomLeftMultiComponentVectorDecoder.cs" />
+    <Compile Include="Decoders\BL\BottomLeftPackingSequenceDecoder.cs" />
+    <Compile Include="Decoders\EP\ExtremePointGroupingVectorDecoder2D.cs" />
+    <Compile Include="Decoders\EP\ExtremePointMultiComponentVectorDecoder2D.cs" />
+    <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder2D.cs" />
+    <Compile Include="Interfaces\I2DGVDecoder.cs" />
+    <Compile Include="Interfaces\I2DMCVDecoder.cs" />
+    <Compile Include="Interfaces\I2DOperator.cs" />
+    <Compile Include="Interfaces\I2DPSDecoder.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
+    <Compile Include="PackingRatioRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RectangularIdenticalBinPackingProblem.cs" />
+    <Compile Include="RectangularPackingBin.cs" />
+    <Compile Include="RectangularPackingItem.cs" />
+    <Compile Include="RectangularPackingShape.cs" />
+    <Compile Include="TwoDimensionalPacking.cs" />
   </ItemGroup>
   <ItemGroup>
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DGVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DGVDecoder.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DGVDecoder.cs	(revision 13606)
@@ -0,0 +1,28 @@
+﻿#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.Interfaces {
+  public interface I2DGVDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DMCVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DMCVDecoder.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DMCVDecoder.cs	(revision 13606)
@@ -0,0 +1,27 @@
+﻿#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.Interfaces {
+  public interface I2DMCVDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DOperator.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DOperator.cs	(revision 13606)
@@ -0,0 +1,25 @@
+﻿#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
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface I2DOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DPSDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DPSDecoder.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/I2DPSDecoder.cs	(revision 13606)
@@ -0,0 +1,27 @@
+﻿#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.Interfaces {
+  public interface I2DPSDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 13606)
@@ -0,0 +1,47 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator2DGV(PackingMoveEvaluator2DGV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator2DGV(this, cloner);
+    }
+    public PackingMoveEvaluator2DGV()
+      : base() {
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 13606)
@@ -0,0 +1,47 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator2DMCV(PackingMoveEvaluator2DMCV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator2DMCV(this, cloner);
+    }
+    public PackingMoveEvaluator2DMCV()
+      : base() {
+    }
+  }
+}
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 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 13606)
@@ -0,0 +1,47 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator2DPS(PackingMoveEvaluator2DPS original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator2DPS(this, cloner);
+    }
+    public PackingMoveEvaluator2DPS()
+      : base() {
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPlan2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPlan2D.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingPlan2D.cs	(revision 13606)
@@ -0,0 +1,48 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("PackingPlan2D", "Represents a solution for a 2D bin packing problem.")]
+  [StorableClass]
+  public class PackingPlan2D : PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
+    public PackingPlan2D(RectangularPackingBin binMeasures) : this(binMeasures, false, false) { }
+    public PackingPlan2D(RectangularPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
+    [StorableConstructor]
+    protected PackingPlan2D(bool deserializing) : base(deserializing) { }
+    protected PackingPlan2D(PackingPlan2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPlan2D(this, cloner);
+    }
+    public override BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> NewBinPacking() {
+      return new BinPacking2D(BinMeasures);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 13606)
@@ -0,0 +1,45 @@
+﻿#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;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [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, RectangularPackingBin, RectangularPackingItem> {
+
+    [StorableConstructor]
+    protected PackingRatioRectangularIdenticalBinEvaluator (bool deserializing) : base(deserializing) { }
+    protected PackingRatioRectangularIdenticalBinEvaluator (PackingRatioRectangularIdenticalBinEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingRatioRectangularIdenticalBinEvaluator() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingRatioRectangularIdenticalBinEvaluator(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs	(revision 13606)
@@ -0,0 +1,136 @@
+﻿#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.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Problem {
+  [Item("Bin Packing Problem (2D, identical rectangles) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
+  public class RectangularIdenticalBinPackingProblem : RegularIdenticalBinPackingProblem<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
+
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {
+      Name = "2D BPP Default Instance",
+      Description = "The default instance for 2D Bin Packing.",
+      BinMeasures = new int[] { 20, 16 },
+      ItemMeasures = new int[][] {
+        new int[] {3,8},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7},
+        new int[] {5,3},
+        new int[] {9,3},
+        new int[] {2,7}
+      },
+      Items = 30
+    };
+    #endregion
+
+    [StorableConstructor]
+    protected RectangularIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
+    protected RectangularIdenticalBinPackingProblem(RectangularIdenticalBinPackingProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RectangularIdenticalBinPackingProblem(this, cloner);
+    }
+    public RectangularIdenticalBinPackingProblem() : base(
+      new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>()) {
+    }
+
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      Operators.RemoveAll(op => op is I3DOperator);
+
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {        
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
+      } else if (SolutionCreator is GroupingVectorRandomCreator) {  
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {  
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
+      } else {
+        string error = "The given problem does not support the selected solution-creator.";
+        ErrorHandling.ShowErrorDialog(error, null);
+      }
+    }
+
+    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
+      return new PackingRatioRectangularIdenticalBinEvaluator ();
+    }
+
+    protected override void InitializeProblemData() {
+      Load(DefaultInstance);
+    }
+
+    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));
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingBin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingBin.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingBin.cs	(revision 13606)
@@ -0,0 +1,44 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking.PackingBin {
+  [Item("RectangularPackingBin", "Represents a rectangular bin for a two-dimensional bin-packing problem.")]
+  [StorableClass]
+  public class RectangularPackingBin : RectangularPackingShape, IPackingBin {
+    public RectangularPackingBin(int width, int height) : base(width, height) { }
+    public RectangularPackingBin() : base() { }
+
+    [StorableConstructor]
+    protected RectangularPackingBin(bool deserializing) : base(deserializing) { }
+    protected RectangularPackingBin(RectangularPackingBin original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RectangularPackingBin(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs	(revision 13606)
@@ -0,0 +1,80 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+
+namespace HeuristicLab.Problems.BinPacking.PackingItem {
+  [Item("RectangularPackingItem", "Represents a rectangular packing-item for bin-packing problems.")]
+  [StorableClass]
+  public class RectangularPackingItem : RectangularPackingShape, IPackingItem {
+
+    public RectangularPackingBin TargetBin {
+      get { return ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value; }
+      set { ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value = value; }
+    }
+
+    public double Weight {
+      get { return ((IFixedValueParameter<DoubleValue>)Parameters["Weight"]).Value.Value; }
+      set { ((IFixedValueParameter<DoubleValue>)Parameters["Weight"]).Value.Value = value; }
+    }
+
+    public int Material {
+      get { return ((IFixedValueParameter<IntValue>)Parameters["Material"]).Value.Value; }
+      set { ((IFixedValueParameter<IntValue>)Parameters["Material"]).Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected RectangularPackingItem(bool deserializing) : base(deserializing) { }
+    protected RectangularPackingItem(RectangularPackingItem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RectangularPackingItem(this, cloner);
+    }
+
+    public RectangularPackingItem()
+      : base() {
+      Parameters.Add(new ValueParameter<RectangularPackingBin>("TargetBin"));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
+    }
+
+    public RectangularPackingItem(int width, int height, RectangularPackingBin targetBin)
+      : this() {
+      this.Weight = width;
+      this.Height = height;
+      this.TargetBin = (RectangularPackingBin)targetBin.Clone();
+    }
+
+    public bool SupportsStacking(IPackingItem other) {
+      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingShape.cs	(revision 13606)
@@ -0,0 +1,144 @@
+﻿#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;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+
+namespace HeuristicLab.Problems.BinPacking.Shapes {
+  [Item("RectangularPackingShape", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
+  [StorableClass]
+  public abstract class RectangularPackingShape : PackingShape<TwoDimensionalPacking>, IRegularPackingShape, IComparable<RectangularPackingShape> {
+    public int Height {
+      get { return ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value; }
+      set { ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value = value; }
+    }
+
+    public int Width {
+      get { return ((IFixedValueParameter<IntValue>)Parameters["Width"]).Value.Value; }
+      set { ((IFixedValueParameter<IntValue>)Parameters["Width"]).Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected RectangularPackingShape(bool deserializing) : base(deserializing) { }
+    protected RectangularPackingShape(RectangularPackingShape original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    protected RectangularPackingShape()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
+    }
+    protected RectangularPackingShape(int width, int height)
+      : this() {
+      this.Height = height;
+      this.Width = width;
+    }
+
+    public override string ToString() {
+      return String.Format("RectangularPackingShape ({0}, {1})", this.Width, this.Height);
+    }
+
+    #region IComparable<RectangularPackingShape> Members
+
+    public int CompareTo(RectangularPackingShape other) {
+      int result = this.Width.CompareTo(other.Width);
+      if (result == 0)
+        result = this.Height.CompareTo(other.Height);
+      return result;
+    }
+
+    public int CompareTo(object obj) {
+      var other = obj as RectangularPackingShape;
+      if (other != null) return CompareTo(other);
+      else throw new ArgumentException(string.Format("Cannot compare to object {0}", obj), "obj");
+    }
+
+    #endregion
+
+
+    #region Helpers
+    public override TwoDimensionalPacking Origin { get { return new TwoDimensionalPacking(0, 0, 0); } }
+    public override int Volume { get { return Height * Width; } }
+
+    public override bool EnclosesPoint(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPoint) {
+      return (myPosition.X <= checkedPoint.X &&
+                (myPosition.X + (myPosition.Rotated ? Height : Width) - 1) >= checkedPoint.X &&
+                myPosition.Y <= checkedPoint.Y &&
+                (myPosition.Y + (myPosition.Rotated ? Width : Height) - 1) >= checkedPoint.Y);
+    }
+    public override bool Encloses(TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
+      return Encloses(checkedPosition, (RectangularPackingShape)checkedShape);
+    }
+    private bool Encloses(TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
+      return Encloses(new RectangleDiagonal(this), new RectangleDiagonal(checkedPosition, checkedShape));
+    }
+    private bool Encloses(RectangleDiagonal r1, RectangleDiagonal r2) {
+      return (r1.x1 <= r2.x1 &&
+                r1.x2 >= r2.x2 &&
+                r1.y1 <= r2.y1 &&
+                r1.y2 >= r2.y2);
+    }
+
+    public override bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
+      return Overlaps(myPosition, checkedPosition, (RectangularPackingShape)checkedShape);
+    }
+    private bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
+      return Overlaps(new RectangleDiagonal(myPosition, this), new RectangleDiagonal(checkedPosition, checkedShape));
+    }
+    private bool Overlaps(RectangleDiagonal r1, RectangleDiagonal r2) {
+      return !(r1.x1 > r2.x2 ||
+               r1.y1 > r2.y2 ||
+               r1.x2 < r2.x1 ||
+               r1.y2 < r2.y1);
+    }
+
+    public void ApplyHorizontalOrientation() {
+      if (Width < Height) {
+        var aux = Width;
+        Width = Height;
+        Height = aux;
+      }
+    }
+    #endregion
+
+
+    private struct RectangleDiagonal {
+      public int x1;
+      public int y1;
+      public int x2;
+      public int y2;
+      public RectangleDiagonal(RectangularPackingShape myShape) : this(new TwoDimensionalPacking(0, 0, 0), myShape) { }
+      public RectangleDiagonal(TwoDimensionalPacking myPosition, RectangularPackingShape myShape) {
+        x1 = myPosition.X;
+        y1 = myPosition.Y;
+        x2 = myPosition.X + (myPosition.Rotated ? myShape.Height : myShape.Width) - 1;
+        y2 = myPosition.Y + (myPosition.Rotated ? myShape.Width : myShape.Height) - 1;
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/TwoDimensionalPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/TwoDimensionalPacking.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/TwoDimensionalPacking.cs	(revision 13606)
@@ -0,0 +1,88 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Dimensions {
+  [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: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/TwoDimensionalPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/TwoDimensionalPacking.cs	(revision 13605)
+++ 	(revision )
@@ -1,88 +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;
-
-namespace HeuristicLab.Problems.BinPacking.Dimensions {
-  [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: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking2D.cs	(revision 13605)
+++ 	(revision )
@@ -1,229 +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;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-
-namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
-  [Item("BinPacking2D", "Represents a single-bin packing for a 2D bin-packing problem.")]
-  [StorableClass]
-  public class BinPacking2D : BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
-
-    public BinPacking2D(RectangularPackingBin binMeasures)
-      : base(binMeasures) {
-      //ExtremePoints = new HashSet<TwoDimensionalPacking>();
-      ExtremePoints = new SortedSet<TwoDimensionalPacking>(new EPComparer2D());
-      ExtremePoints.Add(binMeasures.Origin);
-    }
-    [StorableConstructor]
-    protected BinPacking2D(bool deserializing) : base(deserializing) { }
-    protected BinPacking2D(BinPacking2D original, Cloner cloner)
-      : base(original, cloner) {
-      this.ExtremePoints = new SortedSet<TwoDimensionalPacking>(original.ExtremePoints, new EPComparer2D());
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BinPacking2D(this, cloner);
-    }
-                      
-    protected override void GenerateNewExtremePointsForNewItem(RectangularPackingItem newItem, TwoDimensionalPacking position) {
-
-      int newWidth = position.Rotated ? newItem.Height : newItem.Width;
-      int newHeight = position.Rotated ? newItem.Width : newItem.Height;
-
-      //Find ExtremePoints beginning from sourcepointX
-      var sourcePointX = new TwoDimensionalPacking(0, position.X + newWidth, position.Y);
-      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height) {
-        //Traversing down the y-axis        
-        while (sourcePointX.Y > 0 && !IsPointOccupied(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y - 1))) {
-          sourcePointX.Y--;
-        }
-        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointX.X, sourcePointX.Y));
-      }
-
-
-
-
-      //Find ExtremePoints beginning from sourcepointY
-      var sourcePointY = new TwoDimensionalPacking(0, position.X, position.Y + newItem.Height);
-      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height) {
-        //Traversing down the x-axis  
-        while (sourcePointY.X > 0 && !IsPointOccupied(new TwoDimensionalPacking (0,sourcePointY.X - 1, sourcePointY.Y))) {
-          sourcePointY.X--;
-        }
-        ExtremePoints.Add(new TwoDimensionalPacking(0, sourcePointY.X, sourcePointY.Y));
-      }
-
-      //ExtremePoints.RemoveWhere(ep => IsPointOccupied(ep));
-
-      //ExtremePoints = new HashSet<TwoDimensionalPacking>(ExtremePoints.
-      //  OrderBy(ep => ep.X).
-      //  ThenBy(ep => ep.Y).
-      //  ThenBy(ep => ShortestPossibleSideFromPoint(ep)));
-    }
-
-    public override TwoDimensionalPacking FindExtremePointForItem(RectangularPackingItem measures, bool rotated, bool stackingConstraints) {
-      RectangularPackingItem item = new RectangularPackingItem(
-        rotated ? measures.Height : measures.Width,
-        rotated ? measures.Width : measures.Height,
-        measures.TargetBin);
-
-      int epIndex = 0;
-      while (epIndex < ExtremePoints.Count && (!IsPositionFeasible(item, ExtremePoints.ElementAt(epIndex)))) { epIndex++; }
-
-      if (epIndex < ExtremePoints.Count) {
-        var result = ExtremePoints.ElementAt(epIndex);
-        result.Rotated = rotated;
-        return result;
-      }
-      return null;
-    }
-    public override TwoDimensionalPacking FindPositionBySliding(RectangularPackingItem measures, bool rotated) {
-      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(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))) {
-        //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);
-      }
-
-      return IsPositionFeasible(measures, currentPosition) ? currentPosition : null;
-    }
-    
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures) {
-      var temp = new List<int>(sequence);
-      for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
-        var position = FindPositionBySliding(item, false);
-        if (position != null) {
-          PackItem(temp[i], item, position);
-          sequence.Remove(temp[i]);
-        }
-      }
-    }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
-      var temp = new List<int>(sequence);
-      for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
-        var position = FindPositionBySliding(item, rotationArray[temp[i]]);
-        if (position != null) {
-          PackItem(temp[i], item, position);
-          sequence.Remove(temp[i]);
-        }
-      }
-    }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints) {
-      var temp = new List<int>(sequence);
-      foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
-        var positionFound = FindExtremePointForItem(item, false, false);
-        if (positionFound != null) {
-          PackItem(itemID, item, positionFound);
-          sequence.Remove(itemID);
-        }
-      }
-    }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
-      var temp = new List<int>(sequence);
-      foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
-        var positionFound = FindExtremePointForItem(item, rotationArray[itemID], false);
-        if (positionFound != null) {
-          PackItem(itemID, item, positionFound);
-          sequence.Remove(itemID);
-        }
-      }
-    }
-
-    public override int ShortestPossibleSideFromPoint(TwoDimensionalPacking position) {
-      int shortestSide = int.MaxValue;
-      int width = BinMeasures.Width;
-      int height = BinMeasures.Height;
-
-      if (position.X >= width || position.Y >= height)
-        return shortestSide;
-
-      TwoDimensionalPacking current = new TwoDimensionalPacking(0, position.X, position.Y);
-      while (current.X < width && IsPointOccupied(current)) { current = TwoDimensionalPacking.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); }
-      if (current.Y - position.Y < shortestSide)
-        shortestSide = current.Y - position.Y;
-
-      return shortestSide;
-    }
-    public override bool IsStaticStable(RectangularPackingItem item, TwoDimensionalPacking position) {
-      throw new NotImplementedException();
-    }
-
-
-    protected override void InitializeOccupationLayers() {
-      for (int i = 0; i*10 <= BinMeasures.Width; i += 1 ) {
-        OccupationLayers[i] = new List<int>();
-      }
-    }
-    protected override void AddNewItemToOccupationLayers(int itemID, RectangularPackingItem measures, TwoDimensionalPacking position) {
-      int x1 = position.X / 10;
-      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
-
-      for (int i = x1; i <= x2; i++)
-        OccupationLayers[i].Add(itemID);
-    }
-    protected override List<int> GetLayerItemIDs(TwoDimensionalPacking position) {
-      return OccupationLayers[position.X / 10];
-    }
-    protected override List<int> GetLayerItemIDs(RectangularPackingItem measures, TwoDimensionalPacking position) { 
-      List<int> result = new List<int> ();
-      int x1 = position.X / 10;
-      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
-
-      for (int i = x1; i <= x2; i++)
-        result.AddRange(OccupationLayers[i]);
-
-      return result;
-    }
-  }
-  public class EPComparer2D : IComparer<TwoDimensionalPacking> {
-    public int Compare(TwoDimensionalPacking a, TwoDimensionalPacking b) {
-      int result = a.X.CompareTo(b.X);
-      if (result == 0)
-        result = a.Y.CompareTo(b.Y);
-
-      return result;
-    }
-  }
-}
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 13605)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 13606)
@@ -253,43 +253,6 @@
 
 
-  [Item("PackingPlan2D", "Represents a solution for a 2D bin packing problem.")]
-  [StorableClass]
-  public class PackingPlan2D : PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
-    public PackingPlan2D(RectangularPackingBin binMeasures) : this(binMeasures, false, false) { }
-    public PackingPlan2D(RectangularPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { } 
-    [StorableConstructor]
-    protected PackingPlan2D(bool deserializing) : base(deserializing) { }
-    protected PackingPlan2D(PackingPlan2D original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingPlan2D(this, cloner);
-    }
-    public override BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> NewBinPacking() {
-      return new BinPacking2D(BinMeasures);
-    }
-  }
-
-
-
-
-
-  [Item("PackingPlan3D", "Represents a solution for a 3D bin packing problem.")]
-  [StorableClass]
-  public class PackingPlan3D : PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
-    public PackingPlan3D(CuboidPackingBin binMeasures) : this(binMeasures, false, false) { }
-    public PackingPlan3D(CuboidPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { } 
-    [StorableConstructor]
-    protected PackingPlan3D(bool deserializing) : base(deserializing) { }
-    protected PackingPlan3D(PackingPlan3D original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingPlan3D(this, cloner);
-    }
-    public override BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> NewBinPacking() {
-      return new BinPacking3D(BinMeasures);
-    }
-  }
+
+
 
 }
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 13605)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 13606)
@@ -160,8 +160,4 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="Decoders\2D\BL\BottomLeftMultiComponentVectorDecoder.cs" />
-    <Compile Include="Decoders\2D\EP\ExtremePointGroupingVectorDecoder2D.cs" />
-    <Compile Include="Decoders\2D\EP\ExtremePointMultiComponentVectorDecoder2D.cs" />
-    <Compile Include="Decoders\2D\EP\ExtremePointPackingSequenceDecoder2D.cs" />
     <Compile Include="Decoders\3D\EP\ExtremePointMultiComponentVectorDecoder3D.cs" />
     <Compile Include="Decoders\3D\EP\ExtremePointGroupingVectorDecoder3D.cs" />
@@ -169,7 +165,5 @@
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\2D\BL\BottomLeftGroupingVectorDecoder.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\2D\BL\BottomLeftPackingSequenceDecoder.cs" />
     <Compile Include="Decoders\3D\EP\ISOContainerMultiComponentVectorDecoder3D.cs" />
     <Compile Include="Decoders\PackingSolutionDecoder.cs" />
@@ -228,5 +222,4 @@
     <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorRandomCreator.cs" />
     <Compile Include="Encodings\MultiComponentVector\ThreeWayMultiComponentVectorManipulator.cs" />
-    <Compile Include="Encodings\PackingPlans\BinPacking2D.cs" />
     <Compile Include="Encodings\PackingPlans\BinPacking3D.cs" />
     <Compile Include="Encodings\PackingPlans\BinPacking.cs" />
@@ -265,5 +258,4 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
-    <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\3D\PackingRatioCuboidIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\Abstract\BinUtilizationRegularIdenticalBinEvaluator.cs" />
@@ -277,13 +269,9 @@
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
     <Compile Include="Instances\RealBPPData.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I2DMCVDecoder.cs" />
     <Compile Include="Interfaces\DecoderInterfaces\I3DMCVDecoder.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I2DGVDecoder.cs" />
     <Compile Include="Interfaces\DecoderInterfaces\I3DGVDecoder.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I2DPSDecoder.cs" />
     <Compile Include="Interfaces\DecoderInterfaces\I3DPSDecoder.cs" />
     <Compile Include="Interfaces\IPackingSequenceMoveOperator.cs" />
     <Compile Include="Interfaces\I3DOperator.cs" />
-    <Compile Include="Interfaces\I2DOperator.cs" />
     <Compile Include="Interfaces\IPackingMove.cs" />
     <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" />
@@ -303,13 +291,6 @@
     <Compile Include="Interfaces\IPackingShape.cs" />
     <Compile Include="Interfaces\IPackingDimensions.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs">
-      <SubType>Code</SubType>
-    </Compile>
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs">
       <SubType>Code</SubType>
@@ -324,17 +305,12 @@
     <Compile Include="Dimensions\PackingDimensions.cs" />
     <Compile Include="Dimensions\ThreeDimensionalPacking.cs" />
-    <Compile Include="Dimensions\TwoDimensionalPacking.cs" />
-    <Compile Include="Problem\RectangularIdenticalBinPackingProblem.cs" />
     <Compile Include="Shapes\PackingShape.cs" />
     <Compile Include="Shapes\CuboidPackingShape.cs" />
-    <Compile Include="Shapes\RectangularPackingShape.cs" />
     <Compile Include="Interfaces\IRegularPackingShape.cs" />
     <Compile Include="PackingBin\CuboidPackingBin.cs" />
-    <Compile Include="PackingBin\RectangularPackingBin.cs" />
     <Compile Include="PackingItem\CuboidPackingItem.cs" />
     <Compile Include="Interfaces\IPackingBin.cs" />
     <Compile Include="Interfaces\IPackingItem.cs" />
     <Compile Include="Interfaces\IPackingPlan.cs" />
-    <Compile Include="PackingItem\RectangularPackingItem.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DGVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DGVDecoder.cs	(revision 13605)
+++ 	(revision )
@@ -1,28 +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.Interfaces {
-  public interface I2DGVDecoder : IOperator, IPackingSolutionDecoder {
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DMCVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DMCVDecoder.cs	(revision 13605)
+++ 	(revision )
@@ -1,27 +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.Interfaces {
-  public interface I2DMCVDecoder : IOperator, IPackingSolutionDecoder {
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DPSDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/DecoderInterfaces/I2DPSDecoder.cs	(revision 13605)
+++ 	(revision )
@@ -1,27 +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.Interfaces {
-  public interface I2DPSDecoder : IOperator, IPackingSolutionDecoder {
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I2DOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I2DOperator.cs	(revision 13605)
+++ 	(revision )
@@ -1,25 +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
-
-namespace HeuristicLab.Problems.BinPacking.Interfaces {
-  public interface I2DOperator {
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 13605)
+++ 	(revision )
@@ -1,47 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DGV(PackingMoveEvaluator2DGV original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DGV(this, cloner);
-    }
-    public PackingMoveEvaluator2DGV()
-      : base() {
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 13605)
+++ 	(revision )
@@ -1,47 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DMCV(PackingMoveEvaluator2DMCV original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DMCV(this, cloner);
-    }
-    public PackingMoveEvaluator2DMCV()
-      : base() {
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 13605)
+++ 	(revision )
@@ -1,47 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator2DPS(PackingMoveEvaluator2DPS original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator2DPS(this, cloner);
-    }
-    public PackingMoveEvaluator2DPS()
-      : base() {
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingBin/RectangularPackingBin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingBin/RectangularPackingBin.cs	(revision 13605)
+++ 	(revision )
@@ -1,44 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.BinPacking.PackingBin {
-  [Item("RectangularPackingBin", "Represents a rectangular bin for a two-dimensional bin-packing problem.")]
-  [StorableClass]
-  public class RectangularPackingBin : RectangularPackingShape, IPackingBin {
-    public RectangularPackingBin(int width, int height) : base(width, height) { }
-    public RectangularPackingBin() : base() { }
-
-    [StorableConstructor]
-    protected RectangularPackingBin(bool deserializing) : base(deserializing) { }
-    protected RectangularPackingBin(RectangularPackingBin original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RectangularPackingBin(this, cloner);
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/RectangularPackingItem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/RectangularPackingItem.cs	(revision 13605)
+++ 	(revision )
@@ -1,80 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-
-namespace HeuristicLab.Problems.BinPacking.PackingItem {
-  [Item("RectangularPackingItem", "Represents a rectangular packing-item for bin-packing problems.")]
-  [StorableClass]
-  public class RectangularPackingItem : RectangularPackingShape, IPackingItem {
-
-    public RectangularPackingBin TargetBin {
-      get { return ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value; }
-      set { ((IValueParameter<RectangularPackingBin>)Parameters["TargetBin"]).Value = value; }
-    }
-
-    public double Weight {
-      get { return ((IFixedValueParameter<DoubleValue>)Parameters["Weight"]).Value.Value; }
-      set { ((IFixedValueParameter<DoubleValue>)Parameters["Weight"]).Value.Value = value; }
-    }
-
-    public int Material {
-      get { return ((IFixedValueParameter<IntValue>)Parameters["Material"]).Value.Value; }
-      set { ((IFixedValueParameter<IntValue>)Parameters["Material"]).Value.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected RectangularPackingItem(bool deserializing) : base(deserializing) { }
-    protected RectangularPackingItem(RectangularPackingItem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RectangularPackingItem(this, cloner);
-    }
-
-    public RectangularPackingItem()
-      : base() {
-      Parameters.Add(new ValueParameter<RectangularPackingBin>("TargetBin"));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
-    }
-
-    public RectangularPackingItem(int width, int height, RectangularPackingBin targetBin)
-      : this() {
-      this.Weight = width;
-      this.Height = height;
-      this.TargetBin = (RectangularPackingBin)targetBin.Clone();
-    }
-
-    public bool SupportsStacking(IPackingItem other) {
-      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
-    }
-  }
-}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingPlan3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingPlan3D.cs	(revision 13606)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingPlan3D.cs	(revision 13606)
@@ -0,0 +1,27 @@
+﻿using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("PackingPlan3D", "Represents a solution for a 3D bin packing problem.")]
+  [StorableClass]
+  public class PackingPlan3D : PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
+    public PackingPlan3D(CuboidPackingBin binMeasures) : this(binMeasures, false, false) { }
+    public PackingPlan3D(CuboidPackingBin binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
+    [StorableConstructor]
+    protected PackingPlan3D(bool deserializing) : base(deserializing) { }
+    protected PackingPlan3D(PackingPlan3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPlan3D(this, cloner);
+    }
+    public override BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> NewBinPacking() {
+      return new BinPacking3D(BinMeasures);
+    }
+  }
+}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs	(revision 13605)
+++ 	(revision )
@@ -1,136 +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.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.Evaluators;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-
-namespace HeuristicLab.Problems.BinPacking.Problem {
-  [Item("Bin Packing Problem (2D, identical rectangles) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
-  public class RectangularIdenticalBinPackingProblem : RegularIdenticalBinPackingProblem<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> {
-
-    #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {
-      Name = "2D BPP Default Instance",
-      Description = "The default instance for 2D Bin Packing.",
-      BinMeasures = new int[] { 20, 16 },
-      ItemMeasures = new int[][] {
-        new int[] {3,8},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7},
-        new int[] {5,3},
-        new int[] {9,3},
-        new int[] {2,7}
-      },
-      Items = 30
-    };
-    #endregion
-
-    [StorableConstructor]
-    protected RectangularIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected RectangularIdenticalBinPackingProblem(RectangularIdenticalBinPackingProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RectangularIdenticalBinPackingProblem(this, cloner);
-    }
-    public RectangularIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>()) {
-    }
-
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      Operators.RemoveAll(op => op is I3DOperator);
-
-      PackingSolutionDecoderParameter.ValidValues.Clear();
-      if (SolutionCreator is PackingSequenceRandomCreator) {        
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {  
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {  
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
-      } else {
-        string error = "The given problem does not support the selected solution-creator.";
-        ErrorHandling.ShowErrorDialog(error, null);
-      }
-    }
-
-    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioRectangularIdenticalBinEvaluator ();
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-
-    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));
-    }
-    #endregion
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/RectangularPackingShape.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/RectangularPackingShape.cs	(revision 13605)
+++ 	(revision )
@@ -1,144 +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;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-
-namespace HeuristicLab.Problems.BinPacking.Shapes {
-  [Item("RectangularPackingShape", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
-  [StorableClass]
-  public abstract class RectangularPackingShape : PackingShape<TwoDimensionalPacking>, IRegularPackingShape, IComparable<RectangularPackingShape> {
-    public int Height {
-      get { return ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value; }
-      set { ((IFixedValueParameter<IntValue>)Parameters["Height"]).Value.Value = value; }
-    }
-
-    public int Width {
-      get { return ((IFixedValueParameter<IntValue>)Parameters["Width"]).Value.Value; }
-      set { ((IFixedValueParameter<IntValue>)Parameters["Width"]).Value.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected RectangularPackingShape(bool deserializing) : base(deserializing) { }
-    protected RectangularPackingShape(RectangularPackingShape original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    protected RectangularPackingShape()
-      : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
-    }
-    protected RectangularPackingShape(int width, int height)
-      : this() {
-      this.Height = height;
-      this.Width = width;
-    }
-
-    public override string ToString() {
-      return String.Format("RectangularPackingShape ({0}, {1})", this.Width, this.Height);
-    }
-
-    #region IComparable<RectangularPackingShape> Members
-
-    public int CompareTo(RectangularPackingShape other) {
-      int result = this.Width.CompareTo(other.Width);
-      if (result == 0)
-        result = this.Height.CompareTo(other.Height);
-      return result;
-    }
-
-    public int CompareTo(object obj) {
-      var other = obj as RectangularPackingShape;
-      if (other != null) return CompareTo(other);
-      else throw new ArgumentException(string.Format("Cannot compare to object {0}", obj), "obj");
-    }
-
-    #endregion
-
-
-    #region Helpers
-    public override TwoDimensionalPacking Origin { get { return new TwoDimensionalPacking(0, 0, 0); } }
-    public override int Volume { get { return Height * Width; } }
-
-    public override bool EnclosesPoint(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPoint) {
-      return (myPosition.X <= checkedPoint.X &&
-                (myPosition.X + (myPosition.Rotated ? Height : Width) - 1) >= checkedPoint.X &&
-                myPosition.Y <= checkedPoint.Y &&
-                (myPosition.Y + (myPosition.Rotated ? Width : Height) - 1) >= checkedPoint.Y);
-    }
-    public override bool Encloses(TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
-      return Encloses(checkedPosition, (RectangularPackingShape)checkedShape);
-    }
-    private bool Encloses(TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
-      return Encloses(new RectangleDiagonal(this), new RectangleDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Encloses(RectangleDiagonal r1, RectangleDiagonal r2) {
-      return (r1.x1 <= r2.x1 &&
-                r1.x2 >= r2.x2 &&
-                r1.y1 <= r2.y1 &&
-                r1.y2 >= r2.y2);
-    }
-
-    public override bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, PackingShape<TwoDimensionalPacking> checkedShape) {
-      return Overlaps(myPosition, checkedPosition, (RectangularPackingShape)checkedShape);
-    }
-    private bool Overlaps(TwoDimensionalPacking myPosition, TwoDimensionalPacking checkedPosition, RectangularPackingShape checkedShape) {
-      return Overlaps(new RectangleDiagonal(myPosition, this), new RectangleDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Overlaps(RectangleDiagonal r1, RectangleDiagonal r2) {
-      return !(r1.x1 > r2.x2 ||
-               r1.y1 > r2.y2 ||
-               r1.x2 < r2.x1 ||
-               r1.y2 < r2.y1);
-    }
-
-    public void ApplyHorizontalOrientation() {
-      if (Width < Height) {
-        var aux = Width;
-        Width = Height;
-        Height = aux;
-      }
-    }
-    #endregion
-
-
-    private struct RectangleDiagonal {
-      public int x1;
-      public int y1;
-      public int x2;
-      public int y2;
-      public RectangleDiagonal(RectangularPackingShape myShape) : this(new TwoDimensionalPacking(0, 0, 0), myShape) { }
-      public RectangleDiagonal(TwoDimensionalPacking myPosition, RectangularPackingShape myShape) {
-        x1 = myPosition.X;
-        y1 = myPosition.Y;
-        x2 = myPosition.X + (myPosition.Rotated ? myShape.Height : myShape.Width) - 1;
-        y2 = myPosition.Y + (myPosition.Rotated ? myShape.Width : myShape.Height) - 1;
-      }
-    }
-  }
-}
