Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
06/06/13 03:12:42 (11 years ago)
Author:
jhelm
Message:

#1966: Applied some heavy refactoring on the decoder-classes and cleaned up the code a bit;

Location:
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders
Files:
3 added
17 edited

Legend:

Unmodified
Added
Removed

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

    r9563 r9593  
    77using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    88using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     9using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    910using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    1011using HeuristicLab.Encodings.PermutationEncoding;
    … …  
    1819  public static class BottomLeftFunctions {
    1920
    20 
    21     public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
     21    /*
     22    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> BottomLeftPacking(
    2223      MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    2324      int nrOfBins = solution.NrOfBins;
    … …  
    3031      }
    3132
    32       ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
     33      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
    3334      var remainingItems = new List<PackingInformation>();
    3435
    … …  
    4243          TwoDimensionalPacking position = null;
    4344
    44           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
     45          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures, unpackedItems[i].Rotated);
    4546
    4647          if (position == null) {
    47             position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
    48           }
    49           if (position == null) {
    50             remainingItems.Add(unpackedItems[i]);
     48            position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures, !unpackedItems[i].Rotated);
     49          }
     50          if (position == null) { 
     51            remainingItems.Add(unpackedItems[i]);     
     52            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
    5153          } else {
    52             packingPositions[itemIndex] = position;
    53             solution.PackingInformations[binNr].Remove(unpackedItems[i]);
     54            itemPositions[itemIndex] = position;
    5455            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
    5556          }
    … …  
    6768
    6869          //Look for space in current bin
    69           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
     70          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures, unpackedItems[i].Rotated);
    7071
    7172          if (position == null) {
    72             position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
     73            position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures, !unpackedItems[i].Rotated);
    7374          }
    7475          if (position != null) {
    75             packingPositions[itemIndex] = position;
     76            itemPositions[itemIndex] = position;
    7677            remainingItems.Remove(unpackedItems[i]);
    7778            solution.PackingInformations[binNr].Add(unpackedItems[i]);
    … …  
    8586      }
    8687
    87       return packingPositions;
    88     }
    89 
    90     public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
     88      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     89    }
     90
     91    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> BottomLeftPacking(
    9192      GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    9293
    … …  
    104105      }
    105106
    106       ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
     107      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
    107108      var remainingItems = new List<int>();
    108109
    … …  
    117118
    118119          //Look for space in current bin
    119           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     120          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    120121
    121122          //Did not find enough space in current bin
    … …  
    123124            remainingItems.Add(itemIndex);
    124125          } else
    125             packingPositions[itemIndex] = position;
     126            itemPositions[itemIndex] = position;
    126127        }
    127128      }
    … …  
    137138
    138139          //Look for space in current bin
    139           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     140          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    140141
    141142          if (position != null) {
    142             packingPositions[itemIndex] = position;
     143            itemPositions[itemIndex] = position;
    143144            remainingItems.Remove(itemIndex);
    144145            solution.GroupingVector[itemIndex] = binNr;
    … …  
    150151      }
    151152
    152       return packingPositions;
    153     }
    154 
    155     public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
     153      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     154    }
     155
     156    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> BottomLeftPacking(
    156157      PackingSequenceEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    157158
    158       ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
     159      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
    159160      int nrOfBins = 1;
    160161      for (int i = 0; i < solution.PackingSequence.Length; i++) {
    … …  
    163164        //Look for space in existing bins
    164165        for (int binNr = 0; binNr < nrOfBins; binNr++) {
    165           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     166          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    166167          if (position != null)
    167168            break;
    … …  
    170171        if (position == null) {
    171172          nrOfBins++;
    172           position = BottomLeftFunctions.BottomLeftPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures);
     173          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, nrOfBins - 1, item, itemPositions, itemMeasures);
    173174        }
    174175
    … …  
    176177          position = new TwoDimensionalPacking(-1, 0, 0);
    177178
    178         packingPositions[solution.PackingSequence[i]] = position;
    179       }
    180 
    181       return packingPositions;
    182     }
    183 
    184     private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
     179        itemPositions[solution.PackingSequence[i]] = position;
     180      }
     181
     182      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     183    }
     184
     185    */
     186    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
    185187      return BottomLeftPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false);
    186188    }
    187     private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {     
     189    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {     
    188190      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr,
    189191        binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width),

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

    r9563 r9593  
    6666
    6767      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    68         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
     68        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
    6969
    70       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
     70      result.BinPackings = TwoDimensionalPackingFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures); //BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
    7171      return result;
    7272    }

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

    r9563 r9593  
    6666
    6767      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    68         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
    69      
    70       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
     68        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
     69
     70      result.BinPackings = TwoDimensionalPackingFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures); //BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
    7171
    7272      return result;

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

    r9563 r9593  
    6565
    6666      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    67         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
     67        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
    6868
    69       result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking (solution, binMeasures, itemMeasures);
     69      result.BinPackings = TwoDimensionalPackingFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures); //BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
    7070
    7171      return result;

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

    r9563 r9593  
    6060    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    6161      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    62         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
     62        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
    6363
    64       result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
     64      result.BinPackings = TwoDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);//ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
    6565
    6666      return result;

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

    r9563 r9593  
    6161    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
    6262      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    63         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
     63        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
    6464
    65       result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
     65      result.BinPackings = TwoDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);//ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
    6666
    6767      return result;

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

    r9563 r9593  
    6464
    6565      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
    66         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
     66        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures);
    6767
    68       result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
     68      result.BinPackings = TwoDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);//ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
    6969
    7070      return result;

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

    r9563 r9593  
    77using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    88using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     9using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    910using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    1011using HeuristicLab.Encodings.PermutationEncoding;
    … …  
    2122
    2223
    23     public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(MultiComponentVectorEncoding solution,
     24    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> ExtremePointBasedPacking(MultiComponentVectorEncoding solution,
    2425        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
    2526
    … …  
    9899      }
    99100
    100       return itemPositions;
    101     }
    102 
    103 
    104     public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
     101      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     102    }
     103
     104
     105    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> ExtremePointBasedPacking(GroupingVectorEncoding solution,
    105106        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
    106107
    … …  
    180181      }
    181182
    182       return itemPositions;
    183     }
    184 
    185 
    186     public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution,
     183      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     184    }
     185
     186
     187    public static ObservableList<BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> ExtremePointBasedPacking(PackingSequenceEncoding solution,
    187188        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
    188189
    … …  
    215216      }
    216217
    217       return itemPositions;
    218     }
    219 
    220 
    221     private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
     218      return BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     219    }
     220
     221
     222    public static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
    222223        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions) {
    223224          return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
    224225    }
    225     private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
     226    public static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
    226227        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, bool rotated) {
    227228
    … …  
    233234
    234235      int epIndex = 0;
    235       while (epIndex < extremePoints.Count &&
     236      while (epIndex < extremePoints.Count &&       
     237        //(!IsPositionFeasible(binMeasures, item, extremePoints.ElementAt(epIndex), occupiedPoints)))
    236238        (!BottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures)))
    237239      { epIndex++; }
    … …  
    244246      return null;
    245247    }
    246     private static List<int[,]> IncreaseBinCountForOccupiedPoints(List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
     248    public static List<int[,]> IncreaseBinCountForOccupiedPoints(List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
    247249      occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height]);
    248250      int lastIndex = occupiedPoints.Count - 1;
    … …  
    254256      return occupiedPoints;
    255257    }
    256     private static List<int[,]>  OccupyPointsForNewItem(List<int[,]> occupiedPoints, RectangularPackingItem newItem, TwoDimensionalPacking position, int itemIndex) {
     258    public static List<int[,]>  OccupyPointsForNewItem(List<int[,]> occupiedPoints, RectangularPackingItem newItem, TwoDimensionalPacking position, int itemIndex) {
    257259      int width = position.Rotated ? newItem.Height : newItem.Width;
    258260      int height = position.Rotated ? newItem.Width : newItem.Height;
    … …  
    264266      return occupiedPoints;
    265267    }
    266     private static HashSet<TwoDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints,
     268    public static HashSet<TwoDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints,
    267269        RectangularPackingItem newItem, TwoDimensionalPacking position, RectangularPackingBin binMeasures) {
    268270      int currentBin = position.AssignedBin;
    … …  
    321323      return shortestSide;
    322324    }
     325
     326   
    323327  }
    324328}

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

    r9563 r9593  
    77using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    88using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     9using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    910using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    1011using HeuristicLab.Encodings.PermutationEncoding;
    … …  
    1819  public static class DeepestBottomLeftFunctions {
    1920
    20     public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     21    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> DeepestLeftBottomPacking(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    2122      int nrOfBins = solution.NrOfBins;
    2223
    … …  
    2829      }
    2930
    30       ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
     31      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
    3132      var remainingItems = new List<PackingInformation>();
    3233
    … …  
    4041          ThreeDimensionalPacking position = null;
    4142
    42           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
    43 
    44           if (position == null) {
    45             position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
     43          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures, unpackedItems[i].Rotated);
     44
     45          if (position == null) {
     46            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures, !unpackedItems[i].Rotated);
    4647          }
    4748          if (position == null) {
    … …  
    4950            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
    5051          } else {
    51             packingPositions[itemIndex] = position;
     52            itemPositions[itemIndex] = position;
    5253            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
    5354          }
    … …  
    6566
    6667          //Look for space in current bin
    67           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
    68 
    69           if (position == null) {
    70             position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
     68          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures, unpackedItems[i].Rotated);
     69
     70          if (position == null) {
     71            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures, !unpackedItems[i].Rotated);
    7172          }
    7273          if (position != null) {
    73             packingPositions[itemIndex] = position;
     74            itemPositions[itemIndex] = position;
    7475            remainingItems.Remove(unpackedItems[i]);
    7576            solution.PackingInformations[binNr].Add(unpackedItems[i]);
    … …  
    8384      }
    8485
    85       return packingPositions;
    86     }
    87 
    88     public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     86      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     87    }
     88
     89    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    8990      int nrOfBins = solution.GroupingVector.Max() + 1;
    9091
    … …  
    100101      }
    101102
    102       ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
     103      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
    103104      var remainingItems = new List<int>();
    104105
    … …  
    112113          ThreeDimensionalPacking position = null;
    113114
    114           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     115          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    115116
    116117          if (position == null) {
    117118            remainingItems.Add(itemIndex);
    118119          } else
    119             packingPositions[itemIndex] = position;
     120            itemPositions[itemIndex] = position;
    120121        }
    121122      }
    … …  
    131132
    132133          //Look for space in current bin
    133           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     134          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    134135
    135136          if (position != null) {
    136             packingPositions[itemIndex] = position;
     137            itemPositions[itemIndex] = position;
    137138            remainingItems.Remove(itemIndex);
    138139            //solution.GroupingVector[itemIndex] = binNr;
    … …  
    144145      }
    145146
    146       return packingPositions;
    147     }
    148 
    149     public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(PackingSequenceEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
    150       ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
     147      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     148    }
     149
     150    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> DeepestLeftBottomPacking(PackingSequenceEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     151      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
    151152      int nrOfBins = 1;
    152153      for (int i = 0; i < solution.PackingSequence.Length; i++) {
    … …  
    155156        //Look for space in existing bins
    156157        for (int binNr = 0; binNr < nrOfBins; binNr++) {
    157           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
     158          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, itemPositions, itemMeasures);
    158159          if (position != null)
    159160            break;
    … …  
    162163        if (position == null) {
    163164          nrOfBins++;
    164           position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures);
     165          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, nrOfBins - 1, item, itemPositions, itemMeasures);
    165166        }
    166167
    … …  
    168169          position = new ThreeDimensionalPacking(-1, 0, 0, 0);
    169170
    170         packingPositions[solution.PackingSequence[i]] = position;
    171       }
    172 
    173       return packingPositions;
     171        itemPositions[solution.PackingSequence[i]] = position;
     172      }
     173
     174      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
    174175    }
    175176
    … …  
    204205    }
    205206
     207   
     208
    206209    public static bool IsPositionFeasible(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem,
    207210      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
    … …  
    233236    }
    234237
    235 
    236  
    237238  }
    238239}

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

    r9563 r9593  
    6464      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
    6565
    66       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(
    67         binMeasures, itemMeasures);
     66      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
    6867
    69       ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking(
    70         solution,
    71         binMeasures,
    72         itemMeasures);
    73 
    74 
    75       result.PackingItemPositions = packingPositions;
     68      result.BinPackings = ThreeDimensionalPackingFunctions.DeepestLeftBottomPacking(solution, binMeasures, itemMeasures);
    7669
    7770      return result;

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

    r9563 r9593  
    6666
    6767      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    68         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
    69      
    70       result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);
     68        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
     69
     70      result.BinPackings = ThreeDimensionalPackingFunctions.DeepestLeftBottomPacking(solution, binMeasures, itemMeasures);
    7171
    7272      return result;

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

    r9563 r9593  
    6565
    6666      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    67         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
     67        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
    6868
    69       result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);
     69      result.BinPackings = ThreeDimensionalPackingFunctions.DeepestLeftBottomPacking(solution, binMeasures, itemMeasures);
    7070
    7171      return result;

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

    r9563 r9593  
    3737using HeuristicLab.Problems.BinPacking.Interfaces;
    3838using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
     39using HeuristicLab.Parameters;
    3940
    4041namespace HeuristicLab.Problems.BinPacking.Decoders {
    … …  
    4647      CuboidPackingItem>, I3DGVDecoder {
    4748
     49    public ValueParameter<BoolValue> StackingConstraintsParameter {
     50      get { return (ValueParameter<BoolValue>)Parameters["StackingConstraint"]; }
     51    }
     52
    4853    public ExtremePointGroupingVectorDecoder3D ()
    4954      : base() {
     55      Parameters.Add(new ValueParameter<BoolValue>("StackingConstraint", "A flag determining whether stackingconstraints should be enforced or not."));
    5056    }
    5157    [StorableConstructor]
    … …  
    5864    }
    5965
    60     public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     66    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
    6167      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    62         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
     68        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
    6369
    64       result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
     70      result.BinPackings = ThreeDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures, stackingConstraints);
    6571
    6672      return result;
    … …  
    7278      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
    7379
    74       return Decode(solution, binMeasures, itemMeasures);
     80      return Decode(solution, binMeasures, itemMeasures, StackingConstraintsParameter.Value.Value);
    7581    }
    7682  }

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

    r9563 r9593  
    3838using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    3939using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     40using HeuristicLab.Parameters;
    4041
    4142namespace HeuristicLab.Problems.BinPacking.Decoders {
    … …  
    4748      CuboidPackingItem>, I3DMCVDecoder {
    4849
     50    public ValueParameter<BoolValue> StackingConstraintsParameter {
     51      get { return (ValueParameter<BoolValue>)Parameters["StackingConstraint"]; }
     52    }
     53
    4954    public ExtremePointMultiComponentVectorDecoder3D ()
    5055      : base() {
     56      Parameters.Add(new ValueParameter<BoolValue>("StackingConstraint", "A flag determining whether stackingconstraints should be enforced or not."));
    5157    }
    5258    [StorableConstructor]
    … …  
    5965    }
    6066
    61     public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
     67    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
    6268      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    63         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
     69        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
    6470
    65       result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(ref solution, itemMeasures, binMeasures);
     71      result.BinPackings = ThreeDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures, stackingConstraints);
    6672
    6773      return result;
    … …  
    7379      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
    7480
    75       return Decode(solution, binMeasures, itemMeasures);
     81      return Decode(solution, binMeasures, itemMeasures, StackingConstraintsParameter.Value.Value);
    7682    }
    7783  }

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

    r9563 r9593  
    3636using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    3737using HeuristicLab.Problems.BinPacking.Interfaces;
     38using HeuristicLab.Parameters;
    3839
    3940namespace HeuristicLab.Problems.BinPacking.Decoders {
    … …  
    4546      CuboidPackingItem>, I3DPSDecoder {
    4647
     48    public ValueParameter<BoolValue> StackingConstraintsParameter {
     49      get { return (ValueParameter<BoolValue>)Parameters["StackingConstraint"]; }
     50    }
     51
    4752    public ExtremePointPackingSequenceDecoder3D ()
    4853      : base() {
     54        Parameters.Add(new ValueParameter<BoolValue>("StackingConstraint", "A flag determining whether stackingconstraints should be enforced or not."));
    4955    }
    5056    [StorableConstructor]
    … …  
    6470
    6571      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    66         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
     72        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures);
    6773
    68       result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
     74      result.BinPackings = ThreeDimensionalPackingFunctions.ExtremePointBasedPacking(solution, itemMeasures, binMeasures, StackingConstraintsParameter.Value.Value);
    6975
    7076      return result;

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

    r9563 r9593  
    88using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
    99using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
     10using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
    1011using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
    1112using HeuristicLab.Encodings.PermutationEncoding;
    … …  
    2021
    2122
    22     public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution,
    23         ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
     23    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution,
     24        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, bool stackingConstraints) {
    2425
    2526      #region Preperations
    … …  
    9798      }
    9899
    99       return itemPositions;
    100     }
    101 
    102 
    103     public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
    104         ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
     100      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     101    }
     102
     103
     104    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> ExtremePointBasedPacking(GroupingVectorEncoding solution,
     105        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, bool stackingConstraints) {
    105106
    106107      #region Preperations
    … …  
    139140
    140141          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
    141           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
     142          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, stackingConstraints);
    142143          if (positionFound != null) {
    143144            extremePointsForBin[binNr].Remove(positionFound);
    … …  
    162163
    163164          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
    164           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
     165          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, stackingConstraints);
    165166          if (positionFound != null) {
    166167            extremePointsForBin[binNr].Remove(positionFound);
    … …  
    179180      }
    180181
    181       return itemPositions;
    182     }
    183 
    184 
    185     public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution,
    186         ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
     182      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     183    }
     184
     185
     186    public static ObservableList<BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> ExtremePointBasedPacking(PackingSequenceEncoding solution,
     187        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, bool stackingConstraints) {
    187188
    188189      #region Preperations
    … …  
    200201        var item = itemMeasures[itemIndex];
    201202        extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
    202         var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
     203        var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, stackingConstraints);
    203204        if (positionFound != null) {
    204205          extremePoints.Remove(positionFound);
    … …  
    214215      }
    215216
    216       return itemPositions;
    217     }
     217      return BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, binMeasures, itemMeasures, nrOfBins);
     218    }
     219
     220
    218221
    219222
    220223    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
    221         HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions) {
    222           return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
    223     }
     224        HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool stackingConstraints) {
     225          return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, stackingConstraints, false);
     226    }
     227    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
     228        HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool stackingConstraints, bool rotated) {
     229
     230      var itemFromList = itemMeasures[itemIndex];
     231      CuboidPackingItem item = new CuboidPackingItem(
     232        rotated ? itemFromList.Depth : itemFromList.Width,
     233        itemFromList.Height,
     234        rotated ? itemFromList.Width : itemFromList.Depth,
     235        itemFromList.TargetBin);
     236
     237      int epIndex = 0;
     238      while (epIndex < extremePoints.Count &&   
     239        //(!IsPositionFeasible(binMeasures, item, extremePoints.ElementAt(epIndex), occupiedPoints) ||
     240        (!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
     241        (stackingConstraints && !IsStaticStable(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex)))))
     242      { epIndex++; }
     243
     244      if (epIndex < extremePoints.Count) {
     245        var result = extremePoints.ElementAt(epIndex);
     246        result.Rotated = rotated;
     247        return result;
     248      }
     249      return null;
     250    }
     251
     252
    224253    public static ThreeDimensionalPacking FindExtremePointForItemUsingMaterialAndWeightConstraint(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
    225254       HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
    … …  
    234263      int epIndex = 0;
    235264      while (epIndex < extremePoints.Count &&
     265        //(!IsPositionFeasible(binMeasures, item, extremePoints.ElementAt(epIndex), occupiedPoints) || 
    236266        (!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
    237267        !IsStaticStable(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex)) ||
    … …  
    243273        return result;
    244274      }
    245       return null;
    246     }
    247     public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
    248         HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
    249 
    250       var itemFromList = itemMeasures[itemIndex];
    251       CuboidPackingItem item = new CuboidPackingItem(
    252         rotated ? itemFromList.Depth : itemFromList.Width,
    253         itemFromList.Height,
    254         rotated ? itemFromList.Width : itemFromList.Depth,
    255         itemFromList.TargetBin);
    256 
    257       int epIndex = 0;
    258       while (epIndex < extremePoints.Count &&
    259         (!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
    260         !IsStaticStable(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex))))
    261       { epIndex++; }
    262 
    263       if (epIndex < extremePoints.Count) {
    264         var result = extremePoints.ElementAt(epIndex);
    265         result.Rotated = rotated;
    266         return result;
    267       }
    268275      return null;
    269276    }
    … …  
    439446      return shortestSide;
    440447    }
     448
     449   
    441450  }
    442451}

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

    r9563 r9593  
    6262     
    6363      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
    64         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(new ObservableDictionary<int, CuboidPackingBin>(), itemMeasures);
    65 
     64        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>();
     65                                                                   /*
    6666      #region Preperations
    6767      int nrOfBins = solution.NrOfBins;
    … …  
    153153      }
    154154
    155       result.PackingItemPositions = itemPositions;
    156       result.PackingBinMeasures = resultingBinMeasures;
     155      result.BinPackings = BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.GetBinPackings(itemPositions, resultingBinMeasures, itemMeasures, nrOfBins);   */
    157156      return result;
    158157    }
Note: See TracChangeset for help on using the changeset viewer.