public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth);
actualLength = maxSizeXLength * boxLength + maxSizeXWidth * boxWidth;
actualWidth = Math.Max(maxSizeYLength * boxWidth, maxSizeYWidth * boxLength);
return(maxSizeXLength > 0 && maxSizeXWidth > 0 && maxSizeYLength > 0 && maxSizeYWidth > 0 && (maxSizeXLength % 2 == 0));
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth);
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
double spaceX = maxSizeXLength + maxSizeXWidth > 1 ? (actualLength - (maxSizeXLength * boxLength + maxSizeXWidth * boxWidth)) / (maxSizeXLength + maxSizeXWidth - 1) : 0.0;
double spaceYLength = maxSizeYLength > 1 ? (actualWidth - maxSizeYLength * boxWidth) / (maxSizeYLength - 1) : 0.0;
double spaceYWidth = maxSizeYWidth > 1 ? (actualWidth - maxSizeYWidth * boxLength) / (maxSizeYWidth - 1) : 0.0;
for (int i = 0; i < maxSizeXLength; ++i)
{
for (int j = 0; j < maxSizeYLength; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + i * (boxLength + spaceX)
, offsetY + j * (boxWidth + spaceYLength))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
for (int i = 0; i < maxSizeXWidth; ++i)
{
for (int j = 0; j < maxSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + maxSizeXLength * (boxLength + spaceX) + i * (boxWidth + spaceX) + boxWidth
, offsetY + j * (boxLength + spaceYWidth))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
// maximum space
layer.UpdateMaxSpace(spaceYLength, Name);
layer.UpdateMaxSpace(spaceYWidth, Name);
layer.UpdateMaxSpace(spaceX, Name);
}
public bool GetLayerDimensionsChecked(ILayer2D layer, out double actualLength, out double actualWidth)
{
bool result = GetLayerDimensions(layer, out actualLength, out actualWidth);
if (actualLength > GetPalletLength(layer))
{
throw new EngineException(string.Format("Pattern name={0} : actualLength={1} > palletLength={2} ?"
, this.Name, actualLength, GetPalletLength(layer)));
}
if (actualWidth > GetPalletWidth(layer))
{
throw new EngineException(string.Format("Pattern name={0} : actualWidth={1} > palletWidth={2} ?"
, this.Name, actualWidth, GetPalletWidth(layer)));
}
return(result);
}
public ILayer2D BuildLayer(Packable packable, Vector2D dimContainer, LayerDesc layerDesc, double minSpace)
{
ILayer2D layer = null;
if (packable.IsBrick)
{
// casts
LayerDescBox layerDescBox = layerDesc as LayerDescBox;
// layer instantiation
layer = new Layer2D(packable.OuterDimensions, dimContainer, layerDesc.PatternName, layerDescBox.AxisOrtho, layerDesc.Swapped)
{
ForcedSpace = minSpace
};
// get layer pattern
LayerPatternBox pattern = LayerPatternBox.GetByName(layerDesc.PatternName);
// dimensions
if (!pattern.GetLayerDimensionsChecked(layer as Layer2D, out double actualLength, out double actualWidth))
{
return(null);
}
pattern.GenerateLayer(
layer as Layer2D
, actualLength
, actualWidth);
return(layer);
}
else if (packable.IsCylinder)
{
// casts
CylinderProperties cylProperties = packable as CylinderProperties;
// layer instantiation
layer = new Layer2DCyl(cylProperties.RadiusOuter, cylProperties.Height, dimContainer, layerDesc.Swapped);
// get layer pattern
LayerPatternCyl pattern = LayerPatternCyl.GetByName(layerDesc.PatternName);
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensions(layer as Layer2DCyl, out actualLength, out actualWidth))
{
return(null);
}
pattern.GenerateLayer(layer as Layer2DCyl, actualLength, actualWidth);
}
else
{
throw new EngineException(string.Format("Unexpected packable {0} (Type = {1})", packable.Name, packable.GetType().ToString()));
}
return(layer);
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = layer.Length;
double palletWidth = layer.Width;
Layer2DCylImp layerCyl = layer as Layer2DCylImp;
double radius = layerCyl.Radius;
int alignedRowLength = 0, stagRowLength = 0;
int rowNumber1 = 0, rowNumber2 = 0;
ComputeRowNumberAndLength(layerCyl
, out alignedRowLength, out rowNumber1
, out stagRowLength, out rowNumber2
, out actualLength, out actualWidth);
return(rowNumber1 > 0 && rowNumber2 > 0);
}
public static Bitmap Draw(ILayer2D layer, Packable packable, double height, Size size, bool selected, eGraphMode eMode)
{
if (eGraphMode.GRAPH_2D == eMode)
{
Graphics2DImage graphics = new Graphics2DImage(size);
using (ViewerILayer2D solViewer = new ViewerILayer2D(layer))
{ solViewer.Draw(graphics, packable, height, selected); }
return(graphics.Bitmap);
}
else
{
Graphics3DImage graphics = new Graphics3DImage(size);
graphics.MarginPercentage = 0.05;
using (ViewerILayer2D solViewer = new ViewerILayer2D(layer))
{ solViewer.Draw(graphics, packable, height, selected); }
return(graphics.Bitmap);
}
}
public override bool GetLayerDimensions(ILayer2D layer, out double layerLength, out double layerWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
int noInLength = (int)Math.Floor(palletLength / boxLength);
int noInWidth = (int)Math.Floor((palletWidth - 2 * boxWidth) / boxLength);
layerLength = noInLength * boxLength;
layerWidth = noInWidth * boxLength + 2 * boxWidth;
Debug.Assert(layerLength <= palletLength);
Debug.Assert(layerWidth <= palletWidth);
return(true);
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetOptimalSizeArea1(boxLength, boxWidth, palletLength, palletWidth, out int sizeX_area1, out int sizeY_area1);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth, sizeX_area1, sizeY_area1
, out int sizeX_area2, out int sizeY_area2, out int sizeX_area3, out int sizeY_area3);
actualLength = Math.Max(sizeX_area2 * boxLength, sizeX_area1 * boxWidth + sizeX_area3 * boxLength);
actualWidth = Math.Max(sizeY_area1 * boxLength, sizeY_area3 * boxWidth) + sizeY_area2 * boxWidth;
Debug.Assert(actualLength <= palletLength);
Debug.Assert(actualWidth <= palletWidth);
return(sizeX_area1 > 0 && sizeY_area1 > 0 &&
sizeX_area2 > 0 && sizeY_area2 > 0 &&
sizeX_area3 > 0 && sizeY_area3 > 0);
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double radius = GetRadius(layer);
double diameter = 2.0 * radius;
int alignedRowLength = 0, stagRowLength = 0;
int rowNumber1 = 0, rowNumber2 = 0;
Layer2DCylImp layerCyl = layer as Layer2DCylImp;
ComputeRowNumberAndLength(layerCyl
, out alignedRowLength, out rowNumber1
, out stagRowLength, out rowNumber2
, out actualLength, out actualWidth);
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
for (int j = 0; j < rowNumber1; ++j)
{
for (int i = 0; i < alignedRowLength; ++i)
{
AddPosition(layerCyl, new Vector2D(
radius + offsetX + i * diameter
, radius + offsetY + j * diameter
));
}
}
for (int i = 0; i < rowNumber2; ++i)
{
double y = radius + offsetY + (rowNumber1 - 1.0) * diameter + (i + 1) * radius * Math.Sqrt(3.0);
for (int j = 0; j < (i % 2 == 0 ? stagRowLength : alignedRowLength); ++j)
{
AddPosition(layer, new Vector2D(offsetX + ((i % 2 != 0) ? 0.0 : radius) + j * 2.0 * radius + radius, y));
}
}
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
// compute optimal layout by evaluating all spirale configurations
int sizeX_area1 = 0, sizeY_area1 = 0, sizeX_area2 = 0, sizeY_area2 = 0;
GetOptimalSizesXY(boxLength, boxWidth, palletLength, palletWidth
, out sizeX_area1, out sizeY_area1, out sizeX_area2, out sizeY_area2);
// actual length / actual width
actualLength = sizeX_area1 * boxLength + sizeX_area2 * boxWidth;
actualWidth = sizeY_area1 * boxWidth + sizeY_area2 * boxLength;
if (2.0 * sizeX_area1 * boxLength > palletLength &&
2.0 * sizeY_area1 * boxWidth > actualWidth)
{
actualWidth = 2.0 * sizeY_area1 * boxWidth;
}
else if (2.0 * sizeY_area1 * boxWidth > palletWidth &&
2.0 * sizeX_area1 * boxLength > actualLength)
{
actualLength = 2.0 * sizeX_area1 * boxLength;
}
else if (2.0 * sizeX_area2 * boxWidth > palletLength &&
2.0 * sizeY_area2 * boxLength > actualWidth)
{
actualWidth = 2.0 * sizeY_area2 * boxLength;
}
else if (2.0 * sizeY_area2 * boxLength > palletWidth &&
2.0 * sizeX_area2 * boxWidth > actualLength)
{
actualLength = 2.0 * sizeX_area2 * boxWidth;
}
return(sizeX_area1 > 0 && sizeX_area2 > 0 && sizeY_area1 > 0 && sizeY_area2 > 0);
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out int iStep, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth);
actualLength = maxSizeXLength * boxLength + maxSizeXWidth * boxWidth;
if (maxSizeYWidth >= iStep && (iStep * boxLength <= palletLength))
{
actualLength = Math.Max(actualLength, iStep * boxLength);
}
actualWidth = maxSizeYWidth * boxWidth + maxSizeYLength * boxLength;
if (maxSizeXLength >= iStep && (iStep * boxWidth <= palletWidth))
{
actualWidth = Math.Max(actualWidth, iStep * boxWidth);
}
return(maxSizeXLength > 0 && maxSizeXWidth > 0 && maxSizeYLength > 0 && maxSizeYWidth > 0);
}
protected void GenerateRectanglePositions(ILayer2D layer, Vector2D offset
, double boxLength, double boxWidth
, int noX, int noY
, double startX, double startY
, double spaceX, double spaceY
, bool lengthAligned)
{
double length = lengthAligned ? boxLength : boxWidth;
double width = lengthAligned ? boxWidth : boxLength;
for (int i = 0; i < noX; ++i)
{
for (int j = 0; j < noY; ++j)
{
AddPosition(layer
, new Vector2D(
startX + (lengthAligned ? 0.0 : boxWidth) + i * (length + spaceX)
, startY + j * (width + spaceY)
) + offset
, lengthAligned ? HalfAxis.HAxis.AXIS_X_P : HalfAxis.HAxis.AXIS_Y_P
, lengthAligned ? HalfAxis.HAxis.AXIS_Y_P : HalfAxis.HAxis.AXIS_X_N);
}
}
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0;
int fillSizeXLength = 0, fillSizeYLength = 0, fillSizeXWidth = 0, fillSizeYWidth = 0;
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out maxSizeXLength, out maxSizeYLength, out maxSizeXWidth, out maxSizeYWidth
, out fillSizeXLength, out fillSizeYLength, out fillSizeXWidth, out fillSizeYWidth);
actualLength = Math.Max(maxSizeXLength * boxLength, fillSizeXLength * boxWidth) + Math.Max(maxSizeXWidth * boxWidth, fillSizeXWidth * boxLength);
actualWidth = Math.Max(maxSizeYLength * boxWidth + fillSizeYLength * boxLength, maxSizeYWidth * boxLength + fillSizeYWidth * boxWidth);
return(maxSizeXLength > 0 && maxSizeYLength > 0 &&
maxSizeXWidth > 0 && maxSizeYWidth > 0 &&
(
((maxSizeYLength % 2 == 0) && (fillSizeXLength * fillSizeYLength > 0)) ||
((maxSizeYWidth % 2 == 0) && (fillSizeXWidth * fillSizeYWidth > 0))
));
}
public void AddPosition(ILayer2D layer, Vector2D vPosition, HalfAxis.HAxis lengthAxis, HalfAxis.HAxis widthAxis)
{
Matrix4D matRot = Matrix4D.Identity;
Vector3D vTranslation = Vector3D.Zero;
if (layer.Swapped)
{
matRot = new Matrix4D(
0.0, -1.0, 0.0, 0.0
, 1.0, 0.0, 0.0, 0.0
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0
);
vTranslation = new Vector3D(layer.Length, 0.0, 0.0);
}
Transform3D transfRot = new Transform3D(matRot);
HalfAxis.HAxis lengthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(lengthAxis)));
HalfAxis.HAxis widthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(widthAxis)));
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
Transform3D transfRotTranslation = new Transform3D(matRot);
Vector3D vPositionSwapped = transfRotTranslation.transform(new Vector3D(vPosition.X, vPosition.Y, 0.0));
Layer2D layerBox = layer as Layer2D;
if (!layerBox.IsValidPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped))
{
_log.Warn(string.Format("Attempt to add an invalid position in pattern = {0}, Swapped = {1}", this.Name, layer.Swapped));
return;
}
layerBox.AddPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped);
}
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth)
{
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetOptimalSizesXY(boxLength, boxWidth, palletLength, palletWidth
, out int sizeX_area1, out int sizeY_area1, out int sizeX_area2, out int sizeY_area2);
// actual length / actual width
actualLength = sizeX_area1 * boxLength + sizeX_area2 * boxWidth;
actualWidth = sizeY_area1 * boxWidth + sizeY_area2 * boxLength;
if (2.0 * sizeX_area1 * boxLength > palletLength &&
2.0 * sizeY_area1 * boxWidth > actualWidth)
{
actualWidth = 2.0 * sizeY_area1 * boxWidth;
}
else if (2.0 * sizeY_area1 * boxWidth > palletWidth &&
2.0 * sizeX_area1 * boxLength > actualLength)
{
actualLength = 2.0 * sizeX_area1 * boxLength;
}
else if (2.0 * sizeX_area2 * boxWidth > palletLength &&
2.0 * sizeY_area2 * boxLength > actualWidth)
{
actualWidth = 2.0 * sizeY_area2 * boxLength;
}
else if (2.0 * sizeY_area2 * boxLength > palletWidth &&
2.0 * sizeX_area2 * boxWidth > actualLength)
{
actualLength = 2.0 * sizeX_area2 * boxWidth;
}
return(sizeX_area1 > 0 && sizeX_area2 > 0 && sizeY_area1 > 0 && sizeY_area2 > 0);
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out int iStep, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth);
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
for (int i = 0; i < iStep; ++i)
{
double spaceX = maxSizeXLength + maxSizeXWidth > 1
? (actualLength - maxSizeXLength * boxLength - maxSizeXWidth * boxWidth) / (maxSizeXLength + maxSizeXWidth - 1)
: 0.0;
double spaceY = maxSizeYLength + maxSizeYWidth > 1
? (actualWidth - maxSizeYWidth * boxWidth - maxSizeYLength * boxLength) / (maxSizeYLength + maxSizeYWidth - 1)
: 0.0;
double xBase = offsetX + i * (boxLength + spaceX);
double yBase = offsetY + i * (boxWidth + spaceY);
// first box
AddPosition(
layer
, new Vector2D(xBase + boxWidth, yBase)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
// along X
for (int ix = 0; ix < iStep - 1 - i; ++ix)
{
AddPosition(
layer
, new Vector2D(
xBase + boxWidth + spaceX + ix * (boxLength + spaceX)
, yBase)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
int maxY = (int)Math.Floor(actualWidth / boxWidth);
double ySpaceNew = maxY > 1 ? (actualWidth - boxWidth * maxY) / (maxY - 1) : 0;
for (int ix = iStep - 1 - i; ix < maxSizeXLength - i && i < iStep - 1; ++ix)
{
AddPosition(
layer
, new Vector2D(
xBase + boxWidth + spaceX + ix * (boxLength + spaceX)
, offsetY + i * (boxWidth + ySpaceNew))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
// along Y
for (int iy = 0; iy < iStep - 1 - i; ++iy)
{
AddPosition(
layer
, new Vector2D(
xBase
, yBase + boxLength + spaceY + iy * (boxWidth + spaceY))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
int maxX = (int)Math.Floor(actualLength / boxLength);
double xSpaceNew = maxX > 1 ? (actualLength - boxLength * maxX) / (maxX - 1) : 0;
for (int iy = iStep - 1 - i; iy < maxSizeYWidth - i && i < iStep - 1; ++iy)
{
AddPosition(
layer
, new Vector2D(
offsetX + i * (boxLength + xSpaceNew)
, yBase + boxLength + spaceY + iy * (boxWidth + spaceY))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
// set spacing
layer.UpdateMaxSpace(spaceX, Name);
layer.UpdateMaxSpace(spaceY, Name);
layer.UpdateMaxSpace(Math.Abs(boxLength - boxWidth), Name);
}
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetOptimalSizeArea1(boxLength, boxWidth, palletLength, palletWidth, out int sizeX_area1, out int sizeY_area1);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth, sizeX_area1, sizeY_area1
, out int sizeX_area2, out int sizeY_area2, out int sizeX_area3, out int sizeY_area3);
// compute offsets
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
// compute spaces
double spaceX_area1 = (actualLength - (boxWidth * sizeX_area1 + boxLength * sizeX_area3)) / (sizeX_area1 + sizeX_area3 > 1 ? (sizeX_area1 + sizeX_area3 - 1) : 1.0);
double spaceX_area2 = (actualLength - sizeX_area2 * boxLength) / (sizeX_area2 > 1 ?(sizeX_area2 - 1) : 1.0);
double spaceX_area3 = spaceX_area1;
double spaceY_area1 = 0.0, spaceY_area2 = 0.0, spaceY_area3 = 0.0;
if (sizeY_area1 * boxLength > sizeY_area3 * boxWidth)
{
spaceY_area1 = (actualWidth - sizeY_area1 * boxLength - sizeY_area2 * boxWidth) / (sizeY_area1 + sizeY_area2 > 1 ?(sizeY_area1 + sizeY_area2 - 1) : 1.0);
spaceY_area2 = spaceY_area1;
spaceY_area3 = (sizeY_area1 * (boxLength + spaceY_area1) - sizeY_area3 * boxWidth) / (0 != sizeY_area3 ? sizeY_area3 : 1.0);
}
else
{
spaceY_area3 = (actualWidth - (sizeY_area2 + sizeY_area3) * boxWidth) / (sizeY_area2 + sizeY_area3 > 1 ? (sizeY_area2 + sizeY_area3 - 1) : 1.0);
spaceY_area2 = spaceY_area3;
spaceY_area1 = (sizeY_area3 * (boxWidth + spaceY_area3) - sizeY_area1 * boxLength) / (sizeY_area1 > 0 ? sizeY_area1 : 1.0);
}
// area1
for (int i = 0; i < sizeX_area1; ++i)
{
for (int j = 0; j < sizeY_area1; ++j)
{
AddPosition(layer
, new Vector2D(
offsetX + boxWidth + i * (boxWidth + spaceX_area1)
, offsetY + j * (boxLength + spaceY_area1))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
// area2
for (int i = 0; i < sizeX_area2; ++i)
{
for (int j = 0; j < sizeY_area2; ++j)
{
AddPosition(layer
, new Vector2D(
offsetX + i * (boxLength + spaceX_area2)
, actualWidth + offsetY - (j + 1) * boxWidth - j * spaceY_area2)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
// area3
for (int i = 0; i < sizeX_area3; ++i)
{
for (int j = 0; j < sizeY_area3; ++j)
{
AddPosition(layer
, new Vector2D(
offsetX + sizeX_area1 * (boxWidth + spaceX_area1) + i * (boxLength + spaceX_area3)
, offsetY + j * (boxWidth + spaceY_area3))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
layer.UpdateMaxSpace(spaceX_area1, Name);
layer.UpdateMaxSpace(spaceY_area1, Name);
layer.UpdateMaxSpace(spaceX_area2, Name);
layer.UpdateMaxSpace(spaceY_area2, Name);
layer.UpdateMaxSpace(spaceX_area3, Name);
layer.UpdateMaxSpace(spaceY_area3, Name);
}
protected double GetPalletWidth(ILayer2D layer)
{
return(layer.Swapped ? layer.Length : layer.Width);
}
public abstract void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth);
public abstract bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth);
protected double GetDiameter(ILayer2D layer)
{
return(2.0 * ((Layer2DCylImp)layer).Radius);
}
public ViewerILayer2D(ILayer2D layer)
{
_layer = layer;
}
public void AddSolution(ILayer2D layer, bool alternateLayers = true)
{
Solution = new SolutionLayered(this, layer, alternateLayers);
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
double spiraleLength = boxLength + boxWidth;
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out int noSpiraleX, out int noSpiraleY
, out int noArea2X, out int noArea2Y, out bool area2LengthAligned
, out int noArea3X, out int noArea3Y, out bool area3LengthAligned
, out bool area2First);
Vector2D offset = GetOffset(layer, actualLength, actualWidth);
// spirale
for (int i = 0; i < noSpiraleX; ++i)
{
for (int j = 0; j < noSpiraleY; ++j)
{
double xBase = i * spiraleLength;
double yBase = j * spiraleLength;
AddPosition(
layer
, new Vector2D(xBase, yBase) + offset
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
AddPosition(
layer
, new Vector2D(xBase + boxLength + boxWidth, yBase) + offset
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
AddPosition(
layer
, new Vector2D(xBase + boxLength + boxWidth, yBase + boxLength + boxWidth) + offset
, HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Y_N);
AddPosition(
layer
, new Vector2D(xBase, yBase + boxLength + boxWidth) + offset
, HalfAxis.HAxis.AXIS_Y_N, HalfAxis.HAxis.AXIS_X_P);
}
}
layer.UpdateMaxSpace(Math.Abs(boxLength - boxWidth), Name);
if (area2First)
{
// area 2
double width = Math.Max(noArea2Y * (area2LengthAligned ? boxWidth : boxLength), noSpiraleY * spiraleLength + noArea3Y * (area3LengthAligned ? boxWidth : boxLength));
double ySpace = 0.0;
if (noArea2Y > 1)
{
ySpace = Math.Floor((width - noArea2Y * (area2LengthAligned ? boxWidth : boxLength)) / (noArea2Y - 1));
}
double xStart = Math.Max(
noSpiraleX * spiraleLength
, noArea3X * (area3LengthAligned ? boxLength : boxWidth));
GenerateRectanglePositions(layer, offset, boxLength, boxWidth
, noArea2X, noArea2Y
, xStart, 0.0, 0.0, ySpace, area2LengthAligned);
// area 3
GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea3X, noArea3Y
, 0.0, noSpiraleY * spiraleLength, 0.0, 0.0, area3LengthAligned);
}
else
{
// area 3
double length = Math.Max(noArea3X * (area3LengthAligned ? boxLength : boxWidth), noSpiraleX * spiraleLength + noArea2X * (area2LengthAligned ? boxLength : boxWidth));
double xSpace = 0.0;
if (noArea3X > 1)
{
xSpace = Math.Floor((length - noArea3X * (area3LengthAligned ? boxLength : boxWidth)) / (noArea3X - 1));
}
double yStart = Math.Max(
noSpiraleY * spiraleLength
, noArea2Y * (area2LengthAligned ? boxWidth : boxLength));
GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea3X, noArea3Y
, 0.0, yStart, xSpace, 0.0, area3LengthAligned);
// area 2
GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea2X, noArea2Y
, noSpiraleX * spiraleLength, 0.0, 0.0, 0.0, area2LengthAligned);
}
}
protected void RecursiveInsertion(ILayer2D layer
, Vector2D offset
, double rectLength, double rectWidth
, double boxLength, double boxWidth
)
{
int noInLength = (int)Math.Floor(rectLength / boxLength);
int noInWidth = (int)Math.Floor((rectWidth - 2 * boxWidth) / boxLength);
Vector2D internalOffset = new Vector2D(
0.5 * (rectLength - noInLength * boxLength)
, 0.5 * (rectWidth - noInWidth * boxLength - 2.0 * boxWidth)
);
if (noInWidth <= 0 && 2 * boxWidth > rectWidth)
{
if (boxWidth > rectWidth)
{
noInLength = 0;
}
internalOffset = new Vector2D(
0.5 * (rectLength - noInLength * boxLength)
, 0.5 * (rectWidth - boxWidth));
}
// insert boxes
if (noInLength > 0)
{
for (int i = 0; i < noInLength; ++i)
{
AddPosition(layer
, offset + internalOffset + new Vector2D(i * boxLength, 0.0)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
if (2 * boxWidth <= rectWidth)
{
AddPosition(layer
, offset + internalOffset + new Vector2D(i * boxLength, noInWidth * boxLength + boxWidth)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
for (int i = 0; i < noInWidth; ++i)
{
AddPosition(layer
, offset + internalOffset + new Vector2D(boxWidth, boxWidth + i * boxLength)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
if (2 * boxWidth <= rectLength)
{
AddPosition(layer
, offset + internalOffset + new Vector2D(noInLength * boxLength, boxWidth + i * boxLength)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
// new internal rectangle
if (noInLength > 0 && noInWidth > 0)
{
RecursiveInsertion(layer
, offset + internalOffset + new Vector2D(boxWidth, boxWidth)
, noInLength * boxLength - 2 * boxWidth, noInWidth * boxLength
, boxLength, boxWidth);
}
}
}
protected double GetRadius(ILayer2D layer)
{
return(((Layer2DCylImp)layer).Radius);
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0;
int fillSizeXLength = 0, fillSizeYLength = 0, fillSizeXWidth = 0, fillSizeYWidth = 0;
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out maxSizeXLength, out maxSizeYLength, out maxSizeXWidth, out maxSizeYWidth
, out fillSizeXLength, out fillSizeYLength, out fillSizeXWidth, out fillSizeYWidth);
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
double l1 = Math.Max(maxSizeXLength * boxLength, fillSizeXLength * boxWidth);
double l2 = Math.Max(maxSizeXWidth * boxWidth, fillSizeXWidth * boxLength);
double remainingSpaceX = actualLength - l1 - l2;
l1 = l1 + 0.5 * remainingSpaceX;
l2 = l2 + 0.5 * remainingSpaceX;
double spaceXLength = (l1 - maxSizeXLength * boxLength) / ((double)maxSizeXLength - 0.5);
double spaceXWidth = (l2 - maxSizeXWidth * boxWidth) / ((double)maxSizeXWidth - 0.5);
double spaceYLength = maxSizeYLength > 1 ? (actualWidth - maxSizeYLength * boxWidth - fillSizeYLength * boxLength) / (maxSizeYLength + fillSizeYLength - 1) : 0.0;
double spaceYWidth = maxSizeYWidth > 1 ? (actualWidth - maxSizeYWidth * boxLength - fillSizeYWidth * boxWidth) / (maxSizeYWidth + fillSizeYWidth - 1) : 0.0;
if (1 == maxSizeYLength % 2)
{
// LENGTH
for (int i = 0; i < maxSizeXLength; ++i)
{
for (int j = 0; j < maxSizeYLength; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + i * (boxLength + spaceXLength)
, offsetY + j * (boxWidth + spaceYLength))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
}
else
{
// LENGTH
for (int i = 0; i < maxSizeXLength; ++i)
{
for (int j = 0; j < maxSizeYLength / 2; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + i * (boxLength + spaceXLength)
, offsetY + j * (boxWidth + spaceYLength))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
for (int i = 0; i < maxSizeXLength; ++i)
{
for (int j = maxSizeYLength / 2; j < maxSizeYLength; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + i * (boxLength + spaceXLength)
, offsetY + j * (boxWidth + spaceYLength) + (fillSizeYLength > 0 ? fillSizeYLength * (spaceYLength + boxLength) : 0.0))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
double spaceXFill = fillSizeXLength > 1 ? (l1 - fillSizeXLength * boxWidth) / ((double)fillSizeXLength - 0.5) : 0;
layer.UpdateMaxSpace(spaceXFill, Name);
for (int i = 0; i < fillSizeXLength; ++i)
{
for (int j = 0; j < fillSizeYLength; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + boxWidth + i * (boxWidth + spaceXFill)
, offsetY + (maxSizeYLength / 2) * (boxWidth + spaceYLength) + j * boxLength)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N
);
}
}
}
// WIDTH
if (1 == maxSizeYWidth % 2)
{
for (int i = 0; i < maxSizeXWidth; ++i)
{
for (int j = 0; j < maxSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + maxSizeXLength * (boxLength + spaceXLength) + i * (boxWidth + spaceXWidth) + boxWidth
, offsetY + j * (boxLength + spaceYWidth))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
}
else
{
for (int i = 0; i < maxSizeXWidth; ++i)
{
for (int j = 0; j < maxSizeYWidth / 2; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + actualLength - (i) * (boxWidth + spaceXWidth) /*- boxWidth*/
, offsetY + j * (boxLength + spaceYWidth))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
for (int i = 0; i < maxSizeXWidth; ++i)
{
for (int j = maxSizeYWidth / 2; j < maxSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + actualLength - (i) * (boxWidth + spaceXWidth) /*- boxWidth*/
, offsetY + j * (boxLength + spaceYWidth) + (fillSizeYWidth > 0 ? fillSizeYWidth * (boxWidth + spaceYWidth) : 0.0))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
double spaceXFill = fillSizeXWidth > 1 ? (l2 - fillSizeXWidth * boxLength) / ((double)fillSizeXWidth - 0.5) : 0.0;
layer.UpdateMaxSpace(spaceXFill, Name);
for (int i = 0; i < fillSizeXWidth; ++i)
{
for (int j = 0; j < fillSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + actualLength - (i + 1) * (boxLength + spaceXFill)
, offsetY + (maxSizeYWidth / 2) * (boxLength + spaceYWidth) + j * boxWidth)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P
);
}
}
}
// maximum space
layer.UpdateMaxSpace(spaceYLength, Name);
layer.UpdateMaxSpace(spaceYWidth, Name);
}
public double GetBoxWidth(ILayer2D layer)
{
return(((Layer2D)layer).BoxWidth);
}
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth)
{
// initialization
layer.Clear();
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
double boxLength = GetBoxLength(layer);
double boxWidth = GetBoxWidth(layer);
GetOptimalSizesXY(
boxLength, boxWidth, palletLength, palletWidth
, out int sizeX_area1, out int sizeY_area1
, out int sizeX_area2, out int sizeY_area2
, out int sizeX_area3, out int sizeY_area3
, out int dir_area3);
// compute offsets
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
// area1
for (int i = 0; i < sizeX_area1; ++i)
{
for (int j = 0; j < sizeY_area1; ++j)
{
AddPosition(layer
, new Vector2D(offsetX + i * boxLength, offsetY + j * boxWidth)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
AddPosition(layer
, new Vector2D(palletLength - offsetX - i * boxLength, palletWidth - offsetY - j * boxWidth)
, HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Y_N);
}
}
double spaceX_area1 = actualLength - 2 * sizeX_area1 * boxLength;
double spaceY_area1 = actualWidth - 2 * sizeY_area1 * boxWidth;
// area2
for (int i = 0; i < sizeX_area2; ++i)
{
for (int j = 0; j < sizeY_area2; ++j)
{
AddPosition(layer
, new Vector2D(palletLength - offsetX - i * boxWidth, offsetY + j * boxLength)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
AddPosition(layer
, new Vector2D(offsetX + i * boxWidth, palletWidth - offsetY - j * boxLength)
, HalfAxis.HAxis.AXIS_Y_N, HalfAxis.HAxis.AXIS_X_P);
}
}
double spaceX_area2 = actualLength - 2 * sizeX_area2 * boxWidth;
double spaceY_area2 = actualWidth - 2 * sizeY_area2 * boxLength;
// area3
for (int i = 0; i < sizeX_area3; ++i)
{
for (int j = 0; j < sizeY_area3; ++j)
{
if (dir_area3 == 0)
{
AddPosition(layer
, new Vector2D(
offsetX + 0.5 * (actualLength - sizeX_area3 * boxLength) + i * boxLength
, offsetY + 0.5 * (actualWidth - sizeY_area3 * boxWidth) + j * boxWidth
)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
else
{
AddPosition(layer
, new Vector2D(
offsetX + 0.5 * (actualLength - sizeX_area3 * boxWidth) + (i + 1) * boxWidth
, offsetY + 0.5 * (actualWidth - sizeY_area3 * boxLength) + j * boxLength
)
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
}
double spaceX_area3 = 0.0, spaceY_area3 = 0.0;
if (dir_area3 == 0)
{
spaceX_area3 = 0.5 * (actualLength - sizeX_area3 * boxLength - 2.0 * (spaceX_area1 > 0 ? sizeX_area1 * boxLength : sizeX_area2 * boxWidth));
spaceY_area3 = 0.5 * (actualWidth - sizeY_area3 * boxWidth - 2.0 * (spaceY_area1 > 0 ? sizeY_area1 * boxWidth : sizeY_area2 * boxLength));
}
else
{
spaceX_area3 = 0.5 * (actualLength - sizeX_area3 * boxWidth - 2.0 * (spaceX_area1 > 0 ? sizeX_area1 * boxLength : sizeX_area2 * boxWidth));
spaceY_area3 = 0.5 * (actualWidth - sizeY_area3 * boxLength - 2.0 * (spaceY_area1 > 0 ? sizeY_area1 * boxWidth : sizeY_area2 * boxLength));
}
// set spacing
layer.UpdateMaxSpace(spaceX_area3, Name);
layer.UpdateMaxSpace(spaceY_area3, Name);
}
public double GetBoxWidth(ILayer2D layer)
{
return((layer as Layer2D).BoxWidth);
}
