private List<PackPalletSolution> GenerateSolutions()
{
List<PackPalletSolution> solutions = new List<PackPalletSolution>();
HalfAxis.HAxis[] axes = { HalfAxis.HAxis.AXIS_Z_N, HalfAxis.HAxis.AXIS_Z_P };
// loop throught all patterns
foreach (LayerPattern pattern in LayerPattern.All)
{
// loop throught all axes
foreach (HalfAxis.HAxis axis in axes) // axis
{
// loop through
Layer2D layer = BuildLayer(_packProperties, _palletProperties, _constraintSet, axis, false, false);
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
continue;
pattern.GenerateLayer(layer, actualLength, actualWidth);
// filter by layer weight
if (_constraintSet.MaximumLayerWeight.Activated
&& (layer.Count * _packProperties.Weight > _constraintSet.MaximumLayerWeight.Value))
continue;
// filter by maximum space
if (_constraintSet.MaximumSpaceAllowed.Activated
&& layer.MaximumSpace > _constraintSet.MaximumSpaceAllowed.Value)
continue;
double layerHeight = layer.BoxHeight;
string title = string.Format("{0}-{1}", pattern.Name, axis.ToString());
double zLayer = 0.0;
BoxLayer boxLayer = new BoxLayer(zLayer, 0);
foreach (LayerPosition layerPos in layer)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
boxLayer.Add(boxPos);
}
boxLayer.MaximumSpace = layer.MaximumSpace;
BBox3D layerBBox = boxLayer.BoundingBox(_packProperties);
// filter by overhangX
if (_constraintSet.MinOverhangX.Activated
&& (0.5 * (layerBBox.Length - _palletProperties.Length) < _constraintSet.MinOverhangX.Value))
continue;
// filter by overhangY
if (_constraintSet.MinOverhangY.Activated
&& (0.5 * (layerBBox.Width - _palletProperties.Width) < _constraintSet.MinOverhangY.Value))
continue;
double interlayerThickness = null != _interlayerProperties ? _interlayerProperties.Thickness : 0;
double interlayerWeight = null != _interlayerProperties ? _interlayerProperties.Weight : 0;
PackPalletSolution sol = new PackPalletSolution(null, title, boxLayer);
int noLayer = 1,
noInterlayer = (null != _interlayerProperties && _constraintSet.HasFirstInterlayer) ? 1 : 0;
bool maxHeightReached = _constraintSet.MaximumPalletHeight.Activated
&& (_packProperties.Height
+ noInterlayer * interlayerThickness
+ noLayer * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
bool maxWeightReached = _constraintSet.MaximumPalletWeight.Activated
&& (_palletProperties.Weight
+ noInterlayer * interlayerWeight
+ noLayer * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);
noLayer = 0; noInterlayer = 0;
int iCountInterlayer = 0, iCountSwap = 1;
bool bSwap = false;
while (!maxHeightReached && !maxWeightReached)
{
bool bInterlayer = (0 == iCountInterlayer) && ((noLayer != 0) || _constraintSet.HasFirstInterlayer);
// actually insert new layer
sol.AddLayer(bSwap, bInterlayer);
// increment number of layers
noLayer++;
noInterlayer += (bInterlayer ? 1 : 0);
// update iCountInterlayer && iCountSwap
++iCountInterlayer;
if (iCountInterlayer >= _constraintSet.InterlayerPeriod) iCountInterlayer = 0;
++iCountSwap;
if (iCountSwap > _constraintSet.LayerSwapPeriod) { iCountSwap = 1; bSwap = !bSwap; }
// update maxHeightReached & maxWeightReached
maxHeightReached = _constraintSet.MaximumPalletHeight.Activated
&& (_palletProperties.Height
+ (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerThickness
+ (noLayer + 1) * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
maxWeightReached = _constraintSet.MaximumPalletWeight.Activated
&& (_palletProperties.Weight
+ (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerWeight
+ (noLayer + 1) * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);
}
if (sol.PackCount > 0)
solutions.Add(sol);
} // axis
} // pattern
solutions.Sort();
return solutions;
}
private List <PackPalletSolution> GenerateSolutions()
{
List <PackPalletSolution> solutions = new List <PackPalletSolution>();
HalfAxis.HAxis[] axes = { HalfAxis.HAxis.AXIS_Z_N, HalfAxis.HAxis.AXIS_Z_P };
// loop throught all patterns
foreach (LayerPattern pattern in _patterns)
{
// loop throught all axes
foreach (HalfAxis.HAxis axis in axes) // axis
{
// loop through
Layer layer = new Layer(_packProperties, _palletProperties, _constraintSet, axis, false);
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
{
continue;
}
pattern.GenerateLayer(layer, actualLength, actualWidth);
// filter by layer weight
if (_constraintSet.MaximumLayerWeight.Activated &&
(layer.Count * _packProperties.Weight > _constraintSet.MaximumLayerWeight.Value))
{
continue;
}
// filter by maximum space
if (_constraintSet.MaximumSpaceAllowed.Activated &&
layer.MaximumSpace > _constraintSet.MaximumSpaceAllowed.Value)
{
continue;
}
double layerHeight = layer.BoxHeight;
string title = string.Format("{0}-{1}", pattern.Name, axis.ToString());
double zLayer = 0.0;
BoxLayer boxLayer = new BoxLayer(zLayer, "");
foreach (LayerPosition layerPos in layer)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
boxLayer.Add(boxPos);
}
boxLayer.MaximumSpace = layer.MaximumSpace;
BBox3D layerBBox = boxLayer.BoundingBox(_packProperties);
// filter by overhangX
if (_constraintSet.MinOverhangX.Activated &&
(0.5 * (layerBBox.Length - _palletProperties.Length) < _constraintSet.MinOverhangX.Value))
{
continue;
}
// filter by overhangY
if (_constraintSet.MinOverhangY.Activated &&
(0.5 * (layerBBox.Width - _palletProperties.Width) < _constraintSet.MinOverhangY.Value))
{
continue;
}
double interlayerThickness = null != _interlayerProperties ? _interlayerProperties.Thickness : 0;
double interlayerWeight = null != _interlayerProperties ? _interlayerProperties.Weight : 0;
PackPalletSolution sol = new PackPalletSolution(null, title, boxLayer);
int noLayer = 1,
noInterlayer = (null != _interlayerProperties && _constraintSet.HasFirstInterlayer) ? 1 : 0;
bool maxHeightReached = _constraintSet.MaximumPalletHeight.Activated &&
(_packProperties.Height
+ noInterlayer * interlayerThickness
+ noLayer * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
bool maxWeightReached = _constraintSet.MaximumPalletWeight.Activated &&
(_palletProperties.Weight
+ noInterlayer * interlayerWeight
+ noLayer * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);
noLayer = 0; noInterlayer = 0;
int iCountInterlayer = 0, iCountSwap = 1;
bool bSwap = false;
while (!maxHeightReached && !maxWeightReached)
{
bool bInterlayer = (0 == iCountInterlayer) && ((noLayer != 0) || _constraintSet.HasFirstInterlayer);
// actually insert new layer
sol.AddLayer(bSwap, bInterlayer);
// increment number of layers
noLayer++;
noInterlayer += (bInterlayer ? 1 : 0);
// update iCountInterlayer && iCountSwap
++iCountInterlayer;
if (iCountInterlayer >= _constraintSet.InterlayerPeriod)
{
iCountInterlayer = 0;
}
++iCountSwap;
if (iCountSwap > _constraintSet.LayerSwapPeriod)
{
iCountSwap = 1; bSwap = !bSwap;
}
// update maxHeightReached & maxWeightReached
maxHeightReached = _constraintSet.MaximumPalletHeight.Activated &&
(_palletProperties.Height
+ (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerThickness
+ (noLayer + 1) * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
maxWeightReached = _constraintSet.MaximumPalletWeight.Activated &&
(_palletProperties.Weight
+ (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerWeight
+ (noLayer + 1) * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);
}
if (sol.PackCount > 0)
{
solutions.Add(sol);
}
} // axis
} // pattern
solutions.Sort();
return(solutions);
}
private List <BoxCasePalletSolution> GenerateSolutions()
{
List <BoxCasePalletSolution> solutions = new List <BoxCasePalletSolution>();
// loop through all pallet solutions
foreach (PalletSolutionDesc desc in _palletSolutionList)
{
CasePalletSolution palletSolution = desc.LoadPalletSolution();
if (null == palletSolution)
{
_log.Warn(string.Format("Failed to load pallet solution "));
continue;
}
BoxProperties caseProperties = palletSolution.Analysis.BProperties as BoxProperties;
// loop through all patterns
foreach (LayerPattern pattern in _patterns)
{
if (!_constraintSet.AllowPattern(pattern.Name))
{
continue;
}
// loop through all swap positions (if layer can be swapped)
for (int swapPos = 0; swapPos < (pattern.CanBeSwapped ? 2 : 1); ++swapPos)
{
pattern.Swapped = swapPos == 1;
// loop through all vertical axes
for (int i = 0; i < 3; ++i)
{
HalfAxis.HAxis axisOrtho1 = (HalfAxis.HAxis)(2 * i);
HalfAxis.HAxis axisOrtho2 = (HalfAxis.HAxis)(2 * i + 1);
if (!_constraintSet.AllowOrthoAxis(axisOrtho2))
{
continue;
}
try
{
// build 2 layers (pallet length/width)
Layer layer1 = new Layer(_boxProperties, caseProperties, axisOrtho1);
Layer layer2 = new Layer(_boxProperties, caseProperties, axisOrtho2);
double actualLength1 = 0.0, actualLength2 = 0.0, actualWidth1 = 0.0, actualWidth2 = 0.0;
bool bResult1 = pattern.GetLayerDimensionsChecked(layer1, out actualLength1, out actualWidth1);
bool bResult2 = pattern.GetLayerDimensionsChecked(layer2, out actualLength2, out actualWidth2);
string layerAlignment = string.Empty;
for (int j = 0; j < 4; ++j)
{
Layer layer1T = null, layer2T = null;
if (0 == j && _constraintSet.AllowAlignedLayers && bResult1)
{
pattern.GenerateLayer(layer1, actualLength1, actualWidth1);
layer1T = layer1; layer2T = layer1;
layerAlignment = "aligned-1";
}
else if (1 == j && _constraintSet.AllowAlignedLayers && bResult2)
{
pattern.GenerateLayer(layer2, actualLength2, actualWidth2);
layer1T = layer2; layer2T = layer2;
layerAlignment = "aligned-2";
}
else if (2 == j && _constraintSet.AllowAlternateLayers && bResult1 && bResult2)
{
pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
layer1T = layer1; layer2T = layer2;
layerAlignment = "alternate-12";
}
else if (3 == j && _constraintSet.AllowAlternateLayers && bResult1 && bResult2)
{
pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
layer1T = layer2; layer2T = layer1;
layerAlignment = "alternate-21";
}
if (null == layer1T || null == layer2T || 0 == layer1T.Count || 0 == layer2T.Count)
{
continue;
}
// counters
string axisName = string.Empty;
switch (i)
{
case 0: axisName = "X"; break;
case 1: axisName = "Y"; break;
case 2: axisName = "Z"; break;
default: break;
}
string title = string.Format("{0}-{1}-{2}{3}", pattern.Name, axisName, layerAlignment, swapPos == 1 ? "-swapped" : "");
BoxCasePalletSolution sol = new BoxCasePalletSolution(null, title, desc, layer1T == layer2T);
int iLayerIndex = 0;
bool innerLoopStop = false;
double offsetX = 0.5 * (caseProperties.Length - caseProperties.InsideLength);
double offsetY = 0.5 * (caseProperties.Width - caseProperties.InsideWidth);
double zLayer = 0.5 * (caseProperties.Height - caseProperties.InsideHeight);
int iInterlayer = 0;
int boxCount = 0;
while (
!innerLoopStop
&&
((zLayer + _boxProperties.Dimension(axisOrtho1) < caseProperties.InsideHeight))
)
{
if (_constraintSet.HasInterlayer)
{
if (iInterlayer >= _constraintSet.InterlayerPeriod)
{
InterlayerPos interlayerPos = sol.CreateNewInterlayer(zLayer, 0);
zLayer += _interlayerProperties.Thickness;
iInterlayer = 0;
}
++iInterlayer;
}
// select current layer type
Layer currentLayer = iLayerIndex % 2 == 0 ? layer1T : layer2T;
BoxLayer layer = sol.CreateNewLayer(zLayer, pattern.Name);
foreach (LayerPosition layerPos in currentLayer)
{
int iCount = sol.Count + 1;
innerLoopStop = (_constraintSet.UseMaximumCaseWeight && ((boxCount + 1) * _boxProperties.Weight + caseProperties.Weight > _constraintSet.MaximumCaseWeight)) ||
(_constraintSet.UseMaximumNumberOfItems && ((boxCount + 1) > _constraintSet.MaximumNumberOfItems));
if (!innerLoopStop)
{
BoxPosition boxPos = new BoxPosition(
layerPos.Position
+ offsetX * Vector3D.XAxis
+ offsetY * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPos.LengthAxis
, layerPos.WidthAxis
);
layer.Add(boxPos);
++boxCount;
}
else
{
break;
}
}
// increment layer index
++iLayerIndex;
zLayer += currentLayer.BoxHeight;
}
// insert solution
if (
sol.Count > 0 &&
(!_constraintSet.UseMinimumNumberOfItems || sol.Count >= _constraintSet.MinimumNumberOfItems)
)
{
solutions.Add(sol);
}
}
}
catch (NotImplementedException)
{
_log.Info(string.Format("Pattern {0} is not implemented", pattern.Name));
}
catch (Exception ex)
{
_log.Error(string.Format("Exception caught: {0}", ex.Message));
}
} // loop through all vertical axes
} // loop through all swap positions (if layer can be swapped)
} // loop through all patterns
} // loop through all pallet solutions
// sort solutions
solutions.Sort();
// return list of solutions
return(solutions);
}
public BoxLayer GetBoxLayer(int iLayerIndex, ref bool hasInterlayer, ref double zInterlayer)
{
if (null == _parentAnalysis)
throw new Exception("_parentAnalysis not set.");
double interlayerThickness = (null != _parentAnalysis.InterlayerProperties) ? _parentAnalysis.InterlayerProperties.Thickness : 0.0;
double packHeight = _parentAnalysis.PackProperties.Height;
double zLow = _parentAnalysis.PalletProperties.Height;
int i = 0;
while (i <= iLayerIndex-1)
{
LayerDescriptor desc = _listLayers[i];
zLow += (desc.HasInterlayer ? interlayerThickness : 0.0) + packHeight;
++i;
}
zInterlayer = zLow;
hasInterlayer = _listLayers[iLayerIndex].HasInterlayer;
zLow += hasInterlayer ? interlayerThickness : 0.0;
Transform3D swapTransform = Transform3D.Identity;
if (_listLayers[iLayerIndex].Swapped)
{
Matrix4D matRot = new Matrix4D(
-1.0, 0.0, 0.0, _parentAnalysis.PalletProperties.Length
, 0.0, -1.0, 0.0, _parentAnalysis.PalletProperties.Width
, 0.0, 0.0, 1.0, 0.0
, 0.0, 0.0, 0.0, 1.0);
swapTransform = new Transform3D(matRot);
}
// build BoxLayer
BoxLayer layer = new BoxLayer(zLow + (hasInterlayer ? interlayerThickness : 0.0), 0);
foreach (BoxPosition b in _layer)
{
layer.Add(
new BoxPosition(
swapTransform.transform(b.Position + zLow * Vector3D.ZAxis)
, HalfAxis.Transform(b.DirectionLength, swapTransform)
, HalfAxis.Transform(b.DirectionWidth, swapTransform) )
);
}
return layer;
}
private List <BoxCaseSolution> GenerateSolutions()
{
List <BoxCaseSolution> solutions = new List <BoxCaseSolution>();
int[] patternColumnCount = new int[6];
// loop throw all patterns
foreach (LayerPattern pattern in _patterns)
{
// loop through all vertical axes
for (int i = 0; i < 6; ++i)
{
HalfAxis.HAxis axisOrtho = (HalfAxis.HAxis)i;
if (!_constraintSet.AllowOrthoAxis(axisOrtho))
{
continue;
}
try
{
// build layer
Layer layer = new Layer(_bProperties, _caseProperties, axisOrtho);
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
{
continue;
}
pattern.GenerateLayer(layer, actualLength, actualWidth);
string title = string.Empty;
BoxCaseSolution sol = new BoxCaseSolution(null, axisOrtho, pattern.Name);
double offsetX = 0.5 * (_caseProperties.Length - _caseProperties.InsideLength);
double offsetY = 0.5 * (_caseProperties.Width - _caseProperties.InsideWidth);
double zLayer = 0.5 * (_caseProperties.Height - _caseProperties.InsideHeight);
bool maxWeightReached = _constraintSet.UseMaximumCaseWeight && (_caseProperties.Weight + _bProperties.Weight > _constraintSet.MaximumCaseWeight);
bool maxHeightReached = _bProperties.Dimension(axisOrtho) > _caseProperties.InsideHeight;
bool maxNumberReached = false;
int boxCount = 0;
while (!maxWeightReached && !maxHeightReached && !maxNumberReached)
{
BoxLayer bLayer = sol.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in layer)
{
// increment
++boxCount;
if (maxNumberReached = _constraintSet.UseMaximumNumberOfBoxes && (boxCount > _constraintSet.MaximumNumberOfBoxes))
{
break;
}
double weight = _caseProperties.Weight + boxCount * _bProperties.Weight;
maxWeightReached = _constraintSet.UseMaximumCaseWeight && weight > _constraintSet.MaximumCaseWeight;
if (maxWeightReached)
{
break;
}
// insert new box in current layer
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
+ offsetX * Vector3D.XAxis
+ offsetY * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
bLayer.Add(boxPos);
}
zLayer += layer.BoxHeight;
if (!maxWeightReached && !maxNumberReached)
{
maxHeightReached = zLayer + layer.BoxHeight > 0.5 * (_caseProperties.Height + _caseProperties.InsideHeight);
}
}
// set maximum criterion
if (maxNumberReached)
{
sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXNUMBERREACHED;
}
else if (maxWeightReached)
{
sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXWEIGHTREACHED;
}
else if (maxHeightReached)
{
sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXHEIGHTREACHED;
}
if (string.Equals(pattern.Name, "Column", StringComparison.CurrentCultureIgnoreCase))
{
patternColumnCount[i] = Math.Max(patternColumnCount[i], sol.BoxPerCaseCount);
}
// insert solution
if (sol.BoxPerCaseCount >= patternColumnCount[i])
{
solutions.Add(sol);
}
}
catch (NotImplementedException)
{
_log.Info(string.Format("Pattern {0} is not implemented", pattern.Name));
}
catch (Exception ex)
{
_log.Error(string.Format("Exception caught: {0}", ex.Message));
}
} // loop through all vertical axes
} // loop through all patterns
// sort solutions
solutions.Sort();
/*
* // removes solutions that do not equal the best number
* if (solutions.Count > 0)
* {
* int indexFrom = 0, maxCount = solutions[0].BoxPerCaseCount;
* while (indexFrom < solutions.Count && solutions[indexFrom].BoxPerCaseCount == maxCount)
++indexFrom;
* solutions.RemoveRange(indexFrom, solutions.Count - indexFrom);
* }
*/
return(solutions);
}
/// <summary>
/// build optimal solutions with 2 layer types
/// </summary>
/// <returns></returns>
private List <CasePalletSolution> GenerateOptimizedCombinationOfLayers()
{
List <CasePalletSolution> solutions = new List <CasePalletSolution>();
// generate best layers
Layer[] bestLayers = new Layer[3];
bestLayers[0] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_X_P);
bestLayers[1] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Y_P);
bestLayers[2] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Z_P);
string[] dir = { "X", "Y", "Z" };
for (int i = 0; i < 3; ++i)
{
HalfAxis.HAxis axisOrtho = (HalfAxis.HAxis)(2 * i + 1);
HalfAxis.HAxis axis0 = (HalfAxis.HAxis)((2 * (i + 1)) % 6 + 1);
HalfAxis.HAxis axis1 = (HalfAxis.HAxis)((2 * (i + 2)) % 6 + 1);
int noLayer0 = 0, noLayer1 = 0;
if (GetOptimalRequest(
_bProperties.Dimension(axis0), bestLayers[i % 3].Count
, _bProperties.Dimension(axis1), bestLayers[(i + 1) % 3].Count
, out noLayer0, out noLayer1))
{
Layer layer0 = bestLayers[i % 3];
Layer layer1 = bestLayers[(i + 1) % 3];
// sol0
CasePalletSolution sol0 = new CasePalletSolution(null, string.Format("combination_{0}{1}", dir[i % 3], dir[(i % 3) + 1]), false);
double zLayer = _palletProperties.Height;
double cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;
for (int j = 0; j < noLayer0; ++j)
{
BoxLayer layer = sol0.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in layer0)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- 0.5 * _constraintSet.OverhangX * Vector3D.XAxis
- 0.5 * _constraintSet.OverhangY * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
zLayer += layer0.BoxHeight;
}
for (int j = 0; j < noLayer1; ++j)
{
BoxLayer layer = sol0.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in layer1)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
zLayer += layer1.BoxHeight;
}
solutions.Add(sol0);
// sol1
CasePalletSolution sol1 = new CasePalletSolution(null, string.Format("combination_{0}{1}", dir[i % 3], dir[(i % 3) + 1]), false);
zLayer = _palletProperties.Height;
for (int j = 0; j < noLayer0; ++j)
{
BoxLayer layer = sol1.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in layer1)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
zLayer += layer1.BoxHeight;
}
for (int j = 0; j < noLayer1; ++j)
{
BoxLayer layer = sol1.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in layer0)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
zLayer += layer0.BoxHeight;
}
solutions.Add(sol1);
}
}
return(solutions);
}
private List <CasePalletSolution> GenerateSolutions()
{
// generate best layers
Layer[] bestLayers = new Layer[3];
if (_constraintSet.AllowLastLayerOrientationChange)
{
bestLayers[0] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_X_P);
bestLayers[1] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Y_P);
bestLayers[2] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Z_P);
}
List <CasePalletSolution> solutions = new List <CasePalletSolution>();
// loop through all patterns
foreach (LayerPattern pattern in _patterns)
{
if (!_constraintSet.AllowPattern(pattern.Name))
{
continue;
}
// loop through all swap positions (if layer can be swapped)
for (int swapPos = 0; swapPos < (pattern.CanBeSwapped ? 2 : 1); ++swapPos)
{
pattern.Swapped = swapPos == 1;
// loop through all vertical axes
for (int i = 0; i < 3; ++i)
{
HalfAxis.HAxis axisOrtho1 = (HalfAxis.HAxis)(2 * i);
HalfAxis.HAxis axisOrtho2 = (HalfAxis.HAxis)(2 * i + 1);
if (!_constraintSet.AllowOrthoAxis(axisOrtho2))
{
continue;
}
try
{
// build 2 layers (pallet length/width)
Layer layer1 = new Layer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho1);
Layer layer1_inv = new Layer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho1, true);
Layer layer2 = new Layer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho2);
Layer layer2_inv = new Layer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho2, true);
double actualLength1 = 0.0, actualLength2 = 0.0, actualWidth1 = 0.0, actualWidth2 = 0.0;
pattern.GetLayerDimensionsChecked(layer1, out actualLength1, out actualWidth1);
pattern.GetLayerDimensionsChecked(layer2, out actualLength2, out actualWidth2);
string layerAlignment = string.Empty;
for (int j = 0; j < 6; ++j)
{
Layer layer1T = null, layer2T = null;
if (0 == j && _constraintSet.AllowAlignedLayers)
{
pattern.GenerateLayer(layer1, actualLength1, actualWidth1);
layer1T = layer1; layer2T = layer1;
layerAlignment = "aligned-1";
}
else if (1 == j && _constraintSet.AllowAlignedLayers)
{
pattern.GenerateLayer(layer2, actualLength2, actualWidth2);
layer1T = layer2; layer2T = layer2;
layerAlignment = "aligned-2";
}
else if (2 == j && _constraintSet.AllowAlternateLayers)
{
pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
layer1T = layer1; layer2T = layer2;
layerAlignment = "alternate-12";
}
else if (3 == j && _constraintSet.AllowAlternateLayers)
{
pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
layer1T = layer2; layer2T = layer1;
layerAlignment = "alternate-21";
}
else if (4 == j && _constraintSet.AllowAlternateLayers && pattern.CanBeInverted)
{
pattern.GenerateLayer(layer1, actualLength1, actualWidth1);
pattern.GenerateLayer(layer1_inv, actualLength1, actualWidth1);
layer1T = layer1; layer2T = layer1_inv;
layerAlignment = "inv-1";
}
else if (5 == j && _constraintSet.AllowAlternateLayers && pattern.CanBeInverted)
{
pattern.GenerateLayer(layer2, actualLength2, actualWidth2);
pattern.GenerateLayer(layer2_inv, actualLength2, actualWidth2);
layer1T = layer2; layer2T = layer2_inv;
layerAlignment = "inv-2";
}
if (null == layer1T || null == layer2T || 0 == layer1T.Count || 0 == layer2T.Count)
{
continue;
}
// counters
string axisName = string.Empty;
switch (i)
{
case 0: axisName = "X"; break;
case 1: axisName = "Y"; break;
case 2: axisName = "Z"; break;
default: break;
}
string title = string.Format("{0}-{1}-{2}{3}", pattern.Name, axisName, layerAlignment, swapPos == 1 ? "-swapped" : "");
CasePalletSolution sol = new CasePalletSolution(null, title, layer1T == layer2T);
int iLayerIndex = 0;
double zLayer = _palletProperties.Height;
double capThickness = null != _capProperties ? _capProperties.Thickness : 0;
int iInterlayer = 0;
int iCount = 0;
bool maxWeightReached = _constraintSet.UseMaximumPalletWeight && (_palletProperties.Weight + _bProperties.Weight > _constraintSet.MaximumPalletWeight);
bool maxHeightReached = _constraintSet.UseMaximumHeight && (zLayer + capThickness + _bProperties.Dimension(axisOrtho1) > _constraintSet.MaximumHeight);
bool maxNumberReached = false;
// insert anti-slip interlayer id there is one
if (_constraintSet.HasInterlayerAntiSlip)
{
InterlayerPos interlayerPos = sol.CreateNewInterlayer(zLayer, 1);
zLayer += _interlayerPropertiesAntiSlip.Thickness;
}
while (!maxWeightReached && !maxHeightReached && !maxNumberReached)
{
if (_constraintSet.HasInterlayer)
{
if (iInterlayer >= _constraintSet.InterlayerPeriod)
{
InterlayerPos interlayerPos = sol.CreateNewInterlayer(zLayer, 0);
zLayer += _interlayerProperties.Thickness;
iInterlayer = 0;
}
++iInterlayer;
}
// select current layer type
double cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;
Layer currentLayer = iLayerIndex % 2 == 0 ? layer1T : layer2T;
BoxLayer layer = sol.CreateNewLayer(zLayer, pattern.Name);
foreach (LayerPosition layerPos in currentLayer)
{
++iCount;
maxWeightReached = _constraintSet.UseMaximumPalletWeight && ((iCount * _bProperties.Weight + _palletProperties.Weight) > _constraintSet.MaximumPalletWeight);
maxNumberReached = _constraintSet.UseMaximumNumberOfCases && (iCount > _constraintSet.MaximumNumberOfItems);
if (!maxWeightReached && !maxNumberReached)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
else
{
break;
}
}
// increment layer index
++iLayerIndex;
zLayer += currentLayer.BoxHeight;
// check height
maxHeightReached = _constraintSet.UseMaximumHeight && (zLayer + _bProperties.Dimension(axisOrtho1) > _constraintSet.MaximumHeight);
}
if (maxHeightReached && _constraintSet.AllowLastLayerOrientationChange)
{
// remaining height
double remainingHeight = _constraintSet.MaximumHeight - zLayer;
// test to complete with best layer
Layer bestLayer = null; int ibestLayerCount = 0;
for (int iLayerDir = 0; iLayerDir < 3; ++iLayerDir)
{
// another direction than the current direction
if (iLayerDir == i)
{
continue;
}
Layer layer = bestLayers[iLayerDir];
if (null == layer)
{
continue;
}
int layerCount = Convert.ToInt32(Math.Floor(remainingHeight / layer.BoxHeight));
if (layerCount < 1)
{
continue;
}
if (null == bestLayer || ibestLayerCount * bestLayer.Count < layerCount * layer.Count)
{
bestLayer = layer;
ibestLayerCount = layerCount;
}
}
if (null != bestLayer)
{
double cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;
for (int iAddLayer = 0; iAddLayer < ibestLayerCount; ++iAddLayer)
{
BoxLayer layer = sol.CreateNewLayer(zLayer, string.Empty);
foreach (LayerPosition layerPos in bestLayer)
{
LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
BoxPosition boxPos = new BoxPosition(
layerPosTemp.Position
- (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
- (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
+ zLayer * Vector3D.ZAxis
, layerPosTemp.LengthAxis
, layerPosTemp.WidthAxis
);
layer.Add(boxPos);
}
zLayer += bestLayer.BoxHeight;
}
}
}
// set maximum criterion
if (maxNumberReached)
{
sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXNUMBERREACHED;
}
else if (maxWeightReached)
{
sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXWEIGHTREACHED;
}
else if (maxHeightReached)
{
sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXHEIGHTREACHED;
}
// insert solution
if (sol.Count > 0)
{
solutions.Add(sol);
}
}
}
catch (NotImplementedException)
{
_log.Info(string.Format("Pattern {0} is not implemented", pattern.Name));
}
catch (Exception ex)
{
_log.Error(string.Format("Exception caught: {0}", ex.Message));
}
} // loop through all vertical axes
} // loop through all swap positions (if layer can be swapped)
} // loop through all patterns
// sort solutions
solutions.Sort();
if (ConstraintSet.AllowTwoLayerOrientations && solutions.Count > 0)
{
// get best solution count
int iBestSolutionCount = solutions[0].CaseCount;
// if solutions exceeds
List <CasePalletSolution> multiOrientSolution = GenerateOptimizedCombinationOfLayers();
foreach (CasePalletSolution sol in multiOrientSolution)
{
if (sol.CaseCount > iBestSolutionCount)
{
solutions.Add(sol);
}
}
solutions.Sort();
}
// remove unwanted solutions
if (_constraintSet.UseNumberOfSolutionsKept && solutions.Count > _constraintSet.NumberOfSolutionsKept)
{
// get minimum box count
int minBoxCount = solutions[_constraintSet.NumberOfSolutionsKept].CaseCount;
// remove any solution with less boxes than minBoxCount
while (solutions[solutions.Count - 1].CaseCount < minBoxCount)
{
solutions.RemoveAt(solutions.Count - 1);
}
}
return(solutions);
}
