public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
int sizeX = (int)Math.Floor(palletLength / boxLength);
int sizeY = (int)Math.Floor(palletWidth / boxWidth);
double offsetX = 0.5 * (palletLength - actualLength);
double offsetY = 0.5 * (palletWidth - actualWidth);
double spaceX = sizeX > 1 ? (actualLength - sizeX * boxLength) / (sizeX - 1) : 0.0;
double spaceY = sizeY > 1 ? (actualWidth - sizeY * boxWidth) / (sizeY - 1) : 0.0;
for (int i = 0; i < sizeX; ++i)
{
for (int j = 0; j < sizeY; ++j)
{
AddPosition(layer
, new Vector2D(
offsetX + i * (boxLength + spaceX)
, offsetY + j * (boxWidth + spaceY)
)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
// set spacing to ZERO i.e. no spacing with column layout
layer.UpdateMaxSpace(spaceX);
layer.UpdateMaxSpace(spaceY);
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
// initialization
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(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);
// 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.0 * sizeX_area1 * boxLength;
double spaceY_Area1 = actualWidth - 2.0 * 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.0 * sizeX_area2 * boxWidth;
double spaceY_Area2 = actualWidth - 2.0 * sizeY_area2 * boxLength;
double spaceX = spaceX_Area1 > 0 ? spaceX_Area1 : spaceX_Area2;
double spaceY = spaceY_Area1 > 0 ? spaceY_Area1 : spaceY_Area2;
layer.UpdateMaxSpace(Math.Min(spaceX, spaceY));
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0;
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out maxSizeXLength, out maxSizeXWidth, out maxSizeYLength, out 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 / 2; ++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);
AddPosition(
layer
, new Vector2D(
palletLength - offsetX - i * (boxLength + spaceX)
, palletWidth - offsetY - j * (boxWidth + spaceYLength))
, HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Y_N);
}
}
for (int i = 0; i < maxSizeXWidth; ++i)
{
for (int j = 0; j < maxSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + maxSizeXLength / 2 * (boxLength + spaceX) + i * (boxWidth + spaceX) + boxWidth
, offsetY + j * (boxLength + spaceYWidth))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
layer.UpdateMaxSpace(spaceX);
layer.UpdateMaxSpace(spaceYLength);
layer.UpdateMaxSpace(spaceYWidth);
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
// initialization
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
// compute optimal layout
int sizeX_area1 = 0, sizeY_area1 = 0
, sizeX_area2 = 0, sizeY_area2 = 0
, sizeX_area3 = 0, sizeY_area3 = 0
, dir_area3 = 0;
GetOptimalSizesXY(
boxLength, boxWidth, palletLength, palletWidth
, out sizeX_area1, out sizeY_area1
, out sizeX_area2, out sizeY_area2
, out sizeX_area3, out sizeY_area3
, out 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);
layer.UpdateMaxSpace(spaceY_area3);
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0, iStep = 0;
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth
, out iStep, out maxSizeXLength, out maxSizeXWidth, out maxSizeYLength, out 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;
System.Diagnostics.Debug.Assert(spaceX >= 0.0);
System.Diagnostics.Debug.Assert(spaceY >= 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);
}
}
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(layer);
int sizeX_area1 = 0, sizeY_area1 = 0, sizeX_area2 = 0, sizeY_area2 = 0, sizeX_area3 = 0, sizeY_area3 = 0;
GetOptimalSizeArea1(boxLength, boxWidth, palletLength, palletWidth, out sizeX_area1, out sizeY_area1);
GetSizeXY(boxLength, boxWidth, palletLength, palletWidth, sizeX_area1, sizeY_area1
, out sizeX_area2, out sizeY_area2, out sizeX_area3, out 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);
layer.UpdateMaxSpace(spaceY_area1);
layer.UpdateMaxSpace(spaceX_area2);
layer.UpdateMaxSpace(spaceY_area2);
layer.UpdateMaxSpace(spaceX_area3);
layer.UpdateMaxSpace(spaceY_area3);
}
public override void GenerateLayer(Layer layer, double actualLength, double actualWidth)
{
layer.Clear();
double boxLength = layer.BoxLength;
double boxWidth = layer.BoxWidth;
double palletLength = GetPalletLength(layer);
double palletWidth = GetPalletWidth(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 spaceX = maxSizeXLength + maxSizeXWidth > 1 ? (actualLength - (maxSizeXLength * boxLength + maxSizeXWidth * boxWidth)) / (maxSizeXLength + maxSizeXWidth - 1) : 0.0;
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 + spaceX)
, 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 + spaceX)
, 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 + spaceX)
, offsetY + j * (boxWidth + spaceYLength) + (fillSizeYLength > 0 ? (spaceYLength + boxLength) : 0.0))
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
}
}
double spaceXFill = fillSizeXLength > 1
? (maxSizeXLength * (boxLength + spaceX) - fillSizeXLength * boxWidth) / (fillSizeXLength - 1)
: 0;
layer.UpdateMaxSpace(spaceXFill);
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 + spaceX) + i * (boxWidth + spaceX) + 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 + maxSizeXLength * (boxLength + spaceX) + i * (boxWidth + spaceX) + 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 + maxSizeXLength * (boxLength + spaceX) + i * (boxWidth + spaceX) + boxWidth
, offsetY + j * (boxLength + spaceYWidth) + (fillSizeYWidth > 0 ? (boxWidth + spaceYWidth) : 0.0))
, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N);
}
}
double spaceXFill = (actualLength - maxSizeXLength * (boxLength + spaceX) - fillSizeXWidth * boxLength) / fillSizeXWidth;
layer.UpdateMaxSpace(spaceXFill);
for (int i = 0; i < fillSizeXWidth; ++i)
{
for (int j = 0; j < fillSizeYWidth; ++j)
{
AddPosition(
layer
, new Vector2D(
offsetX + maxSizeXLength * (boxLength + spaceX) + spaceXFill + i * (boxLength + spaceXFill)
, offsetY + (maxSizeYWidth / 2) * (boxLength + spaceYWidth) + j * boxWidth)
, HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P
);
}
}
}
// maximum space
layer.UpdateMaxSpace(spaceYLength);
layer.UpdateMaxSpace(spaceYWidth);
layer.UpdateMaxSpace(spaceX);
}