Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14049)
@@ -31,7 +31,7 @@
   [Item("BinPacking2D", "Represents a single-bin packing for a 2D bin-packing problem.")]
   [StorableClass]
-  public class BinPacking2D : BinPacking<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
-
-    public BinPacking2D(RectangularPackingShape binMeasures)
+  public class BinPacking2D : BinPacking<PackingPosition, PackingShape, PackingItem> {
+
+    public BinPacking2D(PackingShape binMeasures)
       : base(binMeasures) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer2D());
@@ -48,5 +48,5 @@
     }
 
-    protected override void GenerateNewExtremePointsForNewItem(RectangularPackingItem newItem, PackingPosition position) {
+    protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position) {
 
       int newWidth = position.Rotated ? newItem.Height : newItem.Width;
@@ -85,6 +85,6 @@
     }
 
-    public override PackingPosition FindExtremePointForItem(RectangularPackingItem measures, bool rotated, bool stackingConstraints) {
-      RectangularPackingItem item = new RectangularPackingItem(
+    public override PackingPosition FindExtremePointForItem(PackingItem measures, bool rotated, bool stackingConstraints) {
+      PackingItem item = new PackingItem(
         rotated ? measures.Height : measures.Width,
         rotated ? measures.Width : measures.Height,
@@ -102,5 +102,5 @@
       return null;
     }
-    public override PackingPosition FindPositionBySliding(RectangularPackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
       PackingPosition currentPosition = new PackingPosition(0,
         BinMeasures.Width - (rotated ? measures.Height : measures.Width),
@@ -120,5 +120,5 @@
     }
 
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -131,5 +131,5 @@
       }
     }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -142,5 +142,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -153,5 +153,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<RectangularPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -186,5 +186,5 @@
       return shortestSide;
     }
-    public override bool IsStaticStable(RectangularPackingItem item, PackingPosition position) {
+    public override bool IsStaticStable(PackingItem item, PackingPosition position) {
       throw new NotImplementedException();
     }
@@ -196,5 +196,5 @@
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, RectangularPackingItem measures, PackingPosition position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
       int x1 = position.X / 10;
       int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
@@ -206,5 +206,5 @@
       return OccupationLayers[position.X / 10];
     }
-    protected override List<int> GetLayerItemIDs(RectangularPackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
       List<int> result = new List<int>();
       int x1 = position.X / 10;
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 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftGroupingVectorDecoder.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
+  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DGVDecoder {
     public BottomLeftGroupingVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition,RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
+  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition,PackingShape, PackingItem>, I2DMCVDecoder {
     public BottomLeftMultiComponentVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14049)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
+  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DPSDecoder {
 
     public BottomLeftPackingSequenceDecoder(): base() { }
@@ -44,5 +44,5 @@
     }
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14049)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DGVDecoder {
+  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DGVDecoder {
     public ExtremePointGroupingVectorDecoder2D () : base() {}
     [StorableConstructor]
@@ -43,5 +43,5 @@
     }
 
-    public static PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(GroupingVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       Solution result = new Solution(binMeasures, true, false);
       result.Pack(solution, itemMeasures);
@@ -49,5 +49,5 @@
     }
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] // TODO
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DMCVDecoder {
+  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DMCVDecoder {
     public ExtremePointMultiComponentVectorDecoder2D () : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(MultiComponentVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       Solution result = new Solution(binMeasures, true, false);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14049)
@@ -32,5 +32,5 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] // TODO
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<PackingPosition, RectangularPackingShape, RectangularPackingItem>, I2DPSDecoder {
+  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DPSDecoder {
     public ExtremePointPackingSequenceDecoder2D () : base() {}
     [StorableConstructor]
@@ -44,5 +44,5 @@
 
 
-    public override PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingShape binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14049)
@@ -172,11 +172,11 @@
     <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
+    <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioRectangularIdenticalBinEvaluator.cs" />
+    <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RectangularIdenticalBinPackingProblem.cs" />
-    <Compile Include="RectangularPackingItem.cs" />
-    <Compile Include="RectangularPackingShape.cs" />
     <Compile Include="Solution.cs" />
   </ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 14049)
@@ -29,5 +29,5 @@
   [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 14049)
@@ -29,5 +29,5 @@
   [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluators/PackingMoveEvaluator2DPS.cs	(revision 14049)
@@ -29,5 +29,5 @@
   [Item("PackingSequenceMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
+  public class PackingMoveEvaluator2DPS : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I2DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator2DPS(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingItem.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingItem.cs	(revision 14049)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("PackingItem (2d)", "Represents a rectangular packing-item for bin-packing problems.")]
+  [StorableClass]
+  public class PackingItem : PackingShape, IPackingItem {
+
+    public PackingShape TargetBin {
+      get { return ((IValueParameter<PackingShape>)Parameters["TargetBin"]).Value; }
+      set { ((IValueParameter<PackingShape>)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 PackingItem(bool deserializing) : base(deserializing) { }
+    protected PackingItem(PackingItem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingItem(this, cloner);
+    }
+
+    public PackingItem()
+      : base() {
+      Parameters.Add(new ValueParameter<PackingShape>("TargetBin"));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
+    }
+
+    public PackingItem(int width, int height, PackingShape targetBin)
+      : this() {
+      this.Width = width;
+      this.Height = height;
+      this.TargetBin = (PackingShape)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/PackingRatioRectangularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 14049)
@@ -29,5 +29,5 @@
   [Item("Packing-Ratio Rectangular Identical-Bin Evaluator", "Represents an evaluation-algorithm for rectangular-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
   [StorableClass]
-  public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
+  public class PackingRatioRectangularIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, PackingShape, PackingItem> {
 
     [StorableConstructor]
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingShape.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingShape.cs	(revision 14049)
@@ -0,0 +1,147 @@
+﻿#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.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("PackingShape (2d)", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
+  [StorableClass]
+  public class PackingShape : PackingShape<PackingPosition>, IComparable<PackingShape> {
+    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 PackingShape(bool deserializing) : base(deserializing) { }
+    protected PackingShape(PackingShape original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingShape()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
+    }
+    public PackingShape(int width, int height)
+      : this() {
+      this.Height = height;
+      this.Width = width;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingShape(this, cloner);
+    }
+
+    public override string ToString() {
+      return String.Format("RectangularPackingShape ({0}, {1})", this.Width, this.Height);
+    }
+
+    #region IComparable<RectangularPackingShape> Members
+
+    public int CompareTo(PackingShape other) {
+      int result = this.Width.CompareTo(other.Width);
+      if (result == 0)
+        result = this.Height.CompareTo(other.Height);
+      return result;
+    }
+
+    public override int CompareTo(object obj) {
+      var other = obj as PackingShape;
+      if (other != null) return CompareTo(other);
+      else throw new ArgumentException(string.Format("Cannot compare to object {0}", obj), "obj");
+    }
+
+    #endregion
+
+
+    #region Helpers
+    public override PackingPosition Origin { get { return new PackingPosition(0, 0, 0); } }
+    public override int Volume { get { return Height * Width; } }
+
+    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition 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(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
+      return Encloses(checkedPosition, (PackingShape)checkedShape);
+    }
+    private bool Encloses(PackingPosition checkedPosition, PackingShape 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(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
+      return Overlaps(myPosition, checkedPosition, (PackingShape)checkedShape);
+    }
+    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape 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 override 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(PackingShape myShape) : this(new PackingPosition(0, 0, 0), myShape) { }
+      public RectangleDiagonal(PackingPosition myPosition, PackingShape 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/Problem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs	(revision 14049)
@@ -0,0 +1,181 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Data;
+using System;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [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)]
+  // TODO: only support 2d BPPData
+  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+
+    #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 Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+    public Problem() : base(
+      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, PackingShape, PackingItem>()) {
+    }
+
+    #region Problem instance handling
+    public void Load(BPPData data) {
+      var realData = data as RealBPPData;
+      var binData = new PackingShape(data.BinMeasures[0], data.BinMeasures[1]);
+
+      var itemData = new ItemList<PackingItem>(data.Items);
+      for (int j = 0; j < data.Items; j++) {
+        var bin = new PackingShape(data.BinMeasures[0], data.BinMeasures[1]);
+        var item = new PackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], bin);
+        if (realData != null) {
+          item.Weight = realData.ItemWeights[j];
+          item.Material = realData.ItemMaterials[j];
+        }
+        itemData.Add(item);
+      }
+
+      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
+
+      PackingBinMeasures = binData;
+      PackingItemMeasures = itemData;
+
+      ApplyHorizontalOrientation();
+      SortItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+
+    public BPPData Export() {
+      var result = new BPPData {
+        Name = Name,
+        Description = Description,
+        Items = PackingItemsParameter.Value.Value,
+        BinMeasures = new int[] { PackingBinMeasures.Width, PackingBinMeasures.Height }
+      };
+
+      var itemMeasures = new int[result.Items][];
+      int i = 0;
+      foreach (var item in PackingItemMeasures) {
+        itemMeasures[i] = new int[] { item.Width, item.Height };
+        i++;
+      }
+      result.ItemMeasures = itemMeasures;
+      return result;
+    }
+    #endregion
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      // Operators.RemoveAll(op => op is I3DOperator); TODO
+
+      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 PackingPosition(0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, true), pi));
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularIdenticalBinPackingProblem.cs	(revision 14048)
+++ 	(revision )
@@ -1,181 +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;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-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;
-using HeuristicLab.Data;
-using System;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking2D {
-  [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)]
-  // TODO: only support 2d BPPData
-  public class RectangularIdenticalBinPackingProblem : BinPackingProblem<PackingPosition, RectangularPackingShape, RectangularPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
-
-    #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, PackingPosition, RectangularPackingShape, RectangularPackingItem>()) {
-    }
-
-    #region Problem instance handling
-    public void Load(BPPData data) {
-      var realData = data as RealBPPData;
-      var binData = new RectangularPackingShape(data.BinMeasures[0], data.BinMeasures[1]);
-
-      var itemData = new ItemList<RectangularPackingItem>(data.Items);
-      for (int j = 0; j < data.Items; j++) {
-        var bin = new RectangularPackingShape(data.BinMeasures[0], data.BinMeasures[1]);
-        var item = new RectangularPackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], bin);
-        if (realData != null) {
-          item.Weight = realData.ItemWeights[j];
-          item.Material = realData.ItemMaterials[j];
-        }
-        itemData.Add(item);
-      }
-
-      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
-
-      PackingBinMeasures = binData;
-      PackingItemMeasures = itemData;
-
-      ApplyHorizontalOrientation();
-      SortItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-
-
-    public BPPData Export() {
-      var result = new BPPData {
-        Name = Name,
-        Description = Description,
-        Items = PackingItemsParameter.Value.Value,
-        BinMeasures = new int[] { PackingBinMeasures.Width, PackingBinMeasures.Height }
-      };
-
-      var itemMeasures = new int[result.Items][];
-      int i = 0;
-      foreach (var item in PackingItemMeasures) {
-        itemMeasures[i] = new int[] { item.Width, item.Height };
-        i++;
-      }
-      result.ItemMeasures = itemMeasures;
-      return result;
-    }
-    #endregion
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      // Operators.RemoveAll(op => op is I3DOperator); TODO
-
-      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 PackingPosition(0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, true), pi));
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/RectangularPackingItem.cs	(revision 14048)
+++ 	(revision )
@@ -1,78 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking2D {
-  [Item("RectangularPackingItem", "Represents a rectangular packing-item for bin-packing problems.")]
-  [StorableClass]
-  public class RectangularPackingItem : RectangularPackingShape, IPackingItem {
-
-    public RectangularPackingShape TargetBin {
-      get { return ((IValueParameter<RectangularPackingShape>)Parameters["TargetBin"]).Value; }
-      set { ((IValueParameter<RectangularPackingShape>)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<RectangularPackingShape>("TargetBin"));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
-    }
-
-    public RectangularPackingItem(int width, int height, RectangularPackingShape targetBin)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.TargetBin = (RectangularPackingShape)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 14048)
+++ 	(revision )
@@ -1,147 +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.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking2D {
-  [Item("RectangularPackingShape", "Represents the rectangular measures (width, height) of a two-dimensional bin-packing object.")]
-  [StorableClass]
-  public class RectangularPackingShape : PackingShape<PackingPosition>, 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) {
-    }
-    public RectangularPackingShape()
-      : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
-    }
-    public RectangularPackingShape(int width, int height)
-      : this() {
-      this.Height = height;
-      this.Width = width;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RectangularPackingShape(this, cloner);
-    }
-
-    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 override 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 PackingPosition Origin { get { return new PackingPosition(0, 0, 0); } }
-    public override int Volume { get { return Height * Width; } }
-
-    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition 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(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Encloses(checkedPosition, (RectangularPackingShape)checkedShape);
-    }
-    private bool Encloses(PackingPosition 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(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Overlaps(myPosition, checkedPosition, (RectangularPackingShape)checkedShape);
-    }
-    private bool Overlaps(PackingPosition myPosition, PackingPosition 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 override 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 PackingPosition(0, 0, 0), myShape) { }
-      public RectangleDiagonal(PackingPosition 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/Solution.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14049)
@@ -28,7 +28,7 @@
   [Item("Bin Packing Solution (2d)", "Represents a solution for a 2D bin packing problem.")]
   [StorableClass]
-  public class Solution : PackingPlan<PackingPosition, RectangularPackingShape, RectangularPackingItem> {
-    public Solution(RectangularPackingShape binMeasures) : this(binMeasures, false, false) { }
-    public Solution(RectangularPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
+  public class Solution : PackingPlan<PackingPosition, PackingShape, PackingItem> {
+    public Solution(PackingShape binMeasures) : this(binMeasures, false, false) { }
+    public Solution(PackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
     [StorableConstructor]
     protected Solution(bool deserializing) : base(deserializing) { }
@@ -39,5 +39,5 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<PackingPosition, RectangularPackingShape, RectangularPackingItem> NewBinPacking() {
+    public override BinPacking<PackingPosition, PackingShape, PackingItem> NewBinPacking() {
       return new BinPacking2D(BinMeasures);
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14049)
@@ -30,7 +30,7 @@
   [Item("BinPacking3D", "Represents a single-bin packing for a 3D bin-packing problem.")]
   [StorableClass]
-  public class BinPacking3D : BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
-
-    public BinPacking3D(CuboidPackingShape binMeasures)
+  public class BinPacking3D : BinPacking<PackingPosition, PackingShape, PackingItem> {
+
+    public BinPacking3D(PackingShape binMeasures)
       : base(binMeasures) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer3D());
@@ -48,5 +48,5 @@
     }
 
-    protected override void GenerateNewExtremePointsForNewItem(CuboidPackingItem newItem, PackingPosition position) {
+    protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position) {
       int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
       int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
@@ -146,7 +146,7 @@
     }
 
-    public override PackingPosition FindExtremePointForItem(CuboidPackingItem measures, bool rotated, bool stackingConstraints) {
-
-      CuboidPackingItem item = new CuboidPackingItem(
+    public override PackingPosition FindExtremePointForItem(PackingItem measures, bool rotated, bool stackingConstraints) {
+
+      PackingItem item = new PackingItem(
         rotated ? measures.Depth : measures.Width,
         measures.Height,
@@ -170,5 +170,5 @@
     }
 
-    public override PackingPosition FindPositionBySliding(CuboidPackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
       //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
       PackingPosition currentPosition = new PackingPosition(0,
@@ -197,5 +197,5 @@
     }
 
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -208,5 +208,5 @@
       }
     }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -219,5 +219,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -230,5 +230,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -271,5 +271,5 @@
       return shortestSide;
     }
-    public override bool IsStaticStable(CuboidPackingItem item, PackingPosition position) {
+    public override bool IsStaticStable(PackingItem item, PackingPosition position) {
       //Static stability is given, if item is placed on the ground
       if (position.Y == 0)
@@ -314,5 +314,5 @@
     }
 
-    public bool IsSupportedByAtLeastOnePoint(CuboidPackingItem item, PackingPosition position) {
+    public bool IsSupportedByAtLeastOnePoint(PackingItem item, PackingPosition position) {
       if (position.Y == 0)
         return true;
@@ -326,5 +326,5 @@
       return false;
     }
-    public bool IsWeightSupported(CuboidPackingItem item, PackingPosition ep) {
+    public bool IsWeightSupported(PackingItem item, PackingPosition ep) {
       if (ep.Y == 0)
         return true;
@@ -345,5 +345,5 @@
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, CuboidPackingItem measures, PackingPosition position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
       int z1 = position.Z / 10;
       int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
@@ -355,5 +355,5 @@
       return OccupationLayers[position.Z / 10];
     }
-    protected override List<int> GetLayerItemIDs(CuboidPackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
       List<int> result = new List<int>();
       int z1 = position.Z / 10;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs	(revision 14048)
+++ 	(revision )
@@ -1,185 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("Bin Packing Problem (3D, identical cuboids) (BPP)", "Represents a three-dimensional bin-packing problem using only bins with identical measures and bins/items with cuboidic shapes.")]
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
-  // TODO don't support generic BPPData but only 3d BPPData
-  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<PackingPosition, CuboidPackingShape, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
-
-
-    #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {
-      Name = "3D BPP Default Instance",
-      Description = "The default instance for 3D Bin Packing.",
-      BinMeasures = new int[] { 25, 25, 35 },
-      ItemMeasures = new int[][] {
-        new int[] {12,5,10},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9}
-      },
-      Items = 30
-    };
-    #endregion
-
-    [StorableConstructor]
-    protected CuboidIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected CuboidIdenticalBinPackingProblem(CuboidIdenticalBinPackingProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidIdenticalBinPackingProblem(this, cloner);
-    }
-    public CuboidIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, CuboidPackingShape, CuboidPackingItem>()) {
-    }
-
-
-
-    public void Load(BPPData data) {
-      var realData = data as RealBPPData;
-      var binData = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
-
-      var itemData = new ItemList<CuboidPackingItem>(data.Items);
-      for (int j = 0; j < data.Items; j++) {
-        var bin = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
-        var item = new CuboidPackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], data.ItemMeasures[j][2], bin);
-        if (realData != null) {
-          item.Weight = realData.ItemWeights[j];
-          item.Material = realData.ItemMaterials[j];
-        }
-        itemData.Add(item);
-      }
-
-      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
-
-      PackingBinMeasures = binData;
-      PackingItemMeasures = itemData;
-
-      ApplyHorizontalOrientation();
-      SortItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-
-    public BPPData Export() {
-      var result = new BPPData {
-        Name = Name,
-        Description = Description,
-        Items = PackingItemsParameter.Value.Value,
-        BinMeasures = new int[] { PackingBinMeasures.Width, PackingBinMeasures.Height, PackingBinMeasures.Depth }
-      };
-
-      var itemMeasures = new int[result.Items][];
-      int i = 0;
-      foreach (var item in PackingItemMeasures) {
-        itemMeasures[i] = new int[] { item.Width, item.Height, item.Depth };
-        i++;
-      }
-      result.ItemMeasures = itemMeasures;
-      return result;
-    }
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      // Operators.RemoveAll(op => op is I2DOperator); TODO
-
-      PackingSolutionDecoderParameter.ValidValues.Clear();
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
-      } else {
-        string error = "The given problem does not support the selected solution-creator.";
-        ErrorHandling.ShowErrorDialog(error, null);
-      }
-    }
-
-    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioCuboidIdenticalBinEvaluator();
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-
-    protected override void RemoveTooBigItems() {
-      PackingItemMeasures.RemoveAll(pi =>
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, true), pi));
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingItem.cs	(revision 14048)
+++ 	(revision )
@@ -1,117 +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;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("CuboidPackingItem", "Represents a cuboidic packing-item for bin-packing problems.")]
-  [StorableClass]
-  public class CuboidPackingItem : CuboidPackingShape, IPackingItem {
-    public IValueParameter<CuboidPackingShape> TargetBinParameter {
-      get { return (IValueParameter<CuboidPackingShape>)Parameters["TargetBin"]; }
-    }
-    public IFixedValueParameter<DoubleValue> WeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters["Weight"]; }
-    }
-    public IFixedValueParameter<IntValue> MaterialParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Material"]; }
-    }
-
-    public CuboidPackingShape TargetBin {
-      get { return TargetBinParameter.Value; }
-      set { TargetBinParameter.Value = value; }
-    }
-
-    public double Weight {
-      get { return WeightParameter.Value.Value; }
-      set { WeightParameter.Value.Value = value; }
-    }
-
-    public int Material {
-      get { return MaterialParameter.Value.Value; }
-      set { MaterialParameter.Value.Value = value; }
-    }
-
-    public bool SupportsStacking(IPackingItem other) {
-      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
-    }
-
-    [StorableConstructor]
-    protected CuboidPackingItem(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingItem(CuboidPackingItem original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterEvents();
-    }
-    public CuboidPackingItem()
-      : base() {
-      Parameters.Add(new ValueParameter<CuboidPackingShape>("TargetBin"));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
-
-      RegisterEvents();
-    }
-
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin, double weight, int material)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-      this.Weight = weight;
-      this.Material = material;
-      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
-    }
-
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingItem(this, cloner);
-    }
-
-    private void RegisterEvents() {
-      // only because of ToString override
-      WeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      MaterialParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-
-      // target bin does not occur in ToString()
-    }
-
-
-    public override string ToString() {
-      return string.Format("CuboidPackingItem ({0}, {1}, {2}; weight={3}, mat={4})", this.Width, this.Height, this.Depth, this.Weight, this.Material);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs	(revision 14048)
+++ 	(revision )
@@ -1,194 +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.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("CuboidPackingShape", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
-  [StorableClass]
-  public class CuboidPackingShape : PackingShape<PackingPosition>, IComparable<CuboidPackingShape> {
-    public IFixedValueParameter<IntValue> HeightParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
-    }
-    public IFixedValueParameter<IntValue> WidthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Width"]; }
-    }
-    public IFixedValueParameter<IntValue> DepthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Depth"]; }
-    }
-
-    public int Height {
-      get { return HeightParameter.Value.Value; }
-      set { HeightParameter.Value.Value = value; }
-    }
-
-    public int Width {
-      get { return WidthParameter.Value.Value; }
-      set { WidthParameter.Value.Value = value; }
-    }
-
-    public int Depth {
-      get { return DepthParameter.Value.Value; }
-      set { DepthParameter.Value.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected CuboidPackingShape(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingShape(CuboidPackingShape original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterEvents();
-    }
-    public CuboidPackingShape()
-      : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Depth"));
-
-      RegisterEvents();
-    }
-
-    public CuboidPackingShape(int width, int height, int depth)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingShape(this, cloner);
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEvents();
-    }
-
-    private void RegisterEvents() {
-      // only because of ToString override
-      HeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      WidthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      DepthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-    }
-
-    public override string ToString() {
-      return String.Format("CuboidPackingShape ({0}, {1}, {2})", this.Width, this.Height, this.Depth);
-    }
-
-    #region IComparable Members
-
-    public int CompareTo(CuboidPackingShape other) {
-      //Using "Clustered-Area-Height"-comparison as descr
-
-      int result = (this.Width * this.Depth).CompareTo(other.Width * other.Depth);
-
-      if (result == 0)
-        result = this.Volume.CompareTo(other.Volume);
-      if (result == 0)
-        result = this.Height.CompareTo(other.Height);
-      return result;
-    }
-
-    public override int CompareTo(object obj) {
-      var other = (CuboidPackingShape)obj;
-      if (other != null) return CompareTo(other);
-      else throw new ArgumentException(string.Format("Cannot compare with object {0}", obj), "obj");
-    }
-
-    #endregion
-
-    private struct CuboidDiagonal {
-      public int x1;
-      public int y1;
-      public int z1;
-      public int x2;
-      public int y2;
-      public int z2;
-      public CuboidDiagonal(CuboidPackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
-      public CuboidDiagonal(PackingPosition myPosition, CuboidPackingShape myShape) {
-        x1 = myPosition.X;
-        y1 = myPosition.Y;
-        z1 = myPosition.Z;
-        x2 = myPosition.X + (myPosition.Rotated ? myShape.Depth : myShape.Width) - 1;
-        y2 = myPosition.Y + myShape.Height - 1;
-        z2 = myPosition.Z + (myPosition.Rotated ? myShape.Width : myShape.Depth) - 1;
-      }
-    }
-
-
-    #region Helpers
-    public override PackingPosition Origin { get { return new PackingPosition(0, 0, 0, 0); } }
-    public override int Volume { get { return Width * Height * Depth; } }
-
-    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition checkedPoint) {
-      return (myPosition.X <= checkedPoint.X &&
-                (myPosition.X + (myPosition.Rotated ? Depth : Width) - 1) >= checkedPoint.X &&
-                myPosition.Y <= checkedPoint.Y &&
-                (myPosition.Y + Height - 1) >= checkedPoint.Y &&
-                myPosition.Z <= checkedPoint.Z &&
-                (myPosition.Z + (myPosition.Rotated ? Width : Depth) - 1) >= checkedPoint.Z);
-    }
-    public override bool Encloses(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Encloses(checkedPosition, (CuboidPackingShape)checkedShape);
-    }
-    private bool Encloses(PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
-      return Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Encloses(CuboidDiagonal c1, CuboidDiagonal c2) {
-      return (c1.x1 <= c2.x1 &&
-                c1.x2 >= c2.x2 &&
-                c1.y1 <= c2.y1 &&
-                c1.y2 >= c2.y2 &&
-                c1.z1 <= c2.z1 &&
-                c1.z2 >= c2.z2);
-    }
-
-    public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Overlaps(myPosition, checkedPosition, (CuboidPackingShape)checkedShape);
-    }
-    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
-      return Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Overlaps(CuboidDiagonal c1, CuboidDiagonal c2) {
-      return !(c1.x1 > c2.x2 ||
-               c1.y1 > c2.y2 ||
-               c1.z1 > c2.z2 ||
-               c1.x2 < c2.x1 ||
-               c1.y2 < c2.y1 ||
-               c1.z2 < c2.z1);
-    }
-
-    public override void ApplyHorizontalOrientation() {
-      if (Width > Depth) {
-        var aux = Width;
-        Width = Depth;
-        Depth = aux;
-      }
-    }
-    #endregion
-
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, GroupingVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
     public DeepestBottomLeftGroupingVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, MultiComponentVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
     public DeepestBottomLeftMultiComponentVectorDecoder() : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, PackingSequence-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
     public DeepestBottomLeftPackingSequenceDecoder(): base() {}
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
     public ExtremePointGroupingVectorDecoder3D() : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(GroupingVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14049)
@@ -31,5 +31,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
     public ExtremePointMultiComponentVectorDecoder3D () : base() { }
     [StorableConstructor]
@@ -42,5 +42,5 @@
     }
 
-    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(MultiComponentVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48,5 +48,5 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14049)
@@ -32,5 +32,5 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
     public ExtremePointPackingSequenceDecoder3D () : base() {}
     [StorableConstructor]
@@ -44,5 +44,5 @@
 
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14049)
@@ -159,7 +159,4 @@
   <ItemGroup>
     <Compile Include="BinPacking3D.cs" />
-    <Compile Include="CuboidIdenticalBinPackingProblem.cs" />
-    <Compile Include="CuboidPackingItem.cs" />
-    <Compile Include="CuboidPackingShape.cs" />
     <Compile Include="DecoderInterfaces\I3DGVDecoder.cs" />
     <Compile Include="DecoderInterfaces\I3DMCVDecoder.cs" />
@@ -175,7 +172,10 @@
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
+    <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioCuboidIdenticalBinEvaluator.cs" />
+    <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 14049)
@@ -30,5 +30,5 @@
   [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 14049)
@@ -30,5 +30,5 @@
   [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 14049)
@@ -30,5 +30,5 @@
   [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs	(revision 14049)
@@ -0,0 +1,117 @@
+﻿#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.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("PackingItem (3d)", "Represents a cuboidic packing-item for bin-packing problems.")]
+  [StorableClass]
+  public class PackingItem : PackingShape, IPackingItem {
+    public IValueParameter<PackingShape> TargetBinParameter {
+      get { return (IValueParameter<PackingShape>)Parameters["TargetBin"]; }
+    }
+    public IFixedValueParameter<DoubleValue> WeightParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["Weight"]; }
+    }
+    public IFixedValueParameter<IntValue> MaterialParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Material"]; }
+    }
+
+    public PackingShape TargetBin {
+      get { return TargetBinParameter.Value; }
+      set { TargetBinParameter.Value = value; }
+    }
+
+    public double Weight {
+      get { return WeightParameter.Value.Value; }
+      set { WeightParameter.Value.Value = value; }
+    }
+
+    public int Material {
+      get { return MaterialParameter.Value.Value; }
+      set { MaterialParameter.Value.Value = value; }
+    }
+
+    public bool SupportsStacking(IPackingItem other) {
+      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
+    }
+
+    [StorableConstructor]
+    protected PackingItem(bool deserializing) : base(deserializing) { }
+    protected PackingItem(PackingItem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEvents();
+    }
+    public PackingItem()
+      : base() {
+      Parameters.Add(new ValueParameter<PackingShape>("TargetBin"));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
+
+      RegisterEvents();
+    }
+
+    public PackingItem(int width, int height, int depth, PackingShape targetBin, double weight, int material)
+      : this() {
+      this.Width = width;
+      this.Height = height;
+      this.Depth = depth;
+      this.Weight = weight;
+      this.Material = material;
+      this.TargetBin = (PackingShape)targetBin.Clone();
+    }
+
+    public PackingItem(int width, int height, int depth, PackingShape targetBin)
+      : this() {
+      this.Width = width;
+      this.Height = height;
+      this.Depth = depth;
+      this.TargetBin = (PackingShape)targetBin.Clone();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingItem(this, cloner);
+    }
+
+    private void RegisterEvents() {
+      // only because of ToString override
+      WeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
+      MaterialParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
+
+      // target bin does not occur in ToString()
+    }
+
+
+    public override string ToString() {
+      return string.Format("CuboidPackingItem ({0}, {1}, {2}; weight={3}, mat={4})", this.Width, this.Height, this.Depth, this.Weight, this.Material);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 14049)
@@ -28,5 +28,5 @@
   [Item("Packing-Ratio Cuboid Identical-Bin Evaluator", "Represents an evaluation-algorithm for cuboid-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
   [StorableClass]
-  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
+  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, PackingShape, PackingItem> {
 
     [StorableConstructor]
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingShape.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingShape.cs	(revision 14049)
@@ -0,0 +1,194 @@
+﻿#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.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("PackingShape (3d)", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
+  [StorableClass]
+  public class PackingShape : PackingShape<PackingPosition>, IComparable<PackingShape> {
+    public IFixedValueParameter<IntValue> HeightParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
+    }
+    public IFixedValueParameter<IntValue> WidthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Width"]; }
+    }
+    public IFixedValueParameter<IntValue> DepthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Depth"]; }
+    }
+
+    public int Height {
+      get { return HeightParameter.Value.Value; }
+      set { HeightParameter.Value.Value = value; }
+    }
+
+    public int Width {
+      get { return WidthParameter.Value.Value; }
+      set { WidthParameter.Value.Value = value; }
+    }
+
+    public int Depth {
+      get { return DepthParameter.Value.Value; }
+      set { DepthParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected PackingShape(bool deserializing) : base(deserializing) { }
+    protected PackingShape(PackingShape original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEvents();
+    }
+    public PackingShape()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
+      Parameters.Add(new FixedValueParameter<IntValue>("Depth"));
+
+      RegisterEvents();
+    }
+
+    public PackingShape(int width, int height, int depth)
+      : this() {
+      this.Width = width;
+      this.Height = height;
+      this.Depth = depth;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingShape(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      // only because of ToString override
+      HeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
+      WidthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
+      DepthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
+    }
+
+    public override string ToString() {
+      return String.Format("CuboidPackingShape ({0}, {1}, {2})", this.Width, this.Height, this.Depth);
+    }
+
+    #region IComparable Members
+
+    public int CompareTo(PackingShape other) {
+      //Using "Clustered-Area-Height"-comparison as descr
+
+      int result = (this.Width * this.Depth).CompareTo(other.Width * other.Depth);
+
+      if (result == 0)
+        result = this.Volume.CompareTo(other.Volume);
+      if (result == 0)
+        result = this.Height.CompareTo(other.Height);
+      return result;
+    }
+
+    public override int CompareTo(object obj) {
+      var other = (PackingShape)obj;
+      if (other != null) return CompareTo(other);
+      else throw new ArgumentException(string.Format("Cannot compare with object {0}", obj), "obj");
+    }
+
+    #endregion
+
+    private struct CuboidDiagonal {
+      public int x1;
+      public int y1;
+      public int z1;
+      public int x2;
+      public int y2;
+      public int z2;
+      public CuboidDiagonal(PackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
+      public CuboidDiagonal(PackingPosition myPosition, PackingShape myShape) {
+        x1 = myPosition.X;
+        y1 = myPosition.Y;
+        z1 = myPosition.Z;
+        x2 = myPosition.X + (myPosition.Rotated ? myShape.Depth : myShape.Width) - 1;
+        y2 = myPosition.Y + myShape.Height - 1;
+        z2 = myPosition.Z + (myPosition.Rotated ? myShape.Width : myShape.Depth) - 1;
+      }
+    }
+
+
+    #region Helpers
+    public override PackingPosition Origin { get { return new PackingPosition(0, 0, 0, 0); } }
+    public override int Volume { get { return Width * Height * Depth; } }
+
+    public override bool EnclosesPoint(PackingPosition myPosition, PackingPosition checkedPoint) {
+      return (myPosition.X <= checkedPoint.X &&
+                (myPosition.X + (myPosition.Rotated ? Depth : Width) - 1) >= checkedPoint.X &&
+                myPosition.Y <= checkedPoint.Y &&
+                (myPosition.Y + Height - 1) >= checkedPoint.Y &&
+                myPosition.Z <= checkedPoint.Z &&
+                (myPosition.Z + (myPosition.Rotated ? Width : Depth) - 1) >= checkedPoint.Z);
+    }
+    public override bool Encloses(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
+      return Encloses(checkedPosition, (PackingShape)checkedShape);
+    }
+    private bool Encloses(PackingPosition checkedPosition, PackingShape checkedShape) {
+      return Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape));
+    }
+    private bool Encloses(CuboidDiagonal c1, CuboidDiagonal c2) {
+      return (c1.x1 <= c2.x1 &&
+                c1.x2 >= c2.x2 &&
+                c1.y1 <= c2.y1 &&
+                c1.y2 >= c2.y2 &&
+                c1.z1 <= c2.z1 &&
+                c1.z2 >= c2.z2);
+    }
+
+    public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
+      return Overlaps(myPosition, checkedPosition, (PackingShape)checkedShape);
+    }
+    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape checkedShape) {
+      return Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape));
+    }
+    private bool Overlaps(CuboidDiagonal c1, CuboidDiagonal c2) {
+      return !(c1.x1 > c2.x2 ||
+               c1.y1 > c2.y2 ||
+               c1.z1 > c2.z2 ||
+               c1.x2 < c2.x1 ||
+               c1.y2 < c2.y1 ||
+               c1.z2 < c2.z1);
+    }
+
+    public override void ApplyHorizontalOrientation() {
+      if (Width > Depth) {
+        var aux = Width;
+        Width = Depth;
+        Depth = aux;
+      }
+    }
+    #endregion
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs	(revision 14049)
@@ -0,0 +1,185 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bin Packing Problem (3D, identical cuboids) (BPP)", "Represents a three-dimensional bin-packing problem using only bins with identical measures and bins/items with cuboidic shapes.")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
+  // TODO don't support generic BPPData but only 3d BPPData
+  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+
+
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {
+      Name = "3D BPP Default Instance",
+      Description = "The default instance for 3D Bin Packing.",
+      BinMeasures = new int[] { 25, 25, 35 },
+      ItemMeasures = new int[][] {
+        new int[] {12,5,10},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9}
+      },
+      Items = 30
+    };
+    #endregion
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+    public Problem() : base(
+      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, PackingShape, PackingItem>()) {
+    }
+
+
+
+    public void Load(BPPData data) {
+      var realData = data as RealBPPData;
+      var binData = new PackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
+
+      var itemData = new ItemList<PackingItem>(data.Items);
+      for (int j = 0; j < data.Items; j++) {
+        var bin = new PackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
+        var item = new PackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], data.ItemMeasures[j][2], bin);
+        if (realData != null) {
+          item.Weight = realData.ItemWeights[j];
+          item.Material = realData.ItemMaterials[j];
+        }
+        itemData.Add(item);
+      }
+
+      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
+
+      PackingBinMeasures = binData;
+      PackingItemMeasures = itemData;
+
+      ApplyHorizontalOrientation();
+      SortItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+    public BPPData Export() {
+      var result = new BPPData {
+        Name = Name,
+        Description = Description,
+        Items = PackingItemsParameter.Value.Value,
+        BinMeasures = new int[] { PackingBinMeasures.Width, PackingBinMeasures.Height, PackingBinMeasures.Depth }
+      };
+
+      var itemMeasures = new int[result.Items][];
+      int i = 0;
+      foreach (var item in PackingItemMeasures) {
+        itemMeasures[i] = new int[] { item.Width, item.Height, item.Depth };
+        i++;
+      }
+      result.ItemMeasures = itemMeasures;
+      return result;
+    }
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      // Operators.RemoveAll(op => op is I2DOperator); TODO
+
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
+      } else if (SolutionCreator is GroupingVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
+      } else {
+        string error = "The given problem does not support the selected solution-creator.";
+        ErrorHandling.ShowErrorDialog(error, null);
+      }
+    }
+
+    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
+      return new PackingRatioCuboidIdenticalBinEvaluator();
+    }
+
+    protected override void InitializeProblemData() {
+      Load(DefaultInstance);
+    }
+
+    protected override void RemoveTooBigItems() {
+      PackingItemMeasures.RemoveAll(pi =>
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, true), pi));
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs	(revision 14049)
@@ -7,7 +7,7 @@
   [Item("Bin Packing Solution (3d)", "Represents a solution for a 3D bin packing problem.")]
   [StorableClass]
-  public class Solution : PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
-    public Solution(CuboidPackingShape binMeasures) : this(binMeasures, false, false) { }
-    public Solution(CuboidPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
+  public class Solution : PackingPlan<PackingPosition, PackingShape, PackingItem> {
+    public Solution(PackingShape binMeasures) : this(binMeasures, false, false) { }
+    public Solution(PackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
     [StorableConstructor]
     protected Solution(bool deserializing) : base(deserializing) { }
@@ -18,5 +18,5 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> NewBinPacking() {
+    public override BinPacking<PackingPosition, PackingShape, PackingItem> NewBinPacking() {
       return new BinPacking3D(BinMeasures);
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs	(revision 14049)
@@ -33,6 +33,6 @@
     private int selectedItemKey;
     private Size renderSize;
-    private BinPacking<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> packing;
-    public BinPacking<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> Packing {
+    private BinPacking<BinPacking2D.PackingPosition, PackingShape, PackingItem> packing;
+    public BinPacking<BinPacking2D.PackingPosition, PackingShape, PackingItem> Packing {
       get { return packing; }
       set {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs	(revision 14049)
@@ -35,6 +35,6 @@
     private int selectedItemKey;
 
-    private BinPacking<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> packing;
-    public BinPacking<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> Packing {
+    private BinPacking<BinPacking3D.PackingPosition, PackingShape, PackingItem> packing;
+    public BinPacking<BinPacking3D.PackingPosition, PackingShape, PackingItem> Packing {
       get { return packing; }
       set {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan2DView.cs	(revision 14049)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("2-dimensional packing plan view")]
-  [Content(typeof(PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem>), true)]
+  [Content(typeof(PackingPlan<BinPacking2D.PackingPosition, PackingShape, PackingItem>), true)]
   public partial class PackingPlan2DView : ItemView {
 
@@ -35,6 +35,6 @@
     }
 
-    public new PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> Content {
-      get { return (PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem>)base.Content; }
+    public new PackingPlan<BinPacking2D.PackingPosition, PackingShape, PackingItem> Content {
+      get { return (PackingPlan<BinPacking2D.PackingPosition, PackingShape, PackingItem>)base.Content; }
       set { base.Content = value; }
     }
@@ -56,5 +56,5 @@
     }
 
-    private void UpdateState(PackingPlan<BinPacking2D.PackingPosition, RectangularPackingShape, RectangularPackingItem> plan) {
+    private void UpdateState(PackingPlan<BinPacking2D.PackingPosition, PackingShape, PackingItem> plan) {
       int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
       container2DView.Packing = plan.BinPackings[currentBin];
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14049)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("3-dimensional packing plan View")]
-  [Content(typeof(PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem>), true)]
+  [Content(typeof(PackingPlan<BinPacking3D.PackingPosition, PackingShape, PackingItem>), true)]
   public partial class PackingPlan3DView : ItemView {
 
@@ -35,6 +35,6 @@
     }
 
-    public new PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem> Content {
-      get { return (PackingPlan<BinPacking3D.PackingPosition, CuboidPackingShape, CuboidPackingItem>)base.Content; }
+    public new PackingPlan<BinPacking3D.PackingPosition, PackingShape, PackingItem> Content {
+      get { return (PackingPlan<BinPacking3D.PackingPosition, PackingShape, PackingItem>)base.Content; }
       set { base.Content = value; }
     }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 14048)
+++ 	(revision )
@@ -1,253 +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.Optimization;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.PluginInfrastructure;
-using System.Linq;
-using System;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Encodings.PackingEncoding;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("BinPackingProblem", "Abstract class that represents a BinPacking Problem")]
-  [StorableClass]
-  public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
-    where D : class, IPackingPosition 
-    where B : PackingShape<D>, new()
-    where I : PackingShape<D>, IPackingItem, new () {
-
-
-    #region Parameter Properties
-    public OptionalValueParameter<PackingPlan<D,B,I>> BestKnownSolutionParameter {
-      get { return (OptionalValueParameter<PackingPlan<D, B, I>>)Parameters["BestKnownSolution"]; }
-    }
-    public ValueParameter<ItemList<I>> PackingItemMeasuresParameter {
-      get { return (ValueParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
-    }
-    public IFixedValueParameter<IntValue> PackingItemsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["PackingItems"]; }
-    }
-    public IFixedValueParameter<IntValue> LowerBoundParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
-    }
-    public ValueParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
-      get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    public IValueParameter<B> PackingBinMeasuresParameter {
-      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    #endregion
-
-    #region Properties
-    public PackingPlan<D, B, I> BestKnownSolution {
-      get { return BestKnownSolutionParameter.Value; }
-      set { BestKnownSolutionParameter.Value = value; }
-    }
-    public ItemList<I> PackingItemMeasures {
-      get { return PackingItemMeasuresParameter.Value; }
-      set { PackingItemMeasuresParameter.Value = value; } 
-    }
-    public IPackingPlanEvaluator PackingPlanEvaluator {
-      get { return PackingPlanEvaluatorParameter.Value; }
-      set { PackingPlanEvaluatorParameter.Value = value; }
-    }
-    public B PackingBinMeasures {
-      get { return PackingBinMeasuresParameter.Value; }
-      set { PackingBinMeasuresParameter.Value = value; }
-    }
-    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
-      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
-      set { PackingSolutionDecoderParameter.Value = value; }
-    }
-    #endregion
-
-
-    [StorableConstructor]
-    protected BinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected BinPackingProblem(BinPackingProblem<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-      InitializeEventHandlers();
-    }
-
-    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
-
-    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c) : base (e, c){
-      Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
-      Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
-
-      Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
-      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
-      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
-      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
-      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
-      this.Maximization.Value = true;
-      InitializeProblemInstance();
-      InitializeOperators();
-      InitializeEventHandlers();
-    }
-
-    protected abstract void InitializeDecoder();
-    protected virtual void InitializeProblemInstance() {
-      InitializeProblemData();
-      ApplyHorizontalOrientation();
-      SortItems();
-      RemoveTooBigItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-    protected virtual void InitializeOperators() {
-      Operators.Clear();
-      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
-
-      ApplyEncoding();
-      ParameterizeOperators();
-    }
-    protected virtual void InitializeEventHandlers() {
-      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
-      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
-      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
-      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
-      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
-      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
-    }
-
-
-    protected abstract void RemoveTooBigItems();
-    protected abstract void InitializeProblemData();
-    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
-    protected void ApplyHorizontalOrientation() {
-      PackingBinMeasures.ApplyHorizontalOrientation();
-      foreach (IPackingShape shape in PackingItemMeasures) {
-        shape.ApplyHorizontalOrientation();
-      }
-    }
-    protected void SortItems() {
-      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
-    }
-    protected int CalculateLowerBound() {
-      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
-      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
-      int bin = PackingBinMeasures.Volume;
-      return (items + bin - 1) / (bin);
-    }
-
-    private void ApplyEncoding() {
-      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
-        InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
-        InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
-        InitializeDecoder();
-      }
-    }
-    private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
-        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-      }
-
-      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
-      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
-      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
-      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
-      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-      Evaluator.QualityParameter.Hidden = true;
-
-      if (PackingSolutionDecoder != null)
-        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-
-      if (PackingSolutionDecoder != null) {
-        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
-        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
-      } else {
-        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
-        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
-      }
-
-      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
-        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.EncodedSolutionParameter.Hidden = true;
-      }
-
-      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
-        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.ChildParameter.Hidden = true;
-        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.ParentsParameter.Hidden = true;
-      }
-
-      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
-        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-        if (PackingSolutionDecoder != null) {
-          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
-          op.PackingPlanParameter.Hidden = true;
-        } else {
-          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
-          op.PackingPlanParameter.Hidden = false;
-        }
-      }
-
-    }
-
-    #region Events
-    protected override void OnSolutionCreatorChanged() {
-      InitializeOperators();
-    }
-    protected override void OnEvaluatorChanged() {
-      base.OnEvaluatorChanged();
-      ParameterizeOperators();
-    }
-    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    #endregion
-  }
-}
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 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14049)
@@ -160,5 +160,4 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="BinPackingProblem.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorSwap2Manipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorSinglePointCrossover.cs" />
@@ -287,4 +286,5 @@
     <Compile Include="PackingSolutionDecoder.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 14048)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 14049)
@@ -29,5 +29,4 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  [Item("PackingShape", "Represents an abstract shape to describe the measures and the positioning of objects related to bin-packing problems.")]
   [StorableClass]
   public abstract class PackingShape<T> : Item, IPackingShape, IParameterizedItem
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs	(revision 14049)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs	(revision 14049)
@@ -0,0 +1,252 @@
+﻿#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.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.PluginInfrastructure;
+using System.Linq;
+using System;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [StorableClass]
+  public abstract class Problem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
+    where D : class, IPackingPosition 
+    where B : PackingShape<D>, new()
+    where I : PackingShape<D>, IPackingItem, new () {
+
+
+    #region Parameter Properties
+    public OptionalValueParameter<PackingPlan<D,B,I>> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<PackingPlan<D, B, I>>)Parameters["BestKnownSolution"]; }
+    }
+    public ValueParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (ValueParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public IFixedValueParameter<IntValue> PackingItemsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["PackingItems"]; }
+    }
+    public IFixedValueParameter<IntValue> LowerBoundParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
+    }
+    public ValueParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
+      get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    public IValueParameter<B> PackingBinMeasuresParameter {
+      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    #endregion
+
+    #region Properties
+    public PackingPlan<D, B, I> BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public ItemList<I> PackingItemMeasures {
+      get { return PackingItemMeasuresParameter.Value; }
+      set { PackingItemMeasuresParameter.Value = value; } 
+    }
+    public IPackingPlanEvaluator PackingPlanEvaluator {
+      get { return PackingPlanEvaluatorParameter.Value; }
+      set { PackingPlanEvaluatorParameter.Value = value; }
+    }
+    public B PackingBinMeasures {
+      get { return PackingBinMeasuresParameter.Value; }
+      set { PackingBinMeasuresParameter.Value = value; }
+    }
+    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
+      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
+      set { PackingSolutionDecoderParameter.Value = value; }
+    }
+    #endregion
+
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+      InitializeEventHandlers();
+    }
+
+    protected Problem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
+
+    protected Problem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c) : base (e, c){
+      Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
+      Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
+
+      Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
+      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
+      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
+      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
+      this.Maximization.Value = true;
+      InitializeProblemInstance();
+      InitializeOperators();
+      InitializeEventHandlers();
+    }
+
+    protected abstract void InitializeDecoder();
+    protected virtual void InitializeProblemInstance() {
+      InitializeProblemData();
+      ApplyHorizontalOrientation();
+      SortItems();
+      RemoveTooBigItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+    protected virtual void InitializeOperators() {
+      Operators.Clear();
+      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
+
+      ApplyEncoding();
+      ParameterizeOperators();
+    }
+    protected virtual void InitializeEventHandlers() {
+      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+    }
+
+
+    protected abstract void RemoveTooBigItems();
+    protected abstract void InitializeProblemData();
+    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
+    protected void ApplyHorizontalOrientation() {
+      PackingBinMeasures.ApplyHorizontalOrientation();
+      foreach (IPackingShape shape in PackingItemMeasures) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+    protected void SortItems() {
+      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
+    }
+    protected int CalculateLowerBound() {
+      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
+      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
+      int bin = PackingBinMeasures.Volume;
+      return (items + bin - 1) / (bin);
+    }
+
+    private void ApplyEncoding() {
+      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
+        InitializeDecoder();
+      }
+    }
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      }
+
+      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
+      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
+      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
+      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
+      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      Evaluator.QualityParameter.Hidden = true;
+
+      if (PackingSolutionDecoder != null)
+        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+
+      if (PackingSolutionDecoder != null) {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
+      } else {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
+        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.EncodedSolutionParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
+        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ChildParameter.Hidden = true;
+        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+        if (PackingSolutionDecoder != null) {
+          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+          op.PackingPlanParameter.Hidden = true;
+        } else {
+          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
+          op.PackingPlanParameter.Hidden = false;
+        }
+      }
+
+    }
+
+    #region Events
+    protected override void OnSolutionCreatorChanged() {
+      InitializeOperators();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    #endregion
+  }
+}
