private void FillLayerControls()
{
try
{
cbLayerType.BoxProperties = _analysis.Content;
// build layers and fill CCtrl
foreach (LayerDesc layerDesc in _solution.LayerDescriptors)
{
LayerSolver solver = new LayerSolver();
Layer2D layer = solver.BuildLayer(_analysis.ContentDimensions, _analysis.ContainerDimensions, layerDesc);
cbLayerType.Items.Add(layer);
}
if (cbLayerType.Items.Count > 0)
{
cbLayerType.SelectedIndex = 0;
}
// fill combo cbInterlayer
Document document = _document as Document;
cbInterlayer.Initialize(document, this, null);
}
catch (Exception /*ex*/)
{
}
}
private void OnInputChanged(object sender, EventArgs e)
{
try
{
// get box / case
if (!(cbBoxes.SelectedType is PackableBrick packable) ||
!(cbCases.SelectedType is BoxProperties caseProperties))
{
return;
}
// update orientation control
uCtrlCaseOrientation.BProperties = packable;
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DBrickImp> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(caseProperties.InsideLength, caseProperties.InsideWidth)
, 0.5 * (caseProperties.Height - caseProperties.InsideHeight)
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked
);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = caseProperties.InsideHeight;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void FillLayerControls()
{
try
{
cbLayerType.Packable = _analysis.Content;
// build layers and fill CCtrl
foreach (var layerEncap in _solution.LayerEncaps)
{
if (null != layerEncap.LayerDesc)
{
LayerSolver solver = new LayerSolver();
ILayer2D layer = solver.BuildLayer(_analysis.Content, _analysis.ContainerDimensions, layerEncap.LayerDesc, _analysis.ConstraintSet.MinimumSpace.Value);
cbLayerType.Items.Add(layer);
}
else if (null != layerEncap.Layer2D)
{
cbLayerType.Items.Add(layerEncap.Layer2D);
}
}
if (cbLayerType.Items.Count > 0)
{
cbLayerType.SelectedIndex = 0;
}
// fill combo cbInterlayer
Document document = Document as Document;
cbInterlayer.Initialize(document, this, null);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnTimerTick(object sender, EventArgs e)
{
try
{
_timer.Stop();
// get case /pallet
Packable packable = cbCases.SelectedType as Packable;
PalletProperties palletProperties = cbPallets.SelectedType as PalletProperties;
if (null == packable || null == palletProperties)
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
_layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(
palletProperties.Length + 2.0 * uCtrlOverhang.ValueX
, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY)
, palletProperties.Height
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked);
FillGrid();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnInputValueChanged(object sender, EventArgs args)
{
try
{
Packable packable = BundleProp;
// compute
ILayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(CaseInsideLength, CaseInsideWidth)
, 0.0
, BuildConstraintSet()
, true
);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = CaseInsideHeight;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void FillLayerControls()
{
try
{
// get solution
SolutionLayered solution = _analysis.SolutionLay;
// packable
cbLayerType.Packable = _analysis.Content;
// build layers and fill CCtrl
foreach (var layerEncap in solution.LayerEncaps)
{
if (null != layerEncap.Layer2D)
{
cbLayerType.Items.Add(layerEncap.Layer2D);
}
else if (null != layerEncap.LayerDesc)
{
LayerSolver solver = new LayerSolver();
Layer2DBrickImp layer = solver.BuildLayer(_analysis.ContentDimensions, _analysis.ContainerDimensions, layerEncap.LayerDesc as LayerDescBox, 0.0);
cbLayerType.Items.Add(layer);
}
}
if (cbLayerType.Items.Count > 0)
{
cbLayerType.SelectedIndex = 0;
}
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
static void Main(string[] args)
{
bool bestLayersOnly = true;
Vector3D dimBox = new Vector3D(400.0, 300.0, 150.0);
Vector2D dimContainer = new Vector2D(1200.0, 1000.0);
ConstraintSetCasePallet constraintSet = new ConstraintSetCasePallet();
constraintSet.SetMaxHeight(new OptDouble(true, 1200.0));
try
{
LayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(dimBox, dimContainer, 0.0, constraintSet, bestLayersOnly);
int solIndex = 0;
foreach (Layer2D layer in layers)
{
string fileName = string.Format("{0}_{1}.bmp", layer.Name, solIndex++);
string filePath = Path.Combine(Path.GetTempPath(), fileName);
Console.WriteLine(string.Format("Generating {0}...", filePath));
Graphics2DImage graphics = new Graphics2DImage(new Size(150, 150));
ViewerILayer2D solViewer = new ViewerILayer2D(layer);
BoxProperties bProperties = new BoxProperties(null, 400.0, 300.0, 150.0);
bProperties.SetColor(Color.Brown);
solViewer.Draw(graphics, bProperties, 1500.0, false);
graphics.SaveAs(filePath);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void OnInputChanged(object sender, EventArgs e)
{
try
{
// get loaded pallet / truck
PackableBrick packable = cbPallets.SelectedType as PackableBrick;
TruckProperties truckProperties = cbTrucks.SelectedType as TruckProperties;
if (null == packable || null == truckProperties)
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(
truckProperties.InsideLength - 2.0 * uCtrlMinDistanceLoadWall.ValueX
, truckProperties.InsideWidth - 2.0 * uCtrlMinDistanceLoadWall.ValueY)
, 0.0 /* offsetZ */
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked
);
// update control
uCtrlLayerList.SingleSelection = true;
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = truckProperties.InsideHeight - uCtrlMinDistanceLoadRoof.Value;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnInputChanged(object sender, EventArgs e)
{
try
{
// get cylinder / case
if (cbCylinders.SelectedType is CylinderProperties cylinder &&
cbPallets.SelectedType is PalletProperties palletProperties)
{
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DCylImp> layers = solver.BuildLayers(
cylinder.RadiusOuter, cylinder.Height
, new Vector2D(palletProperties.Length + 2.0 * uCtrlOverhang.ValueX, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY)
, palletProperties.Height
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked
);
// update control
uCtrlLayerList.Packable = cylinder;
uCtrlLayerList.ContainerHeight = uCtrlMaximumHeight.Value - palletProperties.Height;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void onInputChanged(object sender, EventArgs e)
{
try
{
// get box / case
PackableBrick packable = cbBoxes.SelectedType as PackableBrick;
BoxProperties caseProperties = cbCases.SelectedType as BoxProperties;
if (null == packable || null == caseProperties)
{
return;
}
// update orientation control
uCtrlCaseOrientation.BProperties = packable;
// compute
LayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(caseProperties.InsideLength, caseProperties.InsideWidth)
, 0.0 /* offsetZ */
, BuildContraintSet()
, checkBoxBestLayersOnly.Checked
);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = caseProperties.InsideHeight;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = LayerSolver.ConvertList(layers);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void onInputChanged(object sender, EventArgs e)
{
try
{
// get cylinder / case
CylinderProperties cylinder = cbCylinders.SelectedType as CylinderProperties;
BoxProperties caseProperties = cbCases.SelectedType as BoxProperties;
if (null == cylinder || null == caseProperties)
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DCyl> layers = solver.BuildLayers(
cylinder.RadiusOuter, cylinder.Height
, new Vector2D(caseProperties.InsideLength, caseProperties.InsideWidth)
, 0.0
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked
);
uCtrlLayerList.Packable = cylinder;
uCtrlLayerList.ContainerHeight = caseProperties.InsideHeight;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void FillLayerControls()
{
try
{
// get solution
Solution solution = _analysis.Solution;
// packable
cbLayerType.Packable = _analysis.Content;
// build layers and fill CCtrl
foreach (LayerDesc layerDesc in solution.LayerDescriptors)
{
LayerSolver solver = new LayerSolver();
Layer2D layer = solver.BuildLayer(_analysis.ContentDimensions, _analysis.ContainerDimensions, layerDesc as LayerDescBox, 0.0);
cbLayerType.Items.Add(layer);
}
if (cbLayerType.Items.Count > 0)
{
cbLayerType.SelectedIndex = 0;
}
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
private void FillLayerControls()
{
try
{
cbLayerType.Packable = _analysis.Content;
// build layers and fill CCtrl
foreach (LayerDesc layerDesc in _solution.LayerDescriptors)
{
LayerSolver solver = new LayerSolver();
Layer2D layer = solver.BuildLayer(_analysis.ContentDimensions, _analysis.ContainerDimensions, layerDesc as LayerDescBox);
cbLayerType.Items.Add(layer);
}
if (cbLayerType.Items.Count > 0)
{
cbLayerType.SelectedIndex = 0;
}
// interlayer combo box
Document doc = _document as Document;
if (null == doc)
{
return;
}
ItemBase[] interlayers = doc.ListByType(typeof(InterlayerProperties)).ToArray();
ComboBoxHelpers.FillCombo(interlayers, cbInterlayer, null);
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
private void OnBestCombinationClicked(object sender, EventArgs e)
{
try
{
Packable packable = cbCases.SelectedType as Packable;
PalletProperties palletProperties = cbPallets.SelectedType as PalletProperties;
if (null == packable || null == palletProperties)
{
return;
}
// get best combination
List <KeyValuePair <LayerDesc, int> > listLayer = new List <KeyValuePair <LayerDesc, int> >();
LayerSolver.GetBestCombination(
packable.OuterDimensions,
new Vector2D(palletProperties.Length + 2.0 * uCtrlOverhang.ValueX, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY),
BuildConstraintSet(),
ref listLayer);
// select best layers
List <LayerDesc> listLayerDesc = new List <LayerDesc>();
foreach (KeyValuePair <LayerDesc, int> kvp in listLayer)
{
listLayerDesc.Add(kvp.Key);
}
uCtrlLayerList.SelectLayers(listLayerDesc);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnInputChanged(object sender, EventArgs e)
{
try
{
// get case /pallet
Packable packable = cbCases.SelectedType as Packable;
PalletProperties palletProperties = cbPallets.SelectedType as PalletProperties;
if (null == packable || null == palletProperties)
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(palletProperties.Length + 2.0 * uCtrlOverhang.ValueX, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY)
, palletProperties.Height
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = uCtrlMaximumHeight.Value - palletProperties.Height;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void onInputChanged(object sender, EventArgs e)
{
try
{
// get case /pallet
ItemBaseCB itemBaseCase = cbCases.SelectedItem as ItemBaseCB;
if (null == itemBaseCase)
{
return;
}
BProperties bProperties = itemBaseCase.Item as BProperties;
ItemBaseCB itemBasePallet = cbPallets.SelectedItem as ItemBaseCB;
if (null == itemBasePallet)
{
return;
}
PalletProperties palletProperties = itemBasePallet.Item as PalletProperties;
// compute
LayerSolver solver = new LayerSolver();
List <Layer2D> layers = solver.BuildLayers(
bProperties.OuterDimensions
, new Vector2D(palletProperties.Length + 2.0 * uCtrlOverhang.ValueX, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY)
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked);
// update control
uCtrlLayerList.BProperties = bProperties;
uCtrlLayerList.ContainerHeight = uCtrlOptMaximumHeight.Value.Value;
uCtrlLayerList.LayerList = layers;
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
public static void GetLayers(Vector3D caseDim, double caseWeight, int palletIndex, double palletWeight, int layerNumber, bool bestLayersOnly, ref List <LayerDetails> listLayers)
{
// case
var boxProperties = new BoxProperties(null, caseDim.X, caseDim.Y, caseDim.Z)
{
TapeColor = Color.Tan,
TapeWidth = new OptDouble(true, 50.0)
};
boxProperties.SetWeight(caseWeight);
boxProperties.SetAllColors(Enumerable.Repeat(Color.Beige, 6).ToArray());
// pallet
Vector3D palletDim = PalletIndexToDim3D(palletIndex);
var palletProperties = new PalletProperties(null, PalletIndexToPalletType(palletIndex), palletDim.X, palletDim.Y, palletDim.Z)
{
Weight = palletWeight,
Color = Color.Yellow
};
// ### define a constraintset object
var constraintSet = new ConstraintSetCasePallet()
{
OptMaxNumber = new OptInt(false, 0),
OptMaxWeight = new OptDouble(true, 1000.0),
Overhang = Vector2D.Zero,
};
constraintSet.SetAllowedOrientations(new bool[] { false, false, true });
constraintSet.OptMaxLayerNumber = layerNumber;
Vector3D vPalletDim = palletProperties.GetStackingDimensions(constraintSet);
// ###
// get a list of all possible layers and fill ListView control
ILayerSolver solver = new LayerSolver();
var layers = solver.BuildLayers(boxProperties.OuterDimensions, new Vector2D(vPalletDim.X, vPalletDim.Y), 0.0, constraintSet, bestLayersOnly);
foreach (var layer in layers)
{
listLayers.Add(
new LayerDetails(
layer.Name,
layer.LayerDescriptor.ToString(),
layer.Count,
layer.NoLayers(caseDim.Z),
caseDim.X, caseDim.Y, caseDim.Z,
palletIndex)
);
}
}
private void OnBestCombinationClicked(object sender, EventArgs e)
{
try
{
// get box & case
if (!(cbBoxes.SelectedType is PackableBrick packable) ||
!(cbCases.SelectedType is BoxProperties caseProperties))
{
return;
}
var constraintSet = BuildConstraintSet();
// get best combination
var listLayer = new List <KeyValuePair <LayerEncap, int> >();
LayerSolver.GetBestCombination(
packable.OuterDimensions,
packable.Bulge,
caseProperties.GetStackingDimensions(constraintSet),
constraintSet,
ref listLayer);
if (0 == listLayer.Count)
{
_log.Warn("Failed to find a single valid layer");
return;
}
// select best layer
List <LayerDesc> layerDesc = new List <LayerDesc>();
foreach (var kvp in listLayer)
{
layerDesc.Add(kvp.Key.LayerDesc);
}
uCtrlLayerList.SelectLayers(layerDesc);
_item = _document.CreateNewAnalysisBoxCase(
ItemName, ItemDescription
, SelectedBoxProperties, SelectedCase
, new List <InterlayerProperties>()
, BuildConstraintSet()
, listLayer
);
Close();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void OnBestCombinationClicked(object sender, EventArgs e)
{
try
{
Packable packable = cbCases.SelectedType as Packable;
PalletProperties palletProperties = cbPallets.SelectedType as PalletProperties;
if (null == packable || null == palletProperties)
{
return;
}
ConstraintSetAbstract constraintSet = BuildConstraintSet();
// get best combination
List <KeyValuePair <LayerDesc, int> > listLayer = new List <KeyValuePair <LayerDesc, int> >();
LayerSolver.GetBestCombination(
packable.OuterDimensions,
palletProperties.GetStackingDimensions(constraintSet),
constraintSet,
ref listLayer);
// select best layers
List <LayerDesc> listLayerDesc = new List <LayerDesc>();
foreach (KeyValuePair <LayerDesc, int> kvp in listLayer)
{
listLayerDesc.Add(kvp.Key);
}
uCtrlLayerList.SelectLayers(listLayerDesc);
_item = _document.CreateNewAnalysisCasePallet(
ItemName, ItemDescription
, SelectedPackable, SelectedPallet
, new List <InterlayerProperties>()
, null, null, null
, BuildConstraintSet()
, listLayer
);
Close();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
private void FillLayerList()
{
// get case /pallet
if (!(cbCases.SelectedType is Packable packable) || !(cbPallets.SelectedType is PalletProperties palletProperties))
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DBrickImp> layers = solver.BuildLayers(
packable.OuterDimensions
, new Vector2D(palletProperties.Length + 2.0 * uCtrlOverhang.ValueX, palletProperties.Width + 2.0 * uCtrlOverhang.ValueY)
, palletProperties.Height
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = uCtrlMaximumHeight.Value - palletProperties.Height;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
private void OnInputChanged(object sender, EventArgs e)
{
try
{
// get box / case
PackableBrick packable = SelectedPackable;
TruckProperties truck = SelectedTruck;
if (null == packable || null == truck)
{
return;
}
// update orientation control
uCtrlCaseOrientation.BProperties = packable;
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DBrickImp> layers = solver.BuildLayers(
packable.OuterDimensions
, packable.Bulge
, new Vector2D(
truck.InsideLength - 2.0 * uCtrlMinDistanceLoadWall.ValueX
, truck.InsideWidth - 2.0 * uCtrlMinDistanceLoadWall.ValueY)
, 0.0 /* offsetZ */
, BuildConstraintSet()
, checkBoxBestLayersOnly.Checked
);
// update control
uCtrlLayerList.Packable = packable;
uCtrlLayerList.ContainerHeight = truck.InsideHeight - uCtrlMinDistanceLoadRoof.Value;
uCtrlLayerList.FirstLayerSelected = true;
uCtrlLayerList.LayerList = layers.Cast <ILayer2D>().ToList();
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
