public Pack(uint pickId, PackProperties packProperties, BoxPosition position)
: base(pickId, packProperties, position)
{
_packProperties = packProperties;
_arrangement = _packProperties.Arrangement;
_innerBox = new Box(0, packProperties.Box);
_forceTransparency = false;
}
public static BoxPosition Transform(BoxPosition boxPosition, Transform3D transform)
{
if (!boxPosition.IsValid)
throw new Exception("Invalid box position : can not transform");
return new BoxPosition(
transform.transform(boxPosition.Position)
, HalfAxis.Transform(boxPosition.DirectionLength, transform)
, HalfAxis.Transform(boxPosition.DirectionWidth, transform)
);
}
public static bool BoxCanMoveInside(BoxPosition bPos, Vector3D dim, Vector2D ptMin, Vector2D ptMax, HalfAxis.HAxis axis)
{
var bbox = bPos.BBox(dim);
switch (axis)
{
case HalfAxis.HAxis.AXIS_X_N: return(bbox.PtMin.X > ptMin.X);
case HalfAxis.HAxis.AXIS_X_P: return(bbox.PtMax.X < ptMax.X);
case HalfAxis.HAxis.AXIS_Y_N: return(bbox.PtMin.Y > ptMin.Y);
case HalfAxis.HAxis.AXIS_Y_P: return(bbox.PtMax.Y < ptMax.Y);
default: return(false);
}
}
private BBox3D ComputeLoadBBox3D()
{
double palletLength = ParentTruckAnalysis.ParentSolution.PalletLength;
double palletWidth = ParentTruckAnalysis.ParentSolution.PalletWidth;
double palletHeight = ParentTruckAnalysis.ParentSolution.PalletHeight;
BBox3D bbox = new BBox3D();
int iLayer = 0;
while (iLayer < NoLayers)
{
foreach (BoxPosition bPositionLayer in Layer)
{
// actual position in load
BoxPosition bpos = new BoxPosition(
new Vector3D(
bPositionLayer.Position.X
, bPositionLayer.Position.Y
, bPositionLayer.Position.Z + palletHeight * iLayer)
, bPositionLayer.DirectionLength
, bPositionLayer.DirectionWidth);
Vector3D[] pts = new Vector3D[8];
Vector3D vI = HalfAxis.ToVector3D(bpos.DirectionLength);
Vector3D vJ = HalfAxis.ToVector3D(bpos.DirectionWidth);
Vector3D vK = Vector3D.CrossProduct(vI, vJ);
pts[0] = bpos.Position;
pts[1] = bpos.Position + palletLength * vI;
pts[2] = bpos.Position + palletWidth * vJ;
pts[3] = bpos.Position + palletLength * vI + palletWidth * vJ;
pts[4] = bpos.Position + palletHeight * vK;
pts[5] = bpos.Position + palletWidth * vJ + palletHeight * vK;;
pts[6] = bpos.Position + HalfAxis.ToVector3D(bpos.DirectionWidth) * palletWidth;
pts[7] = bpos.Position + HalfAxis.ToVector3D(bpos.DirectionLength) * palletLength + HalfAxis.ToVector3D(bpos.DirectionWidth) * palletWidth;
foreach (Vector3D pt in pts)
{
bbox.Extend(pt);
}
}
++iLayer;
}
return(bbox);
}
private BoxPosition ApplyReflection(BoxPosition layerPos, Matrix4D matRot, Vector3D vTranslation)
{
Vector3D dimensions = Analysis.ContentDimensions;
Transform3D transfRot = new Transform3D(matRot);
HalfAxis.HAxis axisLength = HalfAxis.ToHalfAxis(transfRot.transform(HalfAxis.ToVector3D(layerPos.DirectionLength)));
HalfAxis.HAxis axisWidth = HalfAxis.ToHalfAxis(transfRot.transform(HalfAxis.ToVector3D(layerPos.DirectionWidth)));
matRot.M14 = vTranslation[0];
matRot.M24 = vTranslation[1];
matRot.M34 = vTranslation[2];
Transform3D transfRotTranslation = new Transform3D(matRot);
Vector3D transPos = transfRotTranslation.transform(new Vector3D(layerPos.Position.X, layerPos.Position.Y, layerPos.Position.Z));
return(new BoxPosition(
new Vector3D(transPos.X, transPos.Y, transPos.Z)
- dimensions.Z * Vector3D.CrossProduct(HalfAxis.ToVector3D(axisLength), HalfAxis.ToVector3D(axisWidth))
, axisLength
, axisWidth));
}
public static bool HaveIntersection(BoxPosition bPos1, Vector3D dim1, BoxPosition bPos2, Vector3D dim2)
{
var bbox1 = bPos1.BBox(dim1);
var bbox2 = bPos2.BBox(dim2);
Vector3D pt1 = bbox1.PtMin, pt2 = bbox1.PtMax;
Vector3D pt3 = bbox2.PtMin, pt4 = bbox2.PtMax;
Vector3D pt5 = new Vector3D(Math.Max(pt1.X, pt3.X), Math.Max(pt1.Y, pt3.Y), Math.Max(pt1.Z, pt3.Z));
Vector3D pt6 = new Vector3D(Math.Min(pt2.X, pt4.X), Math.Min(pt2.Y, pt4.Y), Math.Min(pt2.Z, pt4.Z));
// no intersections ?
if ((pt5.X - pt6.X > -EPSILON) ||
(pt5.Y - pt6.Y > -EPSILON) ||
(pt5.Z - pt6.Z > -EPSILON))
{
return(false);
}
else
{
return(true);
}
}
public BBox3D(BoxPosition bPos, Vector3D dim)
{
Vector3D lengthAxis = HalfAxis.ToVector3D(bPos.DirectionLength);
Vector3D widthAxis = HalfAxis.ToVector3D(bPos.DirectionWidth);
Vector3D heightAxis = HalfAxis.ToVector3D(bPos.DirectionHeight);
var points = new Vector3D[8];
points[0] = bPos.Position;
points[1] = bPos.Position + dim[0] * lengthAxis;
points[2] = bPos.Position + dim[0] * lengthAxis + dim[1] * widthAxis;
points[3] = bPos.Position + dim[1] * widthAxis;
points[4] = bPos.Position + dim[2] * heightAxis;
points[5] = bPos.Position + dim[2] * heightAxis + dim[0] * lengthAxis;
points[6] = bPos.Position + dim[2] * heightAxis + dim[0] * lengthAxis + dim[1] * widthAxis;
points[7] = bPos.Position + dim[2] * heightAxis + dim[1] * widthAxis;
foreach (var pt in points)
{
Extend(pt);
}
}
public static bool HaveIntersection(List <BoxPosition> list, Vector3D dim, int selectedIndex, BoxPosition bPosition)
{
for (int i = 0; i < list.Count; ++i)
{
if (i != selectedIndex && HaveIntersection(list[i], dim, bPosition, dim))
{
return(true);
}
}
return(false);
}
public BoxPositionIndexed(Vector3D vPos, HalfAxis.HAxis axisLength, HalfAxis.HAxis axisWidth, int index)
{
BPos = new BoxPosition(vPos, axisLength, axisWidth);
Index = index;
}
public void Draw(Graphics3D graphics)
{
if (null == _truckSolution)
throw new Exception("No trucksolution defined!");
// draw truck
Truck truck = new Truck(_truckSolution.ParentTruckAnalysis.TruckProperties);
truck.DrawBegin(graphics);
truck.DrawEnd(graphics);
// get pallet height
CasePalletAnalysis analysis = _truckSolution.ParentTruckAnalysis.ParentAnalysis;
double palletLength = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletLength;
double palletWidth = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletWidth;
double palletHeight = _truckSolution.ParentTruckAnalysis.ParentSolution.PalletHeight;
// get parent pallet solution
CasePalletSolution sol = _truckSolution.ParentTruckAnalysis.ParentSolution;
// draw solution
uint pickIdGlobal = 0;
for (int i = 0; i < _truckSolution.NoLayers; ++i)
{
foreach (BoxPosition bPositionLayer in _truckSolution.Layer)
{
BoxPosition bPalletPosition = new BoxPosition(
new Vector3D(
bPositionLayer.Position.X
, bPositionLayer.Position.Y
, bPositionLayer.Position.Z + palletHeight * i)
, bPositionLayer.DirectionLength
, bPositionLayer.DirectionWidth);
if (_showDetails)
{
// build transformation
Transform3D transformPallet = bPalletPosition.Transformation;
// draw pallet
Pallet pallet = new Pallet(analysis.PalletProperties);
pallet.Draw(graphics, transformPallet);
// draw solution
uint pickId = 0;
foreach (ILayer layer in sol)
{
BoxLayer bLayer = layer as BoxLayer;
if (null != bLayer)
{
foreach (BoxPosition bPosition in bLayer)
graphics.AddBox(new Box(pickId++, analysis.BProperties, BoxPosition.Transform(bPosition, transformPallet)));
}
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
BoxPosition iPos = new BoxPosition(new Vector3D(0.0, 0.0, interlayerPos.ZLow), HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P);
graphics.AddBox(new Box(pickId++, analysis.InterlayerProperties, BoxPosition.Transform(iPos, transformPallet)));
}
}
}
else
{
Box b = new Box(pickIdGlobal++, new BoxProperties(null, palletLength, palletWidth, palletHeight), bPalletPosition);
b.SetAllFacesColor(Color.Chocolate);
graphics.AddBox(b);
}
}
}
// fluch
graphics.UseBoxelOrderer = false; // can not use boxel orderer for full truck view -> too slow...
}
public void AddPosition(BoxPosition position) => Add(position);
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;
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 < 6; ++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";
}
else if (4 == j && _constraintSet.AllowAlternateLayers && pattern.CanBeInverted && bResult1)
{
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 && bResult2)
{
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);
layer.MaximumSpace = currentLayer.MaximumSpace;
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);
// check number
maxNumberReached = _constraintSet.UseMaximumNumberOfCases && (iCount + 1 > _constraintSet.MaximumNumberOfItems);
// check weight
maxWeightReached = _constraintSet.UseMaximumPalletWeight && (((iCount+1) * _bProperties.Weight + _palletProperties.Weight) > _constraintSet.MaximumPalletWeight);
}
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;
}
public void CreateAnimation(uint caseIndex, uint caseCount, List<object> listAnimationObjects, BoxPosition bPos)
{
const int iStep = 5;
_zOffset = _palletSolution.PalletHeight + 100.0;
// build list of time
List<double> listTime = new List<double>();
List<string> listInterp = new List<string>();
listTime.Add(0.0);
listInterp.Add("LINEAR");
for (int i = 0; i < iStep; ++i)
{
listTime.Add(((double)caseIndex + (double)i / (double)(iStep - 1)));
listInterp.Add("LINEAR");
}
listTime.Add(caseCount);
listInterp.Add("LINEAR");
BProperties bProperties = _palletSolution.Analysis.BProperties;
PalletProperties pProperties = _palletSolution.Analysis.PalletProperties;
double yOffset = 0.5 * (_palletSolution.Analysis.PalletProperties.Width - bProperties.Length);
BoxPosition bPosFinal = GetFinalBoxPosition(caseIndex);
List<BoxPosition> listBoxPosition = new List<BoxPosition>();
// -1.
listBoxPosition.Add(GetInitialBoxPosition(caseIndex));
// 0. initialbox position
listBoxPosition.Add(GetInitialBoxPosition(caseIndex));
// 1. position at out storing area
listBoxPosition.Add(new BoxPosition(new Vector3D(_xOffset, yOffset, _zOffset), HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N));
// 2. position above pallet
listBoxPosition.Add(new BoxPosition(new Vector3D(pProperties.Length * 0.5, pProperties.Width * 0.5, _zOffset), bPosFinal.DirectionLength, bPosFinal.DirectionWidth));
// 3. position above final position
listBoxPosition.Add(new BoxPosition(new Vector3D(bPosFinal.Position.X, bPosFinal.Position.Y, _zOffset), bPosFinal.DirectionLength, bPosFinal.DirectionWidth));
// 4. final position
listBoxPosition.Add(bPosFinal);
// 5.
listBoxPosition.Add(bPosFinal);
List<double> listX = new List<double>();
List<double> listY = new List<double>();
List<double> listZ = new List<double>();
List<double> listRX = new List<double>();
List<double> listRY = new List<double>();
List<double> listRZ = new List<double>();
BoxPosition bPprev0 = listBoxPosition[0];
listX.Add(bPprev0.Position.X);
listY.Add(bPprev0.Position.Y);
listZ.Add(bPprev0.Position.Z);
Vector3D vRotPrev0 = bPprev0.Transformation.Rotations;
listRX.Add(vRotPrev0.X);
listRY.Add(vRotPrev0.Y);
listRZ.Add(vRotPrev0.Z);
for (int i = 1; i < listBoxPosition.Count; ++i)
{
BoxPosition bP = listBoxPosition[i];
listX.Add(bP.Position.X);
listY.Add(bP.Position.Y);
listZ.Add(bP.Position.Z);
Vector3D vRot = bP.Transformation.Rotations;
listRX.Add(vRot.X);
listRY.Add(vRot.Y);
listRZ.Add(vRot.Z);
}
// time
source sTime = new source()
{
id = string.Format("sTime_{0}_ID", caseIndex),
name = string.Format("sTime_{0}", caseIndex),
Item = new float_array()
{
id = string.Format("fa_time_{0}_ID", caseIndex),
count = (ulong)listTime.Count,
Values = listTime.ToArray()
},
technique_common = new sourceTechnique_common()
{
accessor = new accessor()
{
source = string.Format("#fa_time_{0}_ID", caseIndex),
count = (ulong)listTime.Count,
stride = 1,
param = new param[]
{
new param() { name="TIME", type="float" }
}
}
}
};
listAnimationObjects.Add(sTime);
// interp
source sInterp = new source()
{
id = string.Format("sInterp_{0}_ID", caseIndex),
name = string.Format("sInterp_{0}", caseIndex),
Item = new Name_array()
{
id = string.Format("na_interp_{0}_ID", caseIndex),
count = (ulong)listInterp.Count,
Values = listInterp.ToArray()
},
technique_common = new sourceTechnique_common()
{
accessor = new accessor()
{
source = string.Format("#na_interp_{0}_ID", caseIndex),
count = (ulong)listInterp.Count,
stride = 1,
param = new param[]
{
new param() { name="INTERPOLATION", type="name" }
}
}
}
};
listAnimationObjects.Add(sInterp);
CreateChannel(listAnimationObjects, caseIndex, "X", "TIME", string.Format("CaseNode_{0}_ID/t.X", caseIndex), listX);
CreateChannel(listAnimationObjects, caseIndex, "Y", "TIME", string.Format("CaseNode_{0}_ID/t.Y", caseIndex), listY);
CreateChannel(listAnimationObjects, caseIndex, "Z", "TIME", string.Format("CaseNode_{0}_ID/t.Z", caseIndex), listZ);
CreateChannel(listAnimationObjects, caseIndex, "RX", "ANGLE", string.Format("CaseNode_{0}_ID/rx.ANGLE", caseIndex), listRX);
CreateChannel(listAnimationObjects, caseIndex, "RY", "ANGLE", string.Format("CaseNode_{0}_ID/ry.ANGLE", caseIndex), listRY);
CreateChannel(listAnimationObjects, caseIndex, "RZ", "ANGLE", string.Format("CaseNode_{0}_ID/rz.ANGLE", caseIndex), listRZ);
}
private BBox3D ComputeLoadBBox3D()
{
double palletLength = ParentTruckAnalysis.ParentSolution.PalletLength;
double palletWidth = ParentTruckAnalysis.ParentSolution.PalletWidth;
double palletHeight = ParentTruckAnalysis.ParentSolution.PalletHeight;
BBox3D bbox = new BBox3D();
int iLayer = 0;
while (iLayer < NoLayers)
{
foreach (BoxPosition bPositionLayer in Layer)
{
// actual position in load
BoxPosition bpos = new BoxPosition(
new Vector3D(
bPositionLayer.Position.X
, bPositionLayer.Position.Y
, bPositionLayer.Position.Z + palletHeight * iLayer)
, bPositionLayer.DirectionLength
, bPositionLayer.DirectionWidth);
Vector3D[] pts = new Vector3D[8];
Vector3D vI = HalfAxis.ToVector3D(bpos.DirectionLength);
Vector3D vJ = HalfAxis.ToVector3D(bpos.DirectionWidth);
Vector3D vK = Vector3D.CrossProduct(vI, vJ);
pts[0] = bpos.Position;
pts[1] = bpos.Position + palletLength * vI;
pts[2] = bpos.Position + palletWidth * vJ;
pts[3] = bpos.Position + palletLength * vI + palletWidth * vJ;
pts[4] = bpos.Position + palletHeight * vK;
pts[5] = bpos.Position + palletWidth * vJ + palletHeight * vK; ;
pts[6] = bpos.Position + HalfAxis.ToVector3D(bpos.DirectionWidth) * palletWidth;
pts[7] = bpos.Position + HalfAxis.ToVector3D(bpos.DirectionLength) * palletLength + HalfAxis.ToVector3D(bpos.DirectionWidth) * palletWidth;
foreach (Vector3D pt in pts)
bbox.Extend(pt);
}
++iLayer;
}
return bbox;
}
public static bool MinDistance(
BoxPosition bPos1, Vector3D dim1
, BoxPosition bPos2, Vector3D dim2
, HalfAxis.HAxis axis
, ref double distance)
{
var bbox1 = bPos1.BBox(dim1);
var bbox2 = bPos2.BBox(dim2);
Vector3D pt1 = bbox1.PtMin, pt2 = bbox1.PtMax;
Vector3D pt3 = bbox2.PtMin, pt4 = bbox2.PtMax;
Vector3D pt5 = new Vector3D(Math.Max(pt1.X, pt3.X), Math.Max(pt1.Y, pt3.Y), Math.Max(pt1.Z, pt3.Z));
Vector3D pt6 = new Vector3D(Math.Min(pt2.X, pt4.X), Math.Min(pt2.Y, pt4.Y), Math.Min(pt2.Z, pt4.Z));
if (axis == HalfAxis.HAxis.AXIS_X_N || axis == HalfAxis.HAxis.AXIS_X_P)
{
if ((pt5.Y - pt6.Y > -EPSILON) || (pt5.Z - pt6.Z > -EPSILON))
{
return(false);
}
if (axis == HalfAxis.HAxis.AXIS_X_N)
{
distance = pt1.X - pt4.X;
return(distance >= -EPSILON);
}
else if (axis == HalfAxis.HAxis.AXIS_X_P)
{
distance = pt3.X - pt2.X;
return(distance >= -EPSILON);
}
}
else if (axis == HalfAxis.HAxis.AXIS_Y_N || axis == HalfAxis.HAxis.AXIS_Y_P)
{
if ((pt5.X - pt6.X > -EPSILON) || (pt5.Z - pt6.Z > -EPSILON))
{
return(false);
}
if (axis == HalfAxis.HAxis.AXIS_Y_N)
{
distance = pt1.Y - pt4.Y;
return(distance >= -EPSILON);
}
else if (axis == HalfAxis.HAxis.AXIS_Y_P)
{
distance = pt3.Y - pt2.Y;
return(distance >= -EPSILON);
}
}
else if (axis == HalfAxis.HAxis.AXIS_Z_N || axis == HalfAxis.HAxis.AXIS_Z_P)
{
if ((pt5.X - pt6.X > -EPSILON) || (pt5.Y - pt6.Z > -EPSILON))
{
return(false);
}
if (axis == HalfAxis.HAxis.AXIS_Z_N)
{
distance = pt1.Z - pt4.Z;
return(distance >= -EPSILON);
}
else if (axis == HalfAxis.HAxis.AXIS_Z_P)
{
distance = pt3.Z - pt2.Z;
return(distance >= -EPSILON);
}
}
distance = 0.0;
return(false);
}
public BoxPositionIndexed(BoxPosition boxPosition, int index)
{
BPos = boxPosition;
Index = index;
}
public BoxPosition Transform(Transform3D transform)
{
return(BoxPosition.Transform(this, transform));
}
protected void Add(BoxPosition position) => _listBoxPosition.Add(position);
public bool IsOnFace(HalfAxis.HAxis axis, BoxPosition boxPosition, ref List <Vector3D> points)
{
return(false);
}
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;
}
public Box(uint pickId, BProperties bProperties, BoxPosition bPosition)
{
if (!bPosition.IsValid)
throw new GraphicsException("Invalid BoxPosition: can not create box");
_pickId = pickId;
_dim[0] = bProperties.Length;
_dim[1] = bProperties.Width;
_dim[2] = bProperties.Height;
_colors = bProperties.Colors;
BoxProperties boxProperties = bProperties as BoxProperties;
if (null != boxProperties)
{
List<Pair<HalfAxis.HAxis, Texture>> textures = boxProperties.TextureList;
foreach (Pair<HalfAxis.HAxis, Texture> tex in textures)
{
int iIndex = (int)tex.first;
if (null == _textureLists[iIndex])
_textureLists[iIndex] = new List<Texture>();
_textureLists[iIndex].Add(tex.second);
}
_showTape = boxProperties.ShowTape;
_tapeWidth = boxProperties.TapeWidth;
_tapeColor = boxProperties.TapeColor;
}
// set position
Position = bPosition.Position;
// set direction length
LengthAxis = HalfAxis.ToVector3D(bPosition.DirectionLength);
// set direction width
WidthAxis = HalfAxis.ToVector3D(bPosition.DirectionWidth);
// IsBundle ?
_isBundle = bProperties.IsBundle;
if (bProperties.IsBundle)
{
BundleProperties bundleProp = bProperties as BundleProperties;
if (null != bundleProp)
_noFlats = bundleProp.NoFlats;
}
}
/// <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;
}
public Box(uint pickId, PackProperties packProperties, BoxPosition bPosition)
{
if (!bPosition.IsValid)
throw new GraphicsException("Invalid BoxPosition: can not create box");
_pickId = pickId;
_dim[0] = packProperties.Length;
_dim[1] = packProperties.Width;
_dim[2] = packProperties.Height;
_colors = new Color[]
{
Color.Chocolate, Color.Chocolate, Color.Chocolate, Color.Chocolate, Color.Chocolate, Color.Chocolate
};
// set position
Position = bPosition.Position;
// set direction length
LengthAxis = HalfAxis.ToVector3D(bPosition.DirectionLength);
// set direction width
WidthAxis = HalfAxis.ToVector3D(bPosition.DirectionWidth);
}
public Box(uint pickId, InterlayerProperties interlayerProperties, BoxPosition bPosition)
{
_pickId = pickId;
_dim[0] = interlayerProperties.Length;
_dim[1] = interlayerProperties.Width;
_dim[2] = interlayerProperties.Thickness;
_colors = new Color[6];
for (int i = 0; i < 6; ++i)
_colors[i] = interlayerProperties.Color;
// set position
Position = bPosition.Position;
// set direction length
LengthAxis = HalfAxis.ToVector3D(bPosition.DirectionLength);
// set direction width
WidthAxis = HalfAxis.ToVector3D(bPosition.DirectionWidth);
}
public BoxPosition(BoxPosition bpos)
{
Position = bpos.Position;
DirectionLength = bpos.DirectionLength;
DirectionWidth = bpos.DirectionWidth;
}
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 LayerPattern.All)
{
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)
{
// 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)
Layer2D layer1 = BuildLayer(_boxProperties, caseProperties, axisOrtho1, swapPos == 1);
Layer2D layer2 = BuildLayer(_boxProperties, caseProperties, axisOrtho2, swapPos == 1);
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)
{
Layer2D 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
Layer2D currentLayer = iLayerIndex % 2 == 0 ? layer1T : layer2T;
BoxLayer layer = sol.CreateNewLayer(zLayer, 0);
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;
}
private List<BoxCaseSolution> GenerateSolutions()
{
List<BoxCaseSolution> solutions = new List<BoxCaseSolution>();
int[] patternColumnCount = new int[6];
// loop throw all patterns
foreach (LayerPattern pattern in LayerPattern.All)
{
// 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
Layer2D layer = BuildLayer(_bProperties, _caseProperties, axisOrtho, false);
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, 0);
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;
}
