Changeset 9563

Timestamp:

06/02/13 04:26:26 (11 years ago)

Author:

jhelm

Message:

#1966: Implemented additional Operator-Wrappers for PackingSequence and GroupingVector; Implemented additional problem-class for Rosenbauer-Problemstatement; Added marker-interfaces for decoder-types;

Location:

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3

Files:

• Analyzers/BestBinPackingSolutionAnalyzer.cs (modified) (3 diffs)
• Decoders/2D/BL/BottomLeftFunctions.cs (modified) (1 diff)
• Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs (modified) (3 diffs)
• Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs (modified) (3 diffs)
• Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs (modified) (3 diffs)
• Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs (modified) (2 diffs)
• Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs (modified) (2 diffs)
• Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs (modified) (3 diffs)
• Decoders/2D/EP/ExtremePointsFunctions2D.cs (modified) (1 diff)
• Decoders/3D/DBL/DeepestBottomLeftFunctions.cs (modified) (1 diff)
• Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs (modified) (3 diffs)
• Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs (modified) (3 diffs)
• Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs (modified) (3 diffs)
• Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs (modified) (2 diffs)
• Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs (modified) (2 diffs)
• Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs (modified) (3 diffs)
• Decoders/3D/EP/ExtremePointPotvinDecoder3D.cs (deleted)
• Decoders/3D/EP/ExtremePointsFunctions3D.cs (modified) (4 diffs)
• Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs (modified) (6 diffs)
• Decoders/IdenticalBinPackingSolutionDecoder.cs (deleted)
• Decoders/PackingSolutionDecoder.cs (modified) (3 diffs)
• Encodings/GroupingVector/GroupingVectorCrossover.cs (modified) (2 diffs)
• Encodings/GroupingVector/GroupingVectorDiscreteCrossover.cs (added)
• Encodings/GroupingVector/GroupingVectorOnePositionManipulator.cs (added)
• Encodings/GroupingVector/GroupingVectorRandomCreator.cs (modified) (1 diff)
• Encodings/GroupingVector/GroupingVectorSinglePointCrossover.cs (added)
• Encodings/GroupingVector/GroupingVectorSwap2Manipulator.cs (added)
• Encodings/GroupingVector/Moves/ChangeGrouping (added)
• Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs (added)
• Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs (added)
• Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/Moves/GroupingMove.cs (added)
• Encodings/GroupingVector/Moves/GroupingMoveAttribute.cs (added)
• Encodings/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs (added)
• Encodings/GroupingVector/Moves/GroupingMoveMaker.cs (added)
• Encodings/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs (added)
• Encodings/GroupingVector/Moves/GroupingTabuMaker.cs (added)
• Encodings/GroupingVector/Moves/SingleGrouping (deleted)
• Encodings/GroupingVector/Moves/SwapGrouping (added)
• Encodings/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs (added)
• Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs (added)
• Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs (added)
• Encodings/GroupingVector/UniformGroupingVectorManipulator.cs (deleted)
• Encodings/MultiComponentVector/BinBasedMultiComponentVectorCrossover.cs (added)
• Encodings/MultiComponentVector/ExperimentalMultiComponentVectorCrossover.cs (added)
• Encodings/MultiComponentVector/Moves/Multi (added)
• Encodings/MultiComponentVector/Moves/Multi/Attributes (added)
• Encodings/MultiComponentVector/Moves/Multi/Attributes/ChangePositionMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Attributes/SingleGroupingMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Attributes/SingleItemRotationMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Attributes/SwapPositionMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/ExhaustiveMultiComponentVectorMoveGenerator.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Moves (added)
• Encodings/MultiComponentVector/Moves/Multi/Moves/ChangePositionMove.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Moves/SingleGroupingMove.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Moves/SingleItemRotationMove.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/Moves/SwapPositionMove.cs (added)
• Encodings/MultiComponentVector/Moves/Multi/StochasticMultiComponentVectorMoveGenerator.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMove.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMoveGenerator.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMoveHardTabuCriterion.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMoveMaker.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorMoveSoftTabuCriterion.cs (added)
• Encodings/MultiComponentVector/Moves/MultiComponentVectorTabuMaker.cs (added)
• Encodings/MultiComponentVector/Moves/ThreeWay (deleted)
• Encodings/MultiComponentVector/Moves/Triple (added)
• Encodings/MultiComponentVector/Moves/Triple/Attributes (added)
• Encodings/MultiComponentVector/Moves/Triple/Attributes/MCVTripleMoveAttribute.cs (added)
• Encodings/MultiComponentVector/Moves/Triple/ExhaustiveMCVTripleMoveGenerator.cs (added)
• Encodings/MultiComponentVector/Moves/Triple/Moves (added)
• Encodings/MultiComponentVector/Moves/Triple/Moves/MCVTripleMove.cs (added)
• Encodings/MultiComponentVector/Moves/Triple/StochasticMCVTripleMoveGenerator.cs (added)
• Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs (modified) (3 diffs)
• Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs (modified) (1 diff)
• Encodings/MultiComponentVector/SequenceBasedMultiComponentVectorCrossover.cs (added)
• Encodings/MultiComponentVector/SequencePreservingMultiComponentVectorCrossover.cs (deleted)
• Encodings/PackingPlans/PackingPlan.cs (modified) (2 diffs)
• Encodings/PackingSequence/Moves (added)
• Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs (added)
• Encodings/PackingSequence/Moves/GroupingMoveMaker.cs (added)
• Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs (added)
• Encodings/PackingSequence/Moves/Insertion (added)
• Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs (added)
• Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs (added)
• Encodings/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs (added)
• Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs (added)
• Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs (added)
• Encodings/PackingSequence/Moves/SequenceMove.cs (added)
• Encodings/PackingSequence/Moves/SequenceMoveAttribute.cs (added)
• Encodings/PackingSequence/Moves/SequenceTabuMaker.cs (added)
• Encodings/PackingSequence/Moves/Swap2 (added)
• Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs (added)
• Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs (added)
• Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs (added)
• Encodings/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs (added)
• Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs (added)
• Encodings/PackingSequence/PackingSequenceCrossover.cs (modified) (2 diffs)
• Encodings/PackingSequence/PackingSequenceEncoding.cs (modified) (3 diffs)
• Encodings/PackingSequence/PackingSequenceInsertionManipulator.cs (added)
• Encodings/PackingSequence/PackingSequenceManipulator.cs (modified) (2 diffs)
• Encodings/PackingSequence/PackingSequenceOrderCrossover.cs (added)
• Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs (added)
• Encodings/PackingSequence/PackingSequenceRandomCreator.cs (modified) (1 diff)
• Encodings/PackingSequence/PackingSequenceSwap2Manipulator.cs (added)
• Encodings/PackingSolutionCreator.cs (modified) (3 diffs)
• Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs (modified) (1 diff)
• Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs (modified) (2 diffs)
• HeuristicLab.Problems.BinPacking-3.3.csproj (modified) (5 diffs)
• Instances/RealBPPData.cs (added)
• Interfaces/DecoderInterfaces (added)
• Interfaces/DecoderInterfaces/I2DGVDecoder.cs (added)
• Interfaces/DecoderInterfaces/I2DMCVDecoder.cs (added)
• Interfaces/DecoderInterfaces/I2DPSDecoder.cs (added)
• Interfaces/DecoderInterfaces/I3DGVDecoder.cs (added)
• Interfaces/DecoderInterfaces/I3DMCVDecoder.cs (added)
• Interfaces/DecoderInterfaces/I3DPSDecoder.cs (added)
• Interfaces/IPackingItem.cs (modified) (1 diff)
• Interfaces/IPackingSequenceMoveOperator.cs (added)
• Interfaces/IPackingSolutionCreator.cs (modified) (1 diff)
• MoveEvaluators/PackingMoveEvaluator.cs (modified) (1 diff)
• MoveEvaluators/PackingMoveEvaluator2DPS.cs (added)
• MoveEvaluators/PackingMoveEvaluator3DPS.cs (added)
• PackingItem/CuboidPackingItem.cs (modified) (4 diffs)
• PackingItem/RectangularPackingItem.cs (modified) (3 diffs)
• Plugin.cs (modified) (1 diff)
• Problem/CuboidIdenticalBinPackingProblem.cs (modified) (3 diffs)
• Problem/ISOContainerBinPackingProblem.cs (modified) (5 diffs)
• Problem/RectangularIdenticalBinPackingProblem.cs (modified) (2 diffs)
• Problem/RegularIdenticalBinPackingProblem.cs (modified) (4 diffs)
• Shapes/CuboidPackingShape.cs (modified) (1 diff)

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs

@@ -34 +34 @@
 using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Problems.BinPacking.Evaluators;
 
 namespace HeuristicLab.Problems.BinPacking.Analyzers {     
@@ -40 +41 @@
   public class BestBinPackingSolutionAnalyzer<D, B, I> : BinPackingAnalyzer<D, B, I>, IStochasticOperator
     where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin
-    where I : PackingShape<D>, IPackingItem {
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
 
     protected BestBinPackingSolutionAnalyzer(BestBinPackingSolutionAnalyzer<D,B,I> original, Cloner cloner)
@@ -93 +94 @@
           bestSolution.Quality.Value = qualities[i].Value;
           bestSolution.PackingItemPositions = new ObservableDictionary<int, D> (solutions[i].PackingItemPositions);
+          bestSolution.PackingBinMeasures = new ObservableDictionary<int, B>(solutions[i].PackingBinMeasures);
         }
       }
+      string binUtilKey = "Overall Bin Utilization";
+      DoubleValue binUtil = BinUtilizationRegularIdenticalBinEvaluator<D, B, I>.CalculateBinUtilization(bestSolution);
+      if (!results.ContainsKey("Overall Bin Utilization"))
+        results.Add(new Result(binUtilKey, binUtil));
+      else
+        results[binUtilKey].Value = binUtil;
 
       return base.Apply();

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs

@@ -8 +8 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs

@@ -44 +44 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DGVDecoder {
 
     public BottomLeftGroupingVectorDecoder()
@@ -60 +60 @@
 
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as GroupingVectorEncoding;
@@ -66 +66 @@
 
       PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
 
       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs

@@ -44 +44 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DMCVDecoder {
 
     public BottomLeftMultiComponentVectorDecoder()
@@ -60 +60 @@
 
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
@@ -66 +66 @@
 
       PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
-        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
       
       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs

@@ -43 +43 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DPSDecoder {
 
     public BottomLeftPackingSequenceDecoder()
@@ -59 +59 @@
 
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -65 +65 @@
 
       PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
 
       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking (solution, binMeasures, itemMeasures);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs

@@ -44 +44 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DGVDecoder {
 
     public ExtremePointGroupingVectorDecoder2D ()
@@ -67 +67 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
                       
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs

@@ -45 +45 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DMCVDecoder {
 
     public ExtremePointMultiComponentVectorDecoder2D ()
@@ -68 +68 @@
     }
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs

@@ -43 +43 @@
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem> {
+      RectangularPackingItem>, I2DPSDecoder {
 
     public ExtremePointPackingSequenceDecoder2D ()
@@ -58 +58 @@
 
 
-    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -64 +64 @@
 
       PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
 
-      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
 
       return result;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs

@@ -8 +8 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs

@@ -8 +8 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs

@@ -43 +43 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DGVDecoder {
 
     public DeepestBottomLeftGroupingVectorDecoder()
@@ -59 +59 @@
 
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as GroupingVectorEncoding;
@@ -65 +65 @@
 
       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(
-        PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        binMeasures, itemMeasures);
 
       ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking(
         solution, 
-        PackingBinMeasuresParameter.ActualValue, 
-        PackingItemMeasuresParameter.ActualValue);
+        binMeasures, 
+        itemMeasures);
 
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs

@@ -44 +44 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DMCVDecoder {
 
     public DeepestBottomLeftMultiComponentVectorDecoder()
@@ -60 +60 @@
 
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
@@ -66 +66 @@
 
       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
-        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
       
       result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs

@@ -43 +43 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DPSDecoder {
 
     public DeepestBottomLeftPackingSequenceDecoder()
@@ -59 +59 @@
 
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -65 +65 @@
 
       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
-        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
 
       result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs

@@ -44 +44 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DGVDecoder {
 
     public ExtremePointGroupingVectorDecoder3D ()
@@ -67 +67 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
                       
       var solution = encodedSolution as GroupingVectorEncoding;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs

@@ -45 +45 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DMCVDecoder {
 
     public ExtremePointMultiComponentVectorDecoder3D ()
@@ -68 +68 @@
     }
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs

@@ -43 +43 @@
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem> {
+      CuboidPackingItem>, I3DPSDecoder {
 
     public ExtremePointPackingSequenceDecoder3D ()
@@ -58 +58 @@
 
 
-    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -64 +64 @@
 
       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
-        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
 
-      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
 
       return result;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs

@@ -9 +9 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;
@@ -221 +222 @@
           return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
     }
+    public static ThreeDimensionalPacking FindExtremePointForItemUsingMaterialAndWeightConstraint(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, itemFromList.Weight, itemFromList.Material);
+
+      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)) ||
+        !WeightIsSupported(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex), itemMeasures))) { epIndex++; }
+
+      if (epIndex < extremePoints.Count) {
+        var result = extremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      }
+      return null;
+    }
     public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
         HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
@@ -228 +252 @@
         rotated ? itemFromList.Depth : itemFromList.Width, 
         itemFromList.Height, 
-        rotated ? itemFromList.Width : itemFromList.Depth, 
+        rotated ? itemFromList.Width : itemFromList.Depth,
         itemFromList.TargetBin);
 
@@ -280 +304 @@
       return false;
     }
+    public static bool WeightIsSupported(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep, ItemList<CuboidPackingItem> items) {
+      //Static stability is given, if item is placed on the ground
+      if (ep.Y == 0)
+        return true;
+
+      if (items[occupiedPoints[ep.X, ep.Y - 1, ep.Z]].SupportsStacking(item)
+        && items[occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.Z]].SupportsStacking(item)
+        && items[occupiedPoints[ep.X, ep.Y - 1, ep.Z + item.Depth - 1]].SupportsStacking(item)
+        && items[occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1]].SupportsStacking(item))
+        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;
+    }
     public static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
       int width = position.Rotated ? newItem.Depth : newItem.Width; 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs

@@ -40 +40 @@
 
 namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [Item("ISO container decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ISOContainerMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ISOContainerMultiComponentVectorDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem>, I3DMCVDecoder {
 
     public ISOContainerMultiComponentVectorDecoder3D ()
@@ -60 +59 @@
     }
 
-    public static MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       
-      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
-        new MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(new ObservableDictionary<int, CuboidPackingBin>(), itemMeasures);
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(new ObservableDictionary<int, CuboidPackingBin>(), itemMeasures);
 
       #region Preperations
       int nrOfBins = solution.NrOfBins;
-
-      //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>>();
+      Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();  
+      ObservableDictionary<int, CuboidPackingBin> resultingBinMeasures = new ObservableDictionary<int, CuboidPackingBin>();
       var occupiedPoints = new List<int[, ,]>();
 
@@ -79 +78 @@
         extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
         occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+        resultingBinMeasures[i] = new CuboidPackingBin(binMeasures.Width, binMeasures.Height, binMeasures.Depth);
       }
 
@@ -95 +95 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, resultingBinMeasures[binNr]);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItemUsingMaterialAndWeightConstraint(itemIndex, itemMeasures, resultingBinMeasures[binNr], extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+
+          if (positionFound == null && resultingBinMeasures[binNr].Depth.Equals(binMeasures.Depth)) {
+            occupiedPoints = DoubleDepthForBinNr(occupiedPoints, ref resultingBinMeasures, binNr);
+            positionFound = ExtremePointsFunctions3D.FindExtremePointForItemUsingMaterialAndWeightConstraint(itemIndex, itemMeasures, resultingBinMeasures[binNr], extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          } 
+
           if (positionFound != null) {
             extremePointsForBin[binNr].Remove(positionFound);
             itemPositions[itemIndex] = positionFound;
             occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, resultingBinMeasures[binNr]);
           } else {
             remainingItems.Add(unpackedItems[i]);
-            //solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
           }
         }
@@ -119 +125 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, resultingBinMeasures[binNr]);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItemUsingMaterialAndWeightConstraint(itemIndex, itemMeasures, resultingBinMeasures[binNr], extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+
+
+          if (positionFound == null && resultingBinMeasures[binNr].Depth.Equals(binMeasures.Depth)) {
+            occupiedPoints = DoubleDepthForBinNr(occupiedPoints, ref resultingBinMeasures, binNr);
+            positionFound = ExtremePointsFunctions3D.FindExtremePointForItemUsingMaterialAndWeightConstraint(itemIndex, itemMeasures, resultingBinMeasures[binNr], extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          } 
+          
           if (positionFound != null) {
             extremePointsForBin[binNr].Remove(positionFound);
             itemPositions[itemIndex] = positionFound;
             occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, resultingBinMeasures[binNr]);
             remainingItems.Remove(unpackedItems[i]);
-            //solution.PackingInformations[binNr].Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
           }
         }
@@ -134 +147 @@
           extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
           occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-          //solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
+          resultingBinMeasures[nrOfBins] = new CuboidPackingBin(binMeasures.Width, binMeasures.Height, binMeasures.Depth);
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
           nrOfBins++;
         }
       }
 
-      return itemPositions;
-
-
+      result.PackingItemPositions = itemPositions;
+      result.PackingBinMeasures = resultingBinMeasures;
       return result;
     }
 
-    protected override MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    private static List<int[, ,]> DoubleDepthForBinNr(List<int[, ,]> occupiedPoints, ref ObservableDictionary<int, CuboidPackingBin> binMeasures, int binNr) {
+      var oldDepth = binMeasures[binNr].Depth;
+      binMeasures[binNr].Depth = binMeasures[binNr].Depth * 2;
+      var newBinOccupation = new int[binMeasures[binNr].Width, binMeasures[binNr].Height, binMeasures[binNr].Depth];
+      for (int w = 0; w < binMeasures[binNr].Width; w++) {
+        for (int h = 0; h < binMeasures[binNr].Height; h++) {
+          for (int d = 0; d < binMeasures[binNr].Depth; d++) {
+            if (d < oldDepth)
+              newBinOccupation[w, h, d] = occupiedPoints[binNr][w, h, d];
+            else
+              newBinOccupation[w, h, d] = -1;
+          }
+        }
+      }
+
+      occupiedPoints[binNr] = newBinOccupation;
+      return occupiedPoints;
+    }
+
+
+
+
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs

@@ -47 +47 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+    private ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
       get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
     }
-    public ILookupParameter<B> PackingBinMeasuresParameter {
+    private ILookupParameter<B> PackingBinMeasuresParameter {
       get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
     }
-    public ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["EncodedSolution"]; }
+    public ILookupParameter<IItem> EncodedSolutionParameter {
+      get { return (ILookupParameter<IItem>)Parameters["EncodedSolution"]; }
     }
     public ILookupParameter<PackingPlan<D,B,I>> PackingPlanParameter {
@@ -62 +62 @@
 
     public PackingSolutionDecoder() : base() {
-      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("EncodedSolution", "The new bin-packing solution represented as encoding."));
+      Parameters.Add(new LookupParameter<IItem>("EncodedSolution", "The new bin-packing solution represented as encoding."));
       Parameters.Add(new LookupParameter<PackingPlan<D, B, I>>("PackingPlan", "The decoded bin-packing solution represented as generalized packing plan."));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
@@ -75 +75 @@
     }
 
-    public abstract PackingPlan<D, B, I> CreatePackingPlanFromEncoding(IPackingSolutionEncoding solution, B binMeasures, ItemList<I> itemMeasures);
+    public abstract PackingPlan<D, B, I> CreatePackingPlanFromEncoding(IItem solution, B binMeasures, ItemList<I> itemMeasures);
 
     public override IOperation Apply() {

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorCrossover.cs

@@ -30 +30 @@
   [Item("Grouping Vector Crossover", "An operator which crosses two GroupingVector representations.")]
   [StorableClass]
-  public class GroupingVectorCrossover : PackingSolutionCrossover, IGroupingVectorOperator {
+  public abstract class GroupingVectorCrossover : PackingSolutionCrossover, IGroupingVectorOperator {
 
     [StorableConstructor]
@@ -40 +40 @@
         ChildParameter.ActualName = "GroupingVector";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GroupingVectorCrossover(this, cloner);
-    }
 
-    public GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
-      GroupingVectorEncoding result = new GroupingVectorEncoding();
-      result.GroupingVector = SinglePointCrossover.Apply(random, parent1.GroupingVector, parent2.GroupingVector);
-      return result;
-    }
+    public abstract GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2);
 
     public override IOperation Apply() {

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs

@@ -68 +68 @@
     }
 
-    protected override IPackingSolutionEncoding CreateSolution() {
+    protected override IItem CreateSolution() {
       return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue);
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs

@@ -46 +46 @@
         return nrOfItems;
       } 
-    }
+    }  
 
     [StorableConstructor]
@@ -64 +64 @@
       : base() {
         PackingInformations = new ObservableDictionary<int, ItemList<PackingInformation>>();
-    }
+    }       
 
     public override string ToString() {
@@ -95 +95 @@
       return PackingInformations.GetHashCode();
     }
+
   }
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs

@@ -76 +76 @@
     }
 
-    protected override IPackingSolutionEncoding CreateSolution() {
+    protected override IItem CreateSolution() {
       return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue, SortedSequenceParameter.Value.Value);
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs

@@ -35 +35 @@
 
 namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
-  //RegularPackingPlan defines that the packingItems have to be parallel to the packingBin in every moment
-  //SimpleRotation defines that the items may be rotated 
-  //  only in one dimension, 
-  //  only once and 
-  //  only by 90degree
-  //    so that parallelism to the correlating bin is ensured
-  //This definition implies that the floor of the (3D) objects never changes (what may be a wanted constraint in most cases..)
   [Item("PackingPlan", "Represents a concrete solution for a bin-packing problem.")]
   [StorableClass]
@@ -85 +78 @@
     public PackingPlan(B binMeasures, ItemList<I> itemMeasures)
       : base() {
-      this.PackingItemMeasures = itemMeasures;
+      this.PackingItemMeasures = new ItemList<I> (itemMeasures);
       this.PackingBinMeasures = new ObservableDictionary<int, B>();
       this.PackingBinMeasures[0] = binMeasures;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs

@@ -29 +29 @@
   [Item("PackingSequenceCrossover", "An operator which crosses two PackingSequence representations.")]
   [StorableClass]
-  public class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
+  public abstract class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
 
     [StorableConstructor]
@@ -39 +39 @@
         ChildParameter.ActualName = "PackingSequence";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingSequenceCrossover(this, cloner);
-    }
 
-    public PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = CosaCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
-    }
+    public abstract PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2);
 
     public override IOperation Apply() {

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceEncoding.cs

@@ -30 +30 @@
   [Item("Packing Sequence Encoding", "Represents an encoding for a bin packing problem using permutation of item-indexes to define the packing sequence.")]
   [StorableClass]
-  public class PackingSequenceEncoding : Item, IPackingSolutionEncoding{
+  public class PackingSequenceEncoding : Item, IPackingSolutionEncoding {
 
     [Storable]
@@ -39 +39 @@
     protected PackingSequenceEncoding(PackingSequenceEncoding original, Cloner cloner)
       : base(original, cloner) {
-        this.PackingSequence = cloner.Clone(original.PackingSequence);
+      this.PackingSequence = cloner.Clone(original.PackingSequence);
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -53 +53 @@
       StringBuilder sb = new StringBuilder();
       sb.Append("[ ");
-      sb.Append(PackingSequence.ToString() + " \n");         
+      sb.Append(PackingSequence.ToString() + " \n");
       sb.Append("]");
       return sb.ToString();

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs

@@ -30 +30 @@
   [Item("PackingSequenceManipulator", "An operator which manipulates a PackingSequence representation.")]
   [StorableClass]
-  public class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
+  public abstract class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
     [StorableConstructor]
     protected PackingSequenceManipulator(bool deserializing) : base(deserializing) { }
@@ -38 +38 @@
         EncodedSolutionParameter.ActualName = "PackingSequence";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingSequenceManipulator(this, cloner);
-    }
 
-    protected void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      Swap2Manipulator.Apply(random, individual.PackingSequence);
-    }
+    protected abstract void Manipulate(IRandom random, PackingSequenceEncoding individual);
 
     public override IOperation Apply() {

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs

@@ -60 +60 @@
     public static PackingSequenceEncoding Apply(int items, IRandom random) {
       var solution = new PackingSequenceEncoding();
-      solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
-      return solution;
-    }
+      solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
+      return solution;
+    }
 
-    protected override IPackingSolutionEncoding CreateSolution() {
+    protected override IItem CreateSolution() {
       return Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionCreator.cs

@@ -32 +32 @@
   public abstract class PackingSolutionCreator : SingleSuccessorOperator, IPackingSolutionCreator {
 
-    public ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["EncodedPackingSolution"]; }
+    public ILookupParameter<IItem> EncodedSolutionParameter {
+      get { return (ILookupParameter<IItem>)Parameters["EncodedPackingSolution"]; }
     }
 
@@ -41 +41 @@
     public PackingSolutionCreator()
       : base() {
-        Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("EncodedPackingSolution", "The new bin packing solution candidate."));
+        Parameters.Add(new LookupParameter<IItem>("EncodedPackingSolution", "The new bin packing solution candidate."));
     }
 
@@ -49 +49 @@
     }
 
-    protected abstract IPackingSolutionEncoding CreateSolution();
+    protected abstract IItem CreateSolution();
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs

@@ -66 +66 @@
 
       //if (itemPositionsAreValid)
-      return CalculateBinUtilization(plan as SingleBinSizePackingPlan<D, B, I>, binMeasure, itemMeasures);
+      return CalculateBinUtilization(plan as PackingPlan<D, B, I>);
 
       //return quality;
     }
 
-    public static DoubleValue CalculateBinUtilization(SingleBinSizePackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) {
+    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
 
-      double usableSpace = binMeasure.MultipliedMeasures;
+      //for (int i = 0; i < nrOfBins; i++) {
+      //  double usableSpace = plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
+      //  var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
+      //  var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+      //  double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
+      //  result += (usedSpaceInThisBin / usableSpace);
+      //}
+
+      //result = result / nrOfBins;
+      //return new DoubleValue (result);
+
+      double totalUsedSpace = 0;
+      double totalUsableSpace = 0;
+
       for (int i = 0; i < nrOfBins; i++) {
+        double usableSpace = plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
         var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
-        var packedItemsInThisBin = itemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+        var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
         double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
-        result += (usedSpaceInThisBin / usableSpace);
+        //result += (usedSpaceInThisBin / usableSpace);
+        totalUsableSpace += usableSpace;
+        totalUsedSpace += usedSpaceInThisBin;
       }
 
-      result = result / nrOfBins;
-      return new DoubleValue (result);
+      result = totalUsedSpace / totalUsableSpace;
+      return new DoubleValue(result);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs

@@ -66 +66 @@
 
       //if (itemPositionsAreValid)
-      return CalculatePackingRatio(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures);
+      return CalculatePackingRatio(plan as PackingPlan<D, B, I>);
 
       //return quality;
@@ -80 +80 @@
         k.......a constant, k>1.
      */
-    public static DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) {
+    public static DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
 
       //C
-      double usableSpace = binMeasure.MultipliedMeasures;
+      //double usableSpace = binMeasure.MultipliedMeasures;
       //nrOfBins = N
       for (int i = 0; i < nrOfBins; i++) {
+        //C
+        double usableSpace = plan.GetPackingBinMeasuresForBinNr(0).MultipliedMeasures;//plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
         var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
-        var packedItemsInThisBin = itemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+        var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
         //Fi
         double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj

@@ -181 +181 @@
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
     <Compile Include="Decoders\2D\BL\BottomLeftPackingSequenceDecoder.cs" />
+    <Compile Include="Decoders\3D\EP\ISOContainerMultiComponentVectorDecoder3D.cs" />
     <Compile Include="Decoders\PackingSolutionDecoder.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\ExhaustiveSingleGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingTabuMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\StochasticSingleGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\UniformGroupingVectorManipulator.cs" />
+    <Compile Include="Encodings\GroupingVector\GroupingVectorSwap2Manipulator.cs" />
+    <Compile Include="Encodings\GroupingVector\GroupingVectorSinglePointCrossover.cs" />
+    <Compile Include="Encodings\GroupingVector\GroupingVectorDiscreteCrossover.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingMove.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\ExhaustiveSwapGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMove.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveMaker.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingTabuMaker.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\StochasticSwapGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveSoftTabuCriterion.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ExhaustiveChangeGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMove.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\StochasticChangeGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\GroupingVectorOnePositionManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorEncoding.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\SequencePreservingMultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\ChangePositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MCVTripleMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SwapPositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SingleGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MultiComponentVectorMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SingleItemRotationMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\StochasticMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\ExhaustiveMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\ChangePositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\MCVTripleMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\MultiComponentVectorMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SwapPositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SingleItemRotationMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SingleGroupingMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorTabuMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\StochasticMultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\BinBasedMultiComponentVectorCrossover.cs" />
+    <Compile Include="Encodings\MultiComponentVector\SequenceBasedMultiComponentVectorCrossover.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\ChangePositionMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Attributes\MCVTripleMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SwapPositionMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleGroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleItemRotationMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\StochasticMCVTripleMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\ExhaustiveMCVTripleMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\ChangePositionMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Moves\MCVTripleMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SwapPositionMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleItemRotationMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleGroupingMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveSoftTabuCriterion.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveMaker.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorTabuMaker.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\StochasticMultiComponentVectorMoveGenerator.cs" />
     <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorEncoding.cs">
       <SubType>Code</SubType>
@@ -226 +238 @@
     <Compile Include="Encodings\MultiComponentVector\ThreeWayMultiComponentVectorManipulator.cs" />
     <Compile Include="Encodings\PackingPlans\PackingPlan.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceCrossover.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceManipulator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceEncoding.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Insertion\ExhaustiveInsertionMoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Insertion\StochasticInsertionMoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMove.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveAttribute.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\PackingSequenceInsertionManipulator.cs" />
+    <Compile Include="Encodings\PackingSequence\PackingSequenceSwap2Manipulator.cs" />
+    <Compile Include="Encodings\PackingSequence\PackingSequencePartiallyMatchedCrossover.cs" />
+    <Compile Include="Encodings\PackingSequence\PackingSequenceOrderCrossover.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\SequenceMove.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\SequenceMoveAttribute.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveMaker.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveSoftTabuCriterion.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\SequenceTabuMaker.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Swap2\ExhaustiveSwap2MoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Swap2\StochasticSwap2MoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2Move.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveAttribute.cs" />
+    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveGenerator.cs" />
+    <Compile Include="Encodings\PackingSequence\PackingSequenceCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Encodings\PackingSequence\PackingSequenceEncoding.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Encodings\PackingSequence\PackingSequenceManipulator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Encodings\PackingSequence\PackingSequenceRandomCreator.cs" />
     <Compile Include="Encodings\PackingSolutionCreator.cs" />
@@ -235 +273 @@
     <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\3D\PackingRatioCuboidIdenticalBinEvaluator.cs" />
+    <Compile Include="Evaluators\Abstract\BinUtilizationRegularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\Abstract\PackingRatioRegularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\Abstract\RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs" />
@@ -245 +284 @@
     <Compile Include="Instances\BPPORLIBParser.cs" />
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
+    <Compile Include="Instances\RealBPPData.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I2DMCVDecoder.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I3DMCVDecoder.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I2DGVDecoder.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I3DGVDecoder.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I2DPSDecoder.cs" />
+    <Compile Include="Interfaces\DecoderInterfaces\I3DPSDecoder.cs" />
+    <Compile Include="Interfaces\IPackingSequenceMoveOperator.cs" />
     <Compile Include="Interfaces\I3DOperator.cs" />
     <Compile Include="Interfaces\I2DOperator.cs" />
@@ -265 +312 @@
     <Compile Include="Interfaces\IPackingShape.cs" />
     <Compile Include="Interfaces\IPackingDimensions.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DPS.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs">

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingItem.cs

@@ -30 +30 @@
   public interface IPackingItem : IPackingShape {
     void AddTargetBinMeasures(int[] targetBinMeasures);
+    double Weight { get; set; }
+    int Material { get; set; }
+    /// <summary>
+    /// Returns if the "other" item can be stacked on this item.
+    /// </summary>
+    /// <param name="other"></param>
+    /// <returns></returns>
+    bool SupportsStacking (IPackingItem other);
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCreator.cs

@@ -29 +29 @@
 namespace HeuristicLab.Problems.BinPacking.Interfaces {
   public interface IPackingSolutionCreator : ISolutionCreator{
-    ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter { get; }
+    ILookupParameter<IItem> EncodedSolutionParameter { get; }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs

@@ -98 +98 @@
       CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
 
-      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio(
-        packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
 
       double moveQuality = quality.Value;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/CuboidPackingItem.cs

@@ -38 +38 @@
 
     public CuboidPackingBin TargetBin { get; set; }
+    public double Weight { get; set; }
+    public int Material { get; set; }
+    public bool SupportsStacking(IPackingItem other) {
+      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
+    }
 
     [StorableConstructor]
@@ -43 +48 @@
     protected CuboidPackingItem(CuboidPackingItem original, Cloner cloner)
       : base(original, cloner) {
+        this.Weight = original.Weight;
+        this.Material = original.Material;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -51 +58 @@
     }
 
+    public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin, double weight, int material) : this(width, height, depth, targetBin) { this.Weight = weight; this.Material = material; }
     public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin) : base(width, height, depth) { this.TargetBin = new CuboidPackingBin(targetBin.Width, targetBin.Height, targetBin.Depth); }
 
@@ -56 +64 @@
       TargetBin = new CuboidPackingBin(targetBinMeasures[0], targetBinMeasures[1], targetBinMeasures[2]);
     }
+
+    public override string ToString() {
+      return String.Format("CuboidPackingItem ({0}, {1}, {2}; w={3}, m={4})", this.Width, this.Height, this.Depth, this.Weight,this.Material);
+    }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/RectangularPackingItem.cs

@@ -37 +37 @@
   public class RectangularPackingItem : RectangularPackingShape, IPackingItem{
 
-    public RectangularPackingBin TargetBin { get; set; } 
+    public RectangularPackingBin TargetBin { get; set; }
+    public double Weight { get; set; }
+    public int Material { get; set; }
+    public bool SupportsStacking(IPackingItem other) {
+      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
+    }
 
     [StorableConstructor]
@@ -43 +48 @@
     protected RectangularPackingItem(RectangularPackingItem original, Cloner cloner)
       : base(original, cloner) {
+      this.Weight = original.Weight;
+      this.Material = original.Material;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -48 +55 @@
     }
     public RectangularPackingItem() : base() {
-
     }
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs

@@ -26 +26 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9473")]
+  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9495")]
   [PluginFile("HeuristicLab.Problems.BinPacking-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs

@@ -44 +44 @@
 using HeuristicLab.Problems.Instances;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -112 +113 @@
     }
     public CuboidIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<PackingSequenceEncoding, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
+      new PackingPlanEvaluationAlgorithm<Permutation, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
     }
 
@@ -121 +122 @@
       Operators.RemoveAll(op => typeof(I2DOperator).IsAssignableFrom(op.GetType()));
 
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder3D();
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {   
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
+        //PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
+      } else if (SolutionCreator is GroupingVectorRandomCreator) {      
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
+        //PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder3D();
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {    
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
+        //PackingSolutionDecoder = ApplicationManager.Manager.GetInstances<ExtremePointMultiComponentVectorDecoder3D>().First();
       } else {
         string error = "The given problem does not support the selected solution-creator.";

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs

@@ -49 +49 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class ISOContainerBinPackingProblem : RegularIdenticalBinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
+  public class ISOContainerBinPackingProblem : CuboidIdenticalBinPackingProblem {
+
 
     #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {  
-      Name = "3D BPP Default Instance", 
-      Description = "The default instance for 3D Bin Packing.",
+    private static readonly RealBPPData DefaultInstance = new RealBPPData() {  
+      Name = "3D BPP with weigthed items Default Instance", 
+      Description = "The default instance for 3D Bin Packing Problem with weighted items.",
       BinMeasures = new int[] {25,25,35},
       ItemMeasures = new int[][] {
@@ -99 +100 @@
         new int[] {9,11,9}
       },
-      Items = 30
+      Items = 30,
+      ItemWeights = new double[] {
+        12*5*10,
+        10*18*20,
+        9*7*7,
+        21*12*4,
+        8*8*12,
+        3*6*14,
+        20*4*9,
+        5*9*8,
+        7*17*3,
+        13*20*15,
+        9*11*9,
+        10*18*20,
+        9*7*7,
+        21*12*4,
+        8*8*12,
+        3*6*14,
+        20*4*9,
+        5*9*8,
+        7*17*3,
+        13*20*15,
+        9*11*9,
+        10*18*20,
+        9*7*7,
+        21*12*4,
+        8*8*12,
+        3*6*14,
+        20*4*9,
+        5*9*8,
+        7*17*3,
+        13*20*15,
+        9*11*9
+      },
+      ItemMaterials = new int[] {
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        1,
+        0,
+        1,
+        1,
+
+      } 
     };
     #endregion
@@ -111 +179 @@
       return new ISOContainerBinPackingProblem(this, cloner);
     }
-    public ISOContainerBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<PackingSequenceEncoding, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
+    public ISOContainerBinPackingProblem()
+      : base() {
     }
 
@@ -119 +187 @@
     #region Helpers
     protected override void InitializeDecoder() {
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder3D();
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
+      Operators.RemoveAll(op => typeof(I2DOperator).IsAssignableFrom(op.GetType()));
+
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.Add(new ISOContainerMultiComponentVectorDecoder3D());
       } else {
         string error = "The given problem does not support the selected solution-creator.";
@@ -131 +198 @@
     }
 
-    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioCuboidIdenticalBinEvaluator();
-    }
-
     protected override void InitializeProblemData() {
       Load(DefaultInstance);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs

@@ -108 +108 @@
     }
     public RectangularIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<PackingSequenceEncoding, TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>()) {
+      new PackingPlanEvaluationAlgorithm<Permutation, TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>()) {
     }
 
@@ -116 +116 @@
       Operators.RemoveAll(op => typeof(I3DOperator).IsAssignableFrom(op.GetType()));
 
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder2D();
-      } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder2D();
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder2D();
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {        
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
+        //PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder2D();
+      } else if (SolutionCreator is GroupingVectorRandomCreator) {  
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
+        //PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder2D();
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {  
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
+        //PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder2D();
       } else {
         string error = "The given problem does not support the selected solution-creator.";

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs

@@ -56 +56 @@
       get { return (ValueParameter<B>)Parameters["PackingBinMeasures"]; }
     }
-    public OptionalValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (OptionalValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    public ConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (ConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
     }
     #endregion
@@ -85 +85 @@
       Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
       Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
-      Parameters.Add(new OptionalValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
+      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
       this.Maximization.Value = true;
       InitializeProblemInstance();
@@ -232 +232 @@
 
     #region Problem instance handling
-    public void Load(BPPData data) { 
+    public virtual void Load(BPPData data) {
+      var realData = data as RealBPPData;
       var binData = new B();
       binData.InitializeFromMeasures (data.BinMeasures);
@@ -241 +242 @@
         item.InitializeFromMeasures(data.ItemMeasures[j]);
         item.AddTargetBinMeasures(data.BinMeasures);
+        if (realData != null) {
+          item.Weight = realData.ItemWeights[j];
+          item.Material = realData.ItemMaterials[j];
+        }
         itemData.Add(item);
       }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs

@@ -130 +130 @@
       //Using "Clustered-Area-Height"-comparison as descr
 
-      int result = this.MultipliedMeasures.CompareTo(other.MultipliedMeasures);
+      int result = (this.Width * this.Depth).CompareTo (other.Width * other.Depth);
+    
+    if (result == 0)
+    result = this.MultipliedMeasures.CompareTo(other.MultipliedMeasures);
       //if (result == 0) {
       //  result = this.Depth.CompareTo(other.Depth) + this.Width.CompareTo(other.Width);
       //  if (result == 0) {        
       //    result = this.Width.CompareTo(other.Width);
-          if (result == 0)               
-            result = this.Height.CompareTo(other.Height);
+    if (result == 0)               
+    result = this.Height.CompareTo(other.Height);
       //  }
       //}