protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position)
{
int newWidth = position.Rotated ? newItem.Height : newItem.Width;
int newHeight = position.Rotated ? newItem.Width : newItem.Height;
//Find ExtremePoints beginning from sourcepointX
var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y);
if (sourcePointX.X < BinShape.Width && sourcePointX.Y < BinShape.Height)
{
//Traversing down the y-axis
var newPoint = new PackingPosition(0, sourcePointX.X, sourcePointX.Y - 1);
while (sourcePointX.Y > 0 && !IsPointOccupied(newPoint))
{
sourcePointX = newPoint;
newPoint = new PackingPosition(0, sourcePointX.X, sourcePointX.Y - 1);
}
ExtremePoints.Add(new PackingPosition(0, sourcePointX.X, sourcePointX.Y));
}
//Find ExtremePoints beginning from sourcepointY
var sourcePointY = new PackingPosition(0, position.X, position.Y + newHeight);
if (sourcePointY.X < BinShape.Width && sourcePointY.Y < BinShape.Height)
{
//Traversing down the x-axis
var newPoint = new PackingPosition(0, sourcePointY.X - 1, sourcePointY.Y);
while (sourcePointY.X > 0 && !IsPointOccupied(newPoint))
{
sourcePointY = newPoint;
newPoint = new PackingPosition(0, sourcePointY.X - 1, sourcePointY.Y);
}
ExtremePoints.Add(new PackingPosition(0, sourcePointY.X, sourcePointY.Y));
}
}
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(newItem, ExtremePoints.ElementAt(epIndex)) ||
!IsSupportedByAtLeastOnePoint(newItem, ExtremePoints.ElementAt(epIndex)) ||
(stackingConstraints && !IsStaticStable(newItem, ExtremePoints.ElementAt(epIndex))) ||
(stackingConstraints && !IsWeightSupported(newItem, ExtremePoints.ElementAt(epIndex)))
))
{
epIndex++;
}
if (epIndex < ExtremePoints.Count)
{
var origPoint = ExtremePoints.ElementAt(epIndex);
var result = new PackingPosition(origPoint.AssignedBin, origPoint.X, origPoint.Y, origPoint.Z, rotated);
return(result);
}
return(null);
}
private void AddExtremePoint(PackingPosition current)
{
if (ExtremePoints.Add(current))
{
var tuple = Tuple.Create(BinShape.Width - current.X, BinShape.Height - current.Y, BinShape.Depth - current.Z);
ResidualSpace.Add(current, tuple);
}
}
public void PackItem(int itemID, TItem item, TPos position)
{
Items[itemID] = item;
Positions[itemID] = position;
ExtremePoints.Remove(position);
foreach (int id in Items.Select(x => x.Key))
{
GenerateNewExtremePointsForNewItem(Items[id], Positions[id]);
}
AddNewItemToOccupationLayers(itemID, item, position);
}
public override void PackItem(int itemID, PackingItem item, PackingPosition position)
{
// base call is deliberately omitted, because UpdateResidualSpace needs to be fitted in before
Items[itemID] = item;
Positions[itemID] = position;
ExtremePoints.Remove(position);
ResidualSpace.Remove(position);
UpdateResidualSpace(item, position);
foreach (int id in Items.Select(x => x.Key))
{
GenerateNewExtremePointsForNewItem(Items[id], Positions[id]);
}
AddNewItemToOccupationLayers(itemID, item, position);
}
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, item.Weight, item.Material);
var ep = ExtremePoints.Where(x => IsPositionFeasible(newItem, x, stackingConstraints)).FirstOrDefault();
if (ep != null)
{
var result = new PackingPosition(ep.AssignedBin, ep.X, ep.Y, ep.Z, rotated);
return(result);
}
return(null);
}
public override PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints)
{
PackingItem rotatedItem = new PackingItem(
rotated ? item.Height : item.Width,
rotated ? item.Width : item.Height,
item.TargetBin);
int epIndex = 0;
while (epIndex < ExtremePoints.Count && (!IsPositionFeasible(rotatedItem, ExtremePoints.ElementAt(epIndex))))
{
epIndex++;
}
if (epIndex < ExtremePoints.Count)
{
var currentPoint = ExtremePoints.ElementAt(epIndex);
var result = new PackingPosition(currentPoint.AssignedBin, currentPoint.X, currentPoint.Y, rotated);
return(result);
}
return(null);
}
public void ExtremePointsNormalTestCase100Points()
{
convexHullTester = new ExtremePoints();
Case100Points();
}
public void ExtremePointsTestCase9()
{
convexHullTester = new ExtremePoints();
Case9();
}
public void ExtremePointsSpecialCaseConvexPolygon()
{
convexHullTester = new ExtremePoints();
SpecialCaseConvexPolygon();
}
public void ExtremePointsSpecialCaseTriangle()
{
convexHullTester = new ExtremePoints();
SpecialCaseTriangle();
}
public void ExtremePointsSpecialCase10SamePoints()
{
convexHullTester = new ExtremePoints();
SpecialCase10SamePoints();
}
public BinPacking2D(PackingShape binShape)
: base(binShape)
{
ExtremePoints.Add(binShape.Origin);
InitializeOccupationLayers();
}
protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position)
{
int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
//Find ExtremePoints beginning from sourcepointX
var sourcePointX = new PackingPosition(0, position.X + newWidth, position.Y, position.Z);
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);
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current)))
{
current = PackingPosition.MoveLeft(current);
}
ExtremePoints.Add(current);
//Traversing down the z-axis
current = new PackingPosition(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
while (current.Z > 0 && !IsPointOccupied(PackingPosition.MoveBack(current)))
{
current = PackingPosition.MoveBack(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add(current);
}
//Find ExtremePoints beginning from sourcepointY
var sourcePointY = new PackingPosition(0, position.X, position.Y + newItem.Height, position.Z);
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);
while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current)))
{
current = PackingPosition.MoveLeft(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add(current);
//Traversing down the z-axis
current = new PackingPosition(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
while (current.Z > 0 && !IsPointOccupied(PackingPosition.MoveBack(current)))
{
current = PackingPosition.MoveBack(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add(current);
}
//Find ExtremePoints beginning from sourcepointZ
var sourcePointZ = new PackingPosition(0, position.X, position.Y, position.Z + newDepth);
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);
while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current)))
{
current = PackingPosition.MoveLeft(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add(current);
//Traversing down the y-axis
current = new PackingPosition(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
while (current.Y > 0 && !IsPointOccupied(PackingPosition.MoveDown(current)))
{
current = PackingPosition.MoveDown(current);
}
ExtremePoints.Add((PackingPosition)current.Clone());
while (current.X > 0 && !IsPointOccupied(PackingPosition.MoveLeft(current)))
{
current = PackingPosition.MoveLeft(current);
}
ExtremePoints.Add(current);
}
}
