Changeset 14049 for branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D

Timestamp:

07/12/16 20:03:45 (8 years ago)

Author:

gkronber

Message:

#1966: simplified class names

Location:

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3

Files:

• BinPacking3D.cs (modified) (13 diffs)
• Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs (modified) (2 diffs)
• Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs (modified) (2 diffs)
• Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs (modified) (2 diffs)
• Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs (modified) (3 diffs)
• Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs (modified) (3 diffs)
• Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs (modified) (2 diffs)
• HeuristicLab.Problems.BinPacking3D-3.3.csproj (modified) (2 diffs)
• MoveEvaluators/PackingMoveEvaluator3DGV.cs (modified) (1 diff)
• MoveEvaluators/PackingMoveEvaluator3DMCV.cs (modified) (1 diff)
• MoveEvaluators/PackingMoveEvaluator3DPS.cs (modified) (1 diff)
• PackingItem.cs (moved) (moved from branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingItem.cs) (6 diffs)
• PackingRatioCuboidIdenticalBinEvaluator.cs (modified) (1 diff)
• PackingShape.cs (moved) (moved from branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidPackingShape.cs) (9 diffs)
• Problem.cs (moved) (moved from branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/CuboidIdenticalBinPackingProblem.cs) (3 diffs)
• Solution.cs (modified) (2 diffs)

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs

@@ -30 +30 @@
   [Item("BinPacking3D", "Represents a single-bin packing for a 3D bin-packing problem.")]
   [StorableClass]
-  public class BinPacking3D : BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
-
-    public BinPacking3D(CuboidPackingShape binMeasures)
+  public class BinPacking3D : BinPacking<PackingPosition, PackingShape, PackingItem> {
+
+    public BinPacking3D(PackingShape binMeasures)
       : base(binMeasures) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer3D());
@@ -48 +48 @@
     }
 
-    protected override void GenerateNewExtremePointsForNewItem(CuboidPackingItem newItem, PackingPosition position) {
+    protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position) {
       int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
       int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
@@ -146 +146 @@
     }
 
-    public override PackingPosition FindExtremePointForItem(CuboidPackingItem measures, bool rotated, bool stackingConstraints) {
-
-      CuboidPackingItem item = new CuboidPackingItem(
+    public override PackingPosition FindExtremePointForItem(PackingItem measures, bool rotated, bool stackingConstraints) {
+
+      PackingItem item = new PackingItem(
         rotated ? measures.Depth : measures.Width,
         measures.Height,
@@ -170 +170 @@
     }
 
-    public override PackingPosition FindPositionBySliding(CuboidPackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
       //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
       PackingPosition currentPosition = new PackingPosition(0,
@@ -197 +197 @@
     }
 
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -208 +208 @@
       }
     }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -219 +219 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -230 +230 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -271 +271 @@
       return shortestSide;
     }
-    public override bool IsStaticStable(CuboidPackingItem item, PackingPosition position) {
+    public override bool IsStaticStable(PackingItem item, PackingPosition position) {
       //Static stability is given, if item is placed on the ground
       if (position.Y == 0)
@@ -314 +314 @@
     }
 
-    public bool IsSupportedByAtLeastOnePoint(CuboidPackingItem item, PackingPosition position) {
+    public bool IsSupportedByAtLeastOnePoint(PackingItem item, PackingPosition position) {
       if (position.Y == 0)
         return true;
@@ -326 +326 @@
       return false;
     }
-    public bool IsWeightSupported(CuboidPackingItem item, PackingPosition ep) {
+    public bool IsWeightSupported(PackingItem item, PackingPosition ep) {
       if (ep.Y == 0)
         return true;
@@ -345 +345 @@
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, CuboidPackingItem measures, PackingPosition position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
       int z1 = position.Z / 10;
       int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
@@ -355 +355 @@
       return OccupationLayers[position.Z / 10];
     }
-    protected override List<int> GetLayerItemIDs(CuboidPackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
       List<int> result = new List<int>();
       int z1 = position.Z / 10;

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

@@ -31 +31 @@
   [Item("Identical bin, three dimensional, GroupingVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
     public DeepestBottomLeftGroupingVectorDecoder() : base() {}
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");

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

@@ -31 +31 @@
   [Item("Identical bin, three dimensional, MultiComponentVector-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
     public DeepestBottomLeftMultiComponentVectorDecoder() : base() { }
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");

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

@@ -31 +31 @@
   [Item("Identical bin, three dimensional, PackingSequence-decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
     public DeepestBottomLeftPackingSequenceDecoder(): base() {}
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");

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

@@ -31 +31 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DGVDecoder {
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
     public ExtremePointGroupingVectorDecoder3D() : base() { }
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(GroupingVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48 +48 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");

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

@@ -31 +31 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DMCVDecoder {
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
     public ExtremePointMultiComponentVectorDecoder3D () : base() { }
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public static PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(MultiComponentVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
       Solution result = new Solution(binMeasures, true, stackingConstraints);
       result.Pack(solution, itemMeasures);
@@ -48 +48 @@
     }
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");

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

@@ -32 +32 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, CuboidPackingShape, CuboidPackingItem>, I3DPSDecoder {
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
     public ExtremePointPackingSequenceDecoder3D () : base() {}
     [StorableConstructor]
@@ -44 +44 @@
 
 
-    public override PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, CuboidPackingShape binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
       var solution = encodedSolution as PackingSequenceEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj

@@ -159 +159 @@
   <ItemGroup>
     <Compile Include="BinPacking3D.cs" />
-    <Compile Include="CuboidIdenticalBinPackingProblem.cs" />
-    <Compile Include="CuboidPackingItem.cs" />
-    <Compile Include="CuboidPackingShape.cs" />
     <Compile Include="DecoderInterfaces\I3DGVDecoder.cs" />
     <Compile Include="DecoderInterfaces\I3DMCVDecoder.cs" />
@@ -175 +172 @@
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
+    <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
     <Compile Include="PackingRatioCuboidIdenticalBinEvaluator.cs" />
+    <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Solution.cs" />

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs

@@ -30 +30 @@
   [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs

@@ -30 +30 @@
   [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs

@@ -30 +30 @@
   [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
   [StorableClass]
-  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
+  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<PackingPosition, PackingShape, PackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
     [StorableConstructor]
     protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingItem.cs

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("CuboidPackingItem", "Represents a cuboidic packing-item for bin-packing problems.")]
+  [Item("PackingItem (3d)", "Represents a cuboidic packing-item for bin-packing problems.")]
   [StorableClass]
-  public class CuboidPackingItem : CuboidPackingShape, IPackingItem {
-    public IValueParameter<CuboidPackingShape> TargetBinParameter {
-      get { return (IValueParameter<CuboidPackingShape>)Parameters["TargetBin"]; }
+  public class PackingItem : PackingShape, IPackingItem {
+    public IValueParameter<PackingShape> TargetBinParameter {
+      get { return (IValueParameter<PackingShape>)Parameters["TargetBin"]; }
     }
     public IFixedValueParameter<DoubleValue> WeightParameter {
@@ -41 +41 @@
     }
 
-    public CuboidPackingShape TargetBin {
+    public PackingShape TargetBin {
       get { return TargetBinParameter.Value; }
       set { TargetBinParameter.Value = value; }
@@ -61 +61 @@
 
     [StorableConstructor]
-    protected CuboidPackingItem(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingItem(CuboidPackingItem original, Cloner cloner)
+    protected PackingItem(bool deserializing) : base(deserializing) { }
+    protected PackingItem(PackingItem original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
     }
-    public CuboidPackingItem()
+    public PackingItem()
       : base() {
-      Parameters.Add(new ValueParameter<CuboidPackingShape>("TargetBin"));
+      Parameters.Add(new ValueParameter<PackingShape>("TargetBin"));
       Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
       Parameters.Add(new FixedValueParameter<IntValue>("Material"));
@@ -75 +75 @@
     }
 
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin, double weight, int material)
+    public PackingItem(int width, int height, int depth, PackingShape targetBin, double weight, int material)
       : this() {
       this.Width = width;
@@ -82 +82 @@
       this.Weight = weight;
       this.Material = material;
-      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
+      this.TargetBin = (PackingShape)targetBin.Clone();
     }
 
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingShape targetBin)
+    public PackingItem(int width, int height, int depth, PackingShape targetBin)
       : this() {
       this.Width = width;
       this.Height = height;
       this.Depth = depth;
-      this.TargetBin = (CuboidPackingShape)targetBin.Clone();
+      this.TargetBin = (PackingShape)targetBin.Clone();
     }
 
@@ -99 +99 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingItem(this, cloner);
+      return new PackingItem(this, cloner);
     }
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingRatioCuboidIdenticalBinEvaluator.cs

@@ -28 +28 @@
   [Item("Packing-Ratio Cuboid Identical-Bin Evaluator", "Represents an evaluation-algorithm for cuboid-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
   [StorableClass]
-  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
+  public class PackingRatioCuboidIdenticalBinEvaluator : PackingRatioRegularIdenticalBinEvaluator<PackingPosition, PackingShape, PackingItem> {
 
     [StorableConstructor]

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/PackingShape.cs

@@ -29 +29 @@
 
 namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("CuboidPackingShape", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
+  [Item("PackingShape (3d)", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
   [StorableClass]
-  public class CuboidPackingShape : PackingShape<PackingPosition>, IComparable<CuboidPackingShape> {
+  public class PackingShape : PackingShape<PackingPosition>, IComparable<PackingShape> {
     public IFixedValueParameter<IntValue> HeightParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
@@ -58 +58 @@
 
     [StorableConstructor]
-    protected CuboidPackingShape(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingShape(CuboidPackingShape original, Cloner cloner)
+    protected PackingShape(bool deserializing) : base(deserializing) { }
+    protected PackingShape(PackingShape original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
     }
-    public CuboidPackingShape()
+    public PackingShape()
       : base() {
       Parameters.Add(new FixedValueParameter<IntValue>("Width"));
@@ -72 +72 @@
     }
 
-    public CuboidPackingShape(int width, int height, int depth)
+    public PackingShape(int width, int height, int depth)
       : this() {
       this.Width = width;
@@ -80 +80 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingShape(this, cloner);
+      return new PackingShape(this, cloner);
     }
 
@@ -101 +101 @@
     #region IComparable Members
 
-    public int CompareTo(CuboidPackingShape other) {
+    public int CompareTo(PackingShape other) {
       //Using "Clustered-Area-Height"-comparison as descr
 
@@ -114 +114 @@
 
     public override int CompareTo(object obj) {
-      var other = (CuboidPackingShape)obj;
+      var other = (PackingShape)obj;
       if (other != null) return CompareTo(other);
       else throw new ArgumentException(string.Format("Cannot compare with object {0}", obj), "obj");
@@ -128 +128 @@
       public int y2;
       public int z2;
-      public CuboidDiagonal(CuboidPackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
-      public CuboidDiagonal(PackingPosition myPosition, CuboidPackingShape myShape) {
+      public CuboidDiagonal(PackingShape myShape) : this(new PackingPosition(0, 0, 0, 0), myShape) { }
+      public CuboidDiagonal(PackingPosition myPosition, PackingShape myShape) {
         x1 = myPosition.X;
         y1 = myPosition.Y;
@@ -153 +153 @@
     }
     public override bool Encloses(PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Encloses(checkedPosition, (CuboidPackingShape)checkedShape);
+      return Encloses(checkedPosition, (PackingShape)checkedShape);
     }
-    private bool Encloses(PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
+    private bool Encloses(PackingPosition checkedPosition, PackingShape checkedShape) {
       return Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape));
     }
@@ -168 +168 @@
 
     public override bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape<PackingPosition> checkedShape) {
-      return Overlaps(myPosition, checkedPosition, (CuboidPackingShape)checkedShape);
+      return Overlaps(myPosition, checkedPosition, (PackingShape)checkedShape);
     }
-    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, CuboidPackingShape checkedShape) {
+    private bool Overlaps(PackingPosition myPosition, PackingPosition checkedPosition, PackingShape checkedShape) {
       return Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape));
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs

@@ -38 +38 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
   // TODO don't support generic BPPData but only 3d BPPData
-  public class CuboidIdenticalBinPackingProblem : BinPackingProblem<PackingPosition, CuboidPackingShape, CuboidPackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
 
 
@@ -94 +94 @@
 
     [StorableConstructor]
-    protected CuboidIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected CuboidIdenticalBinPackingProblem(CuboidIdenticalBinPackingProblem original, Cloner cloner)
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
       : base(original, cloner) {
     }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidIdenticalBinPackingProblem(this, cloner);
+      return new Problem(this, cloner);
     }
-    public CuboidIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, CuboidPackingShape, CuboidPackingItem>()) {
+    public Problem() : base(
+      new PackingPlanEvaluationAlgorithm<Permutation, PackingPosition, PackingShape, PackingItem>()) {
     }
 
@@ -109 +109 @@
     public void Load(BPPData data) {
       var realData = data as RealBPPData;
-      var binData = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
+      var binData = new PackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
 
-      var itemData = new ItemList<CuboidPackingItem>(data.Items);
+      var itemData = new ItemList<PackingItem>(data.Items);
       for (int j = 0; j < data.Items; j++) {
-        var bin = new CuboidPackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
-        var item = new CuboidPackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], data.ItemMeasures[j][2], bin);
+        var bin = new PackingShape(data.BinMeasures[0], data.BinMeasures[1], data.BinMeasures[2]);
+        var item = new PackingItem(data.ItemMeasures[j][0], data.ItemMeasures[j][1], data.ItemMeasures[j][2], bin);
         if (realData != null) {
           item.Weight = realData.ItemWeights[j];

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Solution.cs

@@ -7 +7 @@
   [Item("Bin Packing Solution (3d)", "Represents a solution for a 3D bin packing problem.")]
   [StorableClass]
-  public class Solution : PackingPlan<PackingPosition, CuboidPackingShape, CuboidPackingItem> {
-    public Solution(CuboidPackingShape binMeasures) : this(binMeasures, false, false) { }
-    public Solution(CuboidPackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
+  public class Solution : PackingPlan<PackingPosition, PackingShape, PackingItem> {
+    public Solution(PackingShape binMeasures) : this(binMeasures, false, false) { }
+    public Solution(PackingShape binMeasures, bool useExtremePoints, bool stackingConstraints) : base(binMeasures, useExtremePoints, stackingConstraints) { }
     [StorableConstructor]
     protected Solution(bool deserializing) : base(deserializing) { }
@@ -18 +18 @@
       return new Solution(this, cloner);
     }
-    public override BinPacking<PackingPosition, CuboidPackingShape, CuboidPackingItem> NewBinPacking() {
+    public override BinPacking<PackingPosition, PackingShape, PackingItem> NewBinPacking() {
       return new BinPacking3D(BinMeasures);
     }