public CaseDefinitionViewer(CaseDefinition caseDefinition, BoxProperties boxProperties, CaseOptimConstraintSet caseConstraintSet) { _caseDefinition = caseDefinition; _boxProperties = boxProperties; _caseOptimConstraintSet = caseConstraintSet; _globalOrientation = new Orientation(HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); }
static void Main(string[] args) { bool bestLayersOnly = true; Vector3D dimBox = new Vector3D(400.0, 300.0, 150.0); Vector2D dimContainer = new Vector2D(1200.0, 1000.0); ConstraintSetCasePallet constraintSet = new ConstraintSetCasePallet(); constraintSet.SetMaxHeight(1200.0); try { LayerSolver solver = new LayerSolver(); List<Layer2D> layers = solver.BuildLayers(dimBox, dimContainer, constraintSet, bestLayersOnly); int solIndex = 0; foreach (Layer2D layer in layers) { string fileName = string.Format("{0}_{1}.bmp", layer.Name, solIndex++); string filePath = Path.Combine(Path.GetTempPath(), fileName); Console.WriteLine(string.Format("Generating {0}...", filePath)); Graphics2DImage graphics = new Graphics2DImage( new Size(150, 150) ); SolutionViewerLayer solViewer = new SolutionViewerLayer(layer); BoxProperties bProperties = new BoxProperties(null, 400.0, 300.0, 150.0); bProperties.SetColor(Color.Brown); solViewer.Draw(graphics, bProperties, 1500.0); graphics.SaveAs(filePath); } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public void ProcessAnalysis(BoxCasePalletAnalysis analysis) { _boxProperties = analysis.BoxProperties; _interlayerProperties = analysis.InterlayerProperties; _palletSolutionList = analysis.PalletSolutionsList; _constraintSet = analysis.ConstraintSet; analysis.Solutions = GenerateSolutions(); }
public BoxCaseAnalysis(BProperties bProperties, BoxProperties caseProperties, BCaseConstraintSet constraintSet) : base(bProperties.ParentDocument) { if (!constraintSet.IsValid) throw new Exception("Using invalid box/case constraintset -> Can not instantiate box/case analysis!"); this.BProperties = bProperties; this.CaseProperties = caseProperties; _constraintSet = constraintSet; }
public BoxCasePalletAnalysis(BoxProperties boxProperties, List<PalletSolutionDesc> palletSolutionList, BoxCasePalletConstraintSet constraintSet) : base(boxProperties.ParentDocument) { if (!constraintSet.IsValid) throw new Exception("Using invalid case constraintset -> Can not instantiate case analysis!"); _boxProperties = boxProperties; boxProperties.AddDependancy(this); _palletSolutionsList = palletSolutionList; _constraintSet = constraintSet; }
public CaseOptimizer( BoxProperties boxProperties , PalletProperties palletProperties , PalletConstraintSet palletContraintSet , CaseOptimConstraintSet caseOptimConstraintSet) { _boxProperties = boxProperties; _palletProperties = palletProperties; _palletConstraintSet = palletContraintSet; _caseOptimConstraintSet = caseOptimConstraintSet; }
public void ProcessAnalysis(BoxCaseAnalysis analysis) { _bProperties = analysis.BProperties; _caseProperties = analysis.CaseProperties; _constraintSet = analysis.ConstraintSet; if (!_constraintSet.IsValid) throw new EngineException("Constraint set is invalid!"); analysis.Solutions = GenerateSolutions(); }
public Case(BoxProperties boxProperties) { _length = boxProperties.Length; _width = boxProperties.Width; _height = boxProperties.Height; _insideLength = boxProperties.InsideLength; _insideWidth = boxProperties.InsideWidth; _insideHeight = boxProperties.InsideHeight; _colors = boxProperties.Colors; _colorPath = Color.Black; }
public Case(BoxProperties boxProperties, Transform3D transf) { _length = boxProperties.Length; _width = boxProperties.Width; _height = boxProperties.Height; _insideLength = boxProperties.InsideLength; _insideWidth = boxProperties.InsideWidth; _insideHeight = boxProperties.InsideHeight; _colors = boxProperties.Colors; _colorPath = Color.Black; _transf = transf; }
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()); }
/// <summary> /// constructor (from existing BoxProperties) /// </summary> public FormEditBitmaps(BoxProperties boxProperties) { InitializeComponent(); // set unit labels UnitsManager.AdaptUnitLabels(this); // set internal box properties _boxProperties = boxProperties; // get textures _textures = _boxProperties.TextureListCopy; // set default face cbFace.SelectedIndex = 0; // set horizontal angle trackBarHorizAngle.Value = 225; }
/// <summary> /// Instantiate a new case from a box, a case definition and a case optimization constraintset /// </summary> /// <param name="document">Parent document</param> /// <param name="bProperties">Box properties</param> /// <param name="constraintSet">Case optimization constraint set</param> public CaseOfBoxesProperties(Document document , BoxProperties boxProperties , CaseDefinition caseDefinition , CaseOptimConstraintSet constraintSet) : base(document) { _boxProperties = boxProperties; _boxProperties.AddDependancy(this); _caseDefinition = caseDefinition; _constraintSet = constraintSet; base.Weight = _caseDefinition.CaseEmptyWeight(_boxProperties, _constraintSet); OnAttributeModified(boxProperties); }
/// <summary> /// Instantiate a new case from a box, a case definition and a case optimization constraintset /// </summary> /// <param name="document">Parent document</param> /// <param name="bProperties">Box properties</param> /// <param name="constraintSet">Case optimization constraint set</param> public CaseOfBoxesProperties(Document document , BoxProperties boxProperties , CaseDefinition caseDefinition , ParamSetPackOptim constraintSet) : base(document) { _boxProperties = boxProperties; _boxProperties.AddDependancy(this); _caseDefinition = caseDefinition; _constraintSet = constraintSet; SetWeight(_caseDefinition.CaseEmptyWeight(_boxProperties, _constraintSet)); OnAttributeModified(boxProperties); }
/// <summary> /// constructor (from length, width, height) /// </summary> public FormEditBitmaps(double length, double width, double height, Color[] faceColors) { InitializeComponent(); // set unit labels UnitsManager.AdaptUnitLabels(this); // set internal box properties _boxProperties = new BoxProperties(null, length, width, height); _boxProperties.SetAllColors(faceColors); // get textures _textures = _boxProperties.TextureListCopy; // set default face cbFace.SelectedIndex = 0; // set horizontal angle trackBarHorizAngle.Value = 225; }
static void Main(string[] args) { BoxProperties bProperties = new BoxProperties(null, 1000, 750, 500); Box b = new Box(0, bProperties); Vector3D vNear = new Vector3D(400.0, 1000.0, 0.0); Vector3D vFar = new Vector3D(500.0, -1000.0, 250.0); Ray r = new Ray(vNear, vFar); Vector3D ptInter; if (b.RayIntersect(r, out ptInter)) Console.WriteLine("Point inter : {0}", ptInter); else Console.WriteLine("No intersection found"); }
/// <summary> /// Draw case solution /// </summary> public void Draw(Graphics3D graphics) { if (null == _caseSolution) throw new Exception("No case solution defined!"); // load pallet solution BoxProperties caseProperties; CasePalletSolution palletSolution = _caseSolution.PalletSolutionDesc.LoadPalletSolution(); if (null == palletSolution) caseProperties = new BoxProperties(null, _caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight); else { CasePalletAnalysis palletAnalysis = palletSolution.Analysis; // retrieve case properties caseProperties = palletAnalysis.BProperties as BoxProperties; } if (null == caseProperties) return; // draw case (inside) Case case_ = new Case(caseProperties); case_.DrawInside(graphics); // get case analysis BoxCasePalletAnalysis caseAnalysis = _caseSolution.ParentCaseAnalysis; // draw solution uint pickId = 0; foreach (ILayer layer in _caseSolution) { BoxLayer blayer = layer as BoxLayer; if (null != blayer) { foreach (BoxPosition bPosition in blayer) graphics.AddBox(new Box(pickId++, caseAnalysis.BoxProperties, bPosition)); } InterlayerPos interlayerPos = layer as InterlayerPos; if (null != interlayerPos) { Box box = new Box(pickId++, caseAnalysis.InterlayerProperties); // set position box.Position = new Vector3D(0.0, 0.0, interlayerPos.ZLow); // draw graphics.AddBox(box); } } // get case analysis if (_showDimensions) graphics.AddDimensions(new DimensionCube(_caseSolution.CaseLength, _caseSolution.CaseWidth, _caseSolution.CaseHeight)); }
// static methods static public double EstimateWeight( BoxProperties boxProperties, PackArrangement arrangement, HalfAxis.HAxis orientation , int[] noWalls, double thickness, double surfacicMass) { double length = 0.0, width = 0.0, height = 0.0; PackProperties.GetDimensions(boxProperties, orientation, arrangement, ref length, ref width, ref height); Vector3D vDimensions = new Vector3D( length + noWalls[0] * thickness , width + noWalls[1] * thickness , height + noWalls[2] * thickness); double area = (noWalls[0] * vDimensions.Y * vDimensions.Z + noWalls[1] * vDimensions.X * vDimensions.Z + noWalls[2] * vDimensions.X * vDimensions.Y) * UnitsManager.FactorSquareLengthToArea; return area * surfacicMass; }
public List<CasePalletSolution> Process( BoxProperties boxProperties, PalletProperties palletProperties, InterlayerProperties interlayerProperties, InterlayerProperties interlayerPropertiesAntiSlip, PalletConstraintSet constraintSet) { _bProperties = boxProperties; _palletProperties = palletProperties; _interlayerProperties = interlayerProperties; _interlayerPropertiesAntiSlip = interlayerPropertiesAntiSlip; _constraintSet = constraintSet; // check constraint set validity if (!_constraintSet.IsValid) throw new EngineException("Constraint set is invalid!"); // generate solutions return GenerateSolutions(); }
// static methods static public double EstimateWeight( BoxProperties boxProperties, PackArrangement arrangement, HalfAxis.HAxis orientation , int[] noWalls, double thickness, double surfacicMass) { double length = 0.0, width = 0.0, height = 0.0; PackProperties.GetDimensions(boxProperties, orientation, arrangement, ref length, ref width, ref height); Vector3D vDimensions = new Vector3D( length + noWalls[0] * thickness , width + noWalls[1] * thickness , height + noWalls[2] * thickness); double area = (noWalls[0] * vDimensions.Y * vDimensions.Z + noWalls[1] * vDimensions.X * vDimensions.Z + noWalls[2] * vDimensions.X * vDimensions.Y) * UnitsManager.FactorSquareLengthToArea; return(area * surfacicMass); }
protected AnalysisPackableCase( Document document, Packable packable, BoxProperties caseProperties, ConstraintSetPackableCase constraintSet) : base(document, packable) { // sanity checks if (null != ParentDocument && (null != caseProperties.ParentDocument) && caseProperties.ParentDocument != ParentDocument) { throw new Exception("box & case do not belong to the same document"); } // also add dependancy CaseProperties = caseProperties; ConstraintSet = constraintSet; }
public bool FitsIn(BoxProperties caseProperties, bool allowVerticalX, bool allowVerticalY, bool allowVerticalZ) { double[] dimItem = OuterDimensionsArray; double[] dimCase = caseProperties.InsideDimensionsArray; if (allowVerticalX) { if ( (dimItem[0] <= dimCase[0]) && ( ((dimItem[1] <= dimCase[1]) && (dimItem[2] <= dimCase[2])) || ((dimItem[1] <= dimCase[2]) && (dimItem[2] <= dimCase[1]))) ) { return(true); } } if (allowVerticalY) { if ( (dimItem[1] <= dimCase[1]) && ( ((dimItem[0] <= dimCase[0]) && (dimItem[2] <= dimCase[2])) || ((dimItem[0] <= dimCase[2]) && (dimItem[2] <= dimCase[0]))) ) { return(true); } } if (allowVerticalZ) { if ( (dimItem[2] <= dimCase[2]) && ( ((dimItem[0] <= dimCase[0]) && (dimItem[1] <= dimCase[1])) || ((dimItem[0] <= dimCase[1]) && (dimItem[1] <= dimCase[0]))) ) { return(true); } } return(false); }
protected mesh CreateComplexCaseMesh(BoxProperties caseProperties) { // build box Box box = new Box(0, caseProperties); // build list of vertex double ct = 5.0; Vector3D[] vertices = new Vector3D[16]; // 1st layer vertices[0] = new Vector3D(ct, ct, 0.0); vertices[1] = new Vector3D(box.Length - ct, ct, 0.0); vertices[2] = new Vector3D(box.Length - ct, box.Width - ct, 0.0); vertices[3] = new Vector3D(ct, box.Width - ct, 0.0); // 2nd layer (8) vertices[4] = new Vector3D(0.0, 0.0, ct); vertices[5] = new Vector3D(box.Length, 0.0, ct); vertices[6] = new Vector3D(box.Length, box.Width, ct); vertices[7] = new Vector3D(0.0, box.Width, ct); // 3rd later (8) vertices[8] = new Vector3D(0.0, 0.0, box.Height - ct); vertices[9] = new Vector3D(box.Length, 0.0, box.Height - ct); vertices[10] = new Vector3D(box.Length, box.Width, box.Height - ct); vertices[11] = new Vector3D(0.0, box.Width, box.Height - ct); // 4th layer vertices[12] = new Vector3D(ct, ct, box.Height); vertices[13] = new Vector3D(box.Length - ct, ct, box.Height); vertices[14] = new Vector3D(box.Length - ct, box.Width - ct, box.Height); vertices[15] = new Vector3D(ct, box.Width - ct, box.Height); // build list of loops Loop[] loops = new Loop[14]; mesh caseMesh = new mesh(); return caseMesh; }
public double InnerVolume(BoxProperties boxProperties) { Vector3D innerDim = InnerDimensions(boxProperties); return(innerDim.X * innerDim.Y * innerDim.Z); }
private void InsertPictogram(ref BoxProperties boxProperties) { string pictoPath = Properties.Settings.Default.pictoTOP; if (File.Exists(pictoPath)) { // load image Bitmap bmp = new Bitmap(pictoPath); // case dimensions double length = boxProperties.Length; double width = boxProperties.Width; double height = boxProperties.Height; // dimensions and margins double margin = 2; double pictoSize = 10; double minDim = Math.Min(Math.Min(length, width), Math.Min(width, height)); if (minDim < pictoSize) { margin = 0.0; pictoSize = minDim; } // top position double topPos = boxProperties.Height - margin - pictoSize; // insert picto as a texture boxProperties.AddTexture(HalfAxis.HAxis.AXIS_X_N , UnitsManager.ConvertLengthFrom(new Vector2D(width - margin - pictoSize, topPos), UnitsManager.UnitSystem.UNIT_METRIC2) , UnitsManager.ConvertLengthFrom(new Vector2D(pictoSize, pictoSize), UnitsManager.UnitSystem.UNIT_METRIC2) , 0, bmp); boxProperties.AddTexture(HalfAxis.HAxis.AXIS_X_P , UnitsManager.ConvertLengthFrom(new Vector2D(width - margin - pictoSize, topPos), UnitsManager.UnitSystem.UNIT_METRIC2) , UnitsManager.ConvertLengthFrom(new Vector2D(pictoSize, pictoSize), UnitsManager.UnitSystem.UNIT_METRIC2) , 0, bmp); boxProperties.AddTexture(HalfAxis.HAxis.AXIS_Y_N , UnitsManager.ConvertLengthFrom(new Vector2D(length - margin - pictoSize, topPos), UnitsManager.UnitSystem.UNIT_METRIC2) , UnitsManager.ConvertLengthFrom(new Vector2D(pictoSize, pictoSize), UnitsManager.UnitSystem.UNIT_METRIC2) , 0, bmp); boxProperties.AddTexture(HalfAxis.HAxis.AXIS_Y_P , UnitsManager.ConvertLengthFrom(new Vector2D(length - margin - pictoSize, topPos), UnitsManager.UnitSystem.UNIT_METRIC2) , UnitsManager.ConvertLengthFrom(new Vector2D(pictoSize, pictoSize), UnitsManager.UnitSystem.UNIT_METRIC2) , 0, bmp); } }
public override BBox3D AdditionalBoudingBox(int index) { BoxProperties bProperties = _containers[index] as BoxProperties; return(new BBox3D(Vector3D.Zero, bProperties.OuterDimensions)); }
public override Vector3D DimContainer(int index) { BoxProperties bProperties = _containers[index] as BoxProperties; return(bProperties.InsideDimensions); }
public bool FitsIn(BoxProperties caseProperties, bool allowVerticalX, bool allowVerticalY, bool allowVerticalZ) { double[] dimItem = OuterDimensions; double[] dimCase = caseProperties.InsideDimensions; if (allowVerticalX) { if ( (dimItem[0] <= dimCase[0]) && ( ( (dimItem[1] <= dimCase[1]) && (dimItem[2] <= dimCase[2]) ) || ( (dimItem[1] <= dimCase[2]) && (dimItem[2] <= dimCase[1]) ) ) ) return true; } if (allowVerticalY) { if ( (dimItem[1] <= dimCase[1]) && ( ((dimItem[0] <= dimCase[0]) && (dimItem[2] <= dimCase[2])) || ((dimItem[0] <= dimCase[2]) && (dimItem[2] <= dimCase[0]))) ) return true; } if (allowVerticalZ) { if ( (dimItem[2] <= dimCase[2]) && ( ((dimItem[0] <= dimCase[0]) && (dimItem[1] <= dimCase[1])) || ((dimItem[0] <= dimCase[1]) && (dimItem[1] <= dimCase[0]))) ) return true; } return false; }
public double BoxWidth(BoxProperties boxProperties) { return(boxProperties.Dim(_dim1)); }
public double InnerWeight(BoxProperties boxProperties) { return(_arrangement.Number * boxProperties.Weight); }
internal BoxProperties ToBox(DataBox dtBox) { BoxProperties boxProperties = new BoxProperties(null , dtBox.Dimensions[0], dtBox.Dimensions[1], dtBox.Dimensions[2]); boxProperties.Name = dtBox.Name; boxProperties.Description = dtBox.Description; Color[] colors = new Color[6]; for (int i = 0; i < 6; ++i) colors[i] = Color.Turquoise; boxProperties.SetAllColors(colors); boxProperties.ShowTape = false; boxProperties.Weight = dtBox.Weight; boxProperties.NetWeight = new OptDouble(dtBox.NetWeight > 0, dtBox.NetWeight); return boxProperties; }
internal BoxProperties ToCase(DataCase dtCase) { BoxProperties boxProperties = new BoxProperties(null , dtCase.OuterDimensions[0], dtCase.OuterDimensions[1], dtCase.OuterDimensions[2] , dtCase.InnerDimensions[0], dtCase.InnerDimensions[1], dtCase.InnerDimensions[2]); Color[] colors = new Color[6]; for (int i = 0; i < 6; ++i) colors[i] = Color.Chocolate; boxProperties.Name = dtCase.Name; boxProperties.Description = dtCase.Description; boxProperties.SetAllColors(colors); boxProperties.ShowTape = true; boxProperties.TapeColor = Color.Beige; boxProperties.TapeWidth = UnitsManager.ConvertLengthFrom(50, UnitsManager.UnitSystem.UNIT_METRIC1); boxProperties.Weight = dtCase.Weight; boxProperties.NetWeight = new OptDouble(dtCase.NetWeight > 0.0, dtCase.NetWeight); return boxProperties; }
public BoxCasePalletAnalysis CreateNewBoxCasePalletOptimization( string name, string description , BoxProperties bProperties , BoxCasePalletConstraintSet constraintSet , List<PalletSolutionDesc> palletSolutionList , IBoxCasePalletAnalysisSolver solver) { BoxCasePalletAnalysis analysis = new BoxCasePalletAnalysis(bProperties, palletSolutionList, constraintSet); analysis.Name = name; analysis.Description = description; // insert in list _boxCasePalletOptimizations.Add(analysis); // compute analysis if (null != solver) { solver.ProcessAnalysis(analysis); if (analysis.Solutions.Count < 1) { // remove analysis from list if it has no valid solution _boxCasePalletOptimizations.Remove(analysis); _log.InfoFormat("Failed to find any solution {0}", analysis.Name); return null; } } // notify listeners NotifyOnNewCaseAnalysisCreated(analysis); Modify(); return analysis; }
public BoxCaseAnalysis CreateNewBoxCaseAnalysis( string name, string description , BProperties boxProperties, BoxProperties caseProperties , BCaseConstraintSet constraintSet , IBoxCaseAnalysisSolver solver) { BoxCaseAnalysis analysis = new BoxCaseAnalysis(boxProperties, caseProperties, constraintSet); analysis.Name = name; analysis.Description = description; // insert in list _boxCaseAnalyses.Add(analysis); // compute analysis if (null != solver) { solver.ProcessAnalysis(analysis); if (analysis.Solutions.Count < 1) { // remove analysis from list if it has no valid solution _boxCaseAnalyses.Remove(analysis); return null; } } // notify listeners NotifyOnNewBoxCaseAnalysis(analysis); Modify(); return analysis; }
public double TotalWeight(BoxProperties boxProperties, CaseOptimConstraintSet constraintSet) { return(InnerWeight(boxProperties) + EmptyWeight(boxProperties, constraintSet)); }
protected mesh CreateCaseMesh(BoxProperties caseProperties) { // build box Box box = new Box(0, caseProperties); // build list of vertices / normals / UVs ulong vertexCount = 0, normalCount = 0, uvCount = 0; List<double> doubleArrayPosition = new List<double>(), doubleArrayNormal = new List<double>(), doubleArrayUV = new List<double>(); foreach (Vector3D p in box.PointsSmallOffset) { doubleArrayPosition.Add(p.X); doubleArrayPosition.Add(p.Y); doubleArrayPosition.Add(p.Z); ++vertexCount; } foreach (Vector3D n in box.Normals) { doubleArrayNormal.Add(n.X); doubleArrayNormal.Add(n.Y); doubleArrayNormal.Add(n.Z); ++normalCount; } foreach (Vector2D uv in box.UVs) { doubleArrayUV.Add(uv.X); doubleArrayUV.Add(uv.Y); ++uvCount; } mesh caseMesh = new mesh(); // position source source casePositionSource = new source() { id = "case_position", name = "case_position" }; float_array farrayPosition = new float_array { id = "case_position_float_array", count = (ulong)doubleArrayPosition.Count, Values = doubleArrayPosition.ToArray() }; casePositionSource.technique_common = new sourceTechnique_common() { accessor = new accessor() { stride = 3, count = vertexCount, source = "#case_position_float_array", param = new param[] { new param() { name = "X", type = "float" }, new param() { name = "Y", type = "float" }, new param() { name = "Z", type = "float" } } } }; casePositionSource.Item = farrayPosition; // normal source source casePositionNormal = new source() { id = "case_normal", name = "case_normal" }; float_array farrayNormal = new float_array { id = "case_normal_float_array", count = (ulong)doubleArrayNormal.Count, Values = doubleArrayNormal.ToArray() }; casePositionNormal.technique_common = new sourceTechnique_common() { accessor = new accessor() { stride = 3, count = normalCount, source = "#case_normal_float_array", param = new param[] { new param() { name = "X", type = "float" }, new param() { name = "Y", type = "float" }, new param() { name = "Z", type = "float" } } } }; casePositionNormal.Item = farrayNormal; // uv source source casePositionUV = new source() { id = "case_UV", name = "pallet_UV" }; float_array farrayUV = new float_array { id = "case_UV_float_array", count = (ulong)doubleArrayUV.Count, Values = doubleArrayUV.ToArray() }; casePositionUV.technique_common = new sourceTechnique_common() { accessor = new accessor() { stride = 2, count = vertexCount, source = "#case_UV_float_array", param = new param[] { new param() { name = "S", type = "float" }, new param() { name = "T", type = "float" } } } }; casePositionUV.Item = farrayUV; // insert sources caseMesh.source = new source[] { casePositionSource, casePositionNormal, casePositionUV }; // vertices InputLocal verticesInput = new InputLocal() { semantic = "POSITION", source = "#case_position" }; caseMesh.vertices = new vertices() { id = "case_vertex", input = new InputLocal[] { verticesInput } }; List<object> trianglesList = new List<object>(); // build list of triangles foreach (HalfAxis.HAxis axis in HalfAxis.All) { triangles trianglesCase = new triangles() { material = string.Format("materialCase{0}", (uint)axis), count = 2 }; trianglesCase.input = new InputLocalOffset[] { new InputLocalOffset() { semantic="VERTEX", source="#case_vertex", offset=0} , new InputLocalOffset() { semantic="NORMAL", source="#case_normal", offset=1} , new InputLocalOffset() { semantic="TEXCOORD", source="#case_UV", offset=2, set=0, setSpecified=true } }; string triangle_string = string.Empty; foreach (TriangleIndices tr in box.TrianglesByFace(axis)) triangle_string += tr.ConvertToString(0); trianglesCase.p = triangle_string; trianglesList.Add(trianglesCase); } // build list of lines lines linesCase = new lines() { material = "materialCaseLines", count = 12, input = new InputLocalOffset[] { new InputLocalOffset() { semantic="VERTEX", source="#case_vertex", offset=0} }, p = "0 1 1 2 2 3 3 0 4 5 5 6 6 7 7 4 0 4 1 5 2 6 3 7" }; trianglesList.Add(linesCase); caseMesh.Items = trianglesList.ToArray(); return caseMesh; }
public double BoxHeight(BoxProperties boxProperties) { return(boxProperties.Dim(Dim2)); }
/// <summary> /// constructor /// </summary> /// <param name="doc">Reference of parent <see cref="Document"/></param> /// <param name="box">Reference </param> public PackProperties(Document doc , BoxProperties box , PackArrangement arrangement , HalfAxis.HAxis orientation , PackWrapper wrapper) : base(doc) { _boxProperties = box; _boxProperties.AddDependancy(this); _arrangement = arrangement; _orientation = orientation; _wrapper = wrapper; }
public bool FitsIn(BoxProperties caseProperties) { double[] dimItem = OuterDimensions; Array.Sort(dimItem); double[] dimCase = caseProperties.InsideDimensions; Array.Sort(dimCase); return dimItem[0] <= dimCase[0] && dimItem[1] <= dimCase[1] && dimItem[2] <= dimCase[2]; }
public static void GetDimensions( BoxProperties boxProperties , HalfAxis.HAxis boxOrientation , PackArrangement arrangement , ref double length, ref double width, ref double height) { if (null == boxProperties) return; length = arrangement._iLength * boxProperties.Dim(PackProperties.DimIndex0(boxOrientation)); width = arrangement._iWidth * boxProperties.Dim(PackProperties.DimIndex1(boxOrientation)); height = arrangement._iHeight * boxProperties.Dim(3 - PackProperties.DimIndex0(boxOrientation) - PackProperties.DimIndex1(boxOrientation)); }
public double BoxLength(BoxProperties boxProperties) { return(boxProperties.Dim(_dim0)); }
public double OuterVolume(BoxProperties boxProperties, CaseOptimConstraintSet constraintSet) { Vector3D outerDim = OuterDimensions(boxProperties, constraintSet); return(outerDim.X * outerDim.Y * outerDim.Z); }
public override Vector3D Offset(int index) { BoxProperties bProperties = _containers[index] as BoxProperties; return(bProperties.OuterDimensions - bProperties.InsideDimensions); }
public double CaseEmptyWeight(BoxProperties boxProperties, CaseOptimConstraintSet constraintSet) { return(constraintSet.WallSurfaceMass * Area(boxProperties, constraintSet)); }
Layer2D BuildLayer(BoxProperties boxP, BoxProperties caseP, HalfAxis.HAxis orthoAxis, bool swapped) { return new Layer2D(new Vector3D(boxP.Length, boxP.Width, boxP.Height) , new Vector2D(caseP.InsideLength, caseP.InsideWidth) , orthoAxis , swapped); }
public BoxCaseAnalysis CreateNewBoxCaseAnalysis( string name, string description , BProperties boxProperties, BoxProperties caseProperties , BCaseConstraintSet constraintSet , List<BoxCaseSolution> solutions) { BoxCaseAnalysis analysis = new BoxCaseAnalysis(boxProperties, caseProperties, constraintSet); analysis.Name = name; analysis.Description = description; // insert in list _boxCaseAnalyses.Add(analysis); // set solutions analysis.Solutions = solutions; // notify listeners NotifyOnNewBoxCaseAnalysis(analysis); // set solution selected if it is unique if (solutions.Count == 1) analysis.SelectSolutionByIndex(0); return analysis; }