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
CaseOptimConstraintSet caseOptimConstraintSet = new CaseOptimConstraintSet(
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
);
CaseOptimizer caseOptimizer = new CaseOptimizer(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());
}
private PalletConstraintSet BuildPalletConstraintSet()
{
// build pallet constraint set
CasePalletConstraintSet palletConstraintSet = new CasePalletConstraintSet();
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_N, !ForceVerticalBoxOrientation);
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_P, !ForceVerticalBoxOrientation);
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_N, !ForceVerticalBoxOrientation);
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_P, !ForceVerticalBoxOrientation);
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_N, !ForceVerticalBoxOrientation);
palletConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_P, true);
// use all existing patterns
palletConstraintSet.AllowedPatternString = "Column,Diagonale,Interlocked,Trilock,Spirale";
// allow aligned and alternate layers
palletConstraintSet.AllowAlignedLayers = true;
palletConstraintSet.AllowAlternateLayers = true;
// set maximum pallet height
palletConstraintSet.MaximumHeight = (double)nudPalletHeight.Value;
palletConstraintSet.UseMaximumHeight = true;
// do not use other constraints
palletConstraintSet.UseMaximumPalletWeight = false;
palletConstraintSet.UseMaximumNumberOfCases = false;
palletConstraintSet.UseMaximumWeightOnBox = false;
// overhang
palletConstraintSet.OverhangX = OverhangX;
palletConstraintSet.OverhangY = OverhangY;
return palletConstraintSet;
}
private void FillGrid()
{
try
{
// fill grid solution
gridSolutions.Rows.Clear();
// border
DevAge.Drawing.BorderLine border = new DevAge.Drawing.BorderLine(Color.DarkBlue, 1);
DevAge.Drawing.RectangleBorder cellBorder = new DevAge.Drawing.RectangleBorder(border, border);
// views
CellBackColorAlternate viewNormal = new CellBackColorAlternate(Color.LightBlue, Color.White);
viewNormal.Border = cellBorder;
CheckboxBackColorAlternate viewNormalCheck = new CheckboxBackColorAlternate(Color.LightBlue, Color.White);
viewNormalCheck.Border = cellBorder;
// column header view
SourceGrid.Cells.Views.ColumnHeader viewColumnHeader = new SourceGrid.Cells.Views.ColumnHeader();
DevAge.Drawing.VisualElements.ColumnHeader backHeader = new DevAge.Drawing.VisualElements.ColumnHeader();
backHeader.BackColor = Color.LightGray;
backHeader.Border = DevAge.Drawing.RectangleBorder.NoBorder;
viewColumnHeader.Background = backHeader;
viewColumnHeader.ForeColor = Color.White;
viewColumnHeader.Font = new Font("Arial", 8, FontStyle.Regular);
viewColumnHeader.ElementSort.SortStyle = DevAge.Drawing.HeaderSortStyle.None;
// create the grid
gridSolutions.BorderStyle = BorderStyle.FixedSingle;
gridSolutions.ColumnsCount = 12;
gridSolutions.FixedRows = 1;
gridSolutions.Rows.Insert(0);
// header
SourceGrid.Cells.ColumnHeader columnHeader;
// 0
columnHeader = new SourceGrid.Cells.ColumnHeader("#");
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 0] = columnHeader;
// 1
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_A1);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 1] = columnHeader;
// 2
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_A2);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 2] = columnHeader;
// 3
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_A3);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 3] = columnHeader;
// 4
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_LENGTH);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 4] = columnHeader;
// 5
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_WIDTH);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 5] = columnHeader;
// 6
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_HEIGHT);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 6] = columnHeader;
// 7
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_AREA);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 7] = columnHeader;
// 8
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_CASESLAYER);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 8] = columnHeader;
// 9
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_LAYERS);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 9] = columnHeader;
// 10
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_CASESPALLET);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 10] = columnHeader;
// 11
columnHeader = new SourceGrid.Cells.ColumnHeader(Resources.ID_VOLUMEEFFICIENCY);
columnHeader.AutomaticSortEnabled = false;
columnHeader.View = viewColumnHeader;
gridSolutions[0, 11] = columnHeader;
// column width
gridSolutions.Columns[0].Width = 30;
gridSolutions.Columns[1].Width = 30;
gridSolutions.Columns[2].Width = 30;
gridSolutions.Columns[3].Width = 30;
gridSolutions.Columns[4].Width = 50;
gridSolutions.Columns[5].Width = 50;
gridSolutions.Columns[6].Width = 50;
gridSolutions.Columns[7].Width = 50;
gridSolutions.Columns[8].Width = 80;
gridSolutions.Columns[9].Width = 50;
gridSolutions.Columns[10].Width = 80;
gridSolutions.Columns[11].Width = 100;
// get BoxProperties
BoxProperties boxProperties = SelectedBox;
PalletProperties palletProperties = SelectedPallet;
CaseOptimConstraintSet caseOptimConstraintSet = BuildCaseOptimConstraintSet();
PalletConstraintSet palletConstraintSet = new CasePalletConstraintSet();
palletConstraintSet.MaximumHeight = (double)nudPalletHeight.Value;
// data
int iIndex = 0;
foreach (CaseOptimSolution sol in _solutions)
{
// insert new row
gridSolutions.Rows.Insert(++iIndex);
// # (index)
gridSolutions[iIndex, 0] = new SourceGrid.Cells.Cell(string.Format("{0}", iIndex));
// A1
gridSolutions[iIndex, 1] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.CaseDefinition.Arrangement._iLength));
// A2
gridSolutions[iIndex, 2] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.CaseDefinition.Arrangement._iWidth));
// A3
gridSolutions[iIndex, 3] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.CaseDefinition.Arrangement._iHeight));
// Case inner dimensions
Vector3D innerDim = sol.CaseDefinition.InnerDimensions(boxProperties);
// LENGTH
gridSolutions[iIndex, 4] = new SourceGrid.Cells.Cell(string.Format("{0:0.#}", innerDim.X));
// WIDTH
gridSolutions[iIndex, 5] = new SourceGrid.Cells.Cell(string.Format("{0:0.#}", innerDim.Y));
// HEIGHT
gridSolutions[iIndex, 6] = new SourceGrid.Cells.Cell(string.Format("{0:0.#}", innerDim.Z));
// AREA
gridSolutions[iIndex, 7] = new SourceGrid.Cells.Cell(string.Format("{0:0.00}", sol.CaseDefinition.Area(boxProperties, caseOptimConstraintSet) * 1.0E-06));
// CASES PER LAYER
gridSolutions[iIndex, 8] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.PalletSolution[0].BoxCount));
// LAYERS
gridSolutions[iIndex, 9] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.PalletSolution.Count));
// CASES PER PALLET
gridSolutions[iIndex, 10] = new SourceGrid.Cells.Cell(string.Format("{0}", sol.CaseCount));
// EFFICIENCY
double efficiency = sol.CaseCount * sol.CaseDefinition.InnerVolume(boxProperties) /
((palletProperties.Length - palletConstraintSet.OverhangX)
* (palletProperties.Width - palletConstraintSet.OverhangY)
* (palletConstraintSet.MaximumHeight - palletProperties.Height)
);
gridSolutions[iIndex, 11] = new SourceGrid.Cells.Cell(string.Format("{0:0.00}", efficiency));
}
// select first solution
if (_solutions.Count > 0)
{
gridSolutions.Selection.EnableMultiSelection = false;
gridSolutions.Selection.SelectRow(1, true);
}
}
catch (Exception ex)
{ _log.Error(ex.ToString()); }
graphCtrlBoxesLayout.Invalidate();
graphCtrlPalletLayout.Invalidate();
UpdateToolbarButtons();
}
public bool onFileNew(ref string fileName)
{
// INTEX data are in cms
UnitsManager.CurrentUnitSystem = UnitsManager.UnitSystem.UNIT_METRIC2;
string dbPath = Properties.Settings.Default.DatabasePathINTEX;
if (string.IsNullOrWhiteSpace(dbPath) || !File.Exists(dbPath))
{
OpenFileDialog fd = new OpenFileDialog();
fd.DefaultExt = "xls";
fd.AddExtension = false;
fd.Filter = "Microsoft Excel File (*.xls)|*.xls|All files (*.*)|*.*";
fd.FilterIndex = 0;
fd.RestoreDirectory = true;
fd.CheckFileExists = true;
if (DialogResult.OK != fd.ShowDialog())
return false;
dbPath = fd.FileName;
Properties.Settings.Default.DatabasePathINTEX = dbPath;
Properties.Settings.Default.Save();
}
// load INTEX excel file
List<DataItemINTEX> listItems = null;
List<DataPalletINTEX> listPallets = null;
List<DataCaseINTEX> listCases = null;
try
{
// Set cursor as hourglass
Cursor.Current = Cursors.WaitCursor;
// load excel file
if (!ExcelDataReader.ExcelDataReader.LoadIntexFile(dbPath, ref listItems, ref listPallets, ref listCases))
{
Cursor.Current = Cursors.Default;
MessageBox.Show(
string.Format(Properties.Resources.ID_ERROR_INVALIDFILE, dbPath)
, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
return false;
}
}
catch (Exception ex)
{
MessageBox.Show(
ex.Message
, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
_log.Error(ex.Message);
}
finally
{ Cursor.Current = Cursors.Default; }
// do we have a valid list
if (null == listItems || 0 == listItems.Count)
return false;
// proceed : buid project file
try
{
FormNewINTEX form = new FormNewINTEX();
form._listItems = listItems;
form._listPallets = listPallets;
form._listCases = listCases;
if (DialogResult.OK != form.ShowDialog())
return false;
// create document
DataItemINTEX item = form._currentItem;
Document document = new Document(item._ref, item._description, "INTEX", DateTime.Now, null);
// create box properties
Color[] colorsCase = new Color[6];
for (int i = 0; i < 6; ++i) { colorsCase[i] = Color.Chocolate; }
BoxProperties itemProperties = null;
if (!form.UseIntermediatePacking)
{
itemProperties = document.CreateNewCase(
item._ref
, string.Format("{0};EAN14 : {1};UPC : {2};PCB : {3}", item._description, item._gencode, item._UPC, item._PCB)
, UnitsManager.ConvertLengthFrom(item._length, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._width, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._height, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._length - 0.6, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._width - 0.6, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._height - 0.6, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertMassFrom(item._weight, UnitsManager.UnitSystem.UNIT_METRIC2)
, colorsCase);
}
else
{
itemProperties = document.CreateNewBox(
item._ref
, string.Format("{0};EAN14 : {1};UPC : {2};PCB : {3}", item._description, item._gencode, item._UPC, item._PCB)
, UnitsManager.ConvertLengthFrom(item._length, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._width, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(item._height, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertMassFrom(item._weight, UnitsManager.UnitSystem.UNIT_METRIC2)
, colorsCase);
}
itemProperties.ShowTape = true;
itemProperties.TapeColor = Color.Beige;
itemProperties.TapeWidth = 5.0;
InsertPictogram(ref itemProperties);
BoxProperties currentCase = null;
if (form.UseIntermediatePacking)
{
// create cases
foreach (DataCaseINTEX dataCase in listCases)
{
double lengthInt = dataCase._lengthInt > 0 ? dataCase._lengthInt : dataCase._lengthExt - 2* form.DefaultCaseThickness;
double widthInt = dataCase._widthInt > 0 ? dataCase._widthInt : dataCase._widthExt - 2 * form.DefaultCaseThickness;
double heightInt = dataCase._heightInt > 0 ? dataCase._heightInt : dataCase._heightExt - 2 * form.DefaultCaseThickness;
BoxProperties intercaseProperties = document.CreateNewCase(
dataCase._ref
, string.Format("{0:0.0}*{1:0.0}*{2:0.0}", dataCase._lengthExt, dataCase._widthExt, dataCase._heightExt)
, UnitsManager.ConvertLengthFrom(dataCase._lengthExt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(dataCase._widthExt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(dataCase._heightExt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(lengthInt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(widthInt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(heightInt, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertMassFrom(dataCase._weight, UnitsManager.UnitSystem.UNIT_METRIC2)
, colorsCase);
intercaseProperties.ShowTape = true;
intercaseProperties.TapeColor = Color.Beige;
intercaseProperties.TapeWidth = 5.0;
if (string.Equals( form._currentCase._ref, intercaseProperties.Name))
currentCase = intercaseProperties;
}
}
if (form.UseIntermediatePacking)
{
// Case constraint set
BoxCaseConstraintSet boxCaseConstraintSet = new BoxCaseConstraintSet();
boxCaseConstraintSet.SetAllowedOrthoAxisAll();
if (boxCaseConstraintSet.IsValid)
{
// create case analysis
BoxCaseAnalysis analysis = document.CreateNewBoxCaseAnalysis(
string.Format(Properties.Resources.ID_PACKING, item._ref)
, item._description
, itemProperties
, currentCase
, boxCaseConstraintSet
, new BoxCaseSolver());
}
}
// create pallets
PalletProperties currentPallet = null;
foreach (DataPalletINTEX pallet in listPallets)
{
PalletProperties palletProperties = document.CreateNewPallet(
pallet._type, pallet._type, "EUR"
, UnitsManager.ConvertLengthFrom(pallet._length, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(pallet._width, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertLengthFrom(pallet._height, UnitsManager.UnitSystem.UNIT_METRIC2)
, UnitsManager.ConvertMassFrom(pallet._weight, UnitsManager.UnitSystem.UNIT_METRIC2));
if (string.Equals(form._currentPallet._type, pallet._type))
currentPallet = palletProperties;
}
// *** pallet analysis ***
// constraint set
CasePalletConstraintSet constraintSet = new CasePalletConstraintSet();
constraintSet.UseMaximumHeight = true;
constraintSet.MaximumHeight = UnitsManager.ConvertLengthFrom(form.PalletHeight, UnitsManager.UnitSystem.UNIT_METRIC2);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_P, true);
constraintSet.AllowAlignedLayers = true;
constraintSet.AllowAlternateLayers = true;
constraintSet.SetAllowedPattern("Column");
constraintSet.SetAllowedPattern("Diagonale");
constraintSet.SetAllowedPattern("Interlocked");
constraintSet.SetAllowedPattern("Trilock");
constraintSet.SetAllowedPattern("Spirale");
constraintSet.SetAllowedPattern("Enlarged spirale");
if (constraintSet.IsValid)
{
// create analysis
CasePalletSolver solver = new CasePalletSolver();
CasePalletAnalysis palletAnalysis = document.CreateNewCasePalletAnalysis(
item._ref, item.ToString()
, form.UseIntermediatePacking ? currentCase : itemProperties
, currentPallet,
null, null,
null, null, null,
constraintSet, solver);
}
// save document
fileName = form.FilePath;
document.Write(form.FilePath);
// return true to let application open
return File.Exists(fileName);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
}
private PalletConstraintSet LoadCasePalletConstraintSet_Box(XmlElement eltConstraintSet)
{
CasePalletConstraintSet constraints = new CasePalletConstraintSet();
// align layers allowed
if (eltConstraintSet.HasAttribute("AlignedLayersAllowed"))
constraints.AllowAlignedLayers = string.Equals(eltConstraintSet.Attributes["AlignedLayersAllowed"].Value, "true", StringComparison.CurrentCultureIgnoreCase);
// alternate layers allowed
if (eltConstraintSet.HasAttribute("AlternateLayersAllowed"))
constraints.AllowAlternateLayers = string.Equals(eltConstraintSet.Attributes["AlternateLayersAllowed"].Value, "true", StringComparison.CurrentCultureIgnoreCase);
// allowed orthogonal axes
if (eltConstraintSet.HasAttribute("AllowedBoxPositions"))
{
string allowedOrthoAxes = eltConstraintSet.Attributes["AllowedBoxPositions"].Value;
string[] sAxes = allowedOrthoAxes.Split(',');
foreach (string sAxis in sAxes)
constraints.SetAllowedOrthoAxis(HalfAxis.Parse(sAxis), true);
}
// allowed patterns
if (eltConstraintSet.HasAttribute("AllowedPatterns"))
constraints.AllowedPatternString = eltConstraintSet.Attributes["AllowedPatterns"].Value;
// stop criterions
if (constraints.UseMaximumHeight = eltConstraintSet.HasAttribute("MaximumHeight"))
constraints.MaximumHeight = UnitsManager.ConvertLengthFrom(double.Parse(eltConstraintSet.Attributes["MaximumHeight"].Value), _unitSystem);
if (constraints.UseMaximumNumberOfCases = eltConstraintSet.HasAttribute("ManimumNumberOfItems"))
constraints.MaximumNumberOfItems = int.Parse(eltConstraintSet.Attributes["ManimumNumberOfItems"].Value);
if (constraints.UseMaximumPalletWeight = eltConstraintSet.HasAttribute("MaximumPalletWeight"))
constraints.MaximumPalletWeight = UnitsManager.ConvertMassFrom(double.Parse(eltConstraintSet.Attributes["MaximumPalletWeight"].Value), _unitSystem);
if (constraints.UseMaximumWeightOnBox = eltConstraintSet.HasAttribute("MaximumWeightOnBox"))
constraints.MaximumWeightOnBox = UnitsManager.ConvertMassFrom(double.Parse(eltConstraintSet.Attributes["MaximumWeightOnBox"].Value), _unitSystem);
// overhang / underhang
if (eltConstraintSet.HasAttribute("OverhangX"))
constraints.OverhangX = UnitsManager.ConvertLengthFrom(double.Parse(eltConstraintSet.Attributes["OverhangX"].Value), _unitSystem);
if (eltConstraintSet.HasAttribute("OverhangY"))
constraints.OverhangY = UnitsManager.ConvertLengthFrom(double.Parse(eltConstraintSet.Attributes["OverhangY"].Value), _unitSystem);
// number of solutions to keep
if (constraints.UseNumberOfSolutionsKept = eltConstraintSet.HasAttribute("NumberOfSolutions"))
constraints.NumberOfSolutionsKept = int.Parse(eltConstraintSet.Attributes["NumberOfSolutions"].Value);
// pallet film turns
if (eltConstraintSet.HasAttribute("PalletFilmTurns"))
constraints.PalletFilmTurns = int.Parse(eltConstraintSet.Attributes["PalletFilmTurns"].Value);
// sanity check
if (!constraints.IsValid)
throw new Exception("Invalid constraint set");
return constraints;
}
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
PalletProperties palletProperties = new PalletProperties(doc, "EUR2", 1200, 1000, 150);
Console.WriteLine("=== Pallet properties ===");
Console.WriteLine(palletProperties.ToString());
bool testCylinder = false;
if (!testCylinder)
{
// define box properties
BoxProperties boxProperties = new BoxProperties(doc, 162, 210, 250);
boxProperties.Name = "Box1";
boxProperties.Weight = 3.0;
if (!useSingleColor)
{
boxProperties.SetColor(HalfAxis.HAxis.AXIS_X_N, Color.Red);
boxProperties.SetColor(HalfAxis.HAxis.AXIS_X_P, Color.Red);
boxProperties.SetColor(HalfAxis.HAxis.AXIS_Y_N, Color.Green);
boxProperties.SetColor(HalfAxis.HAxis.AXIS_Y_P, Color.Green);
boxProperties.SetColor(HalfAxis.HAxis.AXIS_Z_N, Color.Blue);
boxProperties.SetColor(HalfAxis.HAxis.AXIS_Z_P, Color.Blue);
}
else
boxProperties.SetColor(Color.Chocolate);
Console.WriteLine(boxProperties.ToString());
InterlayerProperties interlayerProperties = null;
// define constraints
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("Trilock");
constraintSet.AllowAlignedLayers = true;
constraintSet.AllowAlternateLayers = false;
constraintSet.MaximumPalletWeight = 2000;
constraintSet.MaximumNumberOfItems = 2000;
constraintSet.MaximumHeight = 2000.0;
constraintSet.UseMaximumHeight = true;
constraintSet.UseMaximumPalletWeight = true;
constraintSet.UseMaximumWeightOnBox = false;
constraintSet.AllowLastLayerOrientationChange = true;
Console.WriteLine("=== Constraint set ===");
Console.WriteLine(constraintSet.ToString());
// initialize analysis
CasePalletAnalysis analysis = new CasePalletAnalysis(
boxProperties, palletProperties, interlayerProperties,
null, null, null, null,
constraintSet);
// initialize solver
CasePalletSolver solver = new CasePalletSolver();
solver.ProcessAnalysis(analysis);
Console.WriteLine("=== Solutions ===");
int solIndex = 0;
foreach (CasePalletSolution sol in analysis.Solutions)
{
// instantiate graphics
Graphics3DImage graphics = new Graphics3DImage(new Size(1000, 1000));
graphics.CameraPosition = new Vector3D(10000.0, 10000.0, 10000.0);
graphics.Target = Vector3D.Zero;
graphics.SetViewport(-500.0f, -500.0f, 500.0f, 500.0f);
// instantiate solution viewer
CasePalletSolutionViewer sv = new CasePalletSolutionViewer(sol);
sv.Draw(graphics);
// save
string fileName = string.Format("Pallet_{0}.bmp", solIndex++);
string filePath = Path.Combine(Path.GetTempPath(), fileName);
Console.WriteLine("Saving file " + filePath + "...");
graphics.SaveAs(filePath);
}
}
else
{
// cylinder
Console.WriteLine("=== Cylinder properties ===");
CylinderProperties cylProperties = new CylinderProperties(doc, "Cylinder", "Default cylinder",
90, 45.0, 100, 1.5, Color.Gray, Color.SkyBlue, Color.SkyBlue);
Console.WriteLine(cylProperties.ToString());
// constraint set
Console.WriteLine("=== Constraint set ===");
CylinderPalletConstraintSet constraintSet = new CylinderPalletConstraintSet();
constraintSet.UseMaximumPalletHeight = true;
constraintSet.MaximumPalletHeight = 1200.0;
constraintSet.UseMaximumPalletWeight = true;
constraintSet.MaximumPalletWeight = 2000;
constraintSet.UseMaximumNumberOfItems = true;
constraintSet.MaximumNumberOfItems = 2000;
Console.WriteLine(constraintSet.ToString());
// cylinder analysis
CylinderPalletAnalysis analysis = new CylinderPalletAnalysis(cylProperties, palletProperties, null, null, constraintSet);
// initialize solver
CylinderSolver solver = new CylinderSolver();
solver.ProcessAnalysis(analysis);
Console.WriteLine("=== Solutions ===");
int solIndex = 0;
foreach (CylinderPalletSolution sol in analysis.Solutions)
{
// instantiate graphics
Graphics3DImage graphics = new Graphics3DImage(new Size(512, 512));
graphics.CameraPosition = new Vector3D(10000.0, 10000.0, 10000.0);
graphics.Target = Vector3D.Zero;
graphics.SetViewport(-500.0f, -500.0f, 500.0f, 500.0f);
// instantiate solution viewer
CylinderPalletSolutionViewer sv = new CylinderPalletSolutionViewer(sol);
sv.Draw(graphics);
string fileName = string.Format("Pallet_{0}.jpg", solIndex++);
string filePath = Path.Combine(Path.GetTempPath(), fileName);
Console.WriteLine("Saving file " + filePath + "...");
graphics.SaveAs(filePath);
}
}
}
catch (Exception ex)
{
log.Error(ex.ToString());
}
return 0;
}
private CasePalletAnalysis LoadPalletAnalysis(Document doc, string sid)
{
CasePalletAnalysis analysis = null;
palletAnalysis xmlAnalysis = _root.data.analyses.palletAnalysis.Find(delegate(palletAnalysis pa) { return pa.id == sid; });
if (null == xmlAnalysis)
throw new XmlFileProcessorException(string.Format("Failed to load analysis with Id = {0}", xmlAnalysis.id));
BoxProperties caseProperties = LoadCaseById(doc, _root.data.items.library_cases, xmlAnalysis.caseId);
BundleProperties bundleProperties = LoadBundleById(doc, _root.data.items.library_bundles, xmlAnalysis.bundleId);
BProperties bProperties;
PalletConstraintSet constraintSet;
if (null != caseProperties)
{
CasePalletConstraintSet caseConstraintSet = new CasePalletConstraintSet();
// interlayer
caseConstraintSet.HasInterlayer = xmlAnalysis.interlayerPeriodSpecified;
caseConstraintSet.HasInterlayerAntiSlip = false;
// allowed ortho axes
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_N, true);
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_P, true);
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_N, true);
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_P, true);
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_N, true);
caseConstraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_P, true);
// interlayer period
caseConstraintSet.InterlayerPeriod = xmlAnalysis.interlayerPeriodSpecified ? (int)xmlAnalysis.interlayerPeriod : 1;
bProperties = caseProperties;
constraintSet = caseConstraintSet;
}
else if (null != bundleProperties)
{
BundlePalletConstraintSet bundleConstraintSet = new BundlePalletConstraintSet();
bProperties = bundleProperties;
constraintSet = bundleConstraintSet;
}
else
throw new XmlFileProcessorException(string.Format("Failed to load analysis with Id = {0}", xmlAnalysis.id));
// generic constraintSet properties
// allow aligned / alternate layers
constraintSet.AllowAlignedLayers = false;
constraintSet.AllowAlternateLayers = false;
foreach (layerArrangement layerArr in xmlAnalysis.allowedLayerArrangements)
{
if (layerArr == layerArrangement.ALIGNED)
constraintSet.AllowAlignedLayers = true;
if (layerArr == layerArrangement.ROTATED180 | layerArr == layerArrangement.ROTATED90)
constraintSet.AllowAlternateLayers = true;
}
// allowed patterns
foreach (patternName pName in xmlAnalysis.allowedLayerPatterns)
{
switch (pName)
{
case patternName.COLUMN: constraintSet.SetAllowedPattern("Column"); break;
case patternName.DIAGONAL: constraintSet.SetAllowedPattern("Diagonal"); break;
case patternName.INTERLOCK: constraintSet.SetAllowedPattern("Interlock"); break;
case patternName.TRILOCK: constraintSet.SetAllowedPattern("Trilock"); break;
case patternName.SPIRAL: constraintSet.SetAllowedPattern("Spiral"); break;
case patternName.ENLARGED_SPIRAL: constraintSet.SetAllowedPattern("Enlarged spiral"); break;
default: break;
}
}
// overhang
constraintSet.OverhangX = xmlAnalysis.overhang[0];
constraintSet.OverhangY = xmlAnalysis.overhang[1];
// stop criterions
// max height
if (xmlAnalysis.stackingStopCriterions.stopMaxHeight.maxHeightSpecified)
{
constraintSet.UseMaximumHeight = true;
constraintSet.MaximumHeight = xmlAnalysis.stackingStopCriterions.stopMaxHeight.maxHeight;
}
else
constraintSet.UseMaximumHeight = false;
// max weight
if (xmlAnalysis.stackingStopCriterions.stopMaxWeight.maxWeightSpecified)
{
constraintSet.UseMaximumPalletWeight = true;
constraintSet.MaximumPalletWeight = xmlAnalysis.stackingStopCriterions.stopMaxWeight.maxWeight;
}
else
constraintSet.UseMaximumPalletWeight = false;
// max number of box/bundle
if (xmlAnalysis.stackingStopCriterions.stopMaxNumber.maxNumberSpecified)
{
constraintSet.UseMaximumNumberOfCases = true;
constraintSet.MaximumNumberOfItems = (int)xmlAnalysis.stackingStopCriterions.stopMaxNumber.maxNumber;
}
else
constraintSet.UseMaximumNumberOfCases = false;
// max weight on case
if (xmlAnalysis.stackingStopCriterions.stopMaxWeightOnCase.maxWeightOnCaseSpecified)
{
constraintSet.UseMaximumWeightOnBox = true;
constraintSet.MaximumWeightOnBox = xmlAnalysis.stackingStopCriterions.stopMaxWeightOnCase.maxWeightOnCase;
}
else
constraintSet.UseMaximumWeightOnBox = false;
if (null != doc)
{
analysis = doc.CreateNewCasePalletAnalysis(xmlAnalysis.name, xmlAnalysis.description
, bProperties
, LoadPalletById(doc, _root.data.items.library_pallets, xmlAnalysis.palletId)
, LoadInterlayerById(doc, _root.data.items.library_interlayers, xmlAnalysis.interlayerId)
, LoadInterlayerById(doc, _root.data.items.library_interlayers, xmlAnalysis.interlayerAntiSlipId)
, null
, null
, null
, constraintSet
, new TreeDim.StackBuilder.Engine.CasePalletSolver());
}
else
{
// instantiate pallet analysis
analysis = new CasePalletAnalysis(
bProperties
, LoadPalletById(null, _root.data.items.library_pallets, xmlAnalysis.palletId)
, LoadInterlayerById(null, _root.data.items.library_interlayers, xmlAnalysis.interlayerId)
, null
, null
, null
, null
, constraintSet);
// name
analysis.Name = xmlAnalysis.name;
// description
analysis.Description = xmlAnalysis.description;
}
return analysis;
}
/// <summary>
/// Creates a new palet analysis
/// </summary>
/// <returns>created palet analysis</returns>
public CasePalletAnalysis CreateNewCasePalletAnalysisUI()
{
if (!CanCreateCasePalletAnalysis) return null;
FormNewAnalysis form = new FormNewAnalysis(this);
form.Cases = Cases.ToArray();
form.Pallets = Pallets.ToArray();
form.Interlayers = Interlayers.ToArray();
form.PalletCorners = ListByType(typeof(PalletCornerProperties)).ToArray();
form.PalletCaps = ListByType(typeof(PalletCapProperties)).ToArray();
form.PalletFilms = ListByType(typeof(PalletFilmProperties)).ToArray();
if (DialogResult.OK == form.ShowDialog())
{
// build constraint set
CasePalletConstraintSet constraintSet = new CasePalletConstraintSet();
// overhang / underhang
constraintSet.OverhangX = form.OverhangX;
constraintSet.OverhangY = form.OverhangY;
// allowed axes
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_N, form.AllowVerticalX);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_X_P, form.AllowVerticalX);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_N, form.AllowVerticalY);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Y_P, form.AllowVerticalY);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_N, form.AllowVerticalZ);
constraintSet.SetAllowedOrthoAxis(HalfAxis.HAxis.AXIS_Z_P, form.AllowVerticalZ);
// allowed patterns
constraintSet.ClearAllowedPatterns();
foreach (string s in form.AllowedPatterns)
constraintSet.SetAllowedPattern(s);
// allow alternate layer
constraintSet.AllowAlternateLayers = form.AllowAlternateLayers;
constraintSet.AllowAlignedLayers = form.AllowAlignedLayers;
// interlayers
constraintSet.HasInterlayer = form.HasInterlayers;
constraintSet.InterlayerPeriod = form.InterlayerPeriod;
constraintSet.HasInterlayerAntiSlip = form.HasInterlayerAntiSlip;
// stop criterion
constraintSet.UseMaximumHeight = form.UseMaximumPalletHeight;
constraintSet.UseMaximumNumberOfCases = form.UseMaximumNumberOfBoxes;
constraintSet.UseMaximumPalletWeight = form.UseMaximumPalletWeight;
constraintSet.UseMaximumWeightOnBox = form.UseMaximumLoadOnBox;
constraintSet.MaximumHeight = form.MaximumPalletHeight;
constraintSet.MaximumNumberOfItems = form.MaximumNumberOfBoxes;
constraintSet.MaximumPalletWeight = form.MaximumPalletWeight;
constraintSet.MaximumWeightOnBox = form.MaximumLoadOnBox;
// number of solution kept
constraintSet.UseNumberOfSolutionsKept = Properties.Settings.Default.KeepBestSolutions;
if (constraintSet.UseNumberOfSolutionsKept)
constraintSet.NumberOfSolutionsKept = Properties.Settings.Default.NoSolutionsToKeep;
// number of pallet film turns
constraintSet.PalletFilmTurns = form.PalletFilmTurns;
return CreateNewCasePalletAnalysis(
form.AnalysisName, form.AnalysisDescription,
form.SelectedBox, form.SelectedPallet,
form.SelectedInterlayer, form.SelectedInterlayerAntiSlip,
form.SelectedPalletCorners, form.SelectedPalletCap, form.SelectedPalletFilm,
constraintSet,
new CasePalletSolver());
}
return null;
}