public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth); actualLength = maxSizeXLength * boxLength + maxSizeXWidth * boxWidth; actualWidth = Math.Max(maxSizeYLength * boxWidth, maxSizeYWidth * boxLength); return(maxSizeXLength > 0 && maxSizeXWidth > 0 && maxSizeYLength > 0 && maxSizeYWidth > 0 && (maxSizeXLength % 2 == 0)); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth); double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); double spaceX = maxSizeXLength + maxSizeXWidth > 1 ? (actualLength - (maxSizeXLength * boxLength + maxSizeXWidth * boxWidth)) / (maxSizeXLength + maxSizeXWidth - 1) : 0.0; double spaceYLength = maxSizeYLength > 1 ? (actualWidth - maxSizeYLength * boxWidth) / (maxSizeYLength - 1) : 0.0; double spaceYWidth = maxSizeYWidth > 1 ? (actualWidth - maxSizeYWidth * boxLength) / (maxSizeYWidth - 1) : 0.0; for (int i = 0; i < maxSizeXLength; ++i) { for (int j = 0; j < maxSizeYLength; ++j) { AddPosition( layer , new Vector2D( offsetX + i * (boxLength + spaceX) , offsetY + j * (boxWidth + spaceYLength)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } for (int i = 0; i < maxSizeXWidth; ++i) { for (int j = 0; j < maxSizeYWidth; ++j) { AddPosition( layer , new Vector2D( offsetX + maxSizeXLength * (boxLength + spaceX) + i * (boxWidth + spaceX) + boxWidth , offsetY + j * (boxLength + spaceYWidth)) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } // maximum space layer.UpdateMaxSpace(spaceYLength, Name); layer.UpdateMaxSpace(spaceYWidth, Name); layer.UpdateMaxSpace(spaceX, Name); }
public bool GetLayerDimensionsChecked(ILayer2D layer, out double actualLength, out double actualWidth) { bool result = GetLayerDimensions(layer, out actualLength, out actualWidth); if (actualLength > GetPalletLength(layer)) { throw new EngineException(string.Format("Pattern name={0} : actualLength={1} > palletLength={2} ?" , this.Name, actualLength, GetPalletLength(layer))); } if (actualWidth > GetPalletWidth(layer)) { throw new EngineException(string.Format("Pattern name={0} : actualWidth={1} > palletWidth={2} ?" , this.Name, actualWidth, GetPalletWidth(layer))); } return(result); }
public ILayer2D BuildLayer(Packable packable, Vector2D dimContainer, LayerDesc layerDesc, double minSpace) { ILayer2D layer = null; if (packable.IsBrick) { // casts LayerDescBox layerDescBox = layerDesc as LayerDescBox; // layer instantiation layer = new Layer2D(packable.OuterDimensions, dimContainer, layerDesc.PatternName, layerDescBox.AxisOrtho, layerDesc.Swapped) { ForcedSpace = minSpace }; // get layer pattern LayerPatternBox pattern = LayerPatternBox.GetByName(layerDesc.PatternName); // dimensions if (!pattern.GetLayerDimensionsChecked(layer as Layer2D, out double actualLength, out double actualWidth)) { return(null); } pattern.GenerateLayer( layer as Layer2D , actualLength , actualWidth); return(layer); } else if (packable.IsCylinder) { // casts CylinderProperties cylProperties = packable as CylinderProperties; // layer instantiation layer = new Layer2DCyl(cylProperties.RadiusOuter, cylProperties.Height, dimContainer, layerDesc.Swapped); // get layer pattern LayerPatternCyl pattern = LayerPatternCyl.GetByName(layerDesc.PatternName); double actualLength = 0.0, actualWidth = 0.0; if (!pattern.GetLayerDimensions(layer as Layer2DCyl, out actualLength, out actualWidth)) { return(null); } pattern.GenerateLayer(layer as Layer2DCyl, actualLength, actualWidth); } else { throw new EngineException(string.Format("Unexpected packable {0} (Type = {1})", packable.Name, packable.GetType().ToString())); } return(layer); }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = layer.Length; double palletWidth = layer.Width; Layer2DCylImp layerCyl = layer as Layer2DCylImp; double radius = layerCyl.Radius; int alignedRowLength = 0, stagRowLength = 0; int rowNumber1 = 0, rowNumber2 = 0; ComputeRowNumberAndLength(layerCyl , out alignedRowLength, out rowNumber1 , out stagRowLength, out rowNumber2 , out actualLength, out actualWidth); return(rowNumber1 > 0 && rowNumber2 > 0); }
public static Bitmap Draw(ILayer2D layer, Packable packable, double height, Size size, bool selected, eGraphMode eMode) { if (eGraphMode.GRAPH_2D == eMode) { Graphics2DImage graphics = new Graphics2DImage(size); using (ViewerILayer2D solViewer = new ViewerILayer2D(layer)) { solViewer.Draw(graphics, packable, height, selected); } return(graphics.Bitmap); } else { Graphics3DImage graphics = new Graphics3DImage(size); graphics.MarginPercentage = 0.05; using (ViewerILayer2D solViewer = new ViewerILayer2D(layer)) { solViewer.Draw(graphics, packable, height, selected); } return(graphics.Bitmap); } }
public override bool GetLayerDimensions(ILayer2D layer, out double layerLength, out double layerWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); int noInLength = (int)Math.Floor(palletLength / boxLength); int noInWidth = (int)Math.Floor((palletWidth - 2 * boxWidth) / boxLength); layerLength = noInLength * boxLength; layerWidth = noInWidth * boxLength + 2 * boxWidth; Debug.Assert(layerLength <= palletLength); Debug.Assert(layerWidth <= palletWidth); return(true); }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetOptimalSizeArea1(boxLength, boxWidth, palletLength, palletWidth, out int sizeX_area1, out int sizeY_area1); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth, sizeX_area1, sizeY_area1 , out int sizeX_area2, out int sizeY_area2, out int sizeX_area3, out int sizeY_area3); actualLength = Math.Max(sizeX_area2 * boxLength, sizeX_area1 * boxWidth + sizeX_area3 * boxLength); actualWidth = Math.Max(sizeY_area1 * boxLength, sizeY_area3 * boxWidth) + sizeY_area2 * boxWidth; Debug.Assert(actualLength <= palletLength); Debug.Assert(actualWidth <= palletWidth); return(sizeX_area1 > 0 && sizeY_area1 > 0 && sizeX_area2 > 0 && sizeY_area2 > 0 && sizeX_area3 > 0 && sizeY_area3 > 0); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double radius = GetRadius(layer); double diameter = 2.0 * radius; int alignedRowLength = 0, stagRowLength = 0; int rowNumber1 = 0, rowNumber2 = 0; Layer2DCylImp layerCyl = layer as Layer2DCylImp; ComputeRowNumberAndLength(layerCyl , out alignedRowLength, out rowNumber1 , out stagRowLength, out rowNumber2 , out actualLength, out actualWidth); double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); for (int j = 0; j < rowNumber1; ++j) { for (int i = 0; i < alignedRowLength; ++i) { AddPosition(layerCyl, new Vector2D( radius + offsetX + i * diameter , radius + offsetY + j * diameter )); } } for (int i = 0; i < rowNumber2; ++i) { double y = radius + offsetY + (rowNumber1 - 1.0) * diameter + (i + 1) * radius * Math.Sqrt(3.0); for (int j = 0; j < (i % 2 == 0 ? stagRowLength : alignedRowLength); ++j) { AddPosition(layer, new Vector2D(offsetX + ((i % 2 != 0) ? 0.0 : radius) + j * 2.0 * radius + radius, y)); } } }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); // compute optimal layout by evaluating all spirale configurations int sizeX_area1 = 0, sizeY_area1 = 0, sizeX_area2 = 0, sizeY_area2 = 0; GetOptimalSizesXY(boxLength, boxWidth, palletLength, palletWidth , out sizeX_area1, out sizeY_area1, out sizeX_area2, out sizeY_area2); // actual length / actual width actualLength = sizeX_area1 * boxLength + sizeX_area2 * boxWidth; actualWidth = sizeY_area1 * boxWidth + sizeY_area2 * boxLength; if (2.0 * sizeX_area1 * boxLength > palletLength && 2.0 * sizeY_area1 * boxWidth > actualWidth) { actualWidth = 2.0 * sizeY_area1 * boxWidth; } else if (2.0 * sizeY_area1 * boxWidth > palletWidth && 2.0 * sizeX_area1 * boxLength > actualLength) { actualLength = 2.0 * sizeX_area1 * boxLength; } else if (2.0 * sizeX_area2 * boxWidth > palletLength && 2.0 * sizeY_area2 * boxLength > actualWidth) { actualWidth = 2.0 * sizeY_area2 * boxLength; } else if (2.0 * sizeY_area2 * boxLength > palletWidth && 2.0 * sizeX_area2 * boxWidth > actualLength) { actualLength = 2.0 * sizeX_area2 * boxWidth; } return(sizeX_area1 > 0 && sizeX_area2 > 0 && sizeY_area1 > 0 && sizeY_area2 > 0); }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out int iStep, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth); actualLength = maxSizeXLength * boxLength + maxSizeXWidth * boxWidth; if (maxSizeYWidth >= iStep && (iStep * boxLength <= palletLength)) { actualLength = Math.Max(actualLength, iStep * boxLength); } actualWidth = maxSizeYWidth * boxWidth + maxSizeYLength * boxLength; if (maxSizeXLength >= iStep && (iStep * boxWidth <= palletWidth)) { actualWidth = Math.Max(actualWidth, iStep * boxWidth); } return(maxSizeXLength > 0 && maxSizeXWidth > 0 && maxSizeYLength > 0 && maxSizeYWidth > 0); }
protected void GenerateRectanglePositions(ILayer2D layer, Vector2D offset , double boxLength, double boxWidth , int noX, int noY , double startX, double startY , double spaceX, double spaceY , bool lengthAligned) { double length = lengthAligned ? boxLength : boxWidth; double width = lengthAligned ? boxWidth : boxLength; for (int i = 0; i < noX; ++i) { for (int j = 0; j < noY; ++j) { AddPosition(layer , new Vector2D( startX + (lengthAligned ? 0.0 : boxWidth) + i * (length + spaceX) , startY + j * (width + spaceY) ) + offset , lengthAligned ? HalfAxis.HAxis.AXIS_X_P : HalfAxis.HAxis.AXIS_Y_P , lengthAligned ? HalfAxis.HAxis.AXIS_Y_P : HalfAxis.HAxis.AXIS_X_N); } } }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0; int fillSizeXLength = 0, fillSizeYLength = 0, fillSizeXWidth = 0, fillSizeYWidth = 0; GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out maxSizeXLength, out maxSizeYLength, out maxSizeXWidth, out maxSizeYWidth , out fillSizeXLength, out fillSizeYLength, out fillSizeXWidth, out fillSizeYWidth); actualLength = Math.Max(maxSizeXLength * boxLength, fillSizeXLength * boxWidth) + Math.Max(maxSizeXWidth * boxWidth, fillSizeXWidth * boxLength); actualWidth = Math.Max(maxSizeYLength * boxWidth + fillSizeYLength * boxLength, maxSizeYWidth * boxLength + fillSizeYWidth * boxWidth); return(maxSizeXLength > 0 && maxSizeYLength > 0 && maxSizeXWidth > 0 && maxSizeYWidth > 0 && ( ((maxSizeYLength % 2 == 0) && (fillSizeXLength * fillSizeYLength > 0)) || ((maxSizeYWidth % 2 == 0) && (fillSizeXWidth * fillSizeYWidth > 0)) )); }
public void AddPosition(ILayer2D layer, Vector2D vPosition, HalfAxis.HAxis lengthAxis, HalfAxis.HAxis widthAxis) { Matrix4D matRot = Matrix4D.Identity; Vector3D vTranslation = Vector3D.Zero; if (layer.Swapped) { matRot = new Matrix4D( 0.0, -1.0, 0.0, 0.0 , 1.0, 0.0, 0.0, 0.0 , 0.0, 0.0, 1.0, 0.0 , 0.0, 0.0, 0.0, 1.0 ); vTranslation = new Vector3D(layer.Length, 0.0, 0.0); } Transform3D transfRot = new Transform3D(matRot); HalfAxis.HAxis lengthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(lengthAxis))); HalfAxis.HAxis widthAxisSwapped = StackBuilder.Basics.HalfAxis.ToHalfAxis(transfRot.transform(StackBuilder.Basics.HalfAxis.ToVector3D(widthAxis))); matRot.M14 = vTranslation[0]; matRot.M24 = vTranslation[1]; matRot.M34 = vTranslation[2]; Transform3D transfRotTranslation = new Transform3D(matRot); Vector3D vPositionSwapped = transfRotTranslation.transform(new Vector3D(vPosition.X, vPosition.Y, 0.0)); Layer2D layerBox = layer as Layer2D; if (!layerBox.IsValidPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped)) { _log.Warn(string.Format("Attempt to add an invalid position in pattern = {0}, Swapped = {1}", this.Name, layer.Swapped)); return; } layerBox.AddPosition(new Vector2D(vPositionSwapped.X, vPositionSwapped.Y), lengthAxisSwapped, widthAxisSwapped); }
public override bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth) { double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetOptimalSizesXY(boxLength, boxWidth, palletLength, palletWidth , out int sizeX_area1, out int sizeY_area1, out int sizeX_area2, out int sizeY_area2); // actual length / actual width actualLength = sizeX_area1 * boxLength + sizeX_area2 * boxWidth; actualWidth = sizeY_area1 * boxWidth + sizeY_area2 * boxLength; if (2.0 * sizeX_area1 * boxLength > palletLength && 2.0 * sizeY_area1 * boxWidth > actualWidth) { actualWidth = 2.0 * sizeY_area1 * boxWidth; } else if (2.0 * sizeY_area1 * boxWidth > palletWidth && 2.0 * sizeX_area1 * boxLength > actualLength) { actualLength = 2.0 * sizeX_area1 * boxLength; } else if (2.0 * sizeX_area2 * boxWidth > palletLength && 2.0 * sizeY_area2 * boxLength > actualWidth) { actualWidth = 2.0 * sizeY_area2 * boxLength; } else if (2.0 * sizeY_area2 * boxLength > palletWidth && 2.0 * sizeX_area2 * boxWidth > actualLength) { actualLength = 2.0 * sizeX_area2 * boxWidth; } return(sizeX_area1 > 0 && sizeX_area2 > 0 && sizeY_area1 > 0 && sizeY_area2 > 0); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out int iStep, out int maxSizeXLength, out int maxSizeXWidth, out int maxSizeYLength, out int maxSizeYWidth); double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); for (int i = 0; i < iStep; ++i) { double spaceX = maxSizeXLength + maxSizeXWidth > 1 ? (actualLength - maxSizeXLength * boxLength - maxSizeXWidth * boxWidth) / (maxSizeXLength + maxSizeXWidth - 1) : 0.0; double spaceY = maxSizeYLength + maxSizeYWidth > 1 ? (actualWidth - maxSizeYWidth * boxWidth - maxSizeYLength * boxLength) / (maxSizeYLength + maxSizeYWidth - 1) : 0.0; double xBase = offsetX + i * (boxLength + spaceX); double yBase = offsetY + i * (boxWidth + spaceY); // first box AddPosition( layer , new Vector2D(xBase + boxWidth, yBase) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); // along X for (int ix = 0; ix < iStep - 1 - i; ++ix) { AddPosition( layer , new Vector2D( xBase + boxWidth + spaceX + ix * (boxLength + spaceX) , yBase) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } int maxY = (int)Math.Floor(actualWidth / boxWidth); double ySpaceNew = maxY > 1 ? (actualWidth - boxWidth * maxY) / (maxY - 1) : 0; for (int ix = iStep - 1 - i; ix < maxSizeXLength - i && i < iStep - 1; ++ix) { AddPosition( layer , new Vector2D( xBase + boxWidth + spaceX + ix * (boxLength + spaceX) , offsetY + i * (boxWidth + ySpaceNew)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } // along Y for (int iy = 0; iy < iStep - 1 - i; ++iy) { AddPosition( layer , new Vector2D( xBase , yBase + boxLength + spaceY + iy * (boxWidth + spaceY)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } int maxX = (int)Math.Floor(actualLength / boxLength); double xSpaceNew = maxX > 1 ? (actualLength - boxLength * maxX) / (maxX - 1) : 0; for (int iy = iStep - 1 - i; iy < maxSizeYWidth - i && i < iStep - 1; ++iy) { AddPosition( layer , new Vector2D( offsetX + i * (boxLength + xSpaceNew) , yBase + boxLength + spaceY + iy * (boxWidth + spaceY)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } // set spacing layer.UpdateMaxSpace(spaceX, Name); layer.UpdateMaxSpace(spaceY, Name); layer.UpdateMaxSpace(Math.Abs(boxLength - boxWidth), Name); } }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetOptimalSizeArea1(boxLength, boxWidth, palletLength, palletWidth, out int sizeX_area1, out int sizeY_area1); GetSizeXY(boxLength, boxWidth, palletLength, palletWidth, sizeX_area1, sizeY_area1 , out int sizeX_area2, out int sizeY_area2, out int sizeX_area3, out int sizeY_area3); // compute offsets double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); // compute spaces double spaceX_area1 = (actualLength - (boxWidth * sizeX_area1 + boxLength * sizeX_area3)) / (sizeX_area1 + sizeX_area3 > 1 ? (sizeX_area1 + sizeX_area3 - 1) : 1.0); double spaceX_area2 = (actualLength - sizeX_area2 * boxLength) / (sizeX_area2 > 1 ?(sizeX_area2 - 1) : 1.0); double spaceX_area3 = spaceX_area1; double spaceY_area1 = 0.0, spaceY_area2 = 0.0, spaceY_area3 = 0.0; if (sizeY_area1 * boxLength > sizeY_area3 * boxWidth) { spaceY_area1 = (actualWidth - sizeY_area1 * boxLength - sizeY_area2 * boxWidth) / (sizeY_area1 + sizeY_area2 > 1 ?(sizeY_area1 + sizeY_area2 - 1) : 1.0); spaceY_area2 = spaceY_area1; spaceY_area3 = (sizeY_area1 * (boxLength + spaceY_area1) - sizeY_area3 * boxWidth) / (0 != sizeY_area3 ? sizeY_area3 : 1.0); } else { spaceY_area3 = (actualWidth - (sizeY_area2 + sizeY_area3) * boxWidth) / (sizeY_area2 + sizeY_area3 > 1 ? (sizeY_area2 + sizeY_area3 - 1) : 1.0); spaceY_area2 = spaceY_area3; spaceY_area1 = (sizeY_area3 * (boxWidth + spaceY_area3) - sizeY_area1 * boxLength) / (sizeY_area1 > 0 ? sizeY_area1 : 1.0); } // area1 for (int i = 0; i < sizeX_area1; ++i) { for (int j = 0; j < sizeY_area1; ++j) { AddPosition(layer , new Vector2D( offsetX + boxWidth + i * (boxWidth + spaceX_area1) , offsetY + j * (boxLength + spaceY_area1)) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } // area2 for (int i = 0; i < sizeX_area2; ++i) { for (int j = 0; j < sizeY_area2; ++j) { AddPosition(layer , new Vector2D( offsetX + i * (boxLength + spaceX_area2) , actualWidth + offsetY - (j + 1) * boxWidth - j * spaceY_area2) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } // area3 for (int i = 0; i < sizeX_area3; ++i) { for (int j = 0; j < sizeY_area3; ++j) { AddPosition(layer , new Vector2D( offsetX + sizeX_area1 * (boxWidth + spaceX_area1) + i * (boxLength + spaceX_area3) , offsetY + j * (boxWidth + spaceY_area3)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } layer.UpdateMaxSpace(spaceX_area1, Name); layer.UpdateMaxSpace(spaceY_area1, Name); layer.UpdateMaxSpace(spaceX_area2, Name); layer.UpdateMaxSpace(spaceY_area2, Name); layer.UpdateMaxSpace(spaceX_area3, Name); layer.UpdateMaxSpace(spaceY_area3, Name); }
protected double GetPalletWidth(ILayer2D layer) { return(layer.Swapped ? layer.Length : layer.Width); }
public abstract void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth);
public abstract bool GetLayerDimensions(ILayer2D layer, out double actualLength, out double actualWidth);
protected double GetDiameter(ILayer2D layer) { return(2.0 * ((Layer2DCylImp)layer).Radius); }
public ViewerILayer2D(ILayer2D layer) { _layer = layer; }
public void AddSolution(ILayer2D layer, bool alternateLayers = true) { Solution = new SolutionLayered(this, layer, alternateLayers); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); double spiraleLength = boxLength + boxWidth; GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out int noSpiraleX, out int noSpiraleY , out int noArea2X, out int noArea2Y, out bool area2LengthAligned , out int noArea3X, out int noArea3Y, out bool area3LengthAligned , out bool area2First); Vector2D offset = GetOffset(layer, actualLength, actualWidth); // spirale for (int i = 0; i < noSpiraleX; ++i) { for (int j = 0; j < noSpiraleY; ++j) { double xBase = i * spiraleLength; double yBase = j * spiraleLength; AddPosition( layer , new Vector2D(xBase, yBase) + offset , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); AddPosition( layer , new Vector2D(xBase + boxLength + boxWidth, yBase) + offset , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); AddPosition( layer , new Vector2D(xBase + boxLength + boxWidth, yBase + boxLength + boxWidth) + offset , HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Y_N); AddPosition( layer , new Vector2D(xBase, yBase + boxLength + boxWidth) + offset , HalfAxis.HAxis.AXIS_Y_N, HalfAxis.HAxis.AXIS_X_P); } } layer.UpdateMaxSpace(Math.Abs(boxLength - boxWidth), Name); if (area2First) { // area 2 double width = Math.Max(noArea2Y * (area2LengthAligned ? boxWidth : boxLength), noSpiraleY * spiraleLength + noArea3Y * (area3LengthAligned ? boxWidth : boxLength)); double ySpace = 0.0; if (noArea2Y > 1) { ySpace = Math.Floor((width - noArea2Y * (area2LengthAligned ? boxWidth : boxLength)) / (noArea2Y - 1)); } double xStart = Math.Max( noSpiraleX * spiraleLength , noArea3X * (area3LengthAligned ? boxLength : boxWidth)); GenerateRectanglePositions(layer, offset, boxLength, boxWidth , noArea2X, noArea2Y , xStart, 0.0, 0.0, ySpace, area2LengthAligned); // area 3 GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea3X, noArea3Y , 0.0, noSpiraleY * spiraleLength, 0.0, 0.0, area3LengthAligned); } else { // area 3 double length = Math.Max(noArea3X * (area3LengthAligned ? boxLength : boxWidth), noSpiraleX * spiraleLength + noArea2X * (area2LengthAligned ? boxLength : boxWidth)); double xSpace = 0.0; if (noArea3X > 1) { xSpace = Math.Floor((length - noArea3X * (area3LengthAligned ? boxLength : boxWidth)) / (noArea3X - 1)); } double yStart = Math.Max( noSpiraleY * spiraleLength , noArea2Y * (area2LengthAligned ? boxWidth : boxLength)); GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea3X, noArea3Y , 0.0, yStart, xSpace, 0.0, area3LengthAligned); // area 2 GenerateRectanglePositions(layer, offset, boxLength, boxWidth, noArea2X, noArea2Y , noSpiraleX * spiraleLength, 0.0, 0.0, 0.0, area2LengthAligned); } }
protected void RecursiveInsertion(ILayer2D layer , Vector2D offset , double rectLength, double rectWidth , double boxLength, double boxWidth ) { int noInLength = (int)Math.Floor(rectLength / boxLength); int noInWidth = (int)Math.Floor((rectWidth - 2 * boxWidth) / boxLength); Vector2D internalOffset = new Vector2D( 0.5 * (rectLength - noInLength * boxLength) , 0.5 * (rectWidth - noInWidth * boxLength - 2.0 * boxWidth) ); if (noInWidth <= 0 && 2 * boxWidth > rectWidth) { if (boxWidth > rectWidth) { noInLength = 0; } internalOffset = new Vector2D( 0.5 * (rectLength - noInLength * boxLength) , 0.5 * (rectWidth - boxWidth)); } // insert boxes if (noInLength > 0) { for (int i = 0; i < noInLength; ++i) { AddPosition(layer , offset + internalOffset + new Vector2D(i * boxLength, 0.0) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); if (2 * boxWidth <= rectWidth) { AddPosition(layer , offset + internalOffset + new Vector2D(i * boxLength, noInWidth * boxLength + boxWidth) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } for (int i = 0; i < noInWidth; ++i) { AddPosition(layer , offset + internalOffset + new Vector2D(boxWidth, boxWidth + i * boxLength) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); if (2 * boxWidth <= rectLength) { AddPosition(layer , offset + internalOffset + new Vector2D(noInLength * boxLength, boxWidth + i * boxLength) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } // new internal rectangle if (noInLength > 0 && noInWidth > 0) { RecursiveInsertion(layer , offset + internalOffset + new Vector2D(boxWidth, boxWidth) , noInLength * boxLength - 2 * boxWidth, noInWidth * boxLength , boxLength, boxWidth); } } }
protected double GetRadius(ILayer2D layer) { return(((Layer2DCylImp)layer).Radius); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); int maxSizeXLength = 0, maxSizeXWidth = 0, maxSizeYLength = 0, maxSizeYWidth = 0; int fillSizeXLength = 0, fillSizeYLength = 0, fillSizeXWidth = 0, fillSizeYWidth = 0; GetSizeXY(boxLength, boxWidth, palletLength, palletWidth , out maxSizeXLength, out maxSizeYLength, out maxSizeXWidth, out maxSizeYWidth , out fillSizeXLength, out fillSizeYLength, out fillSizeXWidth, out fillSizeYWidth); double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); double l1 = Math.Max(maxSizeXLength * boxLength, fillSizeXLength * boxWidth); double l2 = Math.Max(maxSizeXWidth * boxWidth, fillSizeXWidth * boxLength); double remainingSpaceX = actualLength - l1 - l2; l1 = l1 + 0.5 * remainingSpaceX; l2 = l2 + 0.5 * remainingSpaceX; double spaceXLength = (l1 - maxSizeXLength * boxLength) / ((double)maxSizeXLength - 0.5); double spaceXWidth = (l2 - maxSizeXWidth * boxWidth) / ((double)maxSizeXWidth - 0.5); double spaceYLength = maxSizeYLength > 1 ? (actualWidth - maxSizeYLength * boxWidth - fillSizeYLength * boxLength) / (maxSizeYLength + fillSizeYLength - 1) : 0.0; double spaceYWidth = maxSizeYWidth > 1 ? (actualWidth - maxSizeYWidth * boxLength - fillSizeYWidth * boxWidth) / (maxSizeYWidth + fillSizeYWidth - 1) : 0.0; if (1 == maxSizeYLength % 2) { // LENGTH for (int i = 0; i < maxSizeXLength; ++i) { for (int j = 0; j < maxSizeYLength; ++j) { AddPosition( layer , new Vector2D( offsetX + i * (boxLength + spaceXLength) , offsetY + j * (boxWidth + spaceYLength)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } } else { // LENGTH for (int i = 0; i < maxSizeXLength; ++i) { for (int j = 0; j < maxSizeYLength / 2; ++j) { AddPosition( layer , new Vector2D( offsetX + i * (boxLength + spaceXLength) , offsetY + j * (boxWidth + spaceYLength)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } for (int i = 0; i < maxSizeXLength; ++i) { for (int j = maxSizeYLength / 2; j < maxSizeYLength; ++j) { AddPosition( layer , new Vector2D( offsetX + i * (boxLength + spaceXLength) , offsetY + j * (boxWidth + spaceYLength) + (fillSizeYLength > 0 ? fillSizeYLength * (spaceYLength + boxLength) : 0.0)) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } } double spaceXFill = fillSizeXLength > 1 ? (l1 - fillSizeXLength * boxWidth) / ((double)fillSizeXLength - 0.5) : 0; layer.UpdateMaxSpace(spaceXFill, Name); for (int i = 0; i < fillSizeXLength; ++i) { for (int j = 0; j < fillSizeYLength; ++j) { AddPosition( layer , new Vector2D( offsetX + boxWidth + i * (boxWidth + spaceXFill) , offsetY + (maxSizeYLength / 2) * (boxWidth + spaceYLength) + j * boxLength) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N ); } } } // WIDTH if (1 == maxSizeYWidth % 2) { for (int i = 0; i < maxSizeXWidth; ++i) { for (int j = 0; j < maxSizeYWidth; ++j) { AddPosition( layer , new Vector2D( offsetX + maxSizeXLength * (boxLength + spaceXLength) + i * (boxWidth + spaceXWidth) + boxWidth , offsetY + j * (boxLength + spaceYWidth)) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } } else { for (int i = 0; i < maxSizeXWidth; ++i) { for (int j = 0; j < maxSizeYWidth / 2; ++j) { AddPosition( layer , new Vector2D( offsetX + actualLength - (i) * (boxWidth + spaceXWidth) /*- boxWidth*/ , offsetY + j * (boxLength + spaceYWidth)) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } for (int i = 0; i < maxSizeXWidth; ++i) { for (int j = maxSizeYWidth / 2; j < maxSizeYWidth; ++j) { AddPosition( layer , new Vector2D( offsetX + actualLength - (i) * (boxWidth + spaceXWidth) /*- boxWidth*/ , offsetY + j * (boxLength + spaceYWidth) + (fillSizeYWidth > 0 ? fillSizeYWidth * (boxWidth + spaceYWidth) : 0.0)) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } double spaceXFill = fillSizeXWidth > 1 ? (l2 - fillSizeXWidth * boxLength) / ((double)fillSizeXWidth - 0.5) : 0.0; layer.UpdateMaxSpace(spaceXFill, Name); for (int i = 0; i < fillSizeXWidth; ++i) { for (int j = 0; j < fillSizeYWidth; ++j) { AddPosition( layer , new Vector2D( offsetX + actualLength - (i + 1) * (boxLength + spaceXFill) , offsetY + (maxSizeYWidth / 2) * (boxLength + spaceYWidth) + j * boxWidth) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P ); } } } // maximum space layer.UpdateMaxSpace(spaceYLength, Name); layer.UpdateMaxSpace(spaceYWidth, Name); }
public double GetBoxWidth(ILayer2D layer) { return(((Layer2D)layer).BoxWidth); }
public override void GenerateLayer(ILayer2D layer, double actualLength, double actualWidth) { // initialization layer.Clear(); double palletLength = GetPalletLength(layer); double palletWidth = GetPalletWidth(layer); double boxLength = GetBoxLength(layer); double boxWidth = GetBoxWidth(layer); GetOptimalSizesXY( boxLength, boxWidth, palletLength, palletWidth , out int sizeX_area1, out int sizeY_area1 , out int sizeX_area2, out int sizeY_area2 , out int sizeX_area3, out int sizeY_area3 , out int dir_area3); // compute offsets double offsetX = 0.5 * (palletLength - actualLength); double offsetY = 0.5 * (palletWidth - actualWidth); // area1 for (int i = 0; i < sizeX_area1; ++i) { for (int j = 0; j < sizeY_area1; ++j) { AddPosition(layer , new Vector2D(offsetX + i * boxLength, offsetY + j * boxWidth) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); AddPosition(layer , new Vector2D(palletLength - offsetX - i * boxLength, palletWidth - offsetY - j * boxWidth) , HalfAxis.HAxis.AXIS_X_N, HalfAxis.HAxis.AXIS_Y_N); } } double spaceX_area1 = actualLength - 2 * sizeX_area1 * boxLength; double spaceY_area1 = actualWidth - 2 * sizeY_area1 * boxWidth; // area2 for (int i = 0; i < sizeX_area2; ++i) { for (int j = 0; j < sizeY_area2; ++j) { AddPosition(layer , new Vector2D(palletLength - offsetX - i * boxWidth, offsetY + j * boxLength) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); AddPosition(layer , new Vector2D(offsetX + i * boxWidth, palletWidth - offsetY - j * boxLength) , HalfAxis.HAxis.AXIS_Y_N, HalfAxis.HAxis.AXIS_X_P); } } double spaceX_area2 = actualLength - 2 * sizeX_area2 * boxWidth; double spaceY_area2 = actualWidth - 2 * sizeY_area2 * boxLength; // area3 for (int i = 0; i < sizeX_area3; ++i) { for (int j = 0; j < sizeY_area3; ++j) { if (dir_area3 == 0) { AddPosition(layer , new Vector2D( offsetX + 0.5 * (actualLength - sizeX_area3 * boxLength) + i * boxLength , offsetY + 0.5 * (actualWidth - sizeY_area3 * boxWidth) + j * boxWidth ) , HalfAxis.HAxis.AXIS_X_P, HalfAxis.HAxis.AXIS_Y_P); } else { AddPosition(layer , new Vector2D( offsetX + 0.5 * (actualLength - sizeX_area3 * boxWidth) + (i + 1) * boxWidth , offsetY + 0.5 * (actualWidth - sizeY_area3 * boxLength) + j * boxLength ) , HalfAxis.HAxis.AXIS_Y_P, HalfAxis.HAxis.AXIS_X_N); } } } double spaceX_area3 = 0.0, spaceY_area3 = 0.0; if (dir_area3 == 0) { spaceX_area3 = 0.5 * (actualLength - sizeX_area3 * boxLength - 2.0 * (spaceX_area1 > 0 ? sizeX_area1 * boxLength : sizeX_area2 * boxWidth)); spaceY_area3 = 0.5 * (actualWidth - sizeY_area3 * boxWidth - 2.0 * (spaceY_area1 > 0 ? sizeY_area1 * boxWidth : sizeY_area2 * boxLength)); } else { spaceX_area3 = 0.5 * (actualLength - sizeX_area3 * boxWidth - 2.0 * (spaceX_area1 > 0 ? sizeX_area1 * boxLength : sizeX_area2 * boxWidth)); spaceY_area3 = 0.5 * (actualWidth - sizeY_area3 * boxLength - 2.0 * (spaceY_area1 > 0 ? sizeY_area1 * boxWidth : sizeY_area2 * boxLength)); } // set spacing layer.UpdateMaxSpace(spaceX_area3, Name); layer.UpdateMaxSpace(spaceY_area3, Name); }
public double GetBoxWidth(ILayer2D layer) { return((layer as Layer2D).BoxWidth); }