public AnalysisCylinderPallet(
Packable packable,
PalletProperties palletProperties,
ConstraintSetPackablePallet constraintSet)
: base(packable, palletProperties, constraintSet)
{
}
private void onInputChanged(object sender, EventArgs e)
{
try
{
// get cylinder / case
CylinderProperties cylinder = cbCylinders.SelectedType as CylinderProperties;
PalletProperties palletProperties = cbPallets.SelectedType as PalletProperties;
if (null == cylinder || null == palletProperties)
{
return;
}
// compute
LayerSolver solver = new LayerSolver();
List <Layer2DCyl> 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 = LayerSolver.ConvertList(layers);
}
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;
}
// 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
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 FormNewPallet(Document document, PalletProperties palletProperties)
: base(document, palletProperties)
{
InitializeComponent();
// fill type combo
cbType.Items.AddRange(PalletData.TypeNames);
// initialize data
if (null != palletProperties)
{
PalletTypeName = palletProperties.TypeName;
PalletLength = palletProperties.Length;
PalletWidth = palletProperties.Width;
PalletHeight = palletProperties.Height;
Weight = palletProperties.Weight;
PalletColor = palletProperties.Color;
AdmissibleLoad = palletProperties.AdmissibleLoadWeight;
}
else
{
// set selected item
PalletTypeName = Properties.Settings.Default.PalletTypeName;
OnPalletTypeChanged(this, null);
}
// set unit labels
UnitsManager.AdaptUnitLabels(this);
}
public void Initialize()
{
if (DesignMode)
{
return;
}
// sanity check
Items.Clear();
// load all pallets from database
foreach (string typeName in PalletData.TypeNames)
{
PalletData palletData = PalletData.GetByName(typeName);
PalletProperties palletProperties = new PalletProperties(null, typeName,
palletData.Dimensions.X, palletData.Dimensions.Y, palletData.Dimensions.Z);
palletProperties.ID.SetNameDesc(typeName, palletData.Description);
palletProperties.Weight = palletData.Weight;
palletProperties.Color = Color.Yellow;
Items.Add(new ItemBaseWrapper(palletProperties));
}
// always select first item
if (Items.Count > 0)
{
SelectedIndex = 0;
}
}
static int Main(string[] args)
{
ILog log = LogManager.GetLogger(typeof(Program));
XmlConfigurator.Configure();
try
{
bool useSingleColor = false;
// instantiate document
Document doc = new Document("Test", "Test", "fga", DateTime.Now, null);
// define pallet properties
var palletProperties = new PalletProperties(doc, "EUR2", 1200, 1000, 150);
Console.WriteLine("=== Pallet properties ===");
Console.WriteLine(palletProperties.ToString());
bool testCylinder = false;
if (testCylinder)
{
RunCylinderTest(doc, palletProperties);
}
else
{
RunBoxTest(useSingleColor, doc, palletProperties);
}
}
catch (Exception ex)
{
log.Error(ex.ToString());
}
return(0);
}
private void btAddSolution_Click(object sender, EventArgs e)
{
try
{
// get selected box
BoxProperties boxProperties = SelectedBox;
// get selected pallet
PalletProperties palletProperties = SelectedPallet;
// get selected caseOptimSolution
CaseOptimSolution sol = SelectedSolution;
CaseOptimArrangement arrangement = sol.CaseDefinition.Arrangement;
// build new case name
string name = string.Format("{0}_{1}*{2}*{3}_{4}{5}"
, boxProperties.Name
, arrangement._iLength
, arrangement._iWidth
, arrangement._iHeight
, sol.CaseDefinition.Dim0
, sol.CaseDefinition.Dim1);
// build new case description
string description = string.Format("Case generated by case optimization for box {0} and pallet {1}"
, boxProperties.Name
, palletProperties.Name);
// add new case
CaseOfBoxesProperties caseProperties = _document.CreateNewCaseOfBoxes(
name, description
, boxProperties
, sol.CaseDefinition
, BuildCaseOptimConstraintSet());
// set color
caseProperties.SetColor(Color.Chocolate);
// add new pallet analysis
string analysisName = string.Format("OptimAnalysis{0}_{1}*{2}*{3}_{4}{5}"
, boxProperties.Name
, boxProperties.Name
, arrangement._iLength
, arrangement._iWidth
, arrangement._iHeight
, sol.CaseDefinition.Dim0
, sol.CaseDefinition.Dim1);
string analysisDescription = string.Format("Pallet analysis generated by case optimisation for box {0} and pallet {1}"
, boxProperties.Name
, palletProperties.Name);
List <CasePalletSolution> palletSolutionList = new List <CasePalletSolution>();
palletSolutionList.Add(sol.PalletSolution);
CasePalletAnalysis analysis = _document.CreateNewCasePalletAnalysis(
analysisName
, analysisDescription
, caseProperties
, palletProperties
, null, null
, null, null, null
, BuildPalletConstraintSet()
, palletSolutionList);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
public void Initialize()
{
if (this.DesignMode)
{
return;
}
// sanity check
Items.Clear();
// load all pallets from database
int numberOfItems = 0;
DCSBPallet[] pallets;
using (WCFClient wcfClient = new WCFClient())
{
pallets = wcfClient.Client.GetAllPallets(0, number: ref numberOfItems);
foreach (DCSBPallet pallet in pallets)
{
PalletProperties palletProperties = new PalletProperties(null, pallet.PalletType,
pallet.Dimensions.M0, pallet.Dimensions.M1, pallet.Dimensions.M2);
palletProperties.ID.SetNameDesc(pallet.Name, pallet.Description);
palletProperties.Weight = pallet.Weight;
palletProperties.Color = Color.Yellow;
Items.Add(new ItemBaseWrapper(palletProperties));
}
}
// always select first item
if (Items.Count > 0)
{
SelectedIndex = 0;
}
}
public void Initialize()
{
if (this.DesignMode)
{
return;
}
// sanity check
Items.Clear();
if (null == WCFClientSingleton.Instance)
{
return;
}
// load all pallets from database
DCSBPallet[] pallets = WCFClientSingleton.Instance.Client.GetAllPallets();
foreach (DCSBPallet pallet in pallets)
{
PalletProperties palletProperties = new PalletProperties(null, pallet.PalletType,
pallet.Dimensions.M0, pallet.Dimensions.M1, pallet.Dimensions.M2);
palletProperties.ID.SetNameDesc(pallet.Name, pallet.Description);
palletProperties.Weight = pallet.Weight;
palletProperties.Color = Color.Yellow;
Items.Add(new ItemBaseWrapper(palletProperties));
}
// always select first item
if (Items.Count > 0)
{
SelectedIndex = 0;
}
}
private BBox3D BoundingBoxDim(int index)
{
PalletProperties palletProperties = null;
if (_solution.Analysis is AnalysisCasePallet analysisCasePallet)
{
palletProperties = analysisCasePallet.PalletProperties;
}
if (_solution.Analysis is AnalysisCylinderPallet analysisCylinderPallet)
{
palletProperties = analysisCylinderPallet.PalletProperties;
}
switch (index)
{
case 0: return(_solution.BBoxGlobal);
case 1: return(_solution.BBoxLoadWDeco);
case 2: return(palletProperties.BoundingBox);
case 3: return(new BBox3D(0.0, 0.0, 0.0, palletProperties.Length, palletProperties.Width, 0.0));
default: return(_solution.BBoxGlobal);
}
}
private void onNext(object sender, EventArgs e)
{
try
{
// selected analysis -> get pack
AnalysisCasePallet analysisSel = SelectedAnalysis;
PackProperties packSel = analysisSel.Content as PackProperties;
packSel.ID.SetNameDesc(AnalysisName, AnalysisName);
// create pack
PackProperties packProperties = _doc.CreateNewPack(packSel);
PalletProperties palletProperties = _doc.CreateNewPallet(SelectedPallet);
// create analysis
List <InterlayerProperties> interlayers = new List <InterlayerProperties>();
AnalysisHomo analysis = _doc.CreateNewAnalysisCasePallet(
AnalysisName, AnalysisDescription,
packProperties, palletProperties,
interlayers, null, null, null,
BuildConstraintSet(), analysisSel.Solution.LayerDescriptors);
FormBrowseSolution form = new FormBrowseSolution(_doc, analysis);
if (DialogResult.OK == form.ShowDialog())
{
}
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
private void FillPalletList()
{
int rangeIndex = 0;
int numberOfItems = 0;
using (WCFClient wcfClient = new WCFClient())
{
do
{
DCSBPallet[] dcsbPallets = wcfClient.Client.GetAllPallets(rangeIndex++, ref numberOfItems);
foreach (var dcsbPallet in dcsbPallets)
{
UnitsManager.UnitSystem us = (UnitsManager.UnitSystem)dcsbPallet.UnitSystem;
var palletProperties = new PalletProperties(null,
dcsbPallet.PalletType,
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M0, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M1, us),
UnitsManager.ConvertLengthFrom(dcsbPallet.Dimensions.M2, us)
)
{
Color = Color.FromArgb(dcsbPallet.Color),
Weight = UnitsManager.ConvertMassFrom(dcsbPallet.Weight, us)
};
palletProperties.ID.SetNameDesc(dcsbPallet.Name, dcsbPallet.Description);
lbPallets.Items.Add(new ItemBaseWrapper(palletProperties), true);
}
}while ((rangeIndex + 1) * 20 < numberOfItems);
}
}
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 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());
}
}
static void Main(string[] args)
{
// define box properties
BoxProperties boxProperties = new BoxProperties(null, 120.0, 100.0, 70.0);
// define pallet properties
PalletProperties palletProperties = new PalletProperties(null, "Block", 1200, 1000, 150);
// define pallet constraintSet
CasePalletConstraintSet constraintSet = new CasePalletConstraintSet();
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_N, true);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_P, true);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_N, true);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_P, true);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_N, true);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_P, true);
constraintSet.SetAllowedPattern("Column");
constraintSet.SetAllowedPattern("Diagonale");
constraintSet.SetAllowedPattern("Interlocked");
constraintSet.SetAllowedPattern("Trilock");
constraintSet.SetAllowedPattern("Spirale");
constraintSet.AllowAlignedLayers = true;
constraintSet.AllowAlternateLayers = true;
constraintSet.MaximumHeight = 2000;
constraintSet.MaximumNumberOfItems = 2000;
constraintSet.UseMaximumHeight = true;
constraintSet.UseMaximumPalletWeight = false;
constraintSet.UseMaximumWeightOnBox = false;
Console.WriteLine("=== Constraint set ===");
Console.WriteLine(constraintSet.ToString());
// define case optim constraintSet
ParamSetPackOptim caseOptimConstraintSet = new ParamSetPackOptim(
new int[3] {
2, 2, 4
}
, 4.0, 0.01
, new Vector3D(30.0, 30.0, 70.0)
, new Vector3D(500.0, 500.0, 500.0)
, false
);
PackOptimizer caseOptimizer = new PackOptimizer(boxProperties, palletProperties, constraintSet, caseOptimConstraintSet);
// get all valid case definitions
foreach (CaseDefinition caseDefinition in caseOptimizer.CaseDefinitions(48))
{
Console.WriteLine(caseDefinition.ToString() + caseDefinition.OuterDimensions(boxProperties, caseOptimConstraintSet));
}
// build list of solutions
List <CaseOptimSolution> caseOptimSolutions = caseOptimizer.CaseOptimSolutions(48);
foreach (CaseOptimSolution caseOptimSolution in caseOptimSolutions)
{
Console.WriteLine(caseOptimSolution.ToString());
}
}
public static bool GetHSolutionPart(
List <ContentItem> items,
PalletProperties palletProperties,
HConstraintSetPallet constraintSet,
int solIndex, int binIndex,
Vector3D cameraPosition, bool showCotations, float fontSizeRatio,
Size sz,
ref double weightLoad, ref double weightTotal,
ref Vector3D bbLoad, ref Vector3D bbGlob,
ref byte[] imageBytes,
ref string[] errors
)
{
List <string> lErrors = new List <string>();
try
{
var analysis = new HAnalysisPallet(null)
{
Pallet = palletProperties,
ConstraintSet = constraintSet,
Content = items,
};
HSolver solver = new HSolver();
var solutions = solver.BuildSolutions(analysis);
if (solIndex < solutions.Count)
{
var sol = solutions[solIndex];
bbGlob = sol.BBoxGlobal(binIndex).DimensionsVec;
bbLoad = sol.BBoxLoad(binIndex).DimensionsVec;
weightLoad = sol.LoadWeight(binIndex);
weightTotal = sol.Weight(binIndex);
Graphics3DImage graphics = new Graphics3DImage(sz)
{
FontSizeRatio = fontSizeRatio,
CameraPosition = cameraPosition,
ShowDimensions = showCotations
};
ViewerHSolution sv = new ViewerHSolution(sol, binIndex);
sv.Draw(graphics, Transform3D.Identity);
graphics.Flush();
Bitmap bmp = graphics.Bitmap;
ImageConverter converter = new ImageConverter();
imageBytes = (byte[])converter.ConvertTo(bmp, typeof(byte[]));
}
else
{
lErrors.Add("No valid solution found");
}
}
catch (Exception ex)
{
lErrors.Add(ex.Message);
}
errors = lErrors.ToArray();
return(0 == lErrors.Count);
}
public CylLoad(CylinderProperties cylProperties, PalletProperties palletProperties, HCylinderPalletConstraintSet constraintSet)
{
_palletLength = palletProperties.Length + constraintSet.OverhangX;
_palletWidth = palletProperties.Width + constraintSet.OverhangY;
_palletHeight = palletProperties.Height;
_rowSpacing = constraintSet.RowSpacing;
Initialize(cylProperties);
}
private static bool PalletMatchesDimensionsInMM(PalletProperties palletProperties, double length, double width)
{
double lengthInMM = UnitsManager.ConvertLengthTo(palletProperties.Length, UnitsManager.UnitSystem.UNIT_METRIC1);
double widthInMM = UnitsManager.ConvertLengthTo(palletProperties.Width, UnitsManager.UnitSystem.UNIT_METRIC1);
return((Math.Abs(lengthInMM - length) < 1.0 && Math.Abs(widthInMM - width) < 1.0) ||
(Math.Abs(lengthInMM - width) < 1.0 && Math.Abs(widthInMM - length) < 1.0));
}
public void ProcessAnalysis(PackPalletAnalysis analysis)
{
_packProperties = analysis.PackProperties;
_palletProperties = analysis.PalletProperties;
_interlayerProperties = analysis.InterlayerProperties;
_constraintSet = analysis.ConstraintSet;
analysis.Solutions = GenerateSolutions();
}
public static bool GetHSolutionBestCasePallet(
List <ContentItem> items,
PalletProperties palletProperties,
HConstraintSetPallet constraintSet,
Vector3D cameraPosition,
bool showCotations, float fontSizeRatio, Size sz,
ref int palletCount,
ref string algorithm,
ref byte[] imageBytes,
ref string[] errors)
{
List <string> lErrors = new List <string>();
try
{
var analysis = new HAnalysisPallet(null)
{
Pallet = palletProperties,
ConstraintSet = constraintSet,
Content = items,
};
HSolver solver = new HSolver();
var solutions = solver.BuildSolutions(analysis);
// best solution is most likely : 5
if (solutions.Count > 0)
{
var sol = solutions[solutions.Count - 1];
algorithm = sol.Algorithm;
palletCount = sol.SolItemCount;
Graphics3DImage graphics = new Graphics3DImage(sz)
{
FontSizeRatio = fontSizeRatio,
CameraPosition = cameraPosition,
ShowDimensions = showCotations
};
ViewerHSolution sv = new ViewerHSolution(sol, 0);
sv.Draw(graphics, Transform3D.Identity);
graphics.Flush();
Bitmap bmp = graphics.Bitmap;
ImageConverter converter = new ImageConverter();
imageBytes = (byte[])converter.ConvertTo(bmp, typeof(byte[]));
}
else
{
lErrors.Add("No valid solution found");
}
}
catch (Exception ex)
{
lErrors.Add(ex.Message);
}
errors = lErrors.ToArray();
return(0 == lErrors.Count);
}
internal PalletProperties ToPallet(DataPallet dtPallet)
{
PalletProperties palletProperties = new PalletProperties(null, dtPallet.TypeName
, dtPallet.Dimensions[0], dtPallet.Dimensions[1], dtPallet.Dimensions[2]
);
palletProperties.ID.SetNameDesc(dtPallet.Name, dtPallet.Description);
return(palletProperties);
}
public HCylinderPalletAnalysis(
CylinderProperties cylProperties,
PalletProperties palletProperties,
HCylinderPalletConstraintSet constraintSet)
: base(cylProperties.ParentDocument)
{
CylinderProperties = cylProperties;
PalletProperties = palletProperties;
_constraintSet = constraintSet;
}
public static void GenerateDefaultPalletImage(Vector3D dimPallet, string typeName, Size imgSize, string filename)
{
// instantiate pallet
var palletProperties = new PalletProperties(null, typeName, dimPallet.X, dimPallet.Y, dimPallet.Z);
MultiCaseImageGenerator imageGenerator = new MultiCaseImageGenerator(imgSize, Vector2D.Zero, new Vector2D(dimPallet.X, dimPallet.Y));
Bitmap bmp = imageGenerator.GeneratePalletImage(palletProperties);
bmp.Save(filename);
}
public static bool GetSolutionList(
PackableBrick packableProperties, PalletProperties palletProperties, InterlayerProperties interlayerProperties
, ConstraintSetCasePallet constraintSet
, ref List <AnalysisLayered> analyses)
{
SolverCasePallet solver = new SolverCasePallet(packableProperties, palletProperties, constraintSet);
analyses = solver.BuildAnalyses(false);
return(analyses.Count > 0);
}
public Layer(PackProperties packProperties, PalletProperties palletProperties, PackPalletConstraintSet constraintSet
, HalfAxis.HAxis axisOrtho, bool inversed)
{
_axisOrtho = axisOrtho;
_inversed = inversed;
_forcedSpace = constraintSet.MinimumSpace.Value;
_palletLength = palletProperties.Length + constraintSet.OverhangX + _forcedSpace;
_palletWidth = palletProperties.Width + constraintSet.OverhangY + _forcedSpace;
Initialize(packProperties);
}
protected Layer2D BuildLayer(BProperties boxProperties, PalletProperties palletProperties, PalletCornerProperties cornerProperties
, PalletConstraintSet constraintSet, HalfAxis.HAxis axisOrtho, bool swapped, bool inversed)
{
double cornerThickness = null != cornerProperties ? cornerProperties.Thickness : 0.0;
return(new Layer2D(
boxProperties.OuterDimensions
, new Vector2D(palletProperties.Length + constraintSet.OverhangX - 2.0 * cornerThickness, palletProperties.Width + constraintSet.OverhangY - 2.0 * cornerThickness)
, axisOrtho
, swapped));
}
private Layer2D BuildLayer(PackProperties packProperties, PalletProperties palletProperties, PackPalletConstraintSet constraintSet, HalfAxis.HAxis axisOrtho, bool swapped, bool inversed)
{
double forcedSpace = constraintSet.MinimumSpace.Value;
return(new Layer2D(
new Vector3D(packProperties.Length + forcedSpace, packProperties.Width + forcedSpace, packProperties.Height)
, new Vector2D(
palletProperties.Length + constraintSet.OverhangX + forcedSpace
, _palletProperties.Width + constraintSet.OverhangY + forcedSpace)
, axisOrtho, swapped));
}
public CaseOptimizer(
BoxProperties boxProperties
, PalletProperties palletProperties
, PalletConstraintSet palletContraintSet
, CaseOptimConstraintSet caseOptimConstraintSet)
{
_boxProperties = boxProperties;
_palletProperties = palletProperties;
_palletConstraintSet = palletContraintSet;
_caseOptimConstraintSet = caseOptimConstraintSet;
}
/// <summary>
/// Layer pallet analysis constructor (inversed = false)
/// </summary>
public Layer(BProperties boxProperties, PalletProperties palletProperties, PalletCornerProperties cornerProperties,
PalletConstraintSet constraintSet, HalfAxis.HAxis axisOrtho, bool inversed)
{
double cornerThickness = null != cornerProperties ? cornerProperties.Thickness : 0.0;
_axisOrtho = axisOrtho;
_inversed = inversed;
_palletLength = palletProperties.Length + constraintSet.OverhangX - 2.0 * cornerThickness;
_palletWidth = palletProperties.Width + constraintSet.OverhangY - 2.0 * cornerThickness;
Initialize(boxProperties);
}
