source: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/SequentialPackingFunctions.cs @ 9593

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Collections;
using HeuristicLab.Core;
using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
using HeuristicLab.Encodings.PermutationEncoding;
using HeuristicLab.Problems.BinPacking.Dimensions;
using HeuristicLab.Problems.BinPacking.Interfaces;
using HeuristicLab.Problems.BinPacking.PackingBin;
using HeuristicLab.Problems.BinPacking.PackingItem;
using HeuristicLab.Problems.BinPacking.Shapes;

namespace HeuristicLab.Problems.BinPacking.Decoders {
  public static class SequentialPackingFunctions {     



    public static List<List<int>> GenerateSequenceMatrix(GroupingVectorEncoding gv) {
      List<List<int>> result = new List<List<int>> ();
      int nrOfBins = gv.GroupingVector.Max() + 1;
      for (int i = 0; i < nrOfBins; i++)
        result.Add (new List<int>());
      for (int i = 0; i < gv.GroupingVector.Length; i++ ) {
        result[gv.GroupingVector[i]].Add(i);
      }
      return result;
    }
    public static List<List<int>> GenerateSequenceMatrix(MultiComponentVectorEncoding mcv) {
      List<List<int>> result = new List<List<int>>();
      foreach (var bi in mcv.PackingInformations){
        var temp = new List<int>();
        foreach (var piEntry in bi.Value) {
          temp.Add(piEntry.ItemID);
        }
        result.Add(temp);
      }
      return result;
    }
    public static Dictionary<int, bool> GenerateRotationArray(MultiComponentVectorEncoding solution) {
      Dictionary<int, bool> result = new Dictionary<int, bool>();
      foreach (var bi in solution.PackingInformations)
        foreach (var pi in bi.Value)
          result[pi.ItemID] = pi.Rotated;
      return result;
    }





    public static BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> BottomLeftPacking(
      ref List<int> sequence,  RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
      BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = new BinPacking2D(binMeasures);
      var temp = new List<int>(sequence);
      for (int i = 0; i < temp.Count; i++) {
        var item = itemMeasures[temp[i]];
        TwoDimensionalPacking position = result.FindPositionBySliding(item, false);
        if (position != null) {
          result.PackItem(temp[i], item, position);
          sequence.Remove(temp[i]);
        }
      }
      return result;
    }
    public static BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> BottomLeftPacking(
      ref List<int> sequence, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures, Dictionary<int,bool> rotationArray) {
      BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = new BinPacking2D(binMeasures);
      var temp = new List<int>(sequence);
      for (int i = 0; i < temp.Count; i++) {
        var item = itemMeasures[temp[i]];
        TwoDimensionalPacking position = result.FindPositionBySliding(item, rotationArray[temp[i]]);
        if (position != null) {
          result.PackItem(temp[i], item, position);
          sequence.Remove(temp[i]);
        }
      }
      return result;
    }

    public static BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> DeepestLeftBottomPacking(
      ref List<int> sequence, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
      BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new BinPacking3D(binMeasures);
      var temp = new List<int>(sequence);
      for (int i = 0; i < temp.Count; i++) {
        var item = itemMeasures[temp[i]];
        ThreeDimensionalPacking position = result.FindPositionBySliding(item, false);
        
        if (position != null) {
          result.PackItem(temp[i], item, position);
          sequence.Remove(temp[i]);
        }
      }
      return result;
    }
    public static BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> DeepestLeftBottomPacking(
      ref List<int> sequence, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
      BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new BinPacking3D(binMeasures);
      var temp = new List<int>(sequence);
      for (int i = 0; i < temp.Count; i++) {
        var item = itemMeasures[temp[i]];
        ThreeDimensionalPacking position = result.FindPositionBySliding(item, rotationArray[i]);

        if (position != null) {
          result.PackItem(temp[i], item, position);
          sequence.Remove(temp[i]);
        }
      }
      return result;
    }
        
    public static BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> ExtremePointBasedPacking(
      ref List<int> sequence, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {  
      BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = new BinPacking2D(binMeasures);
      
      var temp = new List<int>(sequence);
      foreach (int itemID in temp) {
        var item = itemMeasures[itemID];
        var positionFound = result.FindExtremePointForItem(item, false, false);
        if (positionFound != null) {
          result.PackItem(itemID, item, positionFound);
          sequence.Remove(itemID);
        } 
      }

      return result;
    }
    public static BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> ExtremePointBasedPacking(
      ref List<int> sequence, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
      BinPacking<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = new BinPacking2D(binMeasures);

      var temp = new List<int>(sequence);
      foreach (int itemID in temp) {
        var item = itemMeasures[itemID];
        var positionFound = result.FindExtremePointForItem(item, rotationArray[itemID], false);
        if (positionFound != null) {
          result.PackItem(itemID, item, positionFound);
          sequence.Remove(itemID);
        }
      }

      return result;
    }

    public static BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> ExtremePointBasedPacking(
      ref List<int> sequence, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
      BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new BinPacking3D(binMeasures);

      var temp = new List<int>(sequence);
      foreach (int itemID in temp) {
        var item = itemMeasures[itemID];
        var positionFound = result.FindExtremePointForItem(item, false, stackingConstraints);
        if (positionFound != null) {
          result.PackItem(itemID, item, positionFound);
          sequence.Remove(itemID);
        }
      }

      return result;
    }
    public static BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> ExtremePointBasedPacking(
      ref List<int> sequence, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
      BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new BinPacking3D(binMeasures);

      var temp = new List<int>(sequence);
      foreach (int itemID in temp) {
        var item = itemMeasures[itemID];
        var positionFound = result.FindExtremePointForItem(item, rotationArray[itemID], stackingConstraints);
        if (positionFound != null) {
          result.PackItem(itemID, item, positionFound);
          sequence.Remove(itemID);
        }
      }

      return result;
    }






         
             /*

    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {
      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(0,
        binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width),
        binMeasures.Height - (rotated ? currentItem.Width : currentItem.Height), rotated);
      //Slide the item as far as possible to the left
      while (IsPositionFeasible(binMeasures, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
        || IsPositionFeasible(binMeasures, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
        //Slide the item as far as possible to the bottom
        while (IsPositionFeasible(binMeasures, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
          currentPosition = MoveDown(currentPosition);
        }
        if (IsPositionFeasible(binMeasures, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
          currentPosition = MoveLeft(currentPosition);
      }

      return IsPositionFeasible(binMeasures, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
    }
    private static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Rotated);
    }
    private static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Rotated);
    }
   

    private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
        HashSet<TwoDimensionalPacking> extremePoints, int[,] occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, bool rotated) {

      var itemFromList = itemMeasures[itemIndex];
      RectangularPackingItem item = new RectangularPackingItem(
        rotated ? itemFromList.Height : itemFromList.Width,
        rotated ? itemFromList.Width : itemFromList.Height,
        itemFromList.TargetBin);

      int epIndex = 0;
      while (epIndex < extremePoints.Count &&
        (!IsPositionFeasible(binMeasures, item, extremePoints.ElementAt(epIndex), occupiedPoints)))
        //(!BottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures))) 
        { epIndex++; }

      if (epIndex < extremePoints.Count) {
        var result = extremePoints.ElementAt(epIndex);
        result.Rotated = rotated;
        return result;
      }
      return null;
    }
    private static HashSet<TwoDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<TwoDimensionalPacking> extremePoints, int[,] occupiedPoints,
        RectangularPackingItem newItem, TwoDimensionalPacking position, RectangularPackingBin binMeasures) {

      int newWidth = position.Rotated ? newItem.Height : newItem.Width;
      int newHeight = position.Rotated ? newItem.Width : newItem.Height;

      //Find ExtremePoints beginning from sourcepointX
      var sourcePointX = new TwoDimensionalPacking(0, position.X + newWidth, position.Y);
      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height) {
        //Traversing down the y-axis                                                                            
        int currentYValue = sourcePointX.Y;
        while (currentYValue > 0 && occupiedPoints[sourcePointX.X, currentYValue] == -1) {
          currentYValue--;
        }
        extremePoints.Add(new TwoDimensionalPacking(0, sourcePointX.X, currentYValue));
      }




      //Find ExtremePoints beginning from sourcepointY
      var sourcePointY = new TwoDimensionalPacking(0, position.X, position.Y + newItem.Height);
      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height) {
        //Traversing down the x-axis  
        int currentXValue = sourcePointY.X;
        while (currentXValue > 0 && occupiedPoints[currentXValue - 1, sourcePointY.Y] == -1) {
          currentXValue--;
        }
        extremePoints.Add(new TwoDimensionalPacking(0, currentXValue, sourcePointY.Y));
      }


      return extremePoints;
    }
    private static HashSet<TwoDimensionalPacking> OrderExtremePoints(HashSet<TwoDimensionalPacking> hashSet, int[,] occupiedPoints, RectangularPackingBin binMeasures) {
      return new HashSet<TwoDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
    }
    private static int ShortestPossibleSideFromEP(TwoDimensionalPacking ep, int[,] occupiedPoints, RectangularPackingBin binMeasures) {
      int shortestSide = int.MaxValue;

      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height)
        return shortestSide;

      int currentX = ep.X;
      while (currentX < binMeasures.Width && occupiedPoints[currentX, ep.Y] == -1) { currentX++; }
      if (currentX - ep.X < shortestSide)
        shortestSide = currentX - ep.X;

      int currentY = ep.Y;
      while (currentY < binMeasures.Height && occupiedPoints[ep.X, currentY] == -1) { currentY++; }
      if (currentY - ep.Y < shortestSide)
        shortestSide = currentY - ep.Y;

      return shortestSide;
    }
    private static int[,] OccupyPointsForNewItem(int[,] occupiedPoints, RectangularPackingItem newItem, TwoDimensionalPacking position, int itemIndex) {
      int width = position.Rotated ? newItem.Height : newItem.Width;
      int height = position.Rotated ? newItem.Width : newItem.Height;
      for (int w = position.X; w < position.X + width; w++) {
        for (int h = position.Y; h < position.Y + height; h++) {
          occupiedPoints[w, h] = itemIndex;
        }
      }
      return occupiedPoints;
    }
    private static int[,] GetOccupiedPoints(RectangularPackingBin binMeasures) {
      var result = new int[binMeasures.Width, binMeasures.Height];
      for (int w = 0; w < binMeasures.Width; w++) {
        for (int h = 0; h < binMeasures.Height; h++) {
            result[w, h] = -1;
        }
      }
      return result;
    }
    private static bool IsPositionFeasible(RectangularPackingBin binMeasures, RectangularPackingItem currentItem,
     TwoDimensionalPacking position, int[,] occupiedPoints) {
      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
      if (!binMeasures.Encloses(position, currentItem))
        return false;

      for (int w = position.X; w < position.X + currentItem.Width; w++) {
        for (int h = position.Y; h < position.Y + currentItem.Height; h++) {
          if (occupiedPoints[w, h] != -1)
            return false;
        }
      }

      return true;
    }
    private static bool IsPositionFeasible(RectangularPackingBin binMeasures, RectangularPackingItem currentItem,
      TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
      if (!binMeasures.Encloses(currentPosition, currentItem))
        return false;

      foreach (var ipEntry in itemPositions) {
        if (itemMeasures[ipEntry.Key].Overlaps(ipEntry.Value, currentPosition, currentItem))
          return false;
      }

      return true;
    }

                          */








     

               /*
    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures, bool rotated) {
      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(0,
        binMeasures.Width - (rotated ? currentItem.Depth : currentItem.Width),
        binMeasures.Height - currentItem.Height,
        binMeasures.Depth - (rotated ? currentItem.Width : currentItem.Depth), rotated);
      //Slide the item as far as possible to the bottom
      while (IsPositionFeasible(binMeasures, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)
        || IsPositionFeasible(binMeasures, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
        || IsPositionFeasible(binMeasures, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
        //Slide the item as far as possible to the left
        while (IsPositionFeasible(binMeasures, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
        || IsPositionFeasible(binMeasures, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
          //Slide the item as far as possible to the back
          while (IsPositionFeasible(binMeasures, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
            currentPosition = MoveBack(currentPosition);
          }
          if (IsPositionFeasible(binMeasures, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
            currentPosition = MoveLeft(currentPosition);
        }
        if (IsPositionFeasible(binMeasures, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures))
          currentPosition = MoveDown(currentPosition);
      }

      return IsPositionFeasible(binMeasures, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
    }
    private static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
    }
    private static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
    }
    private static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
    }
  
    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
        HashSet<ThreeDimensionalPacking> extremePoints, int[, ,] occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool stackingConstraints, bool rotated) {

      var itemFromList = itemMeasures[itemIndex];
      CuboidPackingItem item = new CuboidPackingItem(
        rotated ? itemFromList.Depth : itemFromList.Width,
        itemFromList.Height,
        rotated ? itemFromList.Width : itemFromList.Depth,
        itemFromList.TargetBin);

      int epIndex = 0;
      while (epIndex < extremePoints.Count &&
        (!IsPositionFeasible(binMeasures, item, extremePoints.ElementAt(epIndex), occupiedPoints)
        //(!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
        //||(stackingConstraints && !ExtremePointsFunctions3D.IsStaticStable(occupiedPoints, item, extremePoints.ElementAt(epIndex))) 
        )){ epIndex++; }

      if (epIndex < extremePoints.Count) {
        var result = extremePoints.ElementAt(epIndex);
        result.Rotated = rotated;
        return result;
      }
      return null;
    }
    private static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, int[, ,] occupiedPoints,
        CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) {

      int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
      int newDepth = position.Rotated ? newItem.Width : newItem.Depth;

      //Find ExtremePoints beginning from sourcepointX
      var sourcePointX = new ThreeDimensionalPacking(0, position.X + newWidth, position.Y, position.Z);
      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height && sourcePointX.Z < binMeasures.Depth) {
        //Traversing down the y-axis                                                                            
        int currentYValue = sourcePointX.Y;
        while (currentYValue > 0 && occupiedPoints[sourcePointX.X, currentYValue, sourcePointX.Z] == -1) {
          currentYValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, sourcePointX.X, currentYValue, sourcePointX.Z));

        //Traversing down the z-axis
        int currentZValue = sourcePointX.Z;
        while (currentZValue > 0 && occupiedPoints[sourcePointX.X, sourcePointX.Y, currentZValue - 1] == -1) {
          currentZValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, sourcePointX.X, sourcePointX.Y, currentZValue));
      }




      //Find ExtremePoints beginning from sourcepointY
      var sourcePointY = new ThreeDimensionalPacking(0, position.X, position.Y + newItem.Height, position.Z);
      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height && sourcePointY.Z < binMeasures.Depth) {
        //Traversing down the x-axis  
        int currentXValue = sourcePointY.X;
        while (currentXValue > 0 && occupiedPoints[currentXValue - 1, sourcePointY.Y, sourcePointY.Z] == -1) {
          currentXValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, currentXValue, sourcePointY.Y, sourcePointY.Z));

        //Traversing down the z-axis
        int currentZValue = sourcePointY.Z;
        while (currentZValue > 0 && occupiedPoints[sourcePointY.X, sourcePointY.Y, currentZValue - 1] == -1) {
          currentZValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, sourcePointY.X, sourcePointY.Y, currentZValue));
      }





      //Find ExtremePoints beginning from sourcepointZ
      var sourcePointZ = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z + newDepth);
      if (sourcePointZ.X < binMeasures.Width && sourcePointZ.Y < binMeasures.Height && sourcePointZ.Z < binMeasures.Depth) {
        //Traversing down the x-axis  
        int currentXValue = sourcePointZ.X;
        while (currentXValue > 0 && occupiedPoints[currentXValue - 1, sourcePointZ.Y, sourcePointZ.Z] == -1) {
          currentXValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, currentXValue, sourcePointZ.Y, sourcePointZ.Z));

        //Traversing down the y-axis                                                                            
        int currentYValue = sourcePointZ.Y;
        while (currentYValue > 0 && occupiedPoints[sourcePointZ.X, currentYValue, sourcePointZ.Z] == -1) {
          currentYValue--;
        }
        extremePoints.Add(new ThreeDimensionalPacking(0, sourcePointZ.X, currentYValue, sourcePointZ.Z));
      }


      return extremePoints;
    }
    private static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, int[, ,] occupiedPoints, CuboidPackingBin binMeasures) {
      return new HashSet<ThreeDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.Z).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
    }
    private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, int[, ,] occupiedPoints, CuboidPackingBin binMeasures) {
      int shortestSide = int.MaxValue;

      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height || ep.Z >= binMeasures.Depth)
        return shortestSide;

      int currentX = ep.X;
      while (currentX < binMeasures.Width && occupiedPoints[currentX, ep.Y, ep.Z] == -1) { currentX++; }
      if (currentX - ep.X < shortestSide)
        shortestSide = currentX - ep.X;

      int currentY = ep.Y;
      while (currentY < binMeasures.Height && occupiedPoints[ep.X, currentY, ep.Z] == -1) { currentY++; }
      if (currentY - ep.Y < shortestSide)
        shortestSide = currentY - ep.Y;

      int currentZ = ep.Z;
      while (currentZ < binMeasures.Depth && occupiedPoints[ep.X, ep.Y, currentZ] == -1) { currentZ++; }
      if (currentZ - ep.Z < shortestSide)
        shortestSide = currentZ - ep.Z;

      return shortestSide;
    }
    private static int[, ,] OccupyPointsForNewItem(int[, ,] occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
      int width = position.Rotated ? newItem.Depth : newItem.Width;
      int depth = position.Rotated ? newItem.Width : newItem.Depth;
      for (int w = position.X; w < position.X + width; w++) {
        for (int h = position.Y; h < position.Y + newItem.Height; h++) {
          for (int d = position.Z; d < position.Z + depth; d++) {
            occupiedPoints[w, h, d] = itemIndex;
          }
        }
      }
      return occupiedPoints;
    }
    private static int[,,] GetOccupiedPoints(CuboidPackingBin binMeasures) {
      var result = new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth];
      for (int w = 0; w < binMeasures.Width; w++) {
        for (int h = 0; h < binMeasures.Height; h++) {
          for (int d = 0; d < binMeasures.Depth; d++) {
            result[w, h, d] = -1;
          }
        }
      }
      return result;
    }
    private static bool IsPositionFeasible(CuboidPackingBin binMeasures, CuboidPackingItem currentItem,
      ThreeDimensionalPacking position, int[, ,] occupiedPoints) {
      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
      if (!binMeasures.Encloses(position, currentItem))
        return false;

      for (int w = position.X; w < position.X + currentItem.Width; w++) {
        for (int h = position.Y; h < position.Y + currentItem.Height; h++) {
          for (int d = position.Z; d < position.Z + currentItem.Depth; d++) {
            if (occupiedPoints[w, h, d] != -1)
              return false;
          }
        }
      }

      return true;
    }
    private static bool IsPositionFeasible(CuboidPackingBin binMeasures, CuboidPackingItem currentItem,
      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
      if (!binMeasures.Encloses(currentPosition, currentItem))
        return false;

      foreach (var ipEntry in itemPositions) {
        if (itemMeasures[ipEntry.Key].Overlaps(ipEntry.Value, currentPosition, currentItem))
          return false;
      }

      return true;
    }
                */
    
  }
}