private ConstraintSetBoxCase BuildConstraintSet()
{
// constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(SelectedCaseProperties);
constraintSet.SetAllowedOrientations(uCtrlCaseOrientation.AllowedOrientations);
return(constraintSet);
}
private ConstraintSetBoxCase BuildConstraintSet()
{
// constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(SelectedCase);
constraintSet.SetAllowedOrientations(uCtrlCaseOrientation.AllowedOrientations);
constraintSet.OptMaxWeight = uCtrlOptMaximumWeight.Value;
constraintSet.OptMaxNumber = uCtrlOptMaxNumber.Value;
return(constraintSet);
}
private ConstraintSetBoxCase BuildConstraintSet()
{
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(
new BoxProperties(null
, CaseInsideLength, CaseInsideWidth, CaseInsideHeight
, CaseInsideLength, CaseInsideWidth, CaseInsideHeight));
constraintSet.SetAllowedOrientations(new bool[] { false, false, true });
return(constraintSet);
}
private void BuildAnalyses(object status)
{
try
{
IProgressCallback callback = status as IProgressCallback;
callback.SetRange(0, CheckedIndices.Count - 1);
callback.Begin();
int expectedCount = uCtrlNumberPerCase.Value.Activated ? uCtrlNumberPerCase.Value.Value : -1;
PackableBrick packable = cbBoxes.SelectedType as PackableBrick;
// build list of analyses
for (int i = 0; i < CheckedIndices.Count; ++i)
{
try
{
if (callback.IsAborting)
{
break;
}
callback.StepTo(i);
callback.SetText(string.Format(Resources.ID_EVALUATINGCASE, i + 1, CheckedIndices.Count));
if ((chklbCases.Items[CheckedIndices[i]] as ItemBaseCB).Item is BoxProperties caseProperties)
{
// build constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties);
constraintSet.SetAllowedOrientations(uCtrlCaseOrient.AllowedOrientations);
if (uCtrlNumberPerCase.Value.Activated)
{
constraintSet.SetMaxNumber(uCtrlNumberPerCase.Value.Value);
}
// build solver + get analyses
SolverBoxCase solver = new SolverBoxCase(packable, caseProperties);
var listAnalyses = solver.BuildAnalyses(constraintSet, false);
foreach (var analysis in listAnalyses)
{
if ((-1 == expectedCount) || (expectedCount == analysis.Solution.ItemCount))
{
Analyses.Add(analysis);
}
}
}
}
catch (Exception) {}
}
callback.SetText(Resources.ID_SORTINGSOLUTIONS);
// sort analysis
Analyses.Sort(new AnalysisComparer());
callback.End();
}
catch (Exception) {}
}
protected void ComputeSolutions()
{
// sanity checks
if (cbBoxes.Items.Count == 0 || chklbCases.Items.Count == 0)
{
return;
}
// clear existing analyses
_analyses.Clear();
int expectedCount = uCtrlNumberPerCase.Value.Activated ? uCtrlNumberPerCase.Value.Value : -1;
try
{
PackableBrick packable = cbBoxes.SelectedType as PackableBrick;
// build list of analyses
for (int i = 0; i < _checkedIndices.Count; ++i)
{
if ((chklbCases.Items[_checkedIndices[i]] as ItemBaseCB).Item is BoxProperties caseProperties)
{
// build constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties);
constraintSet.SetAllowedOrientations(uCtrlCaseOrient.AllowedOrientations);
if (uCtrlNumberPerCase.Value.Activated)
{
constraintSet.SetMaxNumber(uCtrlNumberPerCase.Value.Value);
}
// build solver + get analyses
SolverBoxCase solver = new SolverBoxCase(packable, caseProperties);
var listAnalyses = solver.BuildAnalyses(constraintSet, false);
foreach (var analysis in listAnalyses)
{
if ((-1 == expectedCount) || (expectedCount == analysis.Solution.ItemCount))
{
_analyses.Add(analysis);
}
}
}
}
// sort analysis
_analyses.Sort(new AnalysisComparer());
// fill grid
FillGrid();
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
protected void ComputeSolutions()
{
// sanity checks
if (cbBoxes.Items.Count == 0 || chklbCases.Items.Count == 0)
{
return;
}
// clear existing analyses
_analyses.Clear();
try
{
PackableBrick packable = cbBoxes.SelectedType as PackableBrick;
// build list of analyses
for (int i = 0; i < _checkedIndices.Count; ++i)
{
BoxProperties caseProperties = (chklbCases.Items[_checkedIndices[i]] as ItemBaseCB).Item as BoxProperties;
if (null != caseProperties)
{
// build constraint set
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties);
constraintSet.SetAllowedOrientations(uCtrlCaseOrient.AllowedOrientations);
// build solver + get analyses
SolverBoxCase solver = new SolverBoxCase(packable, caseProperties);
_analyses.AddRange(solver.BuildAnalyses(constraintSet));
}
}
// sort analysis
_analyses.Sort(new AnalysisComparer());
// fill grid
FillGrid();
}
catch (Exception ex)
{
_log.Error(ex.Message);
}
}
public DCSBSolution SB_GetBoxCaseBestSolution(
DCSBCase sbBox, DCSBCase sbCase, DCSBInterlayer sbInterlayer
, DCSBConstraintSet sbConstraintSet
, DCCompFormat expectedFormat, bool showCotations)
{
List <string> lErrors = new List <string>();
try
{
BoxProperties boxProperties = new BoxProperties(null
, sbBox.DimensionsOuter.M0, sbBox.DimensionsOuter.M1, sbBox.DimensionsOuter.M2)
{
};
boxProperties.SetWeight(sbBox.Weight);
boxProperties.SetNetWeight(new OptDouble(sbBox.NetWeight.HasValue, sbBox.NetWeight.Value));
if (null != sbBox.Colors && sbBox.Colors.Length >= 6)
{
for (int i = 0; i < 6; ++i)
{
boxProperties.SetColor((HalfAxis.HAxis)i, Color.FromArgb(sbBox.Colors[i]));
}
}
else
{
boxProperties.SetAllColors(Enumerable.Repeat <Color>(Color.Turquoise, 6).ToArray());
}
BoxProperties caseProperties = new BoxProperties(null)
{
InsideLength = null != sbCase.DimensionsInner ? sbCase.DimensionsInner.M0 : 0.0,
InsideWidth = null != sbCase.DimensionsInner ? sbCase.DimensionsInner.M1 : 0.0,
InsideHeight = null != sbCase.DimensionsInner ? sbCase.DimensionsInner.M2 : 0.0,
TapeColor = Color.FromArgb(sbCase.TapeColor),
TapeWidth = new OptDouble(sbCase.TapeWidth != 0.0, sbCase.TapeWidth)
};
caseProperties.SetWeight(sbCase.Weight);
if (null != sbCase.Colors && sbCase.Colors.Length >= 6)
{
for (int i = 0; i < 6; ++i)
{
caseProperties.SetColor((HalfAxis.HAxis)i, Color.FromArgb(sbCase.Colors[i]));
}
}
else
{
caseProperties.SetAllColors(Enumerable.Repeat <Color>(Color.Chocolate, 6).ToArray());
}
OptDouble oMaxWeight = null != sbConstraintSet.MaxWeight ? new OptDouble(sbConstraintSet.MaxWeight.Active, sbConstraintSet.MaxWeight.Value_d) : OptDouble.Zero;
OptInt oMaxNumber = null != sbConstraintSet.MaxNumber ? new OptInt(sbConstraintSet.MaxNumber.Active, sbConstraintSet.MaxNumber.Value_i) : OptInt.Zero;
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(caseProperties)
{
OptMaxWeight = oMaxWeight,
OptMaxNumber = oMaxNumber
};
constraintSet.SetAllowedOrientations(new bool[] { false, false, true });
if (!constraintSet.Valid)
{
throw new Exception("Invalid constraint set");
}
Vector3D cameraPosition = Graphics3D.Corner_0;
int layerCount = 0, caseCount = 0, interlayerCount = 0;
double weightTotal = 0.0, weightLoad = 0.0, volumeEfficiency = 0.0;
double? weightEfficiency = 0.0;
double? weightNet = (double?)null;
Vector3D bbLoad = new Vector3D();
Vector3D bbGlob = new Vector3D();
byte[] imageBytes = null;
string[] errors = null;
if (StackBuilderProcessor.GetBestSolution(
boxProperties, caseProperties, null,
constraintSet, sbConstraintSet.AllowMultipleLayerOrientations,
cameraPosition, showCotations, 0.03f,
new Size(expectedFormat.Size.CX, expectedFormat.Size.CY),
ref layerCount, ref caseCount, ref interlayerCount,
ref weightTotal, ref weightLoad, ref weightNet,
ref bbLoad, ref bbGlob,
ref volumeEfficiency, ref weightEfficiency,
ref imageBytes, ref errors))
{
foreach (string err in errors)
{
lErrors.Add(err);
}
return(new DCSBSolution()
{
LayerCount = layerCount,
CaseCount = caseCount,
InterlayerCount = interlayerCount,
WeightLoad = weightLoad,
WeightTotal = weightTotal,
NetWeight = weightNet,
BBoxLoad = new DCSBDim3D(bbLoad.X, bbLoad.Y, bbLoad.Z),
BBoxTotal = new DCSBDim3D(bbGlob.X, bbGlob.Y, bbGlob.Z),
Efficiency = volumeEfficiency,
OutFile = new DCCompFileOutput()
{
Bytes = imageBytes,
Format = new DCCompFormat()
{
Format = EOutFormat.IMAGE,
Size = new DCCompSize()
{
CX = expectedFormat.Size.CX,
CY = expectedFormat.Size.CY
}
}
},
Errors = lErrors.ToArray()
});
}
}
catch (Exception ex)
{
lErrors.Add(ex.Message);
_log.Error(ex.ToString());
}
return(new DCSBSolution()
{
Errors = lErrors.ToArray()
});
}
private void GenerateResult(
string name
, double length, double width, double height
, double?weight
, ref int stackCount, ref double stackWeight, ref double stackEfficiency
, ref string stackImagePath)
{
stackCount = 0;
stackWeight = 0.0;
stackImagePath = string.Empty;
// generate case
BoxProperties bProperties = new BoxProperties(null, length, width, height);
if (weight.HasValue)
{
bProperties.SetWeight(weight.Value);
}
bProperties.SetColor(Color.Chocolate);
bProperties.TapeWidth = new OptDouble(true, Math.Min(50.0, 0.5 * width));
bProperties.TapeColor = Color.Beige;
Graphics3DImage graphics = null;
if (GenerateImage || GenerateImageInFolder)
{
// generate image path
stackImagePath = Path.Combine(Path.ChangeExtension(Path.GetTempFileName(), "png"));
if (GenerateImageInFolder)
{
stackImagePath = Path.ChangeExtension(Path.Combine(Path.Combine(DirectoryPathImages, name)), "png");
}
graphics = new Graphics3DImage(new Size(ImageSize, ImageSize))
{
FontSizeRatio = this.FontSizeRatio,
CameraPosition = Graphics3D.Corner_0
};
}
// compute analysis
if (0 == Mode)
{
ConstraintSetCasePallet constraintSet = new ConstraintSetCasePallet();
constraintSet.SetAllowedOrientations(new bool[] { !AllowOnlyZOrientation, !AllowOnlyZOrientation, true });
constraintSet.SetMaxHeight(new OptDouble(true, PalletMaximumHeight));
SolverCasePallet solver = new SolverCasePallet(bProperties, PalletProperties, constraintSet);
List <AnalysisLayered> analyses = solver.BuildAnalyses(false);
if (analyses.Count > 0)
{
AnalysisLayered analysis = analyses[0];
stackCount = analysis.Solution.ItemCount;
stackWeight = analysis.Solution.Weight;
stackEfficiency = analysis.Solution.VolumeEfficiency;
if (stackCount <= StackCountMax)
{
if (GenerateImage || GenerateImageInFolder)
{
ViewerSolution sv = new ViewerSolution(analysis.Solution as SolutionLayered);
sv.Draw(graphics, Transform3D.Identity);
graphics.Flush();
}
if (GenerateReport)
{
ReportDataAnalysis inputData = new ReportDataAnalysis(analysis);
string outputFilePath = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(OutputFilePath), string.Format("Report_{0}_on_{1}", analysis.Content.Name, analysis.Container.Name)), "doc");
ReportNode rnRoot = null;
Margins margins = new Margins();
Reporter reporter = new ReporterMSWord(inputData, ref rnRoot, Reporter.TemplatePath, outputFilePath, margins);
}
}
}
}
else
{
BoxProperties container = new BoxProperties(null, TruckLength, TruckWidth, TruckHeight, TruckLength, TruckWidth, TruckHeight);
Color lblue = Color.LightBlue;
container.SetAllColors(new Color[] { lblue, lblue, lblue, lblue, lblue, lblue });
container.SetWeight(0.0);
ConstraintSetBoxCase constraintSet = new ConstraintSetBoxCase(container);
constraintSet.SetAllowedOrientations(new bool[] { !AllowOnlyZOrientation, !AllowOnlyZOrientation, true });
SolverBoxCase solver = new SolverBoxCase(bProperties, container, constraintSet);
List <AnalysisLayered> analyses = solver.BuildAnalyses(false);
if (analyses.Count > 0)
{
AnalysisLayered analysis = analyses[0];
stackCount = analysis.Solution.ItemCount;
stackWeight = analysis.Solution.Weight;
if ((GenerateImage || GenerateImageInFolder) && stackCount <= StackCountMax)
{
ViewerSolution sv = new ViewerSolution(analysis.Solution as SolutionLayered);
sv.Draw(graphics, Transform3D.Identity);
graphics.Flush();
}
}
}
if (GenerateImage)
{
Bitmap bmp = graphics.Bitmap;
bmp.Save(stackImagePath, System.Drawing.Imaging.ImageFormat.Png);
}
}
