private void InitializeSolutionItemList()
{
_solutionItems = new List <SolutionItem>();
bool criterionReached = false;
double zTop = _analysis.Offset.Z;
double weight = _analysis.ContainerWeight;
while (!criterionReached)
{
weight += _layers[0].Count * _analysis.ContentWeight;
zTop += _layers[0].BoxHeight;
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
if (criterionReached)
{
break;
}
else
{
_solutionItems.Add(new SolutionItem(0, -1, false, false));
}
}
}
private void InitializeSolutionItemList()
{
_solutionItems = new List <SolutionItem>();
bool criterionReached = false;
double zTop = _analysis.Offset.Z;
double weight = _analysis.ContainerWeight;
bool symetryX = false, symetryY = false;
while (!criterionReached)
{
weight += _layerTypes[0].Count * _analysis.ContentWeight;
zTop += _layerTypes[0].LayerHeight;
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
if (criterionReached)
{
break;
}
else
{
_solutionItems.Add(new SolutionItem(0, -1, symetryX, symetryY));
}
symetryX = _analysis.AlternateLayersPref ? !symetryX : symetryX;
symetryY = _analysis.AlternateLayersPref ? !symetryY : symetryY;
}
}
public Vector3D GetOffset(ConstraintSetAbstract constraintSet)
{
if (!(constraintSet is ConstraintSetPackablePallet constraintSetPackablePallet))
{
throw new InvalidConstraintSetException();
}
return(new Vector3D(-constraintSetPackablePallet.Overhang.X, -constraintSetPackablePallet.Overhang.Y, Height));
}
public List<Layer2D> BuildLayers(Vector3D dimBox, Vector2D dimContainer, ConstraintSetAbstract constraintSet, bool keepOnlyBest)
{
// instantiate list of layers
List<Layer2D> listLayers0 = new List<Layer2D>();
// loop through all patterns
foreach (LayerPattern pattern in LayerPattern.All)
{
// loop through all orientation
foreach (HalfAxis.HAxis axisOrtho in HalfAxis.All)
{
// is orientation allowed
if ( !constraintSet.AllowOrientation(axisOrtho) )
continue;
// not swapped vs swapped pattern
for (int iSwapped = 0; iSwapped < 1; ++iSwapped)
{
// does swapping makes sense for this layer pattern ?
if (!pattern.CanBeSwapped && (iSwapped == 1))
continue;
// instantiate layer
Layer2D layer = new Layer2D(dimBox, dimContainer, axisOrtho, iSwapped == 1);
layer.PatternName = pattern.Name;
double actualLength = 0.0, actualWidth = 0.0;
if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
continue;
pattern.GenerateLayer(layer, actualLength, actualWidth);
if (0 == layer.Count)
continue;
listLayers0.Add(layer);
}
}
}
// keep only best layers
if (keepOnlyBest)
{
// 1. get best count
int bestCount = 0;
foreach (Layer2D layer in listLayers0)
bestCount = Math.Max(layer.CountInHeight(constraintSet.OptMaxHeight.Value), bestCount);
// 2. remove any layer that does not match the best count given its orientation
List<Layer2D> listLayers1 = new List<Layer2D>();
foreach (Layer2D layer in listLayers0)
{
if (layer.CountInHeight(constraintSet.OptMaxHeight.Value) >= bestCount)
listLayers1.Add(layer);
}
// 3. copy back in original list
listLayers0.Clear();
listLayers0.AddRange(listLayers1);
}
if (constraintSet.OptMaxHeight.Activated)
listLayers0.Sort(new LayerComparerCount(constraintSet.OptMaxHeight.Value));
return listLayers0;
}
public FastEvaluatorLayer2Pallet(
ILayer2D layer, Packable packable, PalletProperties palletProperties,
ConstraintSetAbstract constraintSet)
{
Layer = layer;
Content = packable;
Container = palletProperties;
ConstraintSet = constraintSet;
}
public Vector3D GetStackingDimensions(ConstraintSetAbstract constraintSet)
{
if (constraintSet is ConstraintSetPalletTruck constraintSetPalletTruck)
{
return(new Vector3D(
_length - 2.0 * constraintSetPalletTruck.MinDistanceLoadWall.X
, _width - 2.0 * constraintSetPalletTruck.MinDistanceLoadWall.Y
, _height - constraintSetPalletTruck.MinDistanceLoadRoof));
}
return(InsideDimensions);
}
public Vector3D GetStackingDimensions(ConstraintSetAbstract constraintSet)
{
if (!(constraintSet is ConstraintSetPackablePallet constraintSetPackablePallet))
{
throw new InvalidConstraintSetException();
}
return(new Vector3D(
_length + 2.0 * constraintSetPackablePallet.Overhang.X
, _width + 2.0 * constraintSetPackablePallet.Overhang.Y
, constraintSetPackablePallet.OptMaxHeight.Value - Height));
}
private void RebuildSolutionItemList()
{
bool criterionReached = false;
double zTop = _analysis.Offset.Z;
double weight = _analysis.ContainerWeight;
foreach (SolutionItem solItem in _solutionItems)
{
weight += _layers[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop += _layers[solItem.LayerIndex].BoxHeight + ((-1 != solItem.InterlayerIndex) ? _interlayers[solItem.InterlayerIndex].Thickness : 0.0);
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
if (criterionReached)
{
break;
}
}
// add layers until
while (!criterionReached)
{
SolutionItem solItem = _solutionItems.Last();
weight += _layers[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop += _layers[solItem.LayerIndex].BoxHeight + ((-1 != solItem.InterlayerIndex) ? _interlayers[solItem.InterlayerIndex].Thickness : 0.0);
_solutionItems.Add(new SolutionItem(solItem));
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
}
// remove unneeded layer
while (criterionReached)
{
SolutionItem solItem = _solutionItems.Last();
weight -= _layers[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop -= _layers[solItem.LayerIndex].BoxHeight + ((-1 != solItem.InterlayerIndex) ? _interlayers[solItem.InterlayerIndex].Thickness : 0.0);
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
_solutionItems.Remove(solItem);
}
// reset bounding box to force recompute
_bbox.Reset();
}
public AnalysisPackablePallet(
Packable packable,
PalletProperties palletProperties,
ConstraintSetAbstract constraintSet)
: base(packable.ParentDocument, packable)
{
// sanity checks
if (palletProperties.ParentDocument != ParentDocument)
{
throw new Exception("box & pallet do not belong to the same document");
}
PalletProperties = palletProperties;
_constraintSet = constraintSet;
}
protected AnalysisPackableTruck(Document document, Packable packable, TruckProperties truckProperties,
ConstraintSetAbstract constraintSet)
: base(document, packable)
{
// sanity checks
if (null != ParentDocument &&
null != truckProperties.ParentDocument &&
truckProperties.ParentDocument != ParentDocument)
{
throw new Exception("content & truck do not belong to the same document");
}
// also add dependancy
TruckProperties = truckProperties;
ConstraintSet = constraintSet;
}
protected AnalysisPackablePallet(
Packable packable,
PalletProperties palletProperties,
ConstraintSetAbstract constraintSet,
bool temporary = false)
: base(temporary ? null : packable.ParentDocument, packable)
{
// sanity checks
if (null != ParentDocument &&
(null != packable.ParentDocument) &&
(palletProperties.ParentDocument != ParentDocument))
{
throw new Exception("box & pallet do not belong to the same document");
}
PalletProperties = palletProperties;
ConstraintSet = constraintSet;
}
public bool FitsIn(IContainer container, ConstraintSetAbstract constraintSet)
{
Vector3D vPackable = OuterDimensions;
Vector3D vContainer = container.GetStackingDimensions(constraintSet);
if (constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_X_N) || constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_X_P))
{
if ((vPackable.X <= vContainer.Z) &&
(
(vPackable.Y <= vContainer.X && vPackable.Z <= vContainer.Y) ||
(vPackable.Z <= vContainer.X && vPackable.Y <= vContainer.Y)
))
{
return(true);
}
}
if (constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_Y_N) || constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_Z_P))
{
if ((vPackable.Y <= vContainer.Z) &&
(
(vPackable.X <= vContainer.X && vPackable.Z <= vContainer.Y) ||
(vPackable.Z <= vContainer.X && vPackable.X <= vContainer.Y)
))
{
return(true);
}
}
if (constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_Z_N) || constraintSet.AllowOrientation(HalfAxis.HAxis.AXIS_Z_P))
{
if ((vPackable.Z <= vContainer.Z) &&
(
(vPackable.X <= vContainer.X && vPackable.Y <= vContainer.Y) ||
(vPackable.Y <= vContainer.X && vPackable.X <= vContainer.Y)
))
{
return(true);
}
}
return(false);
}
private void InitializeSolutionItemList()
{
_solutionItems = new List <SolutionItem>();
ConstraintSetAbstract constraintSet = Analysis.ConstraintSet;
double zTop = Analysis.Offset.Z;
double weight = Analysis.ContainerWeight;
int number = 0;
bool allowMultipleLayers = true;
if (constraintSet is ConstraintSetPalletTruck constraintSetPalletTruck)
{
allowMultipleLayers = (constraintSetPalletTruck.OptMaxLayerNumber.Activated &&
constraintSetPalletTruck.OptMaxLayerNumber.Value > 1);
}
bool symetryX = false, symetryY = false;
while (!constraintSet.CritHeightReached(zTop) &&
!constraintSet.CritWeightReached(weight) &&
!constraintSet.CritNumberReached(number))
{
number += _layerTypes[0].Count;
weight += _layerTypes[0].Count * Analysis.ContentWeight;
zTop += _layerTypes[0].LayerHeight;
if (!constraintSet.CritHeightReached(zTop) && (allowMultipleLayers || _solutionItems.Count < 1))
{
_solutionItems.Add(new SolutionItem(0, -1, symetryX, symetryY));
}
else
{
break;
}
symetryX = AlternateLayers ? !symetryX : symetryX;
symetryY = AlternateLayers ? !symetryY : symetryY;
}
}
public void RebuildSolutionItemList()
{
bool criterionReached = false;
double zTop = _analysis.Offset.Z;
double weight = _analysis.ContainerWeight;
List <SolutionItem> solutionItems = new List <SolutionItem>();
foreach (SolutionItem solItem in _solutionItems)
{
weight += _layerTypes[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop += _layerTypes[solItem.LayerIndex].LayerHeight + ((-1 != solItem.InterlayerIndex) ? _analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
solutionItems.Add(solItem);
if (criterionReached)
{
break;
}
}
// add layers until
while (!criterionReached)
{
SolutionItem solItem = null;
if (solutionItems.Count > 0)
{
solItem = solutionItems.Last();
}
else
{
solItem = new SolutionItem(0, -1, false, false);
}
if (solItem.LayerIndex >= _layerTypes.Count)
{
throw new Exception(string.Format("Layer index out of range!"));
}
weight += _layerTypes[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop += _layerTypes[solItem.LayerIndex].LayerHeight + ((-1 != solItem.InterlayerIndex) ? _analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
solutionItems.Add(new SolutionItem(solItem));
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
}
// remove unneeded layer
while (criterionReached)
{
SolutionItem solItem = null;
if (solutionItems.Count > 0)
{
solItem = solutionItems.Last();
}
else
{
solItem = new SolutionItem(0, -1, false, false);
}
if (solItem.LayerIndex >= _layerTypes.Count)
{
throw new Exception(string.Format("Layer index out of range!"));
}
weight -= _layerTypes[solItem.LayerIndex].Count * _analysis.ContentWeight;
zTop -= _layerTypes[solItem.LayerIndex].LayerHeight + ((-1 != solItem.InterlayerIndex) ? _analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
ConstraintSetAbstract constraintSet = _analysis.ConstraintSet;
criterionReached = (ConstraintSet.OptMaxHeight.Activated && zTop >= constraintSet.OptMaxHeight.Value) ||
(ConstraintSet.OptMaxWeight.Activated && weight >= constraintSet.OptMaxWeight.Value);
solutionItems.Remove(solItem);
}
_solutionItems.Clear();
_solutionItems = solutionItems;
// reset bounding box to force recompute
_bbox.Reset();
}
public Vector3D GetOffset(ConstraintSetAbstract constraintSet) => Vector3D.Zero;
public void RebuildSolutionItemList()
{
try
{
ConstraintSetAbstract constraintSet = Analysis.ConstraintSet;
double zTop = Analysis.Offset.Z;
double weight = Analysis.ContainerWeight;
int number = 0;
List <SolutionItem> solutionItems = new List <SolutionItem>();
foreach (SolutionItem solItem in _solutionItems)
{
number += _layerTypes[index : solItem.LayerIndex].Count;
weight += _layerTypes[index : solItem.LayerIndex].Count * Analysis.ContentWeight;
zTop += _layerTypes[solItem.LayerIndex].LayerHeight + ((-1 != solItem.InterlayerIndex) ? Analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
solutionItems.Add(solItem);
if (constraintSet.OneCriterionReached(zTop, weight, number, solutionItems.Count))
{
break;
}
}
// add layers until
while (!constraintSet.OneCriterionReached(zTop, weight, number, solutionItems.Count))
{
SolutionItem solItem = null;
if (solutionItems.Count > 0)
{
solItem = solutionItems.Last();
}
else
{
solItem = new SolutionItem(0, -1, false, false);
}
if (solItem.LayerIndex >= _layerTypes.Count)
{
throw new Exception(string.Format("Layer index out of range!"));
}
number += _layerTypes[solItem.LayerIndex].Count;
weight += _layerTypes[solItem.LayerIndex].Count * Analysis.ContentWeight;
// using zTopAdded because zTop must not be incremented if SolutionItem object is
// not actually added
double zTopIfAdded = zTop + _layerTypes[solItem.LayerIndex].LayerHeight
+ ((-1 != solItem.InterlayerIndex) ? Analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
// only checking on height because weight / number can be modified without removing
// a layer (while outputing solution as a list of case)
if (!constraintSet.CritHeightReached(zTopIfAdded))
{
solutionItems.Add(new SolutionItem(solItem));
zTop = zTopIfAdded;
}
else
{
break;
}
}
// remove unneeded layer
while (constraintSet.CritHeightReached(zTop) && solutionItems.Count > 0)
{
SolutionItem solItem = solutionItems.Last();
if (solItem.LayerIndex >= _layerTypes.Count)
{
throw new Exception(string.Format("Layer index out of range!"));
}
number -= _layerTypes[solItem.LayerIndex].Count;
weight -= _layerTypes[solItem.LayerIndex].Count * Analysis.ContentWeight;
zTop -= _layerTypes[solItem.LayerIndex].LayerHeight
+ ((-1 != solItem.InterlayerIndex) ? Analysis.Interlayer(solItem.InterlayerIndex).Thickness : 0.0);
solutionItems.Remove(solItem);
}
_solutionItems.Clear();
_solutionItems = solutionItems;
// reset bounding box to force recompute
_bbox.Reset();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
public LayerComparerCount(ConstraintSetAbstract constraintSet, double offsetZ)
{
_offsetZ = offsetZ;
_constraintSet = constraintSet;
}
