/// <summary>
/// Loads pallet solution from database file
/// </summary>
public CasePalletSolution LoadPalletSolution()
{
if (null == _palletSolution)
{
if (!File.Exists(FullFilePath))
{
return(null); // database file not available -> existing
}
else
{
Document doc = new Document(FullFilePath, null);
if (!doc.AnalysesCasePallet.Any())
{
return(null); // no analysis -> exiting
}
CasePalletAnalysis analysis = doc.AnalysesCasePallet.First() as CasePalletAnalysis;
if (analysis.Solutions.Count < 1)
{
return(null); // no solution -> exiting
}
_palletSolution = null; // doc.CasePalletAnalyses[0].Solutions[0];
}
}
return(_palletSolution);
}
public DockContentAnalysisCaseOfBoxes(IDocument document, CasePalletAnalysis analysis)
{
_document = document;
_analysis = analysis;
_analysis.AddListener(this);
InitializeComponent();
}
public SelCasePalletSolution(Document document, CasePalletAnalysis analysis, CasePalletSolution sol)
: base(document)
{
_analysis = analysis;
_analysis.AddDependancy(this);
_solution = sol;
Name = sol.Title;
}
public SelCasePalletSolution(Document document, CasePalletAnalysis analysis, CasePalletSolution sol)
: base(document)
{
_analysis = analysis;
_analysis.AddDependancy(this);
_solution = sol;
ID.Name = sol.Title;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="document">object implementing the IDocument interface</param>
/// <param name="analysis">viewed analysis</param>
public DockContentCasePalletAnalysis(IDocument document, CasePalletAnalysis analysis)
{
_document = document;
_analysis = analysis;
_analysis.AddListener(this);
_analysis.SolutionSelected += new CasePalletAnalysis.SelectSolution(onSolutionSelectionChanged);
_analysis.SolutionSelectionRemoved += new CasePalletAnalysis.SelectSolution(onSolutionSelectionChanged);
InitializeComponent();
}
public FormNewAnalysisBundle(Document document, CasePalletAnalysis analysis)
: base(document, analysis)
{
InitializeComponent();
// set unit labels
UnitsManager.AdaptUnitLabels(this);
// save document reference
_document = document;
_analysis = analysis;
// set caption text
if (null != _analysis)
Text = string.Format(Properties.Resources.ID_EDIT, _analysis.Name);
}
/// <summary>
/// Truck analysis
/// </summary>
/// <param name="document">Parent document</param>
/// <param name="analysis">Parent pallet analysis</param>
/// <param name="selSolution">Parent selected solution</param>
/// <param name="truckProperties">TruckProperties item</param>
/// <param name="constraintSet">Constraint set</param>
public TruckAnalysis(
Document document
, CasePalletAnalysis analysis
, SelCasePalletSolution selSolution
, TruckProperties truckProperties
, TruckConstraintSet constraintSet)
: base(document)
{
ID.Name = truckProperties.ID.Name;
_analysis = analysis;
_selSolution = selSolution;
this.TruckProperties = truckProperties;
_constraintSet = constraintSet;
}
/// <summary>
/// Truck analysis
/// </summary>
/// <param name="document">Parent document</param>
/// <param name="analysis">Parent pallet analysis</param>
/// <param name="selSolution">Parent selected solution</param>
/// <param name="truckProperties">TruckProperties item</param>
/// <param name="constraintSet">Constraint set</param>
public TruckAnalysis(
Document document
, CasePalletAnalysis analysis
, SelCasePalletSolution selSolution
, TruckProperties truckProperties
, TruckConstraintSet constraintSet)
: base(document)
{
Name = truckProperties.Name;
_analysis = analysis;
_selSolution = selSolution;
this.TruckProperties = truckProperties;
_constraintSet = constraintSet;
}
/// <summary>
/// Process case/pallet analysis
/// </summary>
/// <param name="analysis">Pallet analysis to process</param>
public void ProcessAnalysis(CasePalletAnalysis analysis)
{
_bProperties = analysis.BProperties;
_palletProperties = analysis.PalletProperties;
_interlayerProperties = analysis.InterlayerProperties;
_interlayerPropertiesAntiSlip = analysis.InterlayerPropertiesAntiSlip;
_cornerProperties = analysis.PalletCornerProperties;
_capProperties = analysis.PalletCapProperties;
_constraintSet = analysis.ConstraintSet;
// check contraint set validity
if (!_constraintSet.IsValid)
throw new EngineException("Constraint set is invalid!");
// generate solutions
analysis.Solutions = GenerateSolutions();
}
/// <summary>
/// Constructor used while browsing/editing existing analysis
/// </summary>
/// <param name="document">Parent document</param>
/// <param name="analysis">Analysis</param>
public FormNewAnalysis(Document document, CasePalletAnalysis analysis)
{
InitializeComponent();
// set unit labels
UnitsManager.AdaptUnitLabels(this);
// save document reference
_document = document;
_analysis = analysis;
// set caption text
Text = string.Format(Properties.Resources.ID_EDIT, _analysis.Name);
// update combo boxes
onInterlayerChecked(this, null);
onAntiSlipInterlayerChecked(this, null);
onPalletCornersChecked(this, null);
onPalletCapChecked(this, null);
onPalletFilmChecked(this, null);
}
/// <summary>
/// Constructor
/// </summary>
public ECTAnalysis(
Document document
, CasePalletAnalysis analysis
, SelCasePalletSolution selSolution)
: base(document)
{
_analysis = analysis;
_selSolution = selSolution;
// get a cardboard quality
foreach (string skey in McKeeFormula.CardboardQualityDictionary.Keys)
{
_qualityData = McKeeFormula.CardboardQualityDictionary[skey];
break;
}
// get a _printSurface value
foreach (string skey in McKeeFormula.PrintCoefDictionary.Keys)
{
_printSurface = skey;
break;
}
}
/// <summary>
/// Constructor
/// </summary>
public ECTAnalysis(
Document document
, CasePalletAnalysis analysis
, SelCasePalletSolution selSolution)
: base(document)
{
_analysis = analysis;
_selSolution = selSolution;
// get a cardboard quality
foreach (string skey in McKeeFormula.CardboardQualityDictionary.Keys)
{
_qualityData = McKeeFormula.CardboardQualityDictionary[skey];
break;
}
// get a _printSurface value
foreach (string skey in McKeeFormula.PrintCoefDictionary.Keys)
{
_printSurface = skey;
break;
}
}
/// <summary>
/// Append new solution descriptor
/// </summary>
/// <param name="desc"></param>
public void Append(SelCasePalletSolution selSolution, string name, bool keepSimilarSolutions)
{
Document document = selSolution.Analysis.ParentDocument;
CasePalletSolution sol = selSolution.Solution;
CasePalletAnalysis analysis = sol.Analysis;
// instantiate new descriptor
PalletSolutionDesc desc = new PalletSolutionDesc(this, sol, name);
// remove similar solutions
if (!keepSimilarSolutions)
{
RemoveByKeyAndCaseDimensions(desc);
}
// save solution as stb file
document.WriteSolution(selSolution, desc.FullFilePath);
_palletSolutionList.Add(desc);
_palletSolutionList.Sort();
if (null != SolutionAppended)
{
SolutionAppended(this, new PalletSolutionEventArgs(desc));
}
Save();
}
private void NotifyOnNewCasePalletAnalysisCreated(CasePalletAnalysis analysis)
{
foreach (IDocumentListener listener in _listeners)
listener.OnNewCasePalletAnalysisCreated(this, analysis);
}
public void SaveCasePalletSolution(CasePalletAnalysis analysis, CasePalletSolution sol, SelCasePalletSolution selSolution, bool unique, XmlElement solutionsElt, XmlDocument xmlDoc)
{
// Solution
XmlElement solutionElt = xmlDoc.CreateElement("Solution");
solutionsElt.AppendChild(solutionElt);
// title
XmlAttribute titleAttribute = xmlDoc.CreateAttribute("Title");
titleAttribute.Value = sol.Title;
solutionElt.Attributes.Append(titleAttribute);
// homogeneousLayers ?
XmlAttribute homogeneousLayersAttribute = xmlDoc.CreateAttribute("HomogeneousLayers");
homogeneousLayersAttribute.Value = sol.HasHomogeneousLayers ? "true" : "false";
solutionElt.Attributes.Append(homogeneousLayersAttribute);
// limit
XmlAttribute limitReached = xmlDoc.CreateAttribute("LimitReached");
limitReached.Value = string.Format("{0}", (int)sol.LimitReached);
solutionElt.Attributes.Append(limitReached);
// layers
XmlElement layersElt = xmlDoc.CreateElement("Layers");
solutionElt.AppendChild(layersElt);
foreach (ILayer layer in sol)
{
BoxLayer boxLayer = layer as BoxLayer;
if (null != boxLayer)
Save(boxLayer, layersElt, xmlDoc);
InterlayerPos interlayerPos = layer as InterlayerPos;
if (null != interlayerPos)
{
// Interlayer
XmlElement interlayerElt = xmlDoc.CreateElement("Interlayer");
layersElt.AppendChild(interlayerElt);
// ZLow
XmlAttribute zlowAttribute = xmlDoc.CreateAttribute("ZLow");
zlowAttribute.Value = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}", interlayerPos.ZLow);
interlayerElt.Attributes.Append(zlowAttribute);
}
}
// Is selected ?
if (null != selSolution)
{
// selected attribute
XmlAttribute selAttribute = xmlDoc.CreateAttribute("Selected");
selAttribute.Value = "true";
solutionElt.Attributes.Append(selAttribute);
// truck analyses
XmlElement truckAnalysesElt = xmlDoc.CreateElement("TruckAnalyses");
solutionElt.AppendChild(truckAnalysesElt);
foreach (TruckAnalysis truckAnalysis in selSolution.TruckAnalyses)
Save(truckAnalysis, unique, truckAnalysesElt, xmlDoc);
// ect analyses
XmlElement ectAnalysesElt = xmlDoc.CreateElement("EctAnalyses");
solutionElt.AppendChild(ectAnalysesElt);
foreach (ECTAnalysis ectAnalysis in selSolution.EctAnalyses)
Save(ectAnalysis, unique, ectAnalysesElt, xmlDoc);
}
}
/// <summary>
/// Creates new DockContentAnalysis view
/// </summary>
/// <param name="analysis">Case pallet analysis to view</param>
/// <returns></returns>
public DockContentCasePalletAnalysis CreateAnalysisViewCasePallet(CasePalletAnalysis analysis)
{
DockContentCasePalletAnalysis form = new DockContentCasePalletAnalysis(this, analysis);
AddView(form);
return form;
}
public void OnNewCasePalletAnalysisCreated(Document doc, CasePalletAnalysis analysis)
{
_log.Info(string.Format("Loaded case/pallet analysis {0}", analysis.Name));
}
public void OnTruckAnalysisRemoved(Document doc, CasePalletAnalysis analysis, SelCasePalletSolution selectedSolution, TruckAnalysis truckAnalysis)
{
}
void onSolutionSelectionChanged(CasePalletAnalysis analysis, SelCasePalletSolution selSolution)
{
UpdateSelectButtonText();
UpdateGridCheckBoxes();
}
/// <summary>
/// Creates a new analysis without generating solutions
/// </summary>
/// <param name="name">Name of analysis</param>
/// <param name="description">Description</param>
/// <param name="box">Case</param>
/// <param name="pallet">Pallet</param>
/// <param name="interlayer">Interlayer</param>
/// <param name="constraintSet">PalletConstraintSet</param>
/// <param name="solutions">Solutions</param>
/// <returns>CasePalletAnalysis generated using input parameters</returns>
public CasePalletAnalysis CreateNewCasePalletAnalysis(
string name, string description
, BProperties box, PalletProperties pallet
, InterlayerProperties interlayer, InterlayerProperties interlayerAntiSlip
, PalletCornerProperties palletCorners, PalletCapProperties palletCap, PalletFilmProperties palletFilm
, PalletConstraintSet constraintSet
, List<CasePalletSolution> solutions)
{
CasePalletAnalysis analysis = new CasePalletAnalysis(
box, pallet,
interlayer, interlayerAntiSlip,
palletCorners, palletCap, palletFilm,
constraintSet);
analysis.Name = name;
analysis.Description = description;
// insert in list
_casePalletAnalyses.Add(analysis);
// set solutions
analysis.Solutions = solutions;
// notify listeners
NotifyOnNewCasePalletAnalysisCreated(analysis);
// set solution selected if it is unique
if (solutions.Count == 1)
analysis.SelectSolutionByIndex(0);
return analysis;
}
/// <summary>
/// handles new truck analysis created
/// </summary>
public void OnNewTruckAnalysisCreated(Document doc, CasePalletAnalysis analysis, SelCasePalletSolution selSolution, TruckAnalysis truckAnalysis)
{
// get parent node
TreeNode parentNode = FindNode(null, new NodeTag(NodeTag.NodeType.NT_CASEPALLETANALYSISSOLUTION, doc, analysis, selSolution));
// insert truckAnalysis node
TreeNode nodeTruckAnalysis = new TreeNode(truckAnalysis.Name, 16, 16);
nodeTruckAnalysis.Tag = new NodeTag(NodeTag.NodeType.NT_TRUCKANALYSIS, doc, analysis, selSolution, truckAnalysis);
parentNode.Nodes.Add(nodeTruckAnalysis);
// expand parent tree node
parentNode.Expand();
}
/// <summary>
/// handles truck analysis removal : removed truck analysis node from
/// </summary>
public void OnTruckAnalysisRemoved(Document doc, CasePalletAnalysis analysis, SelCasePalletSolution selSolution, TruckAnalysis truckAnalysis)
{
// get node
TreeNode truckAnalysisNode = FindNode(null, new NodeTag(NodeTag.NodeType.NT_TRUCKANALYSIS, doc, analysis, selSolution, truckAnalysis));
// test
if (null == truckAnalysisNode)
{
_log.Warn(string.Format("Failed to find a valid tree node for truck analysis {0}", truckAnalysis.Name));
return;
}
// remove node
Nodes.Remove(truckAnalysisNode);
}
public CasePalletSolutionViewer(CasePalletSolution solution)
{
_analysis = null != solution ? solution.Analysis : null;
_solution = solution;
}
void CasePalletAnalysis_InsertSubNodes(Document doc, CasePalletAnalysis analysis, TreeNode nodeAnalysis)
{
// sanity check
if (null == nodeAnalysis) return;
// remove any existing subnodes
nodeAnalysis.Nodes.Clear();
// insert sub box node
int indexIconBoxAnalysis = 4;
if (analysis.BProperties is CaseOfBoxesProperties)
indexIconBoxAnalysis = 18;
else if (analysis.BProperties is BoxProperties)
indexIconBoxAnalysis = 4;
else if (analysis.BProperties is BundleProperties)
indexIconBoxAnalysis = 5;
TreeNode subBoxNode = new TreeNode(analysis.BProperties.Name, indexIconBoxAnalysis, indexIconBoxAnalysis);
subBoxNode.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISBOX, doc, analysis, analysis.BProperties);
nodeAnalysis.Nodes.Add(subBoxNode);
// insert sub pallet node
TreeNode subPalletNode = new TreeNode(analysis.PalletProperties.Name, 7, 7);
subPalletNode.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISPALLET, doc, analysis, analysis.PalletProperties);
nodeAnalysis.Nodes.Add(subPalletNode);
// insert sub interlayer node if any
if (analysis.HasInterlayer)
{
TreeNode subInterlayer = new TreeNode(analysis.InterlayerProperties.Name, 8, 8);
subInterlayer.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISINTERLAYER, doc, analysis, analysis.InterlayerProperties);
nodeAnalysis.Nodes.Add(subInterlayer);
}
if (analysis.HasInterlayerAntiSlip && (analysis.InterlayerProperties != analysis.InterlayerPropertiesAntiSlip))
{
TreeNode subInterlayer = new TreeNode(analysis.InterlayerPropertiesAntiSlip.Name, 8, 8);
subInterlayer.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISINTERLAYER, doc, analysis, analysis.InterlayerPropertiesAntiSlip);
nodeAnalysis.Nodes.Add(subInterlayer);
}
if (analysis.HasPalletCorners)
{
TreeNode subPalletCorners = new TreeNode(analysis.PalletCornerProperties.Name, 10, 10);
subPalletCorners.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISPALLETCORNERS, doc, analysis, analysis.PalletCornerProperties);
nodeAnalysis.Nodes.Add(subPalletCorners);
}
if (analysis.HasPalletCap)
{
TreeNode subPalletCap = new TreeNode(analysis.PalletCapProperties.Name, 11, 11);
subPalletCap.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISPALLETCAP, doc, analysis, analysis.PalletCapProperties);
nodeAnalysis.Nodes.Add(subPalletCap);
}
if (analysis.HasPalletFilm)
{
TreeNode subPalletFilm = new TreeNode(analysis.PalletFilmProperties.Name, 12, 12);
subPalletFilm.Tag = new NodeTag(NodeTag.NodeType.NT_ANALYSISPALLETFILM, doc, analysis, analysis.PalletFilmProperties);
nodeAnalysis.Nodes.Add(subPalletFilm);
}
nodeAnalysis.Expand();
}
/// <summary>
/// Edit specified pallet analysis
/// </summary>
/// <param name="analysis"></param>
public void EditCasePalletAnalysis(CasePalletAnalysis analysis)
{
// do we need to recompute analysis
bool recomputeRequired = false;
if (analysis.IsBoxAnalysis)
{
FormNewAnalysis form = new FormNewAnalysis(this, analysis);
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 (recomputeRequired = (DialogResult.OK == form.ShowDialog()))
{
// analysis name / description
analysis.Name = form.AnalysisName;
analysis.Description = form.AnalysisDescription;
// box / palet / interlayer
analysis.BProperties = form.SelectedBox;
analysis.PalletProperties = form.SelectedPallet;
analysis.InterlayerProperties = form.SelectedInterlayer;
analysis.InterlayerPropertiesAntiSlip = form.SelectedInterlayerAntiSlip;
// build constraint set
CasePalletConstraintSet constraintSet = analysis.ConstraintSet as 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 dir change
constraintSet.AllowTwoLayerOrientations = form.AllowTwoLayerOrientations;
constraintSet.AllowLastLayerOrientationChange = form.AllowLastLayerOrientationChange;
// 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;
// pallet corner
analysis.PalletCornerProperties = form.SelectedPalletCorners;
// pallet cap
analysis.PalletCapProperties = form.SelectedPalletCap;
// pallet film
analysis.PalletFilmProperties = form.SelectedPalletFilm;
// 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;
// pallet film turns
constraintSet.PalletFilmTurns = form.PalletFilmTurns;
}
}
else if (analysis.IsBundleAnalysis)
{
FormNewAnalysisBundle form = new FormNewAnalysisBundle(this, analysis);
form.Boxes = Bundles.ToArray();
form.Pallets = Pallets.ToArray();
if (recomputeRequired = (DialogResult.OK == form.ShowDialog()))
{
// analysis name / description
analysis.Name = form.ItemName;
analysis.Description = form.ItemDescription;
// analysis bundle / pallet
analysis.BProperties = form.SelectedBundle;
analysis.PalletProperties = form.SelectedPallet;
// build constraintSet
BundlePalletConstraintSet constraintSet = analysis.ConstraintSet as BundlePalletConstraintSet;
// overhang / underhang
constraintSet.OverhangX = form.OverhangX;
constraintSet.OverhangY = form.OverhangY;
// allowed patterns
constraintSet.ClearAllowedPatterns();
foreach (string s in form.AllowedPatterns)
constraintSet.SetAllowedPattern(s);
// allow aligned / alternate layer
constraintSet.AllowAlternateLayers = form.AllowAlternateLayers;
constraintSet.AllowAlignedLayers = form.AllowAlignedLayers;
// stop criterions
constraintSet.UseMaximumHeight = form.UseMaximumPalletHeight;
constraintSet.UseMaximumNumberOfCases = form.UseMaximumNumberOfBoxes;
constraintSet.UseMaximumPalletWeight = form.UseMaximumPalletWeight;
constraintSet.MaximumHeight = form.MaximumPalletHeight;
constraintSet.MaximumNumberOfItems = form.MaximumNumberOfBoxes;
constraintSet.MaximumPalletWeight = form.MaximumPalletWeight;
}
}
if (recomputeRequired)
analysis.OnEndUpdate(null);
}
internal void NotifyOnNewECTAnalysisCreated(CasePalletAnalysis analysis, SelCasePalletSolution selSolution, ECTAnalysis ectAnalysis)
{
foreach (IDocumentListener listener in _listeners)
listener.OnNewECTAnalysisCreated(this, analysis, selSolution, ectAnalysis);
}
/// <summary>
/// Creates a new analysis in this document + compute solutions
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="box"></param>
/// <param name="pallet"></param>
/// <param name="interlayer"></param>
/// <param name="constraintSet"></param>
/// <param name="solver">Node : analysis creation requires a solver</param>
/// <returns>An analysis</returns>
public CasePalletAnalysis CreateNewCasePalletAnalysis(
string name, string description
, BProperties box, PalletProperties pallet
, InterlayerProperties interlayer, InterlayerProperties interlayerAntiSlip
, PalletCornerProperties palletCorners, PalletCapProperties palletCap, PalletFilmProperties palletFilm
, PalletConstraintSet constraintSet
, ICasePalletAnalysisSolver solver)
{
CasePalletAnalysis analysis = new CasePalletAnalysis(
box, pallet,
interlayer, interlayerAntiSlip,
palletCorners, palletCap, palletFilm,
constraintSet);
analysis.Name = name;
analysis.Description = description;
// insert in list
_casePalletAnalyses.Add(analysis);
// compute analysis
solver.ProcessAnalysis(analysis);
if (analysis.Solutions.Count < 1)
{ // remove analysis from list if it has no valid solution
_casePalletAnalyses.Remove(analysis);
return null;
}
// notify listeners
NotifyOnNewCasePalletAnalysisCreated(analysis);
Modify();
return analysis;
}
private void Compute()
{
try
{
_document = new Document(_name, _name, "", DateTime.Now, null);
_analysis = null;
// bundle
BundleProperties bundleProperties = _document.CreateNewBundle(_name, _name, FlatLength, FlatWidth, FlatThickness, FlatWeight, Color.Beige, NoFlats);
// pallet
PalletProperties palletProp = _document.CreateNewPallet(CurrentPallet);
// constraint set
BundlePalletConstraintSet constraintSet = new BundlePalletConstraintSet();
constraintSet.OverhangX = 0.0;
constraintSet.OverhangY = 0.0;
constraintSet.UseMaximumNumberOfCases = false;
constraintSet.UseMaximumPalletWeight = false;
constraintSet.UseMaximumWeightOnBox = false;
constraintSet.UseMaximumHeight = true;
constraintSet.MaximumHeight = MaximumPalletHeight;
constraintSet.AllowAlignedLayers = true;
constraintSet.AllowAlternateLayers = true;
constraintSet.AllowedPatternString = "Column,Diagonale,Interlocked,Trilock,Spirale";
_analysis = _document.CreateNewCasePalletAnalysis(
_name, _name
,bundleProperties , palletProp
, null /*interlayer */, null /* interlayerAntiSlip */
, null /* palletCorners */, null /*palletCap */, null /* palletFilm */
, constraintSet
, new CasePalletSolver()
);
// fill grid
FillGrid();
}
catch (Exception ex)
{
_log.Error( ex.ToString());
}
}
public NodeTag(NodeType type, Document document, CasePalletAnalysis analysis, SelCasePalletSolution selSolution, ECTAnalysis ectAnalysis)
{
_type = type;
_document = document;
_itemProperties = null;
_casePalletAnalysis = analysis;
_selSolution = selSolution;
_ectAnalysis = ectAnalysis;
}
/// <summary>
/// handles new analysis created
/// </summary>
/// <param name="doc"></param>
/// <param name="analysis"></param>
public void OnNewCasePalletAnalysisCreated(Document doc, CasePalletAnalysis analysis)
{
// get parent node
TreeNode parentNode = FindNode(null, new NodeTag(NodeTag.NodeType.NT_LISTANALYSIS, doc));
// insert analysis node
int indexIconAnalysis = analysis.IsBoxAnalysis ? 13 : 14;
TreeNode nodeAnalysis = new TreeNode(analysis.Name, indexIconAnalysis, indexIconAnalysis);
nodeAnalysis.Tag = new NodeTag(NodeTag.NodeType.NT_CASEPALLETANALYSIS, doc, analysis);
parentNode.Nodes.Add(nodeAnalysis);
parentNode.Expand();
CasePalletAnalysis_InsertSubNodes(doc, analysis, nodeAnalysis);
// add event handlers for solution selection
analysis.Modified += new CasePalletAnalysis.ModifyAnalysis(onCasePalletAnalysisModified);
analysis.SolutionSelected += new CasePalletAnalysis.SelectSolution(onPalletAnalysisSolutionSelected);
analysis.SolutionSelectionRemoved += new CasePalletAnalysis.SelectSolution(onPalletAnalysisSolutionSelectionRemoved);
}
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;
}
public CasePalletSolution(CasePalletAnalysis analysis, string title, bool homogenousLayer)
{
_parentAnalysis = analysis;
_title = title;
_homogeneousLayer = homogenousLayer;
}
public void OnECTAnalysisRemoved(Document doc, CasePalletAnalysis analysis, SelCasePalletSolution selectedSolution, ECTAnalysis ectAnalysis)
{
}
public void SaveCasePalletAnalysis(CasePalletAnalysis analysis, CasePalletSolution sol, SelCasePalletSolution selSolution, XmlElement parentElement, XmlDocument xmlDoc)
{
// create analysis element
XmlElement xmlAnalysisElt = xmlDoc.CreateElement("AnalysisPallet");
parentElement.AppendChild(xmlAnalysisElt);
// Name
XmlAttribute analysisNameAttribute = xmlDoc.CreateAttribute("Name");
analysisNameAttribute.Value = analysis.Name;
xmlAnalysisElt.Attributes.Append(analysisNameAttribute);
// Description
XmlAttribute analysisDescriptionAttribute = xmlDoc.CreateAttribute("Description");
analysisDescriptionAttribute.Value = analysis.Description;
xmlAnalysisElt.Attributes.Append(analysisDescriptionAttribute);
// BoxId
XmlAttribute boxIdAttribute = xmlDoc.CreateAttribute("BoxId");
boxIdAttribute.Value = string.Format("{0}", analysis.BProperties.Guid);
xmlAnalysisElt.Attributes.Append(boxIdAttribute);
// PalletId
XmlAttribute palletIdAttribute = xmlDoc.CreateAttribute("PalletId");
palletIdAttribute.Value = string.Format("{0}", analysis.PalletProperties.Guid);
xmlAnalysisElt.Attributes.Append(palletIdAttribute);
// InterlayerId
if (null != analysis.InterlayerProperties)
{
XmlAttribute interlayerIdAttribute = xmlDoc.CreateAttribute("InterlayerId");
interlayerIdAttribute.Value = string.Format("{0}", analysis.InterlayerProperties.Guid);
xmlAnalysisElt.Attributes.Append(interlayerIdAttribute);
}
if (null != analysis.InterlayerPropertiesAntiSlip)
{
XmlAttribute interlayerIdAttribute = xmlDoc.CreateAttribute("InterlayerAntiSlipId");
interlayerIdAttribute.Value = string.Format("{1}", analysis.InterlayerPropertiesAntiSlip.Guid);
xmlAnalysisElt.Attributes.Append(interlayerIdAttribute);
}
// ###
// ConstraintSet
bool bundleAnalysis = (analysis.ConstraintSet.GetType() == typeof(BundlePalletConstraintSet));
XmlElement constraintSetElement = xmlDoc.CreateElement(bundleAnalysis ? "ConstraintSetBundle" : "ConstraintSetBox");
XmlAttribute alignedLayersAttribute = xmlDoc.CreateAttribute("AlignedLayersAllowed");
alignedLayersAttribute.Value = string.Format("{0}", analysis.ConstraintSet.AllowAlignedLayers);
constraintSetElement.Attributes.Append(alignedLayersAttribute);
XmlAttribute alternateLayersAttribute = xmlDoc.CreateAttribute("AlternateLayersAllowed");
alternateLayersAttribute.Value = string.Format("{0}", analysis.ConstraintSet.AllowAlternateLayers);
constraintSetElement.Attributes.Append(alternateLayersAttribute);
if (!bundleAnalysis)
{
// allowed box positions
XmlAttribute allowedAxisAttribute = xmlDoc.CreateAttribute("AllowedBoxPositions");
HalfAxis.HAxis[] axes = { HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_Z_P };
string allowedAxes = string.Empty;
foreach (HalfAxis.HAxis axis in axes)
if (analysis.ConstraintSet.AllowOrthoAxis(axis))
{
if (!string.IsNullOrEmpty(allowedAxes))
allowedAxes += ",";
allowedAxes += HalfAxis.ToString(axis);
}
allowedAxisAttribute.Value = allowedAxes;
constraintSetElement.Attributes.Append(allowedAxisAttribute);
}
// allowed layer patterns
XmlAttribute allowedPatternAttribute = xmlDoc.CreateAttribute("AllowedPatterns");
allowedPatternAttribute.Value = analysis.ConstraintSet.AllowedPatternString;
constraintSetElement.Attributes.Append(allowedPatternAttribute);
// stop criterions
if (analysis.ConstraintSet.UseMaximumHeight)
{
XmlAttribute maximumHeightAttribute = xmlDoc.CreateAttribute("MaximumHeight");
maximumHeightAttribute.Value = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}", analysis.ConstraintSet.MaximumHeight);
constraintSetElement.Attributes.Append(maximumHeightAttribute);
}
if (analysis.ConstraintSet.UseMaximumNumberOfCases)
{
XmlAttribute maximumNumberOfItems = xmlDoc.CreateAttribute("ManimumNumberOfItems");
maximumNumberOfItems.Value = string.Format("{0}", analysis.ConstraintSet.MaximumNumberOfItems);
constraintSetElement.Attributes.Append(maximumNumberOfItems);
}
if (analysis.ConstraintSet.UseMaximumPalletWeight)
{
XmlAttribute maximumPalletWeight = xmlDoc.CreateAttribute("MaximumPalletWeight");
maximumPalletWeight.Value = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}", analysis.ConstraintSet.MaximumPalletWeight);
constraintSetElement.Attributes.Append(maximumPalletWeight);
}
if (analysis.ConstraintSet.UseMaximumWeightOnBox)
{
XmlAttribute maximumWeightOnBox = xmlDoc.CreateAttribute("MaximumWeightOnBox");
maximumWeightOnBox.Value = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}", analysis.ConstraintSet.MaximumWeightOnBox);
constraintSetElement.Attributes.Append(maximumWeightOnBox);
}
// overhang / underhang
XmlAttribute overhangX = xmlDoc.CreateAttribute("OverhangX");
overhangX.Value = string.Format("{0}", analysis.ConstraintSet.OverhangX);
constraintSetElement.Attributes.Append(overhangX);
XmlAttribute overhangY = xmlDoc.CreateAttribute("OverhangY");
overhangY.Value = string.Format("{0}", analysis.ConstraintSet.OverhangY);
constraintSetElement.Attributes.Append(overhangY);
// number of solutions to keep
if (analysis.ConstraintSet.UseNumberOfSolutionsKept)
{
XmlAttribute numberOfSolutionsKept = xmlDoc.CreateAttribute("NumberOfSolutions");
numberOfSolutionsKept.Value = "1";
constraintSetElement.Attributes.Append(numberOfSolutionsKept);
}
xmlAnalysisElt.AppendChild(constraintSetElement);
// ###
// Solutions
XmlElement solutionsElt = xmlDoc.CreateElement("Solutions");
xmlAnalysisElt.AppendChild(solutionsElt);
SaveCasePalletSolution(analysis, sol, selSolution, true /* unique */, solutionsElt, xmlDoc );
}
private bool GenerateProject(out Document doc, out CasePalletAnalysis analysis, out CasePalletSolution casePalletSolution)
{
doc = null;
analysis = null;
casePalletSolution = null;
try
{
// build solution
doc = new Document(
_boxName,
string.Format(Properties.Resources.ID_OPTDOCUMENTDESCRIPTION, _boxName),
string.Empty,
DateTime.Now,
null);
// box
BoxProperties boxProperties = doc.CreateNewBox(SelectedBox);
// pallet
PalletProperties palletProperties = doc.CreateNewPallet(SelectedPallet);
// get selected caseOptimSolution
CaseOptimSolution sol = SelectedSolution;
PackArrangement arrangement = sol.CaseDefinition.Arrangement;
// build new case name
string arrangName = string.Format("{0}_{1}x{2}x{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(
Properties.Resources.ID_OPTCASEDESCRIPTION
, boxProperties.Name
, palletProperties.Name);
// add new case
CaseOfBoxesProperties caseProperties = doc.CreateNewCaseOfBoxes(
arrangName, description
, boxProperties
, sol.CaseDefinition
, BuildCaseOptimConstraintSet());
// set color
caseProperties.SetColor(Color.Chocolate);
// add new pallet analysis
string analysisName = string.Format(
Properties.Resources.ID_OPTANALYSISNAME
, boxProperties.Name
, boxProperties.Name
, arrangement._iLength
, arrangement._iWidth
, arrangement._iHeight
, sol.CaseDefinition.Dim0
, sol.CaseDefinition.Dim1);
string analysisDescription = string.Format(
Properties.Resources.ID_OPTANALYSISDESCRIPTION
, boxProperties.Name
, palletProperties.Name);
List<CasePalletSolution> palletSolutionList = new List<CasePalletSolution>();
palletSolutionList.Add(sol.PalletSolution);
analysis = doc.CreateNewCasePalletAnalysis(
analysisName
, analysisDescription
, caseProperties
, palletProperties
, null
, null
, null
, null
, null
, BuildPalletConstraintSet()
, palletSolutionList);
}
catch (Exception ex)
{
_log.Error(ex.ToString());
return false;
}
return true;
}
private void onCasePalletAnalysisModified(CasePalletAnalysis analysis)
{
// retrieve parent document
Document doc = analysis.ParentDocument;
// get parent node
TreeNode parentNode = FindNode(null, new NodeTag(NodeTag.NodeType.NT_CASEPALLETANALYSIS, doc, analysis));
if (null == parentNode) throw new Exception("Failed to locate Analysis (NT_CASEPALLETANALYSIS) node...");
// insert case/pallet/interlayer node
CasePalletAnalysis_InsertSubNodes(doc, analysis, parentNode);
// expand tree node
parentNode.Expand();
}