Changeset 14154 for branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs

Timestamp:

07/21/16 15:08:21 (8 years ago)

Author:

gkronber

Message:

#1966: refactoring

File:

• branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs (modified) (14 diffs)

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

@@ -32 +32 @@
   public class BinPacking3D : BinPacking<PackingPosition, PackingShape, PackingItem> {
 
-    public BinPacking3D(PackingShape binMeasures)
-      : base(binMeasures) {
+    public BinPacking3D(PackingShape binShape)
+      : base(binShape) {
       ExtremePoints = new SortedSet<PackingPosition>(new EPComparer3D());
-      ExtremePoints.Add(binMeasures.Origin);
+      ExtremePoints.Add(binShape.Origin);
+      InitializeOccupationLayers();
     }
     [StorableConstructor]
@@ -41 +42 @@
     protected BinPacking3D(BinPacking3D original, Cloner cloner)
       : base(original, cloner) {
-      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints, new EPComparer3D());
+      this.ExtremePoints = new SortedSet<PackingPosition>(original.ExtremePoints.Select(p => cloner.Clone(p)), new EPComparer3D());
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -53 +54 @@
       //Find ExtremePoints beginning from sourcepointX
       var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y, position.Z);
-      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height && sourcePointX.Z < BinMeasures.Depth) {
+      if (sourcePointX.X < BinShape.Width && sourcePointX.Y < BinShape.Height && sourcePointX.Z < BinShape.Depth) {
         //Traversing down the y-axis  
         PackingPosition current = new PackingPosition(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
@@ -79 +80 @@
       //Find ExtremePoints beginning from sourcepointY
       var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height, position.Z);
-      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height && sourcePointY.Z < BinMeasures.Depth) {
+      if (sourcePointY.X < BinShape.Width && sourcePointY.Y < BinShape.Height && sourcePointY.Z < BinShape.Depth) {
         //Traversing down the x-axis          
         PackingPosition current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
@@ -105 +106 @@
       //Find ExtremePoints beginning from sourcepointZ
       var sourcePointZ = new PackingPosition(0, position.X, position.Y, position.Z + newDepth);
-      if (sourcePointZ.X < BinMeasures.Width && sourcePointZ.Y < BinMeasures.Height && sourcePointZ.Z < BinMeasures.Depth) {
+      if (sourcePointZ.X < BinShape.Width && sourcePointZ.Y < BinShape.Height && sourcePointZ.Z < BinShape.Depth) {
         //Traversing down the x-axis
         PackingPosition current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
@@ -130 +131 @@
     }
 
-    public override PackingPosition FindExtremePointForItem(PackingItem measures, bool rotated, bool stackingConstraints) {
-
-      PackingItem item = new PackingItem(
-        rotated ? measures.Depth : measures.Width,
-        measures.Height,
-        rotated ? measures.Width : measures.Depth,
-        measures.TargetBin);
+    public override PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints) {
+
+      PackingItem newItem = new PackingItem(
+        rotated ? item.Depth : item.Width,
+        item.Height,
+        rotated ? item.Width : item.Depth,
+        item.TargetBin);
 
       int epIndex = 0;
       while (epIndex < ExtremePoints.Count && (
-        !IsPositionFeasible(item, ExtremePoints.ElementAt(epIndex))
-        || !IsSupportedByAtLeastOnePoint(item, ExtremePoints.ElementAt(epIndex))
-        || (stackingConstraints && !IsStaticStable(item, ExtremePoints.ElementAt(epIndex)))
-        || (stackingConstraints && !IsWeightSupported(item, ExtremePoints.ElementAt(epIndex)))
+        !IsPositionFeasible(newItem, ExtremePoints.ElementAt(epIndex))
+        || !IsSupportedByAtLeastOnePoint(newItem, ExtremePoints.ElementAt(epIndex))
+        || (stackingConstraints && !IsStaticStable(newItem, ExtremePoints.ElementAt(epIndex)))
+        || (stackingConstraints && !IsWeightSupported(newItem, ExtremePoints.ElementAt(epIndex)))
       )) { epIndex++; }
 
@@ -154 +155 @@
     }
 
-    public override PackingPosition FindPositionBySliding(PackingItem measures, bool rotated) {
+    public override PackingPosition FindPositionBySliding(PackingItem item, bool rotated) {
       //TODO: does not support stacking constraints yet
       //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
       PackingPosition currentPosition = new PackingPosition(0,
-        BinMeasures.Width - (rotated ? measures.Depth : measures.Width),
-        BinMeasures.Height - measures.Height,
-        BinMeasures.Depth - (rotated ? measures.Width : measures.Depth), rotated);
+        BinShape.Width - (rotated ? item.Depth : item.Width),
+        BinShape.Height - item.Height,
+        BinShape.Depth - (rotated ? item.Width : item.Depth), rotated);
       //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition))
-        || IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
-        || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+      while (IsPositionFeasible(item, PackingPosition.MoveDown(currentPosition))
+        || IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition))
+        || IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
         //Slide the item as far as possible to the left
-        while (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition))
-      || IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+        while (IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition))
+      || IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
           //Slide the item as far as possible to the back
-          while (IsPositionFeasible(measures, PackingPosition.MoveBack(currentPosition))) {
+          while (IsPositionFeasible(item, PackingPosition.MoveBack(currentPosition))) {
             currentPosition = PackingPosition.MoveBack(currentPosition);
           }
-          if (IsPositionFeasible(measures, PackingPosition.MoveLeft(currentPosition)))
+          if (IsPositionFeasible(item, PackingPosition.MoveLeft(currentPosition)))
             currentPosition = PackingPosition.MoveLeft(currentPosition);
         }
-        if (IsPositionFeasible(measures, PackingPosition.MoveDown(currentPosition)))
+        if (IsPositionFeasible(item, PackingPosition.MoveDown(currentPosition)))
           currentPosition = PackingPosition.MoveDown(currentPosition);
       }
 
-      return IsPositionFeasible(measures, currentPosition) ? currentPosition : null;
-    }
-
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures) {
+      return IsPositionFeasible(item, currentPosition) ? currentPosition : null;
+    }
+
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
+        var item = items[temp[i]];
         var position = FindPositionBySliding(item, false);
         if (position != null) {
@@ -193 +194 @@
       }
     }
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
+        var item = items[temp[i]];
         var position = FindPositionBySliding(item, rotationArray[i]);
         if (position != null) {
@@ -204 +205 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
+        var item = items[itemID];
         var positionFound = FindExtremePointForItem(item, false, stackingConstraints);
         if (positionFound != null) {
@@ -215 +216 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
+        var item = items[itemID];
         var positionFound = FindExtremePointForItem(item, rotationArray[itemID], stackingConstraints);
         if (positionFound != null) {
@@ -230 +231 @@
 
       int shortestSide = int.MaxValue;
-      int width = BinMeasures.Width;
-      int height = BinMeasures.Height;
-      int depth = BinMeasures.Depth;
+      int width = BinShape.Width;
+      int height = BinShape.Height;
+      int depth = BinShape.Depth;
 
       if (position.X >= width || position.Y >= height || position.Z >= depth)
@@ -287 +288 @@
         return true;
 
-      if (ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
+      if (Items[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
+        && Items[PointOccupation(new PackingPosition(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
         return true;
 
@@ -298 +299 @@
 
     protected override void InitializeOccupationLayers() {
-      for (int i = 0; i * 10 <= BinMeasures.Depth; i += 1) {
+      for (int i = 0; i * 10 <= BinShape.Depth; i += 1) {
         OccupationLayers[i] = new List<int>();
       }
     }
-    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem measures, PackingPosition position) {
+    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
       int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
+      int z2 = (position.Z + (position.Rotated ? item.Width : item.Depth)) / 10;
 
       for (int i = z1; i <= z2; i++)
@@ -312 +313 @@
       return OccupationLayers[position.Z / 10];
     }
-    protected override List<int> GetLayerItemIDs(PackingItem measures, PackingPosition position) {
+    protected override List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
       List<int> result = new List<int>();
       int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
+      int z2 = (position.Z + (position.Rotated ? item.Width : item.Depth)) / 10;
 
       for (int i = z1; i <= z2; i++)