Changeset 15989 for branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Algorithms

Timestamp:

07/09/18 12:59:38 (7 years ago)

Author:

rhanghof

Message:

#2817:

• Adjusted the unit tests
• Refactoring of the sorter
• Bugfix on the BinPackerResidualSpaceBestFit packer

File:

• branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Algorithms/ExtremePointAlgorithm.cs (modified) (6 diffs)

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Algorithms/ExtremePointAlgorithm.cs

@@ -83 +83 @@
 
     [Storable]
-    private readonly IValueParameter<BoolValue> sortByMaterialParameter;
-
-    public IValueParameter<BoolValue> SortByMaterialParameter {
-      get { return sortByMaterialParameter; }
+    private readonly IValueParameter<BoolValue> sortBySequenceGroupParameter;
+
+    public IValueParameter<BoolValue> SortBySequenceGroupParameter {
+      get { return sortBySequenceGroupParameter; }
     }
 
@@ -116 +116 @@
         "Delta", "[1;100]% Clustered sorting methods use a delta parameter to determine the clusters.", new PercentValue(.1)));
 
-      Parameters.Add(sortByMaterialParameter = new ValueParameter<BoolValue>(
-        "SortByMaterial", "If this parameter is set, the items will be sorted by their material first", new BoolValue(true)));
+      Parameters.Add(sortBySequenceGroupParameter = new ValueParameter<BoolValue>(
+        "SortBySequenceGroup", "If this parameter is set, the items will be sorted by their sequence group first", new BoolValue(true)));
 
       Problem = new PermutationProblem();
@@ -209 +209 @@
                   ExtremePointCreationMethod[] epCreationMethods,
                   CancellationToken token) {
+
       SortingMethod? bestSorting = null;
       FittingMethod? bestFitting = null;
@@ -223 +224 @@
             Permutation sortedItems;
 
-            if (SortByMaterialParameter.Value.Value) {
-              sortedItems = SortItemsByMaterialAndSortingMethod(bin, items, sort, DeltaParameter.Value.Value);
-            } else {
-              sortedItems = SortItemsBySortingMethod(bin, items, sort, DeltaParameter.Value.Value);
-            }
-
+            sortedItems = SortItems(bin, items, sort, DeltaParameter.Value.Value, SortBySequenceGroupParameter.Value.Value);
+            
             var solution = Optimize(new OptimaizationParamters() {
               SortedItems = sortedItems,
@@ -265 +262 @@
     /// <returns></returns>
     private static Solution Optimize(OptimaizationParamters parameters) {
-
       var sol = parameters.Decoder.Decode(parameters.SortedItems, parameters.Bin, parameters.Items, parameters.StackingConstraints);
 
@@ -281 +277 @@
     }
     
-    /// <summary>
-    /// Returns a new permutation of the given items depending on the sorting method
-    /// </summary>
-    /// <param name="bin"></param>
-    /// <param name="items"></param>
-    /// <param name="sortingMethod"></param>
-    /// <param name="delta"></param>
-    /// <returns></returns>
-    private Permutation SortItemsByMaterialAndSortingMethod(PackingShape bin, IList<PackingItem> items, SortingMethod sortingMethod, double delta) {
-      Permutation sorted = null;
-
-      switch (sortingMethod) {
-        case SortingMethod.Given:
-          sorted = new Permutation(PermutationTypes.Absolute, Enumerable.Range(0, items.Count).ToArray());
-          break;
-        case SortingMethod.VolumeHeight:
-          sorted = items.SortByVolumeHeight();
-          break;
-        case SortingMethod.HeightVolume:
-          sorted = items.SortByMaterialHeightVolume();
-          break;
-        case SortingMethod.AreaHeight:
-          sorted = items.SortByMaterialAreaHeight();
-          break;
-        case SortingMethod.HeightArea:
-          sorted = items.SortByMaterialHeightArea();
-          break;
-        case SortingMethod.ClusteredAreaHeight:
-          sorted = items.SortByMaterialClusteredAreaHeight(bin, delta);
-          break;
-        case SortingMethod.ClusteredHeightArea:
-          sorted = items.SortByMaterialClusteredHeightArea(bin, delta);
-          break;
-        default:
-          throw new ArgumentException("Unknown sorting method: " + sortingMethod);
-      }
-      return sorted;
-    }
-
-    /// <summary>
-    /// Returns a new permutation of the given items depending on the material and sorting method
-    /// </summary>
-    /// <param name="bin"></param>
-    /// <param name="items"></param>
-    /// <param name="sortingMethod"></param>
-    /// <param name="delta"></param>
-    /// <returns></returns>
-    private Permutation SortItemsBySortingMethod(PackingShape bin, IList<PackingItem> items, SortingMethod sortingMethod, double delta) {
-      Permutation sorted = null;
-
-      switch (sortingMethod) {
-        case SortingMethod.Given:
-          sorted = new Permutation(PermutationTypes.Absolute, Enumerable.Range(0, items.Count).ToArray());
-          break;
-        case SortingMethod.VolumeHeight:
-          sorted = items.SortByVolumeHeight();
-          break;
-        case SortingMethod.HeightVolume:
-          sorted = items.SortByHeightVolume();
-          break;
-        case SortingMethod.AreaHeight:
-          sorted = items.SortByAreaHeight();
-          break;
-        case SortingMethod.HeightArea:
-          sorted = items.SortByHeightArea();
-          break;
-        case SortingMethod.ClusteredAreaHeight:
-          sorted = items.SortByClusteredAreaHeight(bin, delta);
-          break;
-        case SortingMethod.ClusteredHeightArea:
-          sorted = items.SortByClusteredHeightArea(bin, delta);
-          break;
-        default:
-          throw new ArgumentException("Unknown sorting method: " + sortingMethod);
-      }
-      return sorted;
-    }
+
+    private Permutation SortItems(PackingShape bin, IList<PackingItem> items, SortingMethod sortingMethod, double delta, bool sortBySequenceGroup) {
+      Permutation sortedItems;
+
+      var sorter = PackingItemSorterFactory.CreatePackingItemSorter(sortingMethod);
+      if (sorter is IPackingItemClusteredSorter) {
+        if (sortBySequenceGroup) {
+          sortedItems = (sorter as IPackingItemClusteredSorter).SortPackingItemsBySequenceGroup(items, bin, delta);
+        } else {
+          sortedItems = (sorter as IPackingItemClusteredSorter).SortPackingItems(items, bin, delta);
+        }
+      } else {
+        if (sortBySequenceGroup) {
+          sortedItems = sorter.SortPackingItemsBySequenceGroup(items, bin);
+        } else {
+          sortedItems = sorter.SortPackingItems(items, bin);
+        }
+      }
+      return sortedItems;
+    }    
   }
 }