Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs	(revision 9440)
@@ -0,0 +1,66 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  public static class BottomLeftFunctions {
+    
+
+
+    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+      return BottomLeftPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false);
+    }
+    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {      
+      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, 
+        binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width), 
+        binMeasures.Height - (rotated ? currentItem.Width : currentItem.Height), rotated);
+      //Slide the item as far as possible to the left
+      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+        //Slide the item as far as possible to the bottom
+          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+          currentPosition = MoveDown(currentPosition);
+        }
+          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
+          currentPosition = MoveLeft(currentPosition);
+      }
+
+      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    }
+
+    public static bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
+      TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+      if (!binMeasures.Encloses(currentPosition, currentItem))
+        return false;
+      var itemsWithPositions = itemMeasures.
+        Select((Value, Index) => new { Value, Index }).
+        Where(s => itemPositions.ContainsKey(s.Index)).
+        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
+
+      foreach (var itemWithPosition in itemsWithPositions) {
+        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+          return false;
+      }
+
+      return true;
+    }
+
+    private static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
+      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Rotated);
+    }
+    private static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
+      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Rotated);
+    }
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,146 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftGroupingVectorDecoder(BottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.GroupingVector
+          .Select((Value, Index) => new { Value, Index })
+          .Where(temp => temp.Value == i)
+          .Select(temp => temp.Index).ToList();
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<int>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++ ) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin [binNr];
+        for (int i = 0; i < unpackedItems.Count; i++ ) {
+          var itemIndex = unpackedItems[i];
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+
+          //Did not find enough space in current bin
+          if (position == null) {
+            remainingItems.Add(itemIndex);
+            //if (binNr + 1 >= nrOfBins) {
+            //  nrOfBins++;
+            //  unpackedItemIndexesPerBin[binNr + 1] = new List<int>();
+            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
+            //  unpackedItemIndexesPerBin[binNr].Remove(itemIndex);
+            //} else {
+            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
+            //  unpackedItemIndexesPerBin[binNr + 1].Sort();
+            //}
+            //solution.GroupingVector[itemIndex] = binNr + 1;
+          } else
+            packingPositions[itemIndex] = position;
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<int>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(itemIndex);
+            solution.GroupingVector[itemIndex] = binNr;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          nrOfBins++;
+        }
+      }
+
+      result.PackingItemPositions = packingPositions;
+
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,139 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftMultiComponentVectorDecoder()
+      : base() {
+      //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftMultiComponentVectorDecoder(BottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
+          }
+          if (position == null) {
+            remainingItems.Add(unpackedItems[i]);
+          } else {
+            packingPositions[itemIndex] = position;
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
+          }
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
+          }
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(unpackedItems[i]);
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr;
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          nrOfBins++;
+        }
+      }
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs	(revision 9440)
@@ -0,0 +1,98 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftPackingSequenceDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftPackingSequenceDecoder(BottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      int nrOfBins = 1;
+      for (int i = 0; i < solution.PackingSequence.Length; i++) {
+        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
+        TwoDimensionalPacking position = null;
+        //Look for space in existing bins
+        for (int binNr = 0; binNr < nrOfBins; binNr++) {
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+          if (position != null)
+            break;
+        }
+        //Did not find enough space in any of the existing bins => create new bin
+        if (position == null) {
+          nrOfBins++;
+          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+        }
+
+        if (position == null)
+          position = new TwoDimensionalPacking(-1, 0, 0);
+
+        packingPositions[solution.PackingSequence[i]] = position;
+      }
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 9440)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointGroupingVectorDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder2D(ExtremePointGroupingVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+                      
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointMultiComponentVectorDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder2D(ExtremePointMultiComponentVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointPackingSequenceDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder2D(ExtremePointPackingSequenceDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder2D(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs	(revision 9440)
@@ -0,0 +1,317 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  public static class ExtremPointsFunctions2D {
+
+
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(MultiComponentVectorEncoding solution, 
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.PackingInformations.Max(x => x.AssignedBin) + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector                      
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+      Dictionary<int, HashSet<TwoDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<TwoDimensionalPacking>>();
+      var occupiedPoints = new List<int[,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {        
+        unpackedItemIndexesPerBin[i] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+
+        extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>();
+        extremePointsForBin[i].Add(new TwoDimensionalPacking(i, 0, 0, false));
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      #endregion Preperations
+
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else
+            remainingItems.Add(unpackedItems[i]);
+        }
+      }
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            remainingItems.Remove(unpackedItems[i]);
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<TwoDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();   
+      Dictionary<int, HashSet<TwoDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<TwoDimensionalPacking>>(); 
+      var occupiedPoints = new List<int[,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.GroupingVector
+          .Select((Value, Index) => new { Value, Index })
+          .Where(temp => temp.Value == i)
+          .Select(temp => temp.Index).ToList();
+
+        extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>();
+        extremePointsForBin[i].Add(new TwoDimensionalPacking(i, 0, 0, false));    
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<int>();
+
+      #endregion Preperations
+
+              
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else 
+            remainingItems.Add(itemIndex);
+        }
+      }
+
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<int>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);        
+            remainingItems.Remove(itemIndex);
+          } 
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<TwoDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution, 
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations 
+      var itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();  
+      int nrOfBins = 1;
+
+      var occupiedPoints = new List<int[,]>();
+      occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+
+      HashSet<TwoDimensionalPacking> extremePoints = new HashSet<TwoDimensionalPacking>();
+      extremePoints.Add(new TwoDimensionalPacking(0, 0, 0, false));
+      #endregion
+
+      foreach (int itemIndex in solution.PackingSequence) {
+        var item = itemMeasures[itemIndex];
+        extremePoints = new HashSet<TwoDimensionalPacking>(extremePoints.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+        var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
+        if (positionFound != null) {
+          extremePoints.Remove(positionFound); 
+        }
+        else {
+          positionFound = new TwoDimensionalPacking(nrOfBins, 0, 0);
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+        itemPositions[itemIndex] = positionFound;
+        occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+        extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
+      }
+
+      return itemPositions;
+    }
+
+
+    private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
+        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions) {
+          return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
+    }
+    private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures, 
+        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, bool rotated) {
+
+      var itemFromList = itemMeasures[itemIndex];
+      RectangularPackingItem item = new RectangularPackingItem(
+        rotated ? itemFromList.Height : itemFromList.Width, 
+        rotated ? itemFromList.Width : itemFromList.Height, 
+        itemFromList.TargetBin);
+
+      int epIndex = 0;
+      while (epIndex < extremePoints.Count &&
+        (!BottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures))) 
+      { epIndex++; }
+
+      if (epIndex < extremePoints.Count) {
+        var result = extremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      } 
+      return null;
+    }
+    private static List<int[,]> IncreaseBinCountForOccupiedPoints(List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
+      occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height]);
+      int lastIndex = occupiedPoints.Count - 1;
+      for (int w = 0; w < binMeasures.Width; w++) {
+        for (int h = 0; h < binMeasures.Height; h++) {
+            occupiedPoints[lastIndex][w, h] = -1;
+        }
+      }
+      return occupiedPoints;
+    }
+    private static List<int[,]>  OccupyPointsForNewItem(List<int[,]> occupiedPoints, RectangularPackingItem newItem, TwoDimensionalPacking position, int itemIndex) {
+      int width = position.Rotated ? newItem.Height : newItem.Width; 
+      int height = position.Rotated ? newItem.Width : newItem.Height;
+      for (int w = position.X; w < position.X + width; w++) {
+        for (int h = position.Y; h < position.Y + height; h++) {
+            occupiedPoints[position.AssignedBin][w,h] = itemIndex;
+        }
+      }
+      return occupiedPoints;
+    }
+    private static HashSet<TwoDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, 
+        RectangularPackingItem newItem, TwoDimensionalPacking position, RectangularPackingBin binMeasures) {
+      int currentBin = position.AssignedBin;
+
+      int newWidth = position.Rotated ? newItem.Height : newItem.Width;
+      int newHeight = position.Rotated ? newItem.Width : newItem.Height;
+
+      //Find ExtremePoints beginning from sourcepointX
+      var sourcePointX = new TwoDimensionalPacking(currentBin, position.X + newWidth, position.Y);
+      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height) {
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointX.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointX.X, currentYValue] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new TwoDimensionalPacking(currentBin, sourcePointX.X, currentYValue));
+      }
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointY
+      var sourcePointY = new TwoDimensionalPacking(currentBin, position.X, position.Y + newItem.Height);
+      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height) {
+        //Traversing down the x-axis  
+        int currentXValue = sourcePointY.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointY.Y] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new TwoDimensionalPacking(currentBin, currentXValue, sourcePointY.Y));
+      }
+
+
+      return extremePoints;
+    }
+    private static int ShortestPossibleSideFromEP(TwoDimensionalPacking ep, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
+      int shortestSide = int.MaxValue;
+
+      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height)
+        return shortestSide;
+
+      int currentX = ep.X;
+      while (currentX < binMeasures.Width && occupiedPoints[ep.AssignedBin][currentX, ep.Y] == -1) { currentX++; }   
+      if (currentX - ep.X < shortestSide)
+        shortestSide = currentX - ep.X;
+
+      int currentY = ep.Y;
+      while (currentY < binMeasures.Height && occupiedPoints[ep.AssignedBin][ep.X, currentY] == -1) { currentY++;  }
+      if (currentY - ep.Y < shortestSide)
+        shortestSide = currentY - ep.Y;
+
+      return shortestSide;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs	(revision 9440)
@@ -0,0 +1,143 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  public static class DeepestBottomLeftFunctions {
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.GroupingVector
+          .Select((Value, Index) => new { Value, Index })
+          .Where(temp => temp.Value == i)
+          .Select(temp => temp.Index).ToList();
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<int>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+
+          if (position == null) {
+            remainingItems.Add(itemIndex);
+          } else
+            packingPositions[itemIndex] = position;
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<int>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(itemIndex);
+            //solution.GroupingVector[itemIndex] = binNr;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          nrOfBins++;
+        }
+      }
+
+      return packingPositions;
+    }
+
+
+
+    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
+      return DeepestLeftBottomPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false);
+    }
+    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures, bool rotated) {
+      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
+      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(binNr, 
+        binMeasures.Width - (rotated ? currentItem.Depth : currentItem.Width), 
+        binMeasures.Height - currentItem.Height, 
+        binMeasures.Depth - (rotated ? currentItem.Width : currentItem.Depth), rotated);
+      //Slide the item as far as possible to the bottom
+      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+        //Slide the item as far as possible to the left
+          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+          || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+          //Slide the item as far as possible to the back
+            while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+            currentPosition = MoveBack(currentPosition);
+          }
+            if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
+            currentPosition = MoveLeft(currentPosition);
+        }
+          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures))
+          currentPosition = MoveDown(currentPosition);
+      }
+
+      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    }
+
+    public static bool IsPositionFeasible(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem,
+      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
+      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+      if (!binMeasures.Encloses(currentPosition, currentItem))
+        return false;
+
+      var itemsWithPositions = itemMeasures.
+        Select((Value, Index) => new { Value, Index }).
+        Where(s => itemPositions.ContainsKey(s.Index)).
+        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
+
+      foreach (var itemWithPosition in itemsWithPositions) {
+        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+          return false;
+      }
+
+      return true;
+    }
+
+    private static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
+    }
+    private static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
+    }
+    private static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
+    }
+
+
+  
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,81 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftGroupingVectorDecoder(DeepestBottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(
+        PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking(
+        solution, 
+        PackingBinMeasuresParameter.ActualValue, 
+        PackingItemMeasuresParameter.ActualValue);
+
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,139 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin three dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftMultiComponentVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftMultiComponentVectorDecoder(DeepestBottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
+          }
+          if (position == null) {
+            remainingItems.Add(unpackedItems[i]);
+          } else {
+            packingPositions[itemIndex] = position;
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
+          }
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
+          }
+          if (position != null) {    
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(unpackedItems[i]);
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr;
+            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
+          } 
+        }  
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          nrOfBins++;
+        }
+      }
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 9440)
@@ -0,0 +1,98 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftPackingSequenceDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftPackingSequenceDecoder(DeepestBottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      int nrOfBins = 1;
+      for (int i = 0; i < solution.PackingSequence.Length; i++) {
+        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
+        ThreeDimensionalPacking position = null;
+        //Look for space in existing bins
+        for (int binNr = 0; binNr < nrOfBins; binNr++) {
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+          if (position != null)
+            break;
+        }
+        //Did not find enough space in any of the existing bins => create new bin
+        if (position == null) {
+          nrOfBins++;
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
+        }
+
+        if (position == null)
+          position = new ThreeDimensionalPacking(-1, 0, 0, 0);
+
+        packingPositions[solution.PackingSequence[i]] = position;
+      }
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9440)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointGroupingVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder3D(ExtremePointGroupingVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+                      
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointMultiComponentVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder3D(ExtremePointMultiComponentVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(ref solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointPackingSequenceDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder3D(ExtremePointPackingSequenceDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder3D(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9440)
@@ -0,0 +1,399 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  public static class ExtremePointsFunctions3D {
+
+
+
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution, 
+        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+
+      #region Preperations
+      int lowerBound = solution.PackingInformations.Max(x => x.AssignedBin);
+      int nrOfBins = lowerBound + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector                      
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+      Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
+      var occupiedPoints = new List<int[, ,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {        
+        unpackedItemIndexesPerBin[i] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      #endregion Preperations
+
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else
+            remainingItems.Add(unpackedItems[i]);
+        }
+      }
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            remainingItems.Remove(unpackedItems[i]);
+            if (binNr <= lowerBound) {
+              InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
+            }
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref MultiComponentVectorEncoding solution, int itemIndex, int binNr) {
+      var itemgene = solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex);
+      solution.PackingInformations.Remove (itemgene);
+      itemgene.AssignedBin = binNr;
+      int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);
+      solution.PackingInformations.Insert(targetIndex + 1, itemgene);
+    }
+
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
+        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();   
+      Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>(); 
+      var occupiedPoints = new List<int[, ,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.GroupingVector
+          .Select((Value, Index) => new { Value, Index })
+          .Where(temp => temp.Value == i)
+          .Select(temp => temp.Index).ToList();
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));    
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<int>();
+
+      #endregion Preperations
+
+              
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else 
+            remainingItems.Add(itemIndex);
+        }
+      }
+
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<int>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);        
+            remainingItems.Remove(itemIndex);
+          } 
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution, 
+        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+
+      #region Preperations 
+      var itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();  
+      int nrOfBins = 1;
+
+      var occupiedPoints = new List<int[, ,]>();
+      occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+
+      HashSet<ThreeDimensionalPacking> extremePoints = new HashSet<ThreeDimensionalPacking>();
+      extremePoints.Add(new ThreeDimensionalPacking(0, 0, 0, 0, false));
+      #endregion
+
+      foreach (int itemIndex in solution.PackingSequence) {
+        var item = itemMeasures[itemIndex];
+        extremePoints = new HashSet<ThreeDimensionalPacking>(extremePoints.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+        var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
+        if (positionFound != null) {
+          extremePoints.Remove(positionFound); 
+        }
+        else {
+          positionFound = new ThreeDimensionalPacking(nrOfBins, 0, 0, 0);
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+        itemPositions[itemIndex] = positionFound;
+        occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+        extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
+      }
+
+      return itemPositions;
+    }
+
+
+    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
+        HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions) {
+          return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
+    }
+    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
+        HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
+
+      var itemFromList = itemMeasures[itemIndex];
+      CuboidPackingItem item = new CuboidPackingItem(
+        rotated ? itemFromList.Depth : itemFromList.Width, 
+        itemFromList.Height, 
+        rotated ? itemFromList.Width : itemFromList.Depth, 
+        itemFromList.TargetBin);
+
+      int epIndex = 0;
+      while (epIndex < extremePoints.Count &&
+        (!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
+        !IsStaticStable(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex)))) 
+      { epIndex++; }
+
+      if (epIndex < extremePoints.Count) {
+        var result = extremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      } 
+      return null;
+    }
+    private static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+      occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth]);
+      int lastIndex = occupiedPoints.Count - 1;
+      for (int w = 0; w < binMeasures.Width; w++) {
+        for (int h = 0; h < binMeasures.Height; h++) {
+          for (int d = 0; d < binMeasures.Depth; d++) {
+            occupiedPoints[lastIndex][w, h, d] = -1;
+          }
+        }
+      }
+      return occupiedPoints;
+    }
+    private static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
+      //Static stability is given, if item is placed on the ground
+      if (ep.Y == 0)
+        return true;
+
+      if (occupiedPoints[ep.X, ep.Y - 1, ep.Z] != -1 
+        && occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.Z] != -1 
+        && occupiedPoints[ep.X, ep.Y - 1, ep.Z + item.Depth - 1] != -1 
+        && occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.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;
+    }
+    private static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
+      int width = position.Rotated ? newItem.Depth : newItem.Width; 
+      int depth = position.Rotated ? newItem.Width : newItem.Depth;
+      for (int w = position.X; w < position.X + width; w++) {
+        for (int h = position.Y; h < position.Y + newItem.Height; h++) {
+          for (int d = position.Z; d < position.Z + depth; d++) {
+            occupiedPoints[position.AssignedBin][w,h,d] = itemIndex;
+          }
+        }
+      }
+      return occupiedPoints;
+    }
+    private static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
+        CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) {
+      int currentBin = position.AssignedBin;
+
+      int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
+      int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
+
+      //Find ExtremePoints beginning from sourcepointX
+      var sourcePointX = new ThreeDimensionalPacking(currentBin, position.X + newWidth, position.Y, position.Z);
+      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height && sourcePointX.Z < binMeasures.Depth) {
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointX.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointX.X, currentYValue, sourcePointX.Z] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointX.X, currentYValue, sourcePointX.Z));
+
+        //Traversing down the z-axis
+        int currentZValue = sourcePointX.Z;
+        while (currentZValue > 0 && occupiedPoints[currentBin][sourcePointX.X, sourcePointX.Y, currentZValue - 1] == -1) {
+          currentZValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointX.X, sourcePointX.Y, currentZValue));
+      }
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointY
+      var sourcePointY = new ThreeDimensionalPacking(currentBin, position.X, position.Y + newItem.Height, position.Z);
+      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height && sourcePointY.Z < binMeasures.Depth) {
+        //Traversing down the x-axis  
+        int currentXValue = sourcePointY.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointY.Y, sourcePointY.Z] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, currentXValue, sourcePointY.Y, sourcePointY.Z));
+
+        //Traversing down the z-axis
+        int currentZValue = sourcePointY.Z;
+        while (currentZValue > 0 && occupiedPoints[currentBin][sourcePointY.X, sourcePointY.Y, currentZValue - 1] == -1) {
+          currentZValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointY.X, sourcePointY.Y, currentZValue));
+      }
+
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointZ
+      var sourcePointZ = new ThreeDimensionalPacking(currentBin, 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  
+        int currentXValue = sourcePointZ.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointZ.Y, sourcePointZ.Z] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, currentXValue, sourcePointZ.Y, sourcePointZ.Z));
+
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointZ.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointZ.X, currentYValue, sourcePointZ.Z] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointZ.X, currentYValue, sourcePointZ.Z));
+      }
+
+
+      return extremePoints;
+    }
+    private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+      int shortestSide = int.MaxValue;
+
+      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height || ep.Z >= binMeasures.Depth)
+        return shortestSide;
+
+      int currentX = ep.X;
+      while (currentX < binMeasures.Width && occupiedPoints[ep.AssignedBin][currentX, ep.Y, ep.Z] == -1) { currentX++; }   
+      if (currentX - ep.X < shortestSide)
+        shortestSide = currentX - ep.X;
+
+      int currentY = ep.Y;
+      while (currentY < binMeasures.Height && occupiedPoints[ep.AssignedBin][ep.X, currentY, ep.Z] == -1) { currentY++;  }
+      if (currentY - ep.Y < shortestSide)
+        shortestSide = currentY - ep.Y;
+
+      int currentZ = ep.Z;
+      while (currentZ < binMeasures.Depth && occupiedPoints[ep.AssignedBin][ep.X, ep.Y, currentZ] == -1) { currentZ++; }
+      if (currentZ - ep.Z < shortestSide)
+        shortestSide = currentZ - ep.Z;
+
+      return shortestSide;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs	(revision 9440)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,160 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Lowest Gap Fill Grouping-Vector Decoder", "<Description missing...>")]
+  [StorableClass]
+  public class IB2DLowestGapFillGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public IB2DLowestGapFillGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected IB2DLowestGapFillGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected IB2DLowestGapFillGroupingVectorDecoder(IB2DLowestGapFillGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IB2DLowestGapFillGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as IntegerVector;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      var binMeasures = PackingBinMeasuresParameter.ActualValue;
+      var itemMeasures = PackingItemMeasuresParameter.ActualValue;
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+
+      int nrOfBins = solution.Max();
+
+      //Get all indexes of items for every bin according to grouping-vector
+      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin              = new Dictionary<int, List<int>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution
+          .Select((Value, Index) => new { Value, Index })
+          .Where (temp => temp.Value == i)
+          .Select (temp => temp.Index).ToList();  
+      }
+
+
+
+      //Steps 1-6
+      //2
+      int currentBin = 0;    
+      
+      //3
+      //Take the first position from the first bin
+      TwoDimensionalPacking currentPoint = new TwoDimensionalPacking(currentBin, 0, 0);
+   
+      //4
+      //Assuming that Height is always the shorter edge due to normalizing..
+      int currentGap = binMeasures.Height;
+
+      //5
+      //Take the first (and largest) item for the first bin
+      int currentItemIndex = unpackedItemIndexesPerBin[currentBin][0];
+      RectangularPackingItem currentItem = itemMeasures[currentItemIndex];
+      packingPositions[currentItemIndex] = currentPoint;
+      //6
+      unpackedItemIndexesPerBin[currentBin].RemoveAt(0);
+
+
+      //Steps 7-13          
+
+      //TODO: the first parameter (bin-list) is not finished yet.. it should resemble the used bins in the packing plan..
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(
+          binMeasures, 
+          itemMeasures);
+
+      result.PackingItemPositions = packingPositions;
+      return result;
+    }
+
+    //protected override TwoDimensionalPacking FindFeasiblePositionForItem(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+    //  //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
+    //  TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height);           
+    //  //Slide the item as far as possible to the bottom
+    //  while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+    //    currentPosition = MoveDown(currentPosition);
+    //  }
+    //  //Slide the item as far as possible to the left
+    //  while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)) {
+    //    currentPosition = MoveLeft(currentPosition);
+    //  }
+
+    //  return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    //}
+
+    //private bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
+    //  TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+    //  //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+    //  if (!binMeasures.Encloses(currentPosition, currentItem))
+    //    return false;
+    //  var itemsWithPositions = itemMeasures.
+    //    Select((Value, Index) => new { Value, Index }).
+    //    Where(s => itemPositions.ContainsKey(s.Index)).
+    //    Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index]});
+
+    //  foreach (var itemWithPosition in itemsWithPositions) {
+    //    if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+    //      return false;
+    //  }
+    //  return true;
+    //}
+
+    //private TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
+    //  return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y);
+    //}
+    //private TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
+    //  return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1);
+    //}
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs	(revision 9348)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs	(revision 9440)
@@ -31,5 +31,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Data;
 using HeuristicLab.Collections;
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingHeuristics.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingHeuristics.cs	(revision 9348)
+++ 	(revision )
@@ -1,114 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  public static class PackingHeuristics {
-    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
-      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height);
-      //Slide the item as far as possible to the left
-      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
-        //Slide the item as far as possible to the bottom
-        while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
-          currentPosition = MoveDown(currentPosition);
-        }
-        if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
-          currentPosition = MoveLeft(currentPosition);
-      }
-
-      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
-    }
-
-    private static bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
-      TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
-      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
-      if (!binMeasures.Encloses(currentPosition, currentItem))
-        return false;
-      var itemsWithPositions = itemMeasures.
-        Select((Value, Index) => new { Value, Index }).
-        Where(s => itemPositions.ContainsKey(s.Index)).
-        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
-
-      foreach (var itemWithPosition in itemsWithPositions) {
-        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
-          return false;
-      }
-
-      return true;
-    }
-
-    private static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y);
-    }
-    private static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1);
-    }
-
-
-
-
-
-
-    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
-      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height, binMeasures.Depth - currentItem.Depth);
-
-      //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-        //Slide the item as far as possible to the left
-        while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-          || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-          //Slide the item as far as possible to the back
-          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-            currentPosition = MoveBack(currentPosition);
-          }
-          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
-            currentPosition = MoveLeft(currentPosition);
-        }
-        if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures))
-          currentPosition = MoveDown(currentPosition);
-      }
-
-      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
-    }
-
-    private static bool IsPositionFeasible(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem,
-      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
-      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
-      if (!binMeasures.Encloses(currentPosition, currentItem))
-        return false;
-
-      var itemsWithPositions = itemMeasures.
-        Select((Value, Index) => new { Value, Index }).
-        Where(s => itemPositions.ContainsKey(s.Index)).
-        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
-
-      foreach (var itemWithPosition in itemsWithPositions) {
-        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
-          return false;
-      }
-
-      return true;
-    }
-
-    private static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z);
-    }
-    private static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z);
-    }
-    private static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftGroupingVectorDecoder.cs	(revision 9348)
+++ 	(revision )
@@ -1,130 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")]
-  [StorableClass]
-  public class ThreeDimensionalBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
-      ThreeDimensionalPacking,
-      CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
-
-    public ThreeDimensionalBottomLeftGroupingVectorDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected ThreeDimensionalBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalBottomLeftGroupingVectorDecoder(ThreeDimensionalBottomLeftGroupingVectorDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalBottomLeftGroupingVectorDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as GroupingVectorEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
-
-      RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-      int nrOfBins = solution.GroupingVector.Max() + 1;
-
-      //Get all indexes of items for every bin according to grouping-vector
-      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
-      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
-
-      for (int i = 0; i < nrOfBins; i++) {
-        unpackedItemIndexesPerBin[i] = solution.GroupingVector
-          .Select((Value, Index) => new { Value, Index })
-          .Where(temp => temp.Value == i)
-          .Select(temp => temp.Index).ToList();
-      }
-
-      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-      var remainingItems = new List<int>();
-
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins; binNr++) {
-        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-        var unpackedItems = unpackedItemIndexesPerBin[binNr];
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          ThreeDimensionalPacking position = null;
-
-          position = PackingHeuristics.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          if (position == null) {
-            remainingItems.Add(itemIndex);
-          } else
-            packingPositions[itemIndex] = position;
-        }
-      }
-
-      //Packing of remaining items
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-        var unpackedItems = new List<int>(remainingItems);
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          ThreeDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = PackingHeuristics.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          if (position != null) {    
-            packingPositions[itemIndex] = position;
-            remainingItems.Remove(itemIndex);
-            solution.GroupingVector[itemIndex] = binNr;
-          } 
-        }  
-        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-          nrOfBins++;
-        }
-      }
-
-      result.PackingItemPositions = packingPositions;
-
-      return result;
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftPackingSequenceDecoder.cs	(revision 9348)
+++ 	(revision )
@@ -1,97 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")]
-  [StorableClass]
-  public class ThreeDimensionalBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
-      ThreeDimensionalPacking,
-      CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
-
-    public ThreeDimensionalBottomLeftPackingSequenceDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected ThreeDimensionalBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalBottomLeftPackingSequenceDecoder(ThreeDimensionalBottomLeftPackingSequenceDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalBottomLeftPackingSequenceDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
-
-      RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-
-      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-      int nrOfBins = 1;
-      for (int i = 0; i < solution.PackingSequence.Length; i++) {
-        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
-        ThreeDimensionalPacking position = null;
-        //Look for space in existing bins
-        for (int binNr = 0; binNr < nrOfBins; binNr++) {
-          position = PackingHeuristics.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-          if (position != null)
-            break;
-        }
-        //Did not find enough space in any of the existing bins => create new bin
-        if (position == null) {
-          nrOfBins++;
-          position = PackingHeuristics.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-        }
-
-        if (position == null)
-          position = new ThreeDimensionalPacking(-1, 0, 0, 0);
-
-        packingPositions[solution.PackingSequence[i]] = position;
-      }
-
-      result.PackingItemPositions = packingPositions;
-
-      return result;
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftGroupingVectorDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftGroupingVectorDecoder.cs	(revision 9348)
+++ 	(revision )
@@ -1,146 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
-  [StorableClass]
-  public class TwoDimensionalBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
-      TwoDimensionalPacking,
-      RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
-
-    public TwoDimensionalBottomLeftGroupingVectorDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected TwoDimensionalBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
-    protected TwoDimensionalBottomLeftGroupingVectorDecoder(TwoDimensionalBottomLeftGroupingVectorDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TwoDimensionalBottomLeftGroupingVectorDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as GroupingVectorEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
-
-      RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-
-      int nrOfBins = solution.GroupingVector.Max() + 1;
-
-      //Get all indexes of items for every bin according to grouping-vector
-      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
-      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
-
-      for (int i = 0; i < nrOfBins; i++) {
-        unpackedItemIndexesPerBin[i] = solution.GroupingVector
-          .Select((Value, Index) => new { Value, Index })
-          .Where(temp => temp.Value == i)
-          .Select(temp => temp.Index).ToList();
-      }
-
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      var remainingItems = new List<int>();
-
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins; binNr++ ) {
-        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-        var unpackedItems = unpackedItemIndexesPerBin [binNr];
-        for (int i = 0; i < unpackedItems.Count; i++ ) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = PackingHeuristics.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          //Did not find enough space in current bin
-          if (position == null) {
-            remainingItems.Add(itemIndex);
-            //if (binNr + 1 >= nrOfBins) {
-            //  nrOfBins++;
-            //  unpackedItemIndexesPerBin[binNr + 1] = new List<int>();
-            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
-            //  unpackedItemIndexesPerBin[binNr].Remove(itemIndex);
-            //} else {
-            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
-            //  unpackedItemIndexesPerBin[binNr + 1].Sort();
-            //}
-            //solution.GroupingVector[itemIndex] = binNr + 1;
-          } else
-            packingPositions[itemIndex] = position;
-        }
-      }
-
-      //Packing of remaining items
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-        var unpackedItems = new List<int>(remainingItems);
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = PackingHeuristics.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          if (position != null) {
-            packingPositions[itemIndex] = position;
-            remainingItems.Remove(itemIndex);
-            solution.GroupingVector[itemIndex] = binNr;
-          }
-        }
-        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-          nrOfBins++;
-        }
-      }
-
-      result.PackingItemPositions = packingPositions;
-
-
-      return result;
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftPackingSequenceDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftPackingSequenceDecoder.cs	(revision 9348)
+++ 	(revision )
@@ -1,99 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
-  [StorableClass]
-  public class TwoDimensionalBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
-      TwoDimensionalPacking,
-      RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
-
-    public TwoDimensionalBottomLeftPackingSequenceDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected TwoDimensionalBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
-    protected TwoDimensionalBottomLeftPackingSequenceDecoder(TwoDimensionalBottomLeftPackingSequenceDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TwoDimensionalBottomLeftPackingSequenceDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
-
-      RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      int nrOfBins = 1;
-      //foreach (RectangularPackingItem item in PackingItemMeasuresParameter.ActualValue) {   
-      for (int i = 0; i < solution.PackingSequence.Length; i++) {
-        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
-        TwoDimensionalPacking position = null;
-        //Look for space in existing bins
-        for (int binNr = 0; binNr < nrOfBins; binNr++) {
-          position = PackingHeuristics.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-          if (position != null)
-            break;
-        }
-        //Did not find enough space in any of the existing bins => create new bin
-        if (position == null) {
-          nrOfBins++;
-          position = PackingHeuristics.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-        }
-
-        if (position == null)
-          position = new TwoDimensionalPacking(-1, 0, 0);
-
-        packingPositions[solution.PackingSequence[i]] = position;
-      }
-
-      result.PackingItemPositions = packingPositions;
-
-      return result;
-    }
-  }
-}
