/// <summary>
/// questo metodo, data la posizione inziale di un item,
/// prova a spingerlo in basso e verso sinistra quanto
/// più possibile.
/// Poi, calcola l'hatched region in basso e a sinistra
/// dell'item
/// </summary>
/// <param name="feasiblePoint"></param>
/// <param name="temporaryBin"></param>
/// <param name="temporaryItem"></param>
/// <returns></returns>
private float GetHatchedRegion(Tuple feasiblePoint, NestedItem newNestedItem, Bin <Tuple> temporaryBin, Item temporaryItem)
{
PushItemDown(feasiblePoint, temporaryBin, temporaryItem, newNestedItem);
PushItemLeft(feasiblePoint, temporaryBin, temporaryItem, newNestedItem);
//controllo se l'oggettto, anche essendo stato spostato in basso a sintra, sborda
if (IsBorderObserved(newNestedItem, temporaryBin.Height, temporaryBin.Width))
{
return(0);
}
else
{
return(-1);
}
}
/// <summary>
/// metodo per stabilire se è possibile
/// trovare una posizione in cui nestare
/// un nuovo item
/// </summary>
/// <param name="temporaryBin"></param>
/// <param name="temporaryItem"></param>
/// <returns></returns>
public bool IsBestPositionFound(Bin <Tuple> temporaryBin, Item temporaryItem)
{
SetFeasiblePoints(temporaryBin, temporaryItem);
//se il bin non contiene punti
if (temporaryBin.Points.Count == 0)
{
return(false);
}
else if (temporaryBin.Points.Count == 1 && //se il bin contiene 1 solo punto e quel punto è (0,0)
temporaryBin.Points.ElementAt(0).Pposition == 0 &&
temporaryBin.Points.ElementAt(0).Qposition == 0)
{
temporaryBin.NestedItems = new List <NestedItem>
{
new NestedItem(temporaryItem)
{
BLpPosition = 0,
BLqPosition = 0,
BRpPosition = temporaryItem.Width,
BRqPosition = 0,
TLpPosition = 0,
TLqPosition = temporaryItem.Height
}
};
HandleOperationsPostNestedItem(temporaryBin, temporaryItem, temporaryBin.Points.ElementAt(0));
return(true);
}
else if (temporaryBin.Points.Count > 1)//se il bin contiene n punti
{
foreach (Tuple feasiblePoint in temporaryBin.Points)
{
if (!feasiblePoint.IsUsed)
{
//assegno le coordinate di partenza al nuovo item da nestare, poi inzio a muoverlo
NestedItem newNestedItem = new NestedItem(temporaryItem)
{
BLpPosition = feasiblePoint.Pposition,
BLqPosition = feasiblePoint.Qposition,
BRpPosition = feasiblePoint.Pposition + temporaryItem.Width,
BRqPosition = feasiblePoint.Qposition,
TLpPosition = feasiblePoint.Pposition,
TLqPosition = feasiblePoint.Qposition + temporaryItem.Height
};
feasiblePoint.HatchedRegion = GetHatchedRegion(feasiblePoint, newNestedItem, temporaryBin, temporaryItem);
}
}
//trovo la tupla con lo scarto minore tra quelle ancora disponibili
//(Where(x => x.HatchedRegion >= 0) filtra solo le tuple con hatched region = 0)
Tuple minHatchedRegionTuple = temporaryBin.Points.Where(x => x.IsUsed == false && x.HatchedRegion >= 0)
.OrderBy(x => x.HatchedRegion)
.First();
//controllo se ho più tuple che hanno lo stesso scarto (il minore)
IList <Tuple> minHatchedRegionPoints = new List <Tuple>();
foreach (Tuple point in temporaryBin.Points)
{
if (point.HatchedRegion == minHatchedRegionTuple.HatchedRegion && !point.IsUsed)
{
minHatchedRegionPoints.Add(point);
}
}
if (minHatchedRegionPoints.Count == 1)
{
Tuple minHatchedRegionPoint = minHatchedRegionPoints.ElementAt(0);
temporaryBin.NestedItems.Add(new NestedItem(temporaryItem)
{
BLpPosition = minHatchedRegionPoint.PfinalPosition,
BLqPosition = minHatchedRegionPoint.QfinalPosition,
BRpPosition = minHatchedRegionPoint.PfinalPosition + temporaryItem.Width,
BRqPosition = minHatchedRegionPoint.QfinalPosition,
TLpPosition = minHatchedRegionPoint.PfinalPosition,
TLqPosition = minHatchedRegionPoint.QfinalPosition + temporaryItem.Height
});
HandleOperationsPostNestedItem(temporaryBin, temporaryItem, minHatchedRegionPoint);
return(true);
}
else if (minHatchedRegionPoints.Count > 1)
{
Tuple minCoordinatePoint = ApplyRule(minHatchedRegionPoints);
temporaryBin.NestedItems.Add(new NestedItem(temporaryItem)
{
BLpPosition = minCoordinatePoint.PfinalPosition,
BLqPosition = minCoordinatePoint.QfinalPosition,
BRpPosition = minCoordinatePoint.PfinalPosition + temporaryItem.Width,
BRqPosition = minCoordinatePoint.QfinalPosition,
TLpPosition = minCoordinatePoint.PfinalPosition,
TLqPosition = minCoordinatePoint.QfinalPosition + temporaryItem.Height
});
HandleOperationsPostNestedItem(temporaryBin, temporaryItem, minCoordinatePoint);
return(true);
}
}
return(false);
}
/// <summary>
/// Questo metodo controlla se le dimensione dell'item eccedono quelle del bin
/// </summary>
/// <param name="newNestedItem"></param>
/// <param name="temporaryBinHeight"></param>
/// <param name="temporaryBinWidth"></param>
/// <returns></returns>
bool IsBorderObserved(NestedItem newNestedItem, float temporaryBinHeight, float temporaryBinWidth)
{
return(newNestedItem.TLqPosition < temporaryBinHeight && newNestedItem.BRpPosition < temporaryBinWidth);
}
private void PushItemLeft(Tuple feasiblePoint, Bin <Tuple> temporaryBin, Item temporaryItem, NestedItem newNestedItem)
{
//lista delle intersezioni tra item nuovo e item già in soluzione
IList <NestedItem> intersectedItems = new List <NestedItem>();
foreach (var nestedItem in temporaryBin.NestedItems)
{
if (feasiblePoint.Qposition < nestedItem.TLqPosition &&
feasiblePoint.Qposition >= nestedItem.BRqPosition &&
feasiblePoint.Pposition >= nestedItem.BRpPosition)
{
intersectedItems.Add(nestedItem);
}
}
//3 possibili risultati
if (intersectedItems.Count == 0) //non ho intersezioni
{
newNestedItem.BLpPosition = 0;
newNestedItem.TLpPosition = 0;
newNestedItem.BRpPosition = temporaryItem.Width;
}
else if (intersectedItems.Count == 1) //1 sola intersezione
{
float delta = feasiblePoint.Pposition - intersectedItems.ElementAt(0).Width;
newNestedItem.BLpPosition -= delta;
newNestedItem.TLpPosition -= delta;
newNestedItem.BRpPosition -= delta;
}
else if (intersectedItems.Count > 1) //N intersezioni
{
float widthSum = 0;
foreach (var intersectedItem in intersectedItems)
{
widthSum += intersectedItem.Width;
}
float delta = feasiblePoint.Pposition - widthSum;
newNestedItem.BLpPosition -= delta;
newNestedItem.TLpPosition -= delta;
newNestedItem.BRpPosition -= delta;
}
feasiblePoint.PfinalPosition = newNestedItem.BLpPosition;
}
