Index: branches/HeuristicLab.BinPacking/HeuristicLab.BinPacking.sln
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.BinPacking.sln	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.BinPacking.sln	(revision 14153)
@@ -1,7 +1,5 @@
 ﻿
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25123.0
-MinimumVisualStudioVersion = 10.0.40219.1
+# Visual Studio 2012
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.BinPacking-3.3", "HeuristicLab.Problems.BinPacking\3.3\HeuristicLab.Problems.BinPacking-3.3.csproj", "{F8A55094-3CD5-4034-B0CA-5BD7FFB016D4}"
 EndProject
@@ -9,5 +7,4 @@
 	ProjectSection(SolutionItems) = preProject
 		..\Build.cmd = ..\Build.cmd
-		Performance1.psess = Performance1.psess
 		..\PreBuildEvent.cmd = ..\PreBuildEvent.cmd
 	EndProjectSection
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs	(revision 14153)
@@ -46,12 +46,12 @@
     }
 
-    protected override PackingPosition FindPositionForItem(BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> bp, PackingItem item) {
+    protected override PackingPosition FindPositionForItem(BinPacking2D bp, PackingItem item) {
       return bp.FindPositionBySliding(item, rotated: false);
     }
 
-    protected override BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> CreatePacking(
+    protected override BinPacking2D CreatePacking(
       Solution partialSolution,
       ref IList<int> remainingIDs, IList<PackingItem> items) {
-      var bp = partialSolution.NewBinPacking();
+      var bp = new BinPacking2D(partialSolution.BinMeasures);
       bp.SlidingBasedPacking(ref remainingIDs, items);
       return bp;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs	(revision 14153)
@@ -46,12 +46,12 @@
     }
 
-    protected override PackingPosition FindPositionForItem(BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> bp, PackingItem item) {
+    protected override PackingPosition FindPositionForItem(BinPacking2D bp, PackingItem item) {
       return bp.FindExtremePointForItem(item, false, stackingConstraints: false);
     }
 
-    protected override BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> CreatePacking(
+    protected override BinPacking2D CreatePacking(
       Solution partialSolution,
       ref IList<int> remainingIDs, IList<PackingItem> items) {
-      var bp = partialSolution.NewBinPacking();
+      var bp = new BinPacking2D(partialSolution.BinMeasures);
       bp.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: false);
       return bp;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs	(revision 14153)
@@ -39,5 +39,5 @@
 
 
-    public Solution Decode(IntegerVector intVec, PackingShape binShape, IList<PackingItem> items) {
+    public virtual Solution Decode(IntegerVector intVec, PackingShape binShape, IList<PackingItem> items) {
       var sequenceMatrix = IntegerVectorProblem.GenerateSequenceMatrix(intVec);
       Solution result = CreateSolution(binShape);
@@ -54,5 +54,5 @@
       var temp = new List<int>(remainingIDs);
       foreach (int id in temp) {
-        foreach (var bp in result.BinPackings) {
+        foreach (BinPacking2D bp in result.BinPackings) {
           var position = FindPositionForItem(bp, items[id]);
           if (position != null) {
@@ -70,5 +70,5 @@
       result.UpdateBinPackings();
 
-      // gkronber: original implementation also updates the encoded solution
+      // gkronber: original implementation by Helm also updates the encoded solution (TODO)
       // var newSolution = new int[intVec.Length];
       // int binIndex = 0;
@@ -84,6 +84,6 @@
 
     protected abstract Solution CreateSolution(PackingShape binShape);
-    protected abstract PackingPosition FindPositionForItem(BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> bp, PackingItem item);
-    protected abstract BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> CreatePacking(Solution partialSolution, ref IList<int> remainingIDs, IList<PackingItem> items);
+    protected abstract PackingPosition FindPositionForItem(BinPacking2D bp, PackingItem item);
+    protected abstract BinPacking2D CreatePacking(Solution partialSolution, ref IList<int> remainingIDs, IList<PackingItem> items);
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs	(revision 14153)
@@ -66,10 +66,10 @@
     private void AddOperators() {
 
-      // move operators are not yet supported
+      // move operators are not yet supported (TODO)
       Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
       Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
       Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
 
-      Encoding.ConfigureOperators(Operators.OfType<IOperator>());
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>()); // gkronber: not strictly necessary (only when customer ops are added)
     }
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IDecoder.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IDecoder.cs	(revision 14153)
@@ -20,9 +20,6 @@
 #endregion
 
-using System.Collections;
 using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Problems.BinPacking;
 
 namespace HeuristicLab.Problems.BinPacking2D {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs	(revision 14153)
@@ -23,5 +23,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs	(revision 14153)
@@ -45,5 +45,5 @@
       IList<int> remainingIDs = new List<int>(permutation);
       while (remainingIDs.Count > 0) {
-        var bp = result.NewBinPacking();
+        var bp = new BinPacking2D(binShape);
         bp.SlidingBasedPacking(ref remainingIDs, items);
         result.BinPackings.Add(bp);
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs	(revision 14153)
@@ -45,5 +45,5 @@
       IList<int> remainingIDs = new List<int>(permutation);
       while (remainingIDs.Count > 0) {
-        var bp = result.NewBinPacking();
+        var bp = new BinPacking2D(binShape);
         bp.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: false);
         result.BinPackings.Add(bp);
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/PermutationProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/PermutationProblem.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/PermutationProblem.cs	(revision 14153)
@@ -71,4 +71,6 @@
 
       Encoding.ConfigureOperators(Operators.OfType<IOperator>());
+
+      // TODO: configure the move evaluators (add interface for my move evaluators)
     }
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/ProblemBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/ProblemBase.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/ProblemBase.cs	(revision 14153)
@@ -37,8 +37,8 @@
     where TEnc : class, IEncoding
     where TSol : class, IItem {
-    private readonly string SolutionEvaluatorParameterName = "SolutionEvaluator";
+    protected readonly string SolutionEvaluatorParameterName = "SolutionEvaluator";
     public readonly string EncodedSolutionName = "EncodedSolution";
     #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {
+    private readonly BPPData defaultInstance = new BPPData() {
       Name = "2D BPP Default Instance",
       Description = "The default instance for 2D Bin Packing.",
@@ -155,5 +155,5 @@
       Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "A lower bound for the number of bins that is necessary to pack all items"));
 
-      Load(DefaultInstance);
+      Load(defaultInstance);
     }
 
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Solution.cs	(revision 14153)
@@ -39,7 +39,4 @@
       return new Solution(this, cloner);
     }
-    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 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14153)
@@ -41,5 +41,4 @@
     protected BinPacking3D(BinPacking3D original, Cloner cloner)
       : base(original, cloner) {
-      this.depthWasDoubled = original.depthWasDoubled;
       this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer3D());
     }
@@ -77,7 +76,4 @@
         ExtremePoints.Add(current);
       }
-
-
-
 
       //Find ExtremePoints beginning from sourcepointY
@@ -95,5 +91,5 @@
         ExtremePoints.Add(current);
 
-        //Traversing down the z-axis                                                                   
+        //Traversing down the z-axis
         current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
         while (current.Z > 0 && !IsPointOccupied(PackingPosition.MoveBack(current))) {
@@ -107,12 +103,8 @@
       }
 
-
-
-
-
       //Find ExtremePoints beginning from sourcepointZ
       var sourcePointZ = new PackingPosition(0, position.X, position.Y, position.Z + newDepth);
       if (sourcePointZ.X < BinMeasures.Width && sourcePointZ.Y < BinMeasures.Height && sourcePointZ.Z < BinMeasures.Depth) {
-        //Traversing down the x-axis                                                                             
+        //Traversing down the x-axis
         PackingPosition current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
         while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current))) {
@@ -125,5 +117,5 @@
         ExtremePoints.Add(current);
 
-        //Traversing down the y-axis                                                                     
+        //Traversing down the y-axis
         current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
         while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current))) {
@@ -136,12 +128,4 @@
         ExtremePoints.Add(current);
       }
-
-      //ExtremePoints.RemoveWhere(ep => IsPointOccupied (ep));
-
-      //ExtremePoints = new HashSet<ThreeDimensionalPacking>(ExtremePoints.
-      //  OrderBy(ep => ep.Z).
-      //  ThenBy(ep => ep.X).
-      //  ThenBy(ep => ep.Y)//.ThenBy(ep => ShortestPossibleSideFromPoint(ep)) 
-      //  );
     }
 
@@ -171,4 +155,5 @@
 
     public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
+      //TODO: does not support stacking constraints yet
       //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
       PackingPosition currentPosition = new PackingPosition(0,
@@ -282,35 +267,7 @@
         return true;
 
-
-      //if (occupiedPoints[position.X, position.Y - 1, position.Z] != -1
-      //  && occupiedPoints[position.X + item.Width - 1, position.Y - 1, position.Z] != -1
-      //  && occupiedPoints[position.X, position.Y - 1, position.Z + item.Depth - 1] != -1
-      //  && occupiedPoints[position.X + item.Width - 1, position.Y - 1, position.Z + item.Depth - 1] != -1)
-      //  return true;
-
-      //int groundCount = 0;
-      //for (int x = ep.X; x < ep.X + item.Width - 1; x++) {
-      //  for (int z = ep.Z; z < ep.Z + item.Depth - 1; z++) {
-      //    if (occupiedPoints[x,ep.Y-1, z] != -1)                                                     
-      //      groundCount++;
-      //  }
-      //}
-      //double stableGround = (double)(groundCount) / (double)(item.Width * item.Depth);
-      //if (stableGround > 0.75)
-      //  return true;
-
       return false;
     }
 
-    [Storable]
-    private bool depthWasDoubled = false; // TODO ???
-    public void DoubleDepth() {
-      if (!depthWasDoubled) {
-        var oldDepth = BinMeasures.Depth;
-        BinMeasures.Depth = BinMeasures.Depth * 2;
-        //OccupiedPoints.ChangeBinMeasures(BinMeasures);
-        depthWasDoubled = true;
-      }
-    }
 
     public bool IsSupportedByAtLeastOnePoint(PackingItem item, PackingPosition position) {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/BinUtilizationEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14153)
@@ -0,0 +1,65 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  // NOTE: same implementation as for 2d problem
+  [Item("Bin-Utilization Evaluator (3d)", "Calculates the overall utilization of bin space.")]
+  [StorableClass]
+  public class BinUtilizationEvaluator : Item, IEvaluator {
+
+    [StorableConstructor]
+    protected BinUtilizationEvaluator(bool deserializing) : base(deserializing) { }
+    protected BinUtilizationEvaluator(BinUtilizationEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public BinUtilizationEvaluator() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BinUtilizationEvaluator(this, cloner);
+    }
+
+    #region IEvaluator Members
+    public double Evaluate(Solution solution) {
+      return CalculateBinUtilization(solution);
+    }
+
+
+    public static double CalculateBinUtilization(Solution solution) {
+      int nrOfBins = solution.NrOfBins;
+      double totalUsedSpace = 0;
+      double totalUsableSpace = 0;
+
+      for (int i = 0; i < nrOfBins; i++) {
+        totalUsableSpace += solution.BinPackings[i].BinMeasures.Volume;
+        totalUsedSpace += solution.BinPackings[i].ItemMeasures.Sum(kvp => kvp.Value.Volume);
+      }
+
+      return totalUsedSpace / totalUsableSpace;
+    }
+
+    #endregion
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/PackingRatioEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14153)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  // NOTE: same implementation as for 2d problem
+  [Item("Packing-Ratio Evaluator (3d)", "Calculates the ratio between packed and unpacked space.")]
+  [StorableClass]
+  public class PackingRatioEvaluator : Item, IEvaluator {
+
+    [StorableConstructor]
+    protected PackingRatioEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingRatioEvaluator(PackingRatioEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingRatioEvaluator() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingRatioEvaluator(this, cloner);
+    }
+
+    #region IEvaluator Members
+    public double Evaluate(Solution solution) {
+      return CalculatePackingRatio(solution);
+    }
+
+    /* 
+        Falkenauer:1996 - A Hybrid Grouping Genetic Algorithm for Bin Packing
+        
+        fBPP = (SUM[i=1..N](Fi / C)^k)/N
+        N.......the number of bins used in the solution,
+        Fi......the sum of sizes of the items in the bin i (the fill of the bin),
+        C.......the bin capacity and
+        k.......a constant, k>1.
+     */
+    public static double CalculatePackingRatio(Solution solution) {
+      int nrOfBins = solution.NrOfBins;
+      double result = 0;
+      const double k = 2;
+      for (int i = 0; i < nrOfBins; i++) {
+        double f = solution.BinPackings[i].ItemMeasures.Sum(kvp => kvp.Value.Volume);
+        double c = solution.BinPackings[i].BinMeasures.Volume;
+        result += Math.Pow(f / c, k);
+      }
+
+      result = result / nrOfBins;
+      return result;
+    }
+
+    #endregion
+  }
+}
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 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14153)
@@ -163,12 +163,26 @@
   <ItemGroup>
     <Compile Include="BinPacking3D.cs" />
-    <Compile Include="I3DOperator.cs" />
+    <Compile Include="Evaluators\BinUtilizationEvaluator.cs" />
+    <Compile Include="Evaluators\PackingRatioEvaluator.cs" />
     <Compile Include="Instances\BPPData.cs" />
     <Compile Include="Instances\RandomDataDescriptor.cs" />
     <Compile Include="Instances\RandomInstanceProvider.cs" />
+    <Compile Include="IntegerVectorEncoding\BottomLeftIntegerVectorDecoder.cs" />
+    <Compile Include="IntegerVectorEncoding\ExtremePointIntegerVectorDecoder.cs" />
+    <Compile Include="IntegerVectorEncoding\IntegerVectorDecoderBase.cs" />
+    <Compile Include="IntegerVectorEncoding\IntegerVectorProblem.cs" />
+    <Compile Include="Interfaces\IDecoder.cs" />
+    <Compile Include="Interfaces\IEvaluator.cs" />
+    <Compile Include="MoveEvaluatorBase.cs" />
     <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingShape.cs" />
+    <Compile Include="PermutationEncoding\BottomLeftPermutationDecoder.cs" />
+    <Compile Include="PermutationEncoding\ExtremePointPermutationDecoder.cs" />
+    <Compile Include="PermutationEncoding\PermutationProblem.cs" />
+    <Compile Include="PermutationEncoding\Swap2MoveEvaluator.cs" />
+    <Compile Include="PermutationEncoding\TranslocationMoveEvaluator.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="ProblemBase.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/BottomLeftIntegerVectorDecoder.cs	(revision 14153)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bottom-left IntegerVector Decoder (3d)", "Decodes the integer vector and creates a packing solution candidate")]
+  [StorableClass]
+  public class BottomLeftIntegerVectorDecoder : IntegerVectorDecoderBase {
+
+    [StorableConstructor]
+    protected BottomLeftIntegerVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftIntegerVectorDecoder(BottomLeftIntegerVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public BottomLeftIntegerVectorDecoder() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftIntegerVectorDecoder(this, cloner);
+    }
+
+    public override Solution Decode(IntegerVector intVec, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints) {
+      // TODO
+      if (useStackingConstraints) throw new NotSupportedException("Stacking constraints are not supported by the Bottom-Left IntegerVector Decoder");
+      return base.Decode(intVec, binShape, items, useStackingConstraints: false);
+    }
+
+    protected override Solution CreateSolution(PackingShape binShape, bool useStackingConstraints) {
+      return new Solution(binShape, useExtremePoints: false, stackingConstraints: useStackingConstraints);
+    }
+
+    protected override PackingPosition FindPositionForItem(BinPacking3D bp, PackingItem item, bool useStackingConstraints) {
+      return bp.FindPositionBySliding(item, rotated: false);
+    }
+
+    protected override BinPacking3D CreatePacking(
+      Solution partialSolution,
+      ref IList<int> remainingIDs, IList<PackingItem> items, bool useStackingConstraints) {
+      var bp = new BinPacking3D(partialSolution.BinMeasures);
+      bp.SlidingBasedPacking(ref remainingIDs, items);
+      return bp;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/ExtremePointIntegerVectorDecoder.cs	(revision 14153)
@@ -0,0 +1,60 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Extreme-point IntegerVector Decoder (3d)", "Decodes the integer vector and creates a packing solution candidate")]
+  [StorableClass]
+  public class ExtremePointIntegerVectorDecoder : IntegerVectorDecoderBase {
+
+    [StorableConstructor]
+    protected ExtremePointIntegerVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected ExtremePointIntegerVectorDecoder(ExtremePointIntegerVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ExtremePointIntegerVectorDecoder() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointIntegerVectorDecoder(this, cloner);
+    }
+
+    protected override Solution CreateSolution(PackingShape binShape, bool useStackingConstraints) {
+      return new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints);
+    }
+
+    protected override PackingPosition FindPositionForItem(BinPacking3D bp, PackingItem item, bool useStackingConstraints) {
+      return bp.FindExtremePointForItem(item, rotated: false, stackingConstraints: useStackingConstraints);
+    }
+
+    protected override BinPacking3D CreatePacking(
+      Solution partialSolution,
+      ref IList<int> remainingIDs, IList<PackingItem> items, bool useStackingConstraints) {
+      var bp = new BinPacking3D(partialSolution.BinMeasures);
+      bp.ExtremePointBasedPacking(ref remainingIDs, items, useStackingConstraints);
+      return bp;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorDecoderBase.cs	(revision 14153)
@@ -0,0 +1,89 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [StorableClass]
+  public abstract class IntegerVectorDecoderBase : Item, IDecoder<IntegerVector> {
+
+    [StorableConstructor]
+    protected IntegerVectorDecoderBase(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorDecoderBase(IntegerVectorDecoderBase original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    protected IntegerVectorDecoderBase() : base() { }
+
+
+    public virtual Solution Decode(IntegerVector intVec, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints) {
+      var sequenceMatrix = IntegerVectorProblem.GenerateSequenceMatrix(intVec);
+      Solution result = CreateSolution(binShape, useStackingConstraints);
+
+      //Fill bins according to grouping vector
+      IList<int> remainingIDs = new List<int>();
+      foreach (var sequence in sequenceMatrix) {
+        remainingIDs = remainingIDs.Concat(sequence).ToList();
+        result.BinPackings.Add(CreatePacking(result, ref remainingIDs, items, useStackingConstraints));
+      }
+      result.UpdateBinPackings();
+
+      //Try to put remaining items in existing bins
+      var temp = new List<int>(remainingIDs);
+      foreach (int id in temp) {
+        foreach (BinPacking3D bp in result.BinPackings) {
+          var position = FindPositionForItem(bp, items[id], useStackingConstraints);
+          if (position != null) {
+            bp.PackItem(id, items[id], position);
+            remainingIDs.Remove(id);
+            break;
+          }
+        }
+      }
+
+      //Put still remaining items in new bins
+      while (remainingIDs.Count > 0) {
+        result.BinPackings.Add(CreatePacking(result, ref remainingIDs, items, useStackingConstraints));
+      }
+      result.UpdateBinPackings();
+
+      // gkronber: original implementation by Helm also updates the encoded solution (TODO)
+      // var newSolution = new int[intVec.Length];
+      // int binIndex = 0;
+      // foreach (var bp in result.BinPackings) {
+      //   foreach (var entry in bp.ItemPositions)
+      //     newSolution[entry.Key] = binIndex;
+      //   binIndex++;
+      // }
+      // solution.GroupingVector = new IntegerVector(newSolution);
+
+      return result;
+    }
+
+    protected abstract Solution CreateSolution(PackingShape binShape, bool useStackingConstraints);
+    protected abstract PackingPosition FindPositionForItem(BinPacking3D bp, PackingItem item, bool useStackingConstraints);
+    protected abstract BinPacking3D CreatePacking(Solution partialSolution, ref IList<int> remainingIDs, IList<PackingItem> items, bool useStackingConstraints);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/IntegerVectorEncoding/IntegerVectorProblem.cs	(revision 14153)
@@ -0,0 +1,100 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bin Packing Problem (3D, integer vector encoding) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
+  [StorableClass]
+  [Creatable(Category = CreatableAttribute.Categories.CombinatorialProblems, Priority = 330)]
+  public sealed class IntegerVectorProblem : ProblemBase<IntegerVectorEncoding, IntegerVector> {
+    // persistence
+    [StorableConstructor]
+    private IntegerVectorProblem(bool deserializing) : base(deserializing) { }
+
+    // cloning
+    private IntegerVectorProblem(IntegerVectorProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+
+    public IntegerVectorProblem()
+      : base() {
+      Decoder = new ExtremePointIntegerVectorDecoder(); // default decoder
+
+      // the int vector contains the target bin number for each item
+      Encoding = new IntegerVectorEncoding(EncodedSolutionName, Items.Count, min: 0, max: LowerBound + 1); // NOTE: assumes that all items can be packed into LowerBound+1 bins
+      AddOperators();
+      RegisterEventHandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntegerVectorProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+
+    private void AddOperators() {
+
+      // move operators are not yet supported (TODO)
+      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
+
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>()); // gkronber: not strictly necessary (only when customer ops are added)
+    }
+
+    private void RegisterEventHandlers() {
+      // update encoding length when number of items is changed
+      ItemsParameter.ValueChanged += (sender, args) => Encoding.Length = Items.Count;
+      LowerBoundParameter.Value.ValueChanged += (sender, args) => {
+        for (int i = 0; i < Encoding.Bounds.Rows; i++) {
+          Encoding.Bounds[i, 1] = LowerBound + 1;
+        }
+      };
+    }
+
+    #region helpers
+
+    public static List<List<int>> GenerateSequenceMatrix(IntegerVector intVec) {
+      List<List<int>> result = new List<List<int>>();
+      int nrOfBins = intVec.Max() + 1;
+      for (int i = 0; i < nrOfBins; i++)
+        result.Add(new List<int>());
+      for (int i = 0; i < intVec.Length; i++) {
+        result[intVec[i]].Add(i);
+      }
+      return result;
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IDecoder.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IDecoder.cs	(revision 14153)
@@ -0,0 +1,29 @@
+﻿#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.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface IDecoder<in T> : IItem {
+    Solution Decode(T encodedSolution, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IEvaluator.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IEvaluator.cs	(revision 14153)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface IEvaluator : IItem {
+    double Evaluate(Solution solution);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluatorBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluatorBase.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluatorBase.cs	(revision 14153)
@@ -0,0 +1,99 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [StorableClass]
+  public abstract class MoveEvaluatorBase<TSol, TMove> : SingleSuccessorOperator,
+    ISingleObjectiveMoveEvaluator, ISingleObjectiveMoveOperator
+    where TSol : class, IItem
+    where TMove : class, IItem {
+    public ILookupParameter<TSol> EncodedSolutionParameter {
+      get { return (ILookupParameter<TSol>)Parameters["EncodedSolution"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<ReadOnlyItemList<PackingItem>> PackingItemMeasuresParameter {
+      get { return (LookupParameter<ReadOnlyItemList<PackingItem>>)Parameters["Items"]; }
+    }
+    public ILookupParameter<PackingShape> PackingBinMeasuresParameter {
+      get { return (LookupParameter<PackingShape>)Parameters["BinShape"]; }
+    }
+    public ILookupParameter<IDecoder<TSol>> PackingSolutionDecoderParameter {
+      get { return (ILookupParameter<IDecoder<TSol>>)Parameters["Decoder"]; }
+    }
+    public ILookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
+      get { return (ILookupParameter<IEvaluator>)Parameters["SolutionEvaluator"]; }
+    }
+    public ILookupParameter<TMove> MoveParameter {
+      get { return (ILookupParameter<TMove>)Parameters["Move"]; }
+    }
+    public ILookupParameter<BoolValue> UseStackingConstraintsParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["UseStackingConstraints"]; }
+    }
+
+
+    [StorableConstructor]
+    protected MoveEvaluatorBase(bool deserializing) : base(deserializing) { }
+    protected MoveEvaluatorBase(MoveEvaluatorBase<TSol, TMove> original, Cloner cloner) : base(original, cloner) { }
+    protected MoveEvaluatorBase()
+      : base() {
+      Parameters.Add(new LookupParameter<TSol>("EncodedSolution", "The encoded solution candidate to evaluate"));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a packing solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a packing solution."));
+      Parameters.Add(new LookupParameter<ReadOnlyItemList<PackingItem>>("Items", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<PackingShape>("BinShape", "Packing-bin data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<IDecoder<TSol>>("Decoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
+      Parameters.Add(new LookupParameter<IEvaluator>("SolutionEvaluator", "The actual packing plan evaluation operator."));
+      Parameters.Add(new LookupParameter<TMove>("Move", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("UseStackingConstraints", "A flag that determines if stacking constriants should be checked when solving the problem"));
+    }
+
+    public override IOperation Apply() {
+      var move = MoveParameter.ActualValue;
+      var encSolCandidate = EncodedSolutionParameter.ActualValue;
+      var binShape = PackingBinMeasuresParameter.ActualValue;
+      var items = PackingItemMeasuresParameter.ActualValue;
+
+
+      double moveQuality = EvaluateMove(encSolCandidate, move, binShape, items, UseStackingConstraintsParameter.ActualValue.Value);
+
+      if (MoveQualityParameter.ActualValue == null)
+        MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
+      else
+        MoveQualityParameter.ActualValue.Value = moveQuality;
+      return base.Apply();
+    }
+
+    public abstract double EvaluateMove(TSol encodedSolutionCandidate, TMove move, PackingShape binShape, ReadOnlyItemList<PackingItem> items, bool useStackingConstraints);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs	(revision 14153)
@@ -103,5 +103,5 @@
 
     private void RegisterEvents() {
-      // only because of ToString override
+      // NOTE: only because of ToString override
       WeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
       MaterialParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/BottomLeftPermutationDecoder.cs	(revision 14153)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bottom-left Permutation Decoder (3d)", "Decodes the permutation and creates a packing solution candidate")]
+  [StorableClass]
+  public class BottomLeftPermutationDecoder : Item, IDecoder<Permutation> {
+
+    [StorableConstructor]
+    protected BottomLeftPermutationDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftPermutationDecoder(BottomLeftPermutationDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public BottomLeftPermutationDecoder() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftPermutationDecoder(this, cloner);
+    }
+
+    public Solution Decode(Permutation permutation, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints) {
+      Solution result = new Solution(binShape, useExtremePoints: false, stackingConstraints: useStackingConstraints);
+      IList<int> remainingIDs = new List<int>(permutation);
+      while (remainingIDs.Count > 0) {
+        var bp = new BinPacking3D(binShape);
+        bp.SlidingBasedPacking(ref remainingIDs, items);
+        result.BinPackings.Add(bp);
+      }
+      result.UpdateBinPackings();
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/ExtremePointPermutationDecoder.cs	(revision 14153)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Extreme-point Permutation Decoder (3d)", "Decodes the permutation and creates a packing solution candidate")]
+  [StorableClass]
+  public class ExtremePointPermutationDecoder : Item, IDecoder<Permutation> {
+
+    [StorableConstructor]
+    protected ExtremePointPermutationDecoder(bool deserializing) : base(deserializing) { }
+    protected ExtremePointPermutationDecoder(ExtremePointPermutationDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ExtremePointPermutationDecoder() : base() { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPermutationDecoder(this, cloner);
+    }
+
+    public Solution Decode(Permutation permutation, PackingShape binShape, IList<PackingItem> items, bool useStackingConstraints) {
+      Solution result = new Solution(binShape, useExtremePoints: true, stackingConstraints: useStackingConstraints);
+      IList<int> remainingIDs = new List<int>(permutation);
+      while (remainingIDs.Count > 0) {
+        var bp = new BinPacking3D(binShape);
+        bp.ExtremePointBasedPacking(ref remainingIDs, items, stackingConstraints: useStackingConstraints);
+        result.BinPackings.Add(bp);
+      }
+      result.UpdateBinPackings();
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/PermutationProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/PermutationProblem.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/PermutationProblem.cs	(revision 14153)
@@ -0,0 +1,82 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bin Packing Problem (3D, permutation encoding) (BPP)", "Represents a three-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
+  [StorableClass]
+  [Creatable(Category = CreatableAttribute.Categories.CombinatorialProblems, Priority = 320)]
+  public sealed class PermutationProblem : ProblemBase<PermutationEncoding, Permutation> {
+    // persistence
+    [StorableConstructor]
+    private PermutationProblem(bool deserializing) : base(deserializing) { }
+
+    // cloning
+    private PermutationProblem(PermutationProblem original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEventHandlers();
+    }
+
+    public PermutationProblem()
+      : base() {
+      Decoder = new ExtremePointPermutationDecoder(); // default decoder
+
+      Encoding = new PermutationEncoding(EncodedSolutionName, Items.Count, PermutationTypes.Absolute);
+      AddOperators();
+      RegisterEventHandlers();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PermutationProblem(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+
+    private void AddOperators() {
+      Operators.Add(new TranslocationMoveEvaluator());
+      Operators.Add(new Swap2MoveEvaluator());
+
+      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
+
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>()); 
+
+      // TODO: configure my move evaluators (introduce interface)
+    }
+
+    private void RegisterEventHandlers() {
+      // update encoding length when number of items is changed
+      ItemsParameter.ValueChanged += (sender, args) => Encoding.Length = Items.Count;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs	(revision 14153)
@@ -0,0 +1,57 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Swap2MoveEvaluator", "Move evaluator for 2-opt moves.")]
+  [StorableClass]
+  public sealed class Swap2MoveEvaluator : MoveEvaluatorBase<Permutation, Swap2Move>, IPermutationSwap2MoveOperator {
+    public ILookupParameter<Swap2Move> Swap2MoveParameter {
+      get { return MoveParameter; }
+    }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return EncodedSolutionParameter; }
+    }
+
+    [StorableConstructor]
+    private Swap2MoveEvaluator(bool deserializing) : base(deserializing) { }
+    private Swap2MoveEvaluator(Swap2MoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public Swap2MoveEvaluator()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2MoveEvaluator(this, cloner);
+    }
+
+    public override double EvaluateMove(Permutation permutation, Swap2Move move, PackingShape binShape, ReadOnlyItemList<PackingItem> items, bool useStackingConstraints) {
+      // uses full evaluation
+      Swap2Manipulator.Apply(permutation, move.Index1, move.Index2);
+      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
+
+      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs	(revision 14153)
@@ -0,0 +1,58 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("TranslocationMoveEvaluator", "Move evaluator for insertion or translocation moves.")]
+  [StorableClass]
+  public sealed class TranslocationMoveEvaluator : MoveEvaluatorBase<Permutation, TranslocationMove>, IPermutationTranslocationMoveOperator {
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return MoveParameter; }
+    }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return EncodedSolutionParameter; }
+    }
+    [StorableConstructor]
+    private TranslocationMoveEvaluator(bool deserializing) : base(deserializing) { }
+    private TranslocationMoveEvaluator(TranslocationMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public TranslocationMoveEvaluator()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TranslocationMoveEvaluator(this, cloner);
+    }
+
+    public override double EvaluateMove(Permutation permutation, TranslocationMove move, PackingShape binShape,
+      ReadOnlyItemList<PackingItem> items, bool useStackingConstraints) {
+
+      // uses full evaluation
+      TranslocationManipulator.Apply(permutation, move.Index1, move.Index2, move.Index3);
+      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
+
+      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/ProblemBase.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/ProblemBase.cs	(revision 14153)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/ProblemBase.cs	(revision 14153)
@@ -0,0 +1,275 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Instances;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  // in comparison to the 2d problem the 3d problem implementation also supports checking stacking constraints
+  [StorableClass]
+  public abstract class ProblemBase<TEnc, TSol> :
+    SingleObjectiveBasicProblem<TEnc>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData>
+    where TEnc : class, IEncoding
+    where TSol : class, IItem {
+    protected readonly string SolutionEvaluatorParameterName = "SolutionEvaluator";
+    protected readonly string UseStackingConstraintsParameterName = "UseStackingConstraints";
+
+    public readonly string EncodedSolutionName = "EncodedSolution";
+    #region Default Instance
+    private readonly BPPData defaultInstance = new BPPData() {
+      Name = "3D BPP Default Instance",
+      Description = "The default instance for 3D Bin Packing.",
+      BinShape = new PackingShape(25, 25, 35),
+      Items = new PackingItem[] {
+        new PackingItem(12,5,10, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11, 9,new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35))
+      },
+    };
+    #endregion
+
+    #region parameter properties
+    public IValueParameter<IDecoder<TSol>> DecoderParameter {
+      get { return (IValueParameter<IDecoder<TSol>>)Parameters["Decoder"]; }
+    }
+    public IValueParameter<IEvaluator> SolutionEvaluatorParameter {
+      get { return (IValueParameter<IEvaluator>)Parameters[SolutionEvaluatorParameterName]; }
+    }
+    public IFixedValueParameter<BoolValue> UseStackingConstraintsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UseStackingConstraintsParameterName]; }
+    }
+    public IValueParameter<ReadOnlyItemList<PackingItem>> ItemsParameter {
+      get { return (IValueParameter<ReadOnlyItemList<PackingItem>>)Parameters["Items"]; }
+    }
+    public IValueParameter<PackingShape> BinShapeParameter {
+      get { return (IValueParameter<PackingShape>)Parameters["BinShape"]; }
+    }
+    public IValueParameter<Solution> BestKnownSolutionParameter {
+      get { return (IValueParameter<Solution>)Parameters["BestKnownSolution"]; }
+    }
+    public IFixedValueParameter<IntValue> LowerBoundParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
+    }
+    #endregion
+
+    #region properties
+    public IDecoder<TSol> Decoder {
+      get { return DecoderParameter.Value; }
+      set { DecoderParameter.Value = value; }
+    }
+    public IEvaluator SolutionEvaluator {
+      get { return SolutionEvaluatorParameter.Value; }
+      set { SolutionEvaluatorParameter.Value = value; }
+    }
+    public bool UseStackingConstraints {
+      get { return UseStackingConstraintsParameter.Value.Value; }
+      set { UseStackingConstraintsParameter.Value.Value = value; }
+    }
+    public ReadOnlyItemList<PackingItem> Items {
+      get { return ItemsParameter.Value; }
+      set { ItemsParameter.Value = value; }
+    }
+    public PackingShape BinShape {
+      get { return BinShapeParameter.Value; }
+      set { BinShapeParameter.Value = value; }
+    }
+    public Solution BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public int LowerBound {
+      get { return LowerBoundParameter.Value.Value; }
+    }
+    public int NumberOfItems {
+      get { return Items == null ? 0 : Items.Count; }
+    }
+    #endregion
+
+    // persistence
+    [StorableConstructor]
+    protected ProblemBase(bool deserializing) : base(deserializing) { }
+
+    // cloning
+    protected ProblemBase(ProblemBase<TEnc, TSol> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected ProblemBase()
+      : base() {
+      var defaultEvaluator = new PackingRatioEvaluator();
+      Parameters.Add(new ValueParameter<IDecoder<TSol>>("Decoder", "The decoder translates a permutation to a packing solution candidiates"));
+      Parameters.Add(new ValueParameter<IEvaluator>(SolutionEvaluatorParameterName, "The evaluator calculates qualities of solution candidates", defaultEvaluator));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseStackingConstraintsParameterName, "A flag that determines if stacking constraints are considered when solving the problem.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<ReadOnlyItemList<PackingItem>>("Items", "The items which must be packed into bins"));
+      Parameters.Add(new ValueParameter<PackingShape>("BinShape", "The size of bins into which items must be packed"));
+      Parameters.Add(new OptionalValueParameter<Solution>("BestKnownSolution", "The best solution found so far"));
+      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "A lower bound for the number of bins that is necessary to pack all items"));
+
+      Load(defaultInstance);
+    }
+
+    public override bool Maximization { get { return true; } }
+
+
+    public override double Evaluate(Individual individual, IRandom random) {
+      var encodedSolutionCand = (TSol)individual[EncodedSolutionName];
+      var decoder = Decoder;
+      var solution = decoder.Decode(encodedSolutionCand, BinShape, Items, UseStackingConstraints);
+      return SolutionEvaluator.Evaluate(solution);
+    }
+
+    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      base.Analyze(individuals, qualities, results, random);
+      Analyze(individuals.Select(i => (TSol)i[EncodedSolutionName]).ToArray(), qualities, results, random);
+    }
+
+    // NOTE: same implementation as for 2d problem
+    public virtual void Analyze(TSol[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      var bestSolutionResultName = "Best Packing Solution";
+      var numContainersResultName = "Nr of Containers";
+      var binUtilResultName = "Overall Bin Utilization";
+
+      if (!results.ContainsKey(bestSolutionResultName)) results.Add(new Result(bestSolutionResultName, typeof(Solution)));
+      if (!results.ContainsKey(numContainersResultName)) results.Add(new Result(numContainersResultName, typeof(IntValue)));
+      if (!results.ContainsKey(binUtilResultName)) results.Add(new Result(binUtilResultName, typeof(DoubleValue)));
+
+
+      // find index of item with max quality
+      int bestIdx = 0;
+      for (int j = 1; j < qualities.Length; j++)
+        if (qualities[j] > qualities[bestIdx]) bestIdx = j;
+
+
+      // update best solution so far
+      var bestSolution = results[bestSolutionResultName].Value as Solution;
+      if (bestSolution == null ||
+        bestSolution.Quality.Value < qualities[bestIdx]) {
+
+        var newBestSolution = Decoder.Decode(individuals[bestIdx], BinShape, Items, UseStackingConstraints);
+        newBestSolution.Quality = new DoubleValue(qualities[bestIdx]);
+        results[bestSolutionResultName].Value = newBestSolution;
+        results[numContainersResultName].Value = new IntValue(newBestSolution.NrOfBins);
+        results[binUtilResultName].Value = new DoubleValue(BinUtilizationEvaluator.CalculateBinUtilization(newBestSolution));
+
+        // update best known solution
+        var bestKnownQuality = BestKnownQualityParameter.Value;
+        if (bestKnownQuality == null ||
+            bestKnownQuality.Value < qualities[bestIdx]) {
+          BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[bestIdx]);
+          BestKnownSolutionParameter.ActualValue = newBestSolution;
+        }
+      }
+    }
+
+
+    #region Problem instance handling
+    public void Load(BPPData data) {
+      BestKnownSolutionParameter.Value = null;
+      BestKnownQualityParameter.Value = null;
+
+      if (data.BestKnownQuality.HasValue)
+        BestKnownQuality = data.BestKnownQuality.Value;
+
+      BinShape = data.BinShape;
+      var items = new ItemList<PackingItem>(data.Items);
+      items.Sort((x, y) => y.CompareTo(x));
+      Items = items.AsReadOnly();
+
+      ApplyHorizontalOrientation();
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+
+    public BPPData Export() {
+      return new BPPData {
+        Name = Name,
+        Description = Description,
+        BinShape = BinShape,
+        Items = Items.ToArray()
+      };
+    }
+    #endregion
+
+
+    #region helpers
+    private void ApplyHorizontalOrientation() {
+      BinShape.ApplyHorizontalOrientation();
+      foreach (var shape in Items) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+
+    private 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 itemsVol = Items.Select(x => x.Volume).Sum();
+      int binVol = BinShape.Volume;
+      return (itemsVol + binVol - 1) / (binVol);
+    }
+
+    #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 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs	(revision 14153)
@@ -18,7 +18,4 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<PackingPosition, PackingShape, PackingItem> NewBinPacking() {
-      return new BinPacking3D(BinMeasures);
-    }
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml	(revision 14153)
@@ -35,5 +35,5 @@
         <Viewport3D Name="viewport3D1" >
             <Viewport3D.Camera>
-                <PerspectiveCamera x:Name="camMain" Position="0.5 5 5" LookDirection="0 -1 -1"> <!-- camera position for design time-->
+                <PerspectiveCamera x:Name="camMain" Position="0.5 8 8" LookDirection="0 -1 -1"> <!-- camera position for design time-->
                 </PerspectiveCamera>
             </Viewport3D.Camera>
@@ -128,5 +128,5 @@
                         </RotateTransform3D>
                         <TranslateTransform3D OffsetX="0.5" OffsetY="0.5" OffsetZ="0.5" />
-                        <ScaleTransform3D x:Name="scaleZoom" CenterX="0.5" CenterY="0.5" CenterZ="0.5" ScaleX="1" ScaleY="1" ScaleZ="1"/>
+                        <ScaleTransform3D x:Name="scaleZoom" CenterX="0.5" CenterY="0.5" CenterZ="0.5" ScaleX="0.6" ScaleY="0.6" ScaleZ="0.6"/>
                     </Transform3DGroup>
                 </ModelVisual3D.Transform>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14153)
@@ -29,7 +29,6 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  [Item("PackingPlan", "Represents a concrete solution for a bin-packing problem.")]
   [StorableClass]
-  public abstract class PackingPlan<D, B, I> : Item, IPackingPlan
+  public abstract class PackingPlan<D, B, I> : Item
     where D : class, IPackingPosition
     where B : PackingShape<D>
@@ -86,5 +85,4 @@
 
 
-    public abstract BinPacking<D, B, I> NewBinPacking();
     public void UpdateBinPackings() {
       BinPackings.RemoveAll(x => x.ItemPositions.Count == 0);
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 14151)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14153)
@@ -179,5 +179,4 @@
     <Compile Include="PackingDimensions.cs" />
     <Compile Include="Interfaces\IPackingItem.cs" />
-    <Compile Include="Interfaces\IPackingPlan.cs" />
     <Compile Include="PackingShape.cs" />
     <Compile Include="PackingSolutionDecoder.cs" />
