Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14154)
@@ -32,14 +32,16 @@
   public class BinPacking2D : BinPacking.BinPacking<PackingPosition, PackingShape, PackingItem> {
 
-    public BinPacking2D(PackingShape binMeasures)
-      : base(binMeasures) {
+    public BinPacking2D(PackingShape binShape)
+      : base(binShape) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer2D());
-      ExtremePoints.Add(binMeasures.Origin);
-    }
+      ExtremePoints.Add(binShape.Origin);
+      InitializeOccupationLayers();
+    }
+
     [StorableConstructor]
     protected BinPacking2D(bool deserializing) : base(deserializing) { }
     protected BinPacking2D(BinPacking2D original, Cloner cloner)
       : base(original, cloner) {
-      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer2D());
+      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints.Select(p => cloner.Clone(p)), new EPComparer2D());
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -54,5 +56,5 @@
       //Find ExtremePoints beginning from sourcepointX
       var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y);
-      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height) {
+      if (sourcePointX.X < BinShape.Width && sourcePointX.Y < BinShape.Height) {
         //Traversing down the y-axis        
         var newPoint = new PackingPosition(0, sourcePointX.X, sourcePointX.Y - 1);
@@ -66,5 +68,5 @@
       //Find ExtremePoints beginning from sourcepointY
       var sourcePointY = new PackingPosition(0, position.X, position.Y + newHeight);
-      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height) {
+      if (sourcePointY.X < BinShape.Width && sourcePointY.Y < BinShape.Height) {
         //Traversing down the x-axis  
         var newPoint = new PackingPosition(0, sourcePointY.X - 1, sourcePointY.Y);
@@ -96,6 +98,6 @@
     public override PackingPosition FindPositionBySliding(PackingItem item, bool rotated) {
       PackingPosition currentPosition = new PackingPosition(0,
-        BinMeasures.Width - (rotated ? item.Height : item.Width),
-        BinMeasures.Height - (rotated ? item.Width : item.Height), rotated);
+        BinShape.Width - (rotated ? item.Height : item.Width),
+        BinShape.Height - (rotated ? item.Width : item.Height), rotated);
       //Slide the item as far as possible to the left
       while (IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition))
@@ -159,6 +161,6 @@
     public override int ShortestPossibleSideFromPoint(PackingPosition position) {
       int shortestSide = int.MaxValue;
-      int width = BinMeasures.Width;
-      int height = BinMeasures.Height;
+      int width = BinShape.Width;
+      int height = BinShape.Height;
 
       if (position.X >= width || position.Y >= height)
@@ -182,13 +184,13 @@
     }
 
-
     protected override void InitializeOccupationLayers() {
-      for (int i = 0; i * 10 <= BinMeasures.Width; i += 1) {
+      for (int i = 0; i * 10 <= BinShape.Width; i += 1) {
         OccupationLayers[i] = new List<int>();
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
+
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
       int x1 = position.X / 10;
-      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
+      int x2 = (position.X + (position.Rotated ? item.Height : item.Width)) / 10;
 
       for (int i = x1; i <= x2; i++)
@@ -198,8 +200,8 @@
       return OccupationLayers[position.X / 10];
     }
-    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
       List<int> result = new List<int>();
       int x1 = position.X / 10;
-      int x2 = (position.X + (position.Rotated ? measures.Height : measures.Width)) / 10;
+      int x2 = (position.X + (position.Rotated ? item.Height : item.Width)) / 10;
 
       for (int i = x1; i <= x2; i++)
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/BinUtilizationEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/BinUtilizationEvaluator.cs	(revision 14154)
@@ -53,6 +53,6 @@
 
       for (int i = 0; i < nrOfBins; i++) {
-        totalUsableSpace += solution.BinPackings[i].BinMeasures.Volume;
-        totalUsedSpace += solution.BinPackings[i].ItemMeasures.Sum(kvp => kvp.Value.Volume);
+        totalUsableSpace += solution.BinPackings[i].BinShape.Volume;
+        totalUsedSpace += solution.BinPackings[i].Items.Sum(kvp => kvp.Value.Volume);
       }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/PackingRatioEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Evaluators/PackingRatioEvaluator.cs	(revision 14154)
@@ -60,6 +60,6 @@
       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;
+        double f = solution.BinPackings[i].Items.Sum(kvp => kvp.Value.Volume);
+        double c = solution.BinPackings[i].BinShape.Volume;
         result += Math.Pow(f / c, k);
       }
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14154)
@@ -172,4 +172,5 @@
     <Compile Include="IntegerVectorEncoding\ExtremePointIntegerVectorDecoder.cs" />
     <Compile Include="IntegerVectorEncoding\IntegerVectorProblem.cs" />
+    <Compile Include="Interfaces\IOperator.cs" />
     <Compile Include="Interfaces\IDecoder.cs" />
     <Compile Include="Interfaces\IEvaluator.cs" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IOperator.cs	(revision 14154)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Interfaces/IOperator.cs	(revision 14154)
@@ -0,0 +1,31 @@
+﻿#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.BinPacking2D {
+  public interface IOperator<TSol> : IItem {
+    ILookupParameter<ReadOnlyItemList<PackingItem>> ItemsParameter { get; }
+    ILookupParameter<PackingShape> BinShapeParameter { get; }
+    ILookupParameter<IDecoder<TSol>> DecoderParameter { get; }
+    ILookupParameter<IEvaluator> SolutionEvaluatorParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/MoveEvaluatorBase.cs	(revision 14154)
@@ -31,5 +31,5 @@
   [StorableClass]
   public abstract class MoveEvaluatorBase<TSol, TMove> : SingleSuccessorOperator,
-    ISingleObjectiveMoveEvaluator, ISingleObjectiveMoveOperator
+    ISingleObjectiveMoveEvaluator, ISingleObjectiveMoveOperator, IOperator<TSol>
     where TSol : class, IItem
     where TMove : class, IItem {
@@ -43,14 +43,14 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<ReadOnlyItemList<PackingItem>> PackingItemMeasuresParameter {
+    public ILookupParameter<ReadOnlyItemList<PackingItem>> ItemsParameter {
       get { return (LookupParameter<ReadOnlyItemList<PackingItem>>)Parameters["Items"]; }
     }
-    public ILookupParameter<PackingShape> PackingBinMeasuresParameter {
+    public ILookupParameter<PackingShape> BinShapeParameter {
       get { return (LookupParameter<PackingShape>)Parameters["BinShape"]; }
     }
-    public ILookupParameter<IDecoder<TSol>> PackingSolutionDecoderParameter {
+    public ILookupParameter<IDecoder<TSol>> DecoderParameter {
       get { return (ILookupParameter<IDecoder<TSol>>)Parameters["Decoder"]; }
     }
-    public ILookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
+    public ILookupParameter<IEvaluator> SolutionEvaluatorParameter {
       get { return (ILookupParameter<IEvaluator>)Parameters["SolutionEvaluator"]; }
     }
@@ -78,6 +78,6 @@
       var move = MoveParameter.ActualValue;
       var encSolCandidate = EncodedSolutionParameter.ActualValue;
-      var binShape = PackingBinMeasuresParameter.ActualValue;
-      var items = PackingItemMeasuresParameter.ActualValue;
+      var binShape = BinShapeParameter.ActualValue;
+      var items = ItemsParameter.ActualValue;
 
 
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/PermutationProblem.cs	(revision 14154)
@@ -23,4 +23,5 @@
 
 using System.Linq;
+using System.Windows.Forms;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -72,5 +73,10 @@
       Encoding.ConfigureOperators(Operators.OfType<IOperator>());
 
-      // TODO: configure the move evaluators (add interface for my move evaluators)
+      foreach (var op in Operators.OfType<IOperator<Permutation>>()) {
+        op.BinShapeParameter.ActualName = BinShapeParameter.Name;
+        op.ItemsParameter.ActualName = ItemsParameter.Name;
+        op.SolutionEvaluatorParameter.ActualName = SolutionEvaluatorParameter.Name;
+        op.DecoderParameter.ActualName = DecoderParameter.Name;
+      }
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/Swap2MoveEvaluator.cs	(revision 14154)
@@ -50,7 +50,7 @@
       // uses full evaluation
       Swap2Manipulator.Apply(permutation, move.Index1, move.Index2);
-      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items);
+      var solution = DecoderParameter.ActualValue.Decode(permutation, binShape, items);
 
-      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+      return SolutionEvaluatorParameter.ActualValue.Evaluate(solution);
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PermutationEncoding/TranslocationMoveEvaluator.cs	(revision 14154)
@@ -51,7 +51,7 @@
       // uses full evaluation
       TranslocationManipulator.Apply(permutation, move.Index1, move.Index2, move.Index3);
-      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items);
+      var solution = DecoderParameter.ActualValue.Decode(permutation, binShape, items);
 
-      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+      return SolutionEvaluatorParameter.ActualValue.Evaluate(solution);
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14154)
@@ -32,8 +32,9 @@
   public class BinPacking3D : BinPacking<PackingPosition, PackingShape, PackingItem> {
 
-    public BinPacking3D(PackingShape binMeasures)
-      : base(binMeasures) {
+    public BinPacking3D(PackingShape binShape)
+      : base(binShape) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer3D());
-      ExtremePoints.Add(binMeasures.Origin);
+      ExtremePoints.Add(binShape.Origin);
+      InitializeOccupationLayers();
     }
     [StorableConstructor]
@@ -41,5 +42,5 @@
     protected BinPacking3D(BinPacking3D original, Cloner cloner)
       : base(original, cloner) {
-      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer3D());
+      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints.Select(p => cloner.Clone(p)), new EPComparer3D());
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -53,5 +54,5 @@
       //Find ExtremePoints beginning from sourcepointX
       var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y, position.Z);
-      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height && sourcePointX.Z < BinMeasures.Depth) {
+      if (sourcePointX.X < BinShape.Width && sourcePointX.Y < BinShape.Height && sourcePointX.Z < BinShape.Depth) {
         //Traversing down the y-axis  
         PackingPosition current = new PackingPosition(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
@@ -79,5 +80,5 @@
       //Find ExtremePoints beginning from sourcepointY
       var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height, position.Z);
-      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height && sourcePointY.Z < BinMeasures.Depth) {
+      if (sourcePointY.X < BinShape.Width && sourcePointY.Y < BinShape.Height && sourcePointY.Z < BinShape.Depth) {
         //Traversing down the x-axis          
         PackingPosition current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
@@ -105,5 +106,5 @@
       //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) {
+      if (sourcePointZ.X < BinShape.Width && sourcePointZ.Y < BinShape.Height && sourcePointZ.Z < BinShape.Depth) {
         //Traversing down the x-axis
         PackingPosition current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
@@ -130,18 +131,18 @@
     }
 
-    public override PackingPosition FindExtremePointForItem(PackingItem measures, bool rotated, bool stackingConstraints) {
-
-      PackingItem item = new PackingItem(
-        rotated ? measures.Depth : measures.Width,
-        measures.Height,
-        rotated ? measures.Width : measures.Depth,
-        measures.TargetBin);
+    public override PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints) {
+
+      PackingItem newItem = new PackingItem(
+        rotated ? item.Depth : item.Width,
+        item.Height,
+        rotated ? item.Width : item.Depth,
+        item.TargetBin);
 
       int epIndex = 0;
       while (epIndex < ExtremePoints.Count && (
-        !IsPositionFeasible(item, ExtremePoints.ElementAt(epIndex))
-        || !IsSupportedByAtLeastOnePoint(item, ExtremePoints.ElementAt(epIndex))
-        || (stackingConstraints && !IsStaticStable(item, ExtremePoints.ElementAt(epIndex)))
-        || (stackingConstraints && !IsWeightSupported(item, ExtremePoints.ElementAt(epIndex)))
+        !IsPositionFeasible(newItem, ExtremePoints.ElementAt(epIndex))
+        || !IsSupportedByAtLeastOnePoint(newItem, ExtremePoints.ElementAt(epIndex))
+        || (stackingConstraints && !IsStaticStable(newItem, ExtremePoints.ElementAt(epIndex)))
+        || (stackingConstraints && !IsWeightSupported(newItem, ExtremePoints.ElementAt(epIndex)))
       )) { epIndex++; }
 
@@ -154,36 +155,36 @@
     }
 
-    public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(PackingItem item, 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,
-        BinMeasures.Width - (rotated ? measures.Depth : measures.Width),
-        BinMeasures.Height - measures.Height,
-        BinMeasures.Depth - (rotated ? measures.Width : measures.Depth), rotated);
+        BinShape.Width - (rotated ? item.Depth : item.Width),
+        BinShape.Height - item.Height,
+        BinShape.Depth - (rotated ? item.Width : item.Depth), rotated);
       //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition))
-        || IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
-        || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+      while (IsPositionFeasible(item, PackingPosition.MoveDown(currentPosition))
+        || IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition))
+        || IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
         //Slide the item as far as possible to the left
-        while (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
-      || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+        while (IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition))
+      || IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
           //Slide the item as far as possible to the back
-          while (IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+          while (IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
             currentPosition = PackingPosition.MoveBack(currentPosition);
           }
-          if (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition)))
+          if (IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition)))
             currentPosition = PackingPosition.MoveLeft(currentPosition);
         }
-        if (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition)))
+        if (IsPositionFeasible(item, PackingPosition.MoveDown(currentPosition)))
           currentPosition = PackingPosition.MoveDown(currentPosition);
       }
 
-      return IsPositionFeasible(measures, currentPosition) ? currentPosition : null;
-    }
-
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures) {
+      return IsPositionFeasible(item, currentPosition) ? currentPosition : null;
+    }
+
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
+        var item = items[temp[i]];
         var position = FindPositionBySliding(item, false);
         if (position != null) {
@@ -193,8 +194,8 @@
       }
     }
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
+        var item = items[temp[i]];
         var position = FindPositionBySliding(item, rotationArray[i]);
         if (position != null) {
@@ -204,8 +205,8 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
+        var item = items[itemID];
         var positionFound = FindExtremePointForItem(item, false, stackingConstraints);
         if (positionFound != null) {
@@ -215,8 +216,8 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
+        var item = items[itemID];
         var positionFound = FindExtremePointForItem(item, rotationArray[itemID], stackingConstraints);
         if (positionFound != null) {
@@ -230,7 +231,7 @@
 
       int shortestSide = int.MaxValue;
-      int width = BinMeasures.Width;
-      int height = BinMeasures.Height;
-      int depth = BinMeasures.Depth;
+      int width = BinShape.Width;
+      int height = BinShape.Height;
+      int depth = BinShape.Depth;
 
       if (position.X >= width || position.Y >= height || position.Z >= depth)
@@ -287,8 +288,8 @@
         return true;
 
-      if (ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
+      if (Items[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
         return true;
 
@@ -298,11 +299,11 @@
 
     protected override void InitializeOccupationLayers() {
-      for (int i = 0; i * 10 <= BinMeasures.Depth; i += 1) {
+      for (int i = 0; i * 10 <= BinShape.Depth; i += 1) {
         OccupationLayers[i] = new List<int>();
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
       int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
+      int z2 = (position.Z + (position.Rotated ? item.Width : item.Depth)) / 10;
 
       for (int i = z1; i <= z2; i++)
@@ -312,8 +313,8 @@
       return OccupationLayers[position.Z / 10];
     }
-    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
       List<int> result = new List<int>();
       int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
+      int z2 = (position.Z + (position.Rotated ? item.Width : item.Depth)) / 10;
 
       for (int i = z1; i <= z2; i++)
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 14154)
@@ -54,6 +54,6 @@
 
       for (int i = 0; i < nrOfBins; i++) {
-        totalUsableSpace += solution.BinPackings[i].BinMeasures.Volume;
-        totalUsedSpace += solution.BinPackings[i].ItemMeasures.Sum(kvp => kvp.Value.Volume);
+        totalUsableSpace += solution.BinPackings[i].BinShape.Volume;
+        totalUsedSpace += solution.BinPackings[i].Items.Sum(kvp => kvp.Value.Volume);
       }
 
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 14154)
@@ -61,6 +61,6 @@
       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;
+        double f = solution.BinPackings[i].Items.Sum(kvp => kvp.Value.Volume);
+        double c = solution.BinPackings[i].BinShape.Volume;
         result += Math.Pow(f / c, k);
       }
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14154)
@@ -174,4 +174,5 @@
     <Compile Include="Interfaces\IDecoder.cs" />
     <Compile Include="Interfaces\IEvaluator.cs" />
+    <Compile Include="Interfaces\IOperator.cs" />
     <Compile Include="MoveEvaluatorBase.cs" />
     <Compile Include="PackingItem.cs" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IOperator.cs	(revision 14154)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Interfaces/IOperator.cs	(revision 14154)
@@ -0,0 +1,33 @@
+﻿#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.Data;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface IOperator<TSol> : IItem {
+    ILookupParameter<ReadOnlyItemList<PackingItem>> ItemsParameter { get; }
+    ILookupParameter<PackingShape> BinShapeParameter { get; }
+    ILookupParameter<IDecoder<TSol>> DecoderParameter { get; }
+    ILookupParameter<IEvaluator> SolutionEvaluatorParameter { get; }
+    ILookupParameter<BoolValue> UseStackingConstraintsParameter { get; }
+  }
+}
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 14154)
@@ -31,5 +31,5 @@
   [StorableClass]
   public abstract class MoveEvaluatorBase<TSol, TMove> : SingleSuccessorOperator,
-    ISingleObjectiveMoveEvaluator, ISingleObjectiveMoveOperator
+    ISingleObjectiveMoveEvaluator, ISingleObjectiveMoveOperator, IOperator<TSol>
     where TSol : class, IItem
     where TMove : class, IItem {
@@ -43,14 +43,14 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<ReadOnlyItemList<PackingItem>> PackingItemMeasuresParameter {
+    public ILookupParameter<ReadOnlyItemList<PackingItem>> ItemsParameter {
       get { return (LookupParameter<ReadOnlyItemList<PackingItem>>)Parameters["Items"]; }
     }
-    public ILookupParameter<PackingShape> PackingBinMeasuresParameter {
+    public ILookupParameter<PackingShape> BinShapeParameter {
       get { return (LookupParameter<PackingShape>)Parameters["BinShape"]; }
     }
-    public ILookupParameter<IDecoder<TSol>> PackingSolutionDecoderParameter {
+    public ILookupParameter<IDecoder<TSol>> DecoderParameter {
       get { return (ILookupParameter<IDecoder<TSol>>)Parameters["Decoder"]; }
     }
-    public ILookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
+    public ILookupParameter<IEvaluator> SolutionEvaluatorParameter {
       get { return (ILookupParameter<IEvaluator>)Parameters["SolutionEvaluator"]; }
     }
@@ -82,6 +82,6 @@
       var move = MoveParameter.ActualValue;
       var encSolCandidate = EncodedSolutionParameter.ActualValue;
-      var binShape = PackingBinMeasuresParameter.ActualValue;
-      var items = PackingItemMeasuresParameter.ActualValue;
+      var binShape = BinShapeParameter.ActualValue;
+      var items = ItemsParameter.ActualValue;
 
 
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 14154)
@@ -70,7 +70,13 @@
       Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
 
-      Encoding.ConfigureOperators(Operators.OfType<IOperator>()); 
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>());
 
-      // TODO: configure my move evaluators (introduce interface)
+      foreach (var op in Operators.OfType<IOperator<Permutation>>()) {
+        op.BinShapeParameter.ActualName = BinShapeParameter.Name;
+        op.ItemsParameter.ActualName = ItemsParameter.Name;
+        op.SolutionEvaluatorParameter.ActualName = SolutionEvaluatorParameter.Name;
+        op.DecoderParameter.ActualName = DecoderParameter.Name;
+        op.UseStackingConstraintsParameter.ActualName = UseStackingConstraintsParameter.Name;
+      }
     }
 
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 14154)
@@ -50,7 +50,7 @@
       // uses full evaluation
       Swap2Manipulator.Apply(permutation, move.Index1, move.Index2);
-      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
+      var solution = DecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
 
-      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+      return SolutionEvaluatorParameter.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 14154)
@@ -51,7 +51,7 @@
       // uses full evaluation
       TranslocationManipulator.Apply(permutation, move.Index1, move.Index2, move.Index3);
-      var solution = PackingSolutionDecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
+      var solution = DecoderParameter.ActualValue.Decode(permutation, binShape, items, useStackingConstraints);
 
-      return PackingPlanEvaluatorParameter.ActualValue.Evaluate(solution);
+      return SolutionEvaluatorParameter.ActualValue.Evaluate(solution);
     }
   }
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container2DView.xaml.cs	(revision 14154)
@@ -71,6 +71,6 @@
       if (packing == null) return;
       // the container should fill the whole size
-      var scalingX = renderSize.Width / Packing.BinMeasures.Width;
-      var scalingY = renderSize.Height / Packing.BinMeasures.Width;
+      var scalingX = renderSize.Width / Packing.BinShape.Width;
+      var scalingY = renderSize.Height / Packing.BinShape.Width;
       // draw container
       drawingContext.DrawRectangle(Brushes.LightGray, new Pen(Brushes.Black, 1), new Rect(new Point(0, 0), renderSize));
@@ -79,8 +79,8 @@
       var unselectedBrush = selectedItemKey < 0 ? selectedBrush : Brushes.DarkGray;
 
-      foreach (var t in Packing.ItemMeasures) {
+      foreach (var t in Packing.Items) {
         var key = t.Key;
         var item = t.Value;
-        var pos = Packing.ItemPositions[key];
+        var pos = Packing.Positions[key];
 
         var scaledPos = new Point(pos.X * scalingX, pos.Y * scalingY);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml	(revision 14154)
@@ -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="0.6" ScaleY="0.6" ScaleZ="0.6"/>
+                        <ScaleTransform3D x:Name="scaleZoom" CenterX="0.5" CenterY="0.5" CenterZ="0.5" ScaleX="1" ScaleY="1" ScaleZ="1"/>
                     </Transform3DGroup>
                 </ModelVisual3D.Transform>
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Container3DView.xaml.cs	(revision 14154)
@@ -47,5 +47,5 @@
     public Container3DView() {
       InitializeComponent();
-      camMain.Position = new Point3D(0.5, 2, 2); // for design time we use a different camera position 
+      camMain.Position = new Point3D(0.5, 3, 3); // for design time we use a different camera position 
       Clear();
     }
@@ -80,6 +80,6 @@
       //  - from rotation and Z-ordering
 
-      foreach (var item in packing.ItemMeasures.OrderBy(i => packing.ItemPositions[i.Key].Z)) {
-        var position = packing.ItemPositions[item.Key];
+      foreach (var item in packing.Items.OrderBy(i => packing.Positions[i.Key].Z)) {
+        var position = packing.Positions[item.Key];
 
         var w = position.Rotated ? item.Value.Depth : item.Value.Width;
@@ -98,5 +98,5 @@
       }
 
-      var container = packing.BinMeasures;
+      var container = packing.BinShape;
       // draw a transparent container
       AddCube(meshTransparent, container.Origin.X, container.Origin.Y, container.Origin.Z, container.Width, container.Height, container.Depth, addInsideTriangles: true);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlan3DView.cs	(revision 14154)
@@ -67,5 +67,5 @@
       int currentBin = (binSelection != null) ? (int)(binSelection.SelectedIndex) : 0;
       var packing = Content.BinPackings[currentBin];
-      foreach (var item in packing.ItemMeasures) {
+      foreach (var item in packing.Items) {
         itemSelection.Items.Add(item.Key);
       }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14154)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -30,20 +31,20 @@
   [Item("BinPacking", "Represents a single-bin packing for a bin-packing problem.")]
   [StorableClass]
-  public abstract class BinPacking<D, B, I> : Item
-    where D : class, IPackingPosition
-    where B : PackingShape<D>
-    where I : PackingShape<D> {
+  public abstract class BinPacking<TPos, TBin, TItem> : Item
+    where TPos : class, IPackingPosition
+    where TBin : PackingShape<TPos>
+    where TItem : PackingShape<TPos> {
     #region Properties
     [Storable]
-    public ObservableDictionary<int, D> ItemPositions { get; private set; }
+    public ObservableDictionary<int, TPos> Positions { get; private set; }
 
     [Storable]
-    public ObservableDictionary<int, I> ItemMeasures { get; private set; } // TODO: rename to items
+    public ObservableDictionary<int, TItem> Items { get; private set; }
 
     [Storable]
-    public B BinMeasures { get; private set; }
+    public TBin BinShape { get; private set; }
 
     [Storable]
-    public SortedSet<D> ExtremePoints { get; protected set; }
+    public SortedSet<TPos> ExtremePoints { get; protected set; }
 
     [Storable]
@@ -52,11 +53,10 @@
     #endregion Properties
 
-    protected BinPacking(B binMeasures)
+    protected BinPacking(TBin binShape)
       : base() {
-      ItemPositions = new ObservableDictionary<int, D>();
-      ItemMeasures = new ObservableDictionary<int, I>();
-      BinMeasures = (B)binMeasures.Clone();
+      Positions = new ObservableDictionary<int, TPos>();
+      Items = new ObservableDictionary<int, TItem>();
+      BinShape = (TBin)binShape.Clone();
       OccupationLayers = new Dictionary<int, List<int>>();
-      InitializeOccupationLayers(); // TODO
     }
 
@@ -64,30 +64,39 @@
     [StorableConstructor]
     protected BinPacking(bool deserializing) : base(deserializing) { }
-    protected BinPacking(BinPacking<D, B, I> original, Cloner cloner)
+    protected BinPacking(BinPacking<TPos, TBin, TItem> original, Cloner cloner)
       : base(original, cloner) {
-      this.ItemPositions = new ObservableDictionary<int, D>(original.ItemPositions);
-      this.ItemMeasures = new ObservableDictionary<int, I>(original.ItemMeasures);
-      this.BinMeasures = (B)original.BinMeasures.Clone(cloner);
-      this.OccupationLayers = new Dictionary<int, List<int>>(original.OccupationLayers);
+      this.Positions = new ObservableDictionary<int, TPos>();
+      foreach (var kvp in original.Positions) {
+        Positions.Add(kvp.Key, cloner.Clone(kvp.Value));
+      }
+      this.Items = new ObservableDictionary<int, TItem>();
+      foreach (var kvp in original.Items) {
+        Items.Add(kvp.Key, cloner.Clone(kvp.Value));
+      }
+      this.BinShape = (TBin)original.BinShape.Clone(cloner);
+      this.OccupationLayers = new Dictionary<int, List<int>>();
+      foreach (var kvp in original.OccupationLayers) {
+        OccupationLayers.Add(kvp.Key, new List<int>(kvp.Value));
+      }
     }
 
-    protected abstract void GenerateNewExtremePointsForNewItem(I measures, D position);
+    protected abstract void GenerateNewExtremePointsForNewItem(TItem item, TPos position);
 
-    public abstract D FindExtremePointForItem(I measures, bool rotated, bool stackingConstraints);
-    public abstract D FindPositionBySliding(I measures, bool rotated);
+    public abstract TPos FindExtremePointForItem(TItem item, bool rotated, bool stackingConstraints);
+    public abstract TPos FindPositionBySliding(TItem item, bool rotated);
 
-    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<I> itemMeasures);
-    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, Dictionary<int, bool> rotationArray);
-    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, bool stackingConstraints);
-    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<TItem> items);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<TItem> items, Dictionary<int, bool> rotationArray);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<TItem> items, bool stackingConstraints);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<TItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray);
 
-    public void PackItem(int itemID, I measures, D position) {
-      ItemMeasures[itemID] = measures;
-      ItemPositions[itemID] = position;
+    public void PackItem(int itemID, TItem item, TPos position) {
+      Items[itemID] = item;
+      Positions[itemID] = position;
       ExtremePoints.Remove(position);
-      foreach (int id in ItemMeasures.Select(x => x.Key))
-        GenerateNewExtremePointsForNewItem(ItemMeasures[id], ItemPositions[id]);
+      foreach (int id in Items.Select(x => x.Key))
+        GenerateNewExtremePointsForNewItem(Items[id], Positions[id]);
 
-      AddNewItemToOccupationLayers(itemID, measures, position);
+      AddNewItemToOccupationLayers(itemID, item, position);
     }
 
@@ -95,7 +104,7 @@
       get {
         double result = 0;
-        foreach (var entry in ItemMeasures)
+        foreach (var entry in Items)
           result += entry.Value.Volume;
-        result /= BinMeasures.Volume;
+        result /= BinShape.Volume;
         return result;
       }
@@ -103,7 +112,7 @@
 
 
-    public int PointOccupation(D position) {
+    public int PointOccupation(TPos position) {
       foreach (var id in GetLayerItemIDs(position)) {
-        if (ItemMeasures[id].EnclosesPoint(ItemPositions[id], position))
+        if (Items[id].EnclosesPoint(Positions[id], position))
           return id;
       }
@@ -111,18 +120,18 @@
     }
 
-    public bool IsPointOccupied(D position) {
+    public bool IsPointOccupied(TPos position) {
       foreach (var id in GetLayerItemIDs(position)) {
-        if (ItemMeasures[id].EnclosesPoint(ItemPositions[id], position))
+        if (Items[id].EnclosesPoint(Positions[id], position))
           return true;
       }
       return false;
     }
-    public bool IsPositionFeasible(I measures, D position) {
+    public bool IsPositionFeasible(TItem item, TPos position) {
       //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the point is supported by something; 3. the item does not collide with another already packed item
-      if (!BinMeasures.Encloses(position, measures))
+      if (!BinShape.Encloses(position, item))
         return false;
 
-      foreach (var id in GetLayerItemIDs(measures, position)) {
-        if (ItemMeasures[id].Overlaps(ItemPositions[id], position, measures))
+      foreach (var id in GetLayerItemIDs(item, position)) {
+        if (Items[id].Overlaps(Positions[id], position, item))
           return false;
       }
@@ -130,12 +139,12 @@
       return true;
     }
-    public abstract int ShortestPossibleSideFromPoint(D position);
-    public abstract bool IsStaticStable(I measures, D position);
+    public abstract int ShortestPossibleSideFromPoint(TPos position);
+    public abstract bool IsStaticStable(TItem measures, TPos position);
 
 
     protected abstract void InitializeOccupationLayers();
-    protected abstract void AddNewItemToOccupationLayers(int itemID, I measures, D position);
-    protected abstract List<int> GetLayerItemIDs(D position);
-    protected abstract List<int> GetLayerItemIDs(I measures, D position);
+    protected abstract void AddNewItemToOccupationLayers(int itemID, TItem item, TPos position);
+    protected abstract List<int> GetLayerItemIDs(TPos position);
+    protected abstract List<int> GetLayerItemIDs(TItem item, TPos position);
   }
 }
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 14153)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14154)
@@ -86,5 +86,5 @@
 
     public void UpdateBinPackings() {
-      BinPackings.RemoveAll(x => x.ItemPositions.Count == 0);
+      BinPackings.RemoveAll(x => x.Positions.Count == 0);
       BinPackings = new ObservableList<BinPacking<D, B, I>>(BinPackings.OrderByDescending(bp => bp.PackingDensity));
     }
