示例#1
0
 private void CheckPosition(LayerPosition bPosition)
 {
     if (!bPosition.IsValid)
     {
         throw new GraphicsException("Invalid BoxPosition: can not create box");
     }
 }
示例#2
0
        /// <summary>
        /// if box bottom oriented to Z+, reverse box
        /// </summary>
        private LayerPosition AdjustLayerPosition(LayerPosition layerPos)
        {
            LayerPosition layerPosTemp = layerPos;

            if (layerPosTemp.HeightAxis == HalfAxis.HAxis.AXIS_Z_N)
            {
                if (layerPosTemp.LengthAxis == HalfAxis.HAxis.AXIS_X_P)
                {
                    layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_Y_P;
                    layerPosTemp.Position += new Vector3D(0.0, -_bProperties.Width, -_bProperties.Height);
                }
                else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_Y_P)
                {
                    layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_X_N;
                    layerPosTemp.Position += new Vector3D(_bProperties.Width, 0.0, -_bProperties.Height);
                }
                else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_X_N)
                {
                    layerPosTemp.LengthAxis = HalfAxis.HAxis.AXIS_X_P;
                    layerPosTemp.Position  += new Vector3D(-_bProperties.Length, 0.0, -_bProperties.Height);
                }
                else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_Y_N)
                {
                    layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_X_P;
                    layerPosTemp.Position += new Vector3D(-_bProperties.Width, 0.0, -_bProperties.Height);
                }
            }
            return(layerPosTemp);
        }
 /// <summary>
 /// if box bottom oriented to Z+, reverse box
 /// </summary>
 private LayerPosition AdjustLayerPosition(LayerPosition layerPos)
 {
     LayerPosition layerPosTemp = layerPos;
     if (layerPosTemp.HeightAxis == HalfAxis.HAxis.AXIS_Z_N)
     {
         if (layerPosTemp.LengthAxis == HalfAxis.HAxis.AXIS_X_P)
         {
             layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_Y_P;
             layerPosTemp.Position += new Vector3D(0.0, -_bProperties.Width, -_bProperties.Height);
         }
         else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_Y_P)
         {
             layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_X_N;
             layerPosTemp.Position += new Vector3D(_bProperties.Width, 0.0, -_bProperties.Height);
         }
         else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_X_N)
         {
             layerPosTemp.LengthAxis = HalfAxis.HAxis.AXIS_X_P;
             layerPosTemp.Position += new Vector3D(-_bProperties.Length, 0.0, -_bProperties.Height);
         }
         else if (layerPos.LengthAxis == HalfAxis.HAxis.AXIS_Y_N)
         {
             layerPosTemp.WidthAxis = HalfAxis.HAxis.AXIS_X_P;
             layerPosTemp.Position += new Vector3D(-_bProperties.Width, 0.0, -_bProperties.Height);
         }
     }
     return layerPosTemp;
 }
示例#4
0
        public Box(uint pickId, Packable packable, LayerPosition bPosition)
        {
            if (!bPosition.IsValid)
            {
                throw new GraphicsException("Invalid BoxPosition: can not create box");
            }
            _pickId = pickId;
            _dim[0] = packable.Length;
            _dim[1] = packable.Width;
            _dim[2] = packable.Height;

            // set position
            Position = bPosition.Position;
            // set direction length
            LengthAxis = HalfAxis.ToVector3D(bPosition.LengthAxis);
            // set direction width
            WidthAxis = HalfAxis.ToVector3D(bPosition.WidthAxis);

            _colors = Enumerable.Repeat <Color>(Color.Chocolate, 6).ToArray();

            BProperties bProperties = packable as BProperties;

            if (null != bProperties)
            {
                _colors = bProperties.Colors;

                BoxProperties boxProperties = packable as BoxProperties;
                if (null != boxProperties)
                {
                    List <Pair <HalfAxis.HAxis, Texture> > textures = boxProperties.TextureList;
                    foreach (Pair <HalfAxis.HAxis, Texture> tex in textures)
                    {
                        int iIndex = (int)tex.first;
                        if (null == _textureLists[iIndex])
                        {
                            _textureLists[iIndex] = new List <Texture>();
                        }
                        _textureLists[iIndex].Add(tex.second);
                    }
                    _showTape  = boxProperties.ShowTape;
                    _tapeWidth = boxProperties.TapeWidth;
                    _tapeColor = boxProperties.TapeColor;
                }
                // IsBundle ?
                _isBundle = bProperties.IsBundle;
                if (bProperties.IsBundle)
                {
                    BundleProperties bundleProp = packable as BundleProperties;
                    if (null != bundleProp)
                    {
                        _noFlats = bundleProp.NoFlats;
                    }
                }
            }
            PackProperties packProperties = packable as PackProperties;

            if (null != packProperties)
            {
            }
        }
示例#5
0
 public Pack(uint pickId, PackProperties packProperties, LayerPosition position)
     : base(pickId, packProperties, position)
 {
     _packProperties    = packProperties;
     _arrangement       = _packProperties.Arrangement;
     _innerBox          = new Box(0, packProperties.Box);
     _forceTransparency = false;
 }
        public void ShouldGetTheNewPosition()
        {
            var position = TimeCode.FromSeconds(60d, SmpteFrameRate.Smpte2997NonDrop);

            var layerPosition = new LayerPosition {
                Position = position
            };

            Assert.AreEqual(position, layerPosition.Position);
        }
        public void ShouldGetTheLayerType()
        {
            var trackType = TrackType.Visual;

            var layerPosition = new LayerPosition {
                LayerType = trackType
            };

            Assert.AreEqual(trackType, layerPosition.LayerType);
        }
示例#8
0
        public Box(uint pickId, PackableBrick packable, LayerPosition bPosition)
        {
            // sanity checks
            CheckPosition(bPosition);
            // dimensions
            PickId  = pickId;
            _dim[0] = packable.Length;
            _dim[1] = packable.Width;
            _dim[2] = packable.Height;
            // weight
            _weight = packable.Weight;
            // set position
            BoxPosition = new BoxPosition(bPosition.Position, bPosition.LengthAxis, bPosition.WidthAxis);
            // colors
            Colors = Enumerable.Repeat <Color>(Color.Chocolate, 6).ToArray();

            BProperties bProperties = PackableToBProperties(packable);

            if (null != bProperties)
            {
                Colors = bProperties.Colors;

                if (bProperties is BoxProperties boxProperties)
                {
                    List <Pair <HalfAxis.HAxis, Texture> > textures = boxProperties.TextureList;
                    foreach (Pair <HalfAxis.HAxis, Texture> tex in textures)
                    {
                        int iIndex = (int)tex.first;
                        if (null == TextureLists[iIndex])
                        {
                            TextureLists[iIndex] = new List <Texture>();
                        }
                        TextureLists[iIndex].Add(tex.second);
                    }
                    TapeWidth = boxProperties.TapeWidth;
                    TapeColor = boxProperties.TapeColor;

                    _showTopLabel = boxProperties.ShowTopLabel;
                }
                // IsBundle ?
                IsBundle = bProperties.IsBundle;
                if (bProperties.IsBundle)
                {
                    BundleProperties bundleProp = packable as BundleProperties;
                    if (null != bundleProp)
                    {
                        BundleFlats = bundleProp.NoFlats;
                    }
                }
            }
            if (packable is PackProperties packProperties)
            {
            }
        }
示例#9
0
        private void OnTileChanged(string layer, int x, int y)
        {
            var layerPos = new LayerPosition(layer, x, y);

            if (this.tileLights.TryGetValue(layerPos, out var lastLight))
            {
                this.Penumbra.Lights.Remove(lastLight);
                this.tileLights.Remove(layerPos);
            }

            var tile = this.GetTile(x, y, layer);

            if (tile.IsBlank)
            {
                return;
            }
            var tileset     = tile.GetTileset(this.Tiles);
            var tilesetTile = tileset.GetTilesetTile(tile, this.Tiles);

            var light = this.CreateTileLight(x + 0.5F, y + 0.5F, tilesetTile);

            if (light != null)
            {
                this.tileLights.Add(layerPos, light);
                this.Penumbra.Lights.Add(light);
            }

            foreach (var obj in tilesetTile.Objects)
            {
                if (obj.Name == "Hull")
                {
                    this.Penumbra.Hulls.Add(new Hull(new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1))
                    {
                        Position = obj.Position + new Vector2(x, y) * this.TileSize,
                        Scale    = obj.Size
                    });
                }
            }
        }
示例#10
0
 public void ShowWarningTooltip(string text, LayerPosition layerPosition)
 {
 }
示例#11
0
        private List <BoxCaseSolution> GenerateSolutions()
        {
            List <BoxCaseSolution> solutions = new List <BoxCaseSolution>();

            int[] patternColumnCount = new int[6];
            // loop throw all patterns
            foreach (LayerPattern pattern in LayerPattern.All)
            {
                // loop through all vertical axes
                for (int i = 0; i < 6; ++i)
                {
                    HalfAxis.HAxis axisOrtho = (HalfAxis.HAxis)i;
                    if (!_constraintSet.AllowOrthoAxis(axisOrtho))
                    {
                        continue;
                    }
                    try
                    {
                        // build layer
                        Layer2D layer = BuildLayer(_bProperties, _caseProperties, axisOrtho, false);
                        double  actualLength = 0.0, actualWidth = 0.0;
                        if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
                        {
                            continue;
                        }
                        pattern.GenerateLayer(layer, actualLength, actualWidth);

                        string          title            = string.Empty;
                        BoxCaseSolution sol              = new BoxCaseSolution(null, axisOrtho, pattern.Name);
                        double          offsetX          = 0.5 * (_caseProperties.Length - _caseProperties.InsideLength);
                        double          offsetY          = 0.5 * (_caseProperties.Width - _caseProperties.InsideWidth);
                        double          zLayer           = 0.5 * (_caseProperties.Height - _caseProperties.InsideHeight);
                        bool            maxWeightReached = _constraintSet.UseMaximumCaseWeight && (_caseProperties.Weight + _bProperties.Weight > _constraintSet.MaximumCaseWeight);
                        bool            maxHeightReached = _bProperties.Dimension(axisOrtho) > _caseProperties.InsideHeight;
                        bool            maxNumberReached = false;
                        int             boxCount         = 0;

                        while (!maxWeightReached && !maxHeightReached && !maxNumberReached)
                        {
                            BoxLayer bLayer = sol.CreateNewLayer(zLayer, 0);

                            foreach (LayerPosition layerPos in layer)
                            {
                                // increment
                                ++boxCount;
                                if (maxNumberReached = _constraintSet.UseMaximumNumberOfBoxes && (boxCount > _constraintSet.MaximumNumberOfBoxes))
                                {
                                    break;
                                }

                                double weight = _caseProperties.Weight + boxCount * _bProperties.Weight;
                                maxWeightReached = _constraintSet.UseMaximumCaseWeight && weight > _constraintSet.MaximumCaseWeight;
                                if (maxWeightReached)
                                {
                                    break;
                                }
                                // insert new box in current layer
                                LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                                BoxPosition   boxPos       = new BoxPosition(
                                    layerPosTemp.Position
                                    + offsetX * Vector3D.XAxis
                                    + offsetY * Vector3D.YAxis
                                    + zLayer * Vector3D.ZAxis
                                    , layerPosTemp.LengthAxis
                                    , layerPosTemp.WidthAxis
                                    );
                                bLayer.Add(boxPos);
                            }
                            zLayer += layer.BoxHeight;
                            if (!maxWeightReached && !maxNumberReached)
                            {
                                maxHeightReached = zLayer + layer.BoxHeight > 0.5 * (_caseProperties.Height + _caseProperties.InsideHeight);
                            }
                        }
                        // set maximum criterion
                        if (maxNumberReached)
                        {
                            sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXNUMBERREACHED;
                        }
                        else if (maxWeightReached)
                        {
                            sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXWEIGHTREACHED;
                        }
                        else if (maxHeightReached)
                        {
                            sol.LimitReached = BoxCaseSolution.Limit.LIMIT_MAXHEIGHTREACHED;
                        }

                        if (string.Equals(pattern.Name, "Column", StringComparison.CurrentCultureIgnoreCase))
                        {
                            patternColumnCount[i] = Math.Max(patternColumnCount[i], sol.BoxPerCaseCount);
                        }

                        // insert solution
                        if (sol.BoxPerCaseCount >= patternColumnCount[i])
                        {
                            solutions.Add(sol);
                        }
                    }
                    catch (NotImplementedException)
                    {
                        _log.Info(string.Format("Pattern {0} is not implemented", pattern.Name));
                    }
                    catch (Exception ex)
                    {
                        _log.Error(string.Format("Exception caught: {0}", ex.Message));
                    }
                } // loop through all vertical axes
            }     // loop through all patterns

            // sort solutions
            solutions.Sort();

            /*
             * // removes solutions that do not equal the best number
             * if (solutions.Count > 0)
             * {
             *  int indexFrom = 0, maxCount = solutions[0].BoxPerCaseCount;
             *  while (indexFrom < solutions.Count && solutions[indexFrom].BoxPerCaseCount == maxCount)
             ++indexFrom;
             *  solutions.RemoveRange(indexFrom, solutions.Count - indexFrom);
             * }
             */
            return(solutions);
        }
示例#12
0
        private List <PackPalletSolution> GenerateSolutions()
        {
            var solutions = new List <PackPalletSolution>();

            HalfAxis.HAxis[] axes = { HalfAxis.HAxis.AXIS_Z_N, HalfAxis.HAxis.AXIS_Z_P };
            // loop throught all patterns
            foreach (LayerPatternBox pattern in LayerPatternBox.All)
            {
                // loop throught all axes
                foreach (HalfAxis.HAxis axis in axes) // axis
                {
                    // loop through
                    Layer2D layer = BuildLayer(_packProperties, _palletProperties, _constraintSet, axis, false, false);
                    double  actualLength = 0.0, actualWidth = 0.0;
                    if (!pattern.GetLayerDimensionsChecked(layer, out actualLength, out actualWidth))
                    {
                        continue;
                    }
                    pattern.GenerateLayer(layer, actualLength, actualWidth);

                    // filter by layer weight
                    if (_constraintSet.MaximumLayerWeight.Activated &&
                        (layer.Count * _packProperties.Weight > _constraintSet.MaximumLayerWeight.Value))
                    {
                        continue;
                    }
                    // filter by maximum space
                    if (_constraintSet.MaximumSpaceAllowed.Activated &&
                        layer.MaximumSpace > _constraintSet.MaximumSpaceAllowed.Value)
                    {
                        continue;
                    }
                    double layerHeight = layer.BoxHeight;

                    string title    = string.Format("{0}-{1}", pattern.Name, axis);
                    double zLayer   = 0.0;
                    var    boxLayer = new Layer3DBox(zLayer, 0);
                    foreach (LayerPosition layerPos in layer)
                    {
                        LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                        var           boxPos       = new BoxPosition(
                            layerPosTemp.Position
                            - (0.5 * _constraintSet.OverhangX) * Vector3D.XAxis
                            - (0.5 * _constraintSet.OverhangY) * Vector3D.YAxis
                            + zLayer * Vector3D.ZAxis
                            , layerPosTemp.LengthAxis
                            , layerPosTemp.WidthAxis
                            );
                        boxLayer.Add(boxPos);
                    }
                    boxLayer.MaximumSpace = layer.MaximumSpace;
                    BBox3D layerBBox = boxLayer.BoundingBox(_packProperties);
                    // filter by overhangX
                    if (_constraintSet.MinOverhangX.Activated &&
                        (0.5 * (layerBBox.Length - _palletProperties.Length) < _constraintSet.MinOverhangX.Value))
                    {
                        continue;
                    }
                    // filter by overhangY
                    if (_constraintSet.MinOverhangY.Activated &&
                        (0.5 * (layerBBox.Width - _palletProperties.Width) < _constraintSet.MinOverhangY.Value))
                    {
                        continue;
                    }

                    double interlayerThickness = null != _interlayerProperties ? _interlayerProperties.Thickness : 0;
                    double interlayerWeight    = null != _interlayerProperties ? _interlayerProperties.Weight : 0;

                    var sol          = new PackPalletSolution(null, title, boxLayer);
                    int noLayer      = 1,
                        noInterlayer = (null != _interlayerProperties && _constraintSet.HasFirstInterlayer) ? 1 : 0;

                    bool maxHeightReached = _constraintSet.MaximumPalletHeight.Activated &&
                                            (_packProperties.Height
                                             + noInterlayer * interlayerThickness
                                             + noLayer * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
                    bool maxWeightReached = _constraintSet.MaximumPalletWeight.Activated &&
                                            (_palletProperties.Weight
                                             + noInterlayer * interlayerWeight
                                             + noLayer * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);

                    noLayer = 0; noInterlayer = 0;
                    int  iCountInterlayer = 0, iCountSwap = 1;
                    bool bSwap = false;
                    while (!maxHeightReached && !maxWeightReached)
                    {
                        bool bInterlayer = (0 == iCountInterlayer) && ((noLayer != 0) || _constraintSet.HasFirstInterlayer);
                        // actually insert new layer
                        sol.AddLayer(bSwap, bInterlayer);
                        // increment number of layers
                        noLayer++;
                        noInterlayer += (bInterlayer ? 1 : 0);
                        // update iCountInterlayer && iCountSwap
                        ++iCountInterlayer;
                        if (iCountInterlayer >= _constraintSet.InterlayerPeriod)
                        {
                            iCountInterlayer = 0;
                        }
                        ++iCountSwap;
                        if (iCountSwap > _constraintSet.LayerSwapPeriod)
                        {
                            iCountSwap = 1; bSwap = !bSwap;
                        }
                        // update maxHeightReached & maxWeightReached
                        maxHeightReached = _constraintSet.MaximumPalletHeight.Activated &&
                                           (_palletProperties.Height
                                            + (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerThickness
                                            + (noLayer + 1) * layer.BoxHeight) > _constraintSet.MaximumPalletHeight.Value;
                        maxWeightReached = _constraintSet.MaximumPalletWeight.Activated &&
                                           (_palletProperties.Weight
                                            + (noInterlayer + (iCountInterlayer == 0 ? 1 : 0)) * interlayerWeight
                                            + (noLayer + 1) * boxLayer.Count * _packProperties.Weight > _constraintSet.MaximumPalletWeight.Value);
                    }

                    if (sol.PackCount > 0)
                    {
                        solutions.Add(sol);
                    }
                } // axis
            }     // pattern
            solutions.Sort();
            return(solutions);
        }
示例#13
0
        /// <summary>
        /// build optimal solutions with 2 layer types
        /// </summary>
        /// <returns></returns>
        private List <CasePalletSolution> GenerateOptimizedCombinationOfLayers()
        {
            List <CasePalletSolution> solutions = new List <CasePalletSolution>();

            // generate best layers
            Layer2D[] bestLayers = new Layer2D[3];
            bestLayers[0] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_X_P);
            bestLayers[1] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Y_P);
            bestLayers[2] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Z_P);

            string[] dir = { "X", "Y", "Z" };
            for (int i = 0; i < 3; ++i)
            {
                HalfAxis.HAxis axisOrtho = (HalfAxis.HAxis)(2 * i + 1);
                HalfAxis.HAxis axis0     = (HalfAxis.HAxis)((2 * (i + 1)) % 6 + 1);
                HalfAxis.HAxis axis1     = (HalfAxis.HAxis)((2 * (i + 2)) % 6 + 1);

                int noLayer0 = 0, noLayer1 = 0;
                if (GetOptimalRequest(
                        _bProperties.Dimension(axis0), bestLayers[i % 3].Count
                        , _bProperties.Dimension(axis1), bestLayers[(i + 1) % 3].Count
                        , out noLayer0, out noLayer1))
                {
                    Layer2D layer0 = bestLayers[i % 3];
                    Layer2D layer1 = bestLayers[(i + 1) % 3];

                    // sol0
                    CasePalletSolution sol0            = new CasePalletSolution(null, string.Format("combination_{0}{1}", dir[i % 3], dir[(i % 3) + 1]), false);
                    double             zLayer          = _palletProperties.Height;
                    double             cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;

                    for (int j = 0; j < noLayer0; ++j)
                    {
                        Layer3DBox layer = sol0.CreateNewLayer(zLayer, 0);
                        foreach (LayerPosition layerPos in layer0)
                        {
                            LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                            BoxPosition   boxPos       = new BoxPosition(
                                layerPosTemp.Position
                                - 0.5 * _constraintSet.OverhangX * Vector3D.XAxis
                                - 0.5 * _constraintSet.OverhangY * Vector3D.YAxis
                                + zLayer * Vector3D.ZAxis
                                , layerPosTemp.LengthAxis
                                , layerPosTemp.WidthAxis
                                );
                            layer.Add(boxPos);
                        }
                        zLayer += layer0.BoxHeight;
                    }
                    for (int j = 0; j < noLayer1; ++j)
                    {
                        Layer3DBox layer = sol0.CreateNewLayer(zLayer, 0);
                        foreach (LayerPosition layerPos in layer1)
                        {
                            LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                            BoxPosition   boxPos       = new BoxPosition(
                                layerPosTemp.Position
                                - (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
                                - (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
                                + zLayer * Vector3D.ZAxis
                                , layerPosTemp.LengthAxis
                                , layerPosTemp.WidthAxis
                                );
                            layer.Add(boxPos);
                        }
                        zLayer += layer1.BoxHeight;
                    }
                    solutions.Add(sol0);

                    // sol1
                    CasePalletSolution sol1 = new CasePalletSolution(null, string.Format("combination_{0}{1}", dir[i % 3], dir[(i % 3) + 1]), false);
                    zLayer = _palletProperties.Height;

                    for (int j = 0; j < noLayer0; ++j)
                    {
                        Layer3DBox layer = sol1.CreateNewLayer(zLayer, 0);
                        foreach (LayerPosition layerPos in layer1)
                        {
                            LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                            BoxPosition   boxPos       = new BoxPosition(
                                layerPosTemp.Position
                                - (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
                                - (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
                                + zLayer * Vector3D.ZAxis
                                , layerPosTemp.LengthAxis
                                , layerPosTemp.WidthAxis
                                );
                            layer.Add(boxPos);
                        }
                        zLayer += layer1.BoxHeight;
                    }
                    for (int j = 0; j < noLayer1; ++j)
                    {
                        Layer3DBox layer = sol1.CreateNewLayer(zLayer, 0);
                        foreach (LayerPosition layerPos in layer0)
                        {
                            LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                            BoxPosition   boxPos       = new BoxPosition(
                                layerPosTemp.Position
                                - (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
                                - (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
                                + zLayer * Vector3D.ZAxis
                                , layerPosTemp.LengthAxis
                                , layerPosTemp.WidthAxis
                                );
                            layer.Add(boxPos);
                        }
                        zLayer += layer0.BoxHeight;
                    }
                    solutions.Add(sol1);
                }
            }
            return(solutions);
        }
示例#14
0
        private List <CasePalletSolution> GenerateSolutions()
        {
            // generate best layers
            Layer2D[] bestLayers = new Layer2D[3];
            if (_constraintSet.AllowLastLayerOrientationChange)
            {
                bestLayers[0] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_X_P);
                bestLayers[1] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Y_P);
                bestLayers[2] = GenerateBestLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, HalfAxis.HAxis.AXIS_Z_P);
            }

            List <CasePalletSolution> solutions = new List <CasePalletSolution>();

            // loop through all patterns
            foreach (LayerPatternBox pattern in LayerPatternBox.All)
            {
                if (!_constraintSet.AllowPattern(pattern.Name))
                {
                    continue;
                }
                // loop through all swap positions (if layer can be swapped)
                for (int swapPos = 0; swapPos < (pattern.CanBeSwapped ? 2 : 1); ++swapPos)
                {
                    // loop through all vertical axes
                    for (int i = 0; i < 3; ++i)
                    {
                        HalfAxis.HAxis axisOrtho1 = (HalfAxis.HAxis)(2 * i);
                        HalfAxis.HAxis axisOrtho2 = (HalfAxis.HAxis)(2 * i + 1);

                        if (!_constraintSet.AllowOrthoAxis(axisOrtho2))
                        {
                            continue;
                        }
                        try
                        {
                            // build 2 layers (pallet length/width)
                            Layer2D layer1 = BuildLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho1, swapPos == 1, false);
                            Layer2D layer1_inv = BuildLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho1, swapPos == 1, true);
                            Layer2D layer2 = BuildLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho2, swapPos == 1, false);
                            Layer2D layer2_inv = BuildLayer(_bProperties, _palletProperties, _cornerProperties, _constraintSet, axisOrtho2, swapPos == 1, true);
                            double  actualLength1 = 0.0, actualLength2 = 0.0, actualWidth1 = 0.0, actualWidth2 = 0.0;
                            bool    bResult1 = pattern.GetLayerDimensionsChecked(layer1, out actualLength1, out actualWidth1);
                            bool    bResult2 = pattern.GetLayerDimensionsChecked(layer2, out actualLength2, out actualWidth2);

                            string layerAlignment = string.Empty;
                            for (int j = 0; j < 6; ++j)
                            {
                                Layer2D layer1T = null, layer2T = null;
                                if (0 == j && _constraintSet.AllowAlignedLayers && bResult1)
                                {
                                    pattern.GenerateLayer(layer1, actualLength1, actualWidth1);
                                    layer1T        = layer1; layer2T = layer1;
                                    layerAlignment = "aligned-1";
                                }
                                else if (1 == j && _constraintSet.AllowAlignedLayers && bResult2)
                                {
                                    pattern.GenerateLayer(layer2, actualLength2, actualWidth2);
                                    layer1T        = layer2; layer2T = layer2;
                                    layerAlignment = "aligned-2";
                                }
                                else if (2 == j && _constraintSet.AllowAlternateLayers && bResult1 && bResult2)
                                {
                                    pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
                                    pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
                                    layer1T        = layer1; layer2T = layer2;
                                    layerAlignment = "alternate-12";
                                }
                                else if (3 == j && _constraintSet.AllowAlternateLayers && bResult1 && bResult2)
                                {
                                    pattern.GenerateLayer(layer1, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
                                    pattern.GenerateLayer(layer2, Math.Max(actualLength1, actualLength2), Math.Max(actualWidth1, actualWidth2));
                                    layer1T        = layer2; layer2T = layer1;
                                    layerAlignment = "alternate-21";
                                }
                                else if (4 == j && _constraintSet.AllowAlternateLayers && pattern.CanBeInverted && bResult1)
                                {
                                    pattern.GenerateLayer(layer1, actualLength1, actualWidth1);
                                    pattern.GenerateLayer(layer1_inv, actualLength1, actualWidth1);
                                    layer1T        = layer1; layer2T = layer1_inv;
                                    layerAlignment = "inv-1";
                                }
                                else if (5 == j && _constraintSet.AllowAlternateLayers && pattern.CanBeInverted && bResult2)
                                {
                                    pattern.GenerateLayer(layer2, actualLength2, actualWidth2);
                                    pattern.GenerateLayer(layer2_inv, actualLength2, actualWidth2);
                                    layer1T        = layer2; layer2T = layer2_inv;
                                    layerAlignment = "inv-2";
                                }

                                if (null == layer1T || null == layer2T || 0 == layer1T.Count || 0 == layer2T.Count)
                                {
                                    continue;
                                }

                                // counters
                                string axisName = string.Empty;
                                switch (i)
                                {
                                case 0: axisName = "X"; break;

                                case 1: axisName = "Y"; break;

                                case 2: axisName = "Z"; break;

                                default: break;
                                }
                                string title = string.Format("{0}-{1}-{2}{3}", pattern.Name, axisName, layerAlignment, swapPos == 1 ? "-swapped" : "");

                                CasePalletSolution sol = new CasePalletSolution(null, title, layer1T == layer2T);
                                int    iLayerIndex     = 0;
                                double zLayer          = _palletProperties.Height;
                                double capThickness    = null != _capProperties ? _capProperties.Thickness : 0;
                                int    iInterlayer     = 0;
                                int    iCount          = 0;

                                bool maxWeightReached = _constraintSet.UseMaximumPalletWeight && (_palletProperties.Weight + _bProperties.Weight > _constraintSet.MaximumPalletWeight);
                                bool maxHeightReached = _constraintSet.UseMaximumHeight && (zLayer + capThickness + _bProperties.Dimension(axisOrtho1) > _constraintSet.MaximumHeight);
                                bool maxNumberReached = false;

                                // insert anti-slip interlayer id there is one
                                if (_constraintSet.HasInterlayerAntiSlip)
                                {
                                    InterlayerPos interlayerPos = sol.CreateNewInterlayer(zLayer, 1);
                                    zLayer += _interlayerPropertiesAntiSlip.Thickness;
                                }

                                while (!maxWeightReached && !maxHeightReached && !maxNumberReached)
                                {
                                    if (_constraintSet.HasInterlayer)
                                    {
                                        if (iInterlayer >= _constraintSet.InterlayerPeriod)
                                        {
                                            InterlayerPos interlayerPos = sol.CreateNewInterlayer(zLayer, 0);
                                            zLayer     += _interlayerProperties.Thickness;
                                            iInterlayer = 0;
                                        }
                                        ++iInterlayer;
                                    }

                                    // select current layer type
                                    double     cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;
                                    Layer2D    currentLayer    = iLayerIndex % 2 == 0 ? layer1T : layer2T;
                                    Layer3DBox layer           = sol.CreateNewLayer(zLayer, 0);
                                    layer.MaximumSpace = currentLayer.MaximumSpace;

                                    foreach (LayerPosition layerPos in currentLayer)
                                    {
                                        ++iCount;
                                        maxWeightReached = _constraintSet.UseMaximumPalletWeight && ((iCount * _bProperties.Weight + _palletProperties.Weight) > _constraintSet.MaximumPalletWeight);
                                        maxNumberReached = _constraintSet.UseMaximumNumberOfCases && (iCount > _constraintSet.MaximumNumberOfItems);
                                        if (!maxWeightReached && !maxNumberReached)
                                        {
                                            LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                                            BoxPosition   boxPos       = new BoxPosition(
                                                layerPosTemp.Position
                                                - (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
                                                - (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
                                                + zLayer * Vector3D.ZAxis
                                                , layerPosTemp.LengthAxis
                                                , layerPosTemp.WidthAxis
                                                );
                                            layer.Add(boxPos);
                                        }
                                        else
                                        {
                                            break;
                                        }
                                    }

                                    // increment layer index
                                    ++iLayerIndex;
                                    zLayer += currentLayer.BoxHeight;

                                    // check height
                                    maxHeightReached = _constraintSet.UseMaximumHeight && (zLayer + _bProperties.Dimension(axisOrtho1) > _constraintSet.MaximumHeight);
                                    // check number
                                    maxNumberReached = _constraintSet.UseMaximumNumberOfCases && (iCount + 1 > _constraintSet.MaximumNumberOfItems);
                                    // check weight
                                    maxWeightReached = _constraintSet.UseMaximumPalletWeight && (((iCount + 1) * _bProperties.Weight + _palletProperties.Weight) > _constraintSet.MaximumPalletWeight);
                                }

                                if (maxHeightReached && _constraintSet.AllowLastLayerOrientationChange)
                                {
                                    // remaining height
                                    double remainingHeight = _constraintSet.MaximumHeight - zLayer;
                                    // test to complete with best layer
                                    Layer2D bestLayer = null; int ibestLayerCount = 0;
                                    for (int iLayerDir = 0; iLayerDir < 3; ++iLayerDir)
                                    {
                                        // another direction than the current direction
                                        if (iLayerDir == i)
                                        {
                                            continue;
                                        }

                                        Layer2D layer = bestLayers[iLayerDir];
                                        if (null == layer)
                                        {
                                            continue;
                                        }

                                        int layerCount = Convert.ToInt32(Math.Floor(remainingHeight / layer.BoxHeight));
                                        if (layerCount < 1)
                                        {
                                            continue;
                                        }

                                        if (null == bestLayer || ibestLayerCount * bestLayer.Count < layerCount * layer.Count)
                                        {
                                            bestLayer       = layer;
                                            ibestLayerCount = layerCount;
                                        }
                                    }

                                    if (null != bestLayer)
                                    {
                                        double cornerThickness = null != _cornerProperties ? _cornerProperties.Thickness : 0.0;

                                        for (int iAddLayer = 0; iAddLayer < ibestLayerCount; ++iAddLayer)
                                        {
                                            Layer3DBox layer = sol.CreateNewLayer(zLayer, 0);

                                            foreach (LayerPosition layerPos in bestLayer)
                                            {
                                                LayerPosition layerPosTemp = AdjustLayerPosition(layerPos);
                                                BoxPosition   boxPos       = new BoxPosition(
                                                    layerPosTemp.Position
                                                    - (0.5 * _constraintSet.OverhangX - cornerThickness) * Vector3D.XAxis
                                                    - (0.5 * _constraintSet.OverhangY - cornerThickness) * Vector3D.YAxis
                                                    + zLayer * Vector3D.ZAxis
                                                    , layerPosTemp.LengthAxis
                                                    , layerPosTemp.WidthAxis
                                                    );
                                                layer.Add(boxPos);
                                            }
                                            zLayer += bestLayer.BoxHeight;
                                        }
                                    }
                                }

                                // set maximum criterion
                                if (maxNumberReached)
                                {
                                    sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXNUMBERREACHED;
                                }
                                else if (maxWeightReached)
                                {
                                    sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXWEIGHTREACHED;
                                }
                                else if (maxHeightReached)
                                {
                                    sol.LimitReached = CasePalletSolution.Limit.LIMIT_MAXHEIGHTREACHED;
                                }

                                // insert solution
                                if (sol.Count > 0)
                                {
                                    solutions.Add(sol);
                                }
                            }
                        }
                        catch (NotImplementedException)
                        {
                            _log.Info(string.Format("Pattern {0} is not implemented", pattern.Name));
                        }
                        catch (Exception ex)
                        {
                            _log.Error(string.Format("Exception caught: {0}", ex.Message));
                        }
                    } // loop through all vertical axes
                }     // loop through all swap positions (if layer can be swapped)
            }         // loop through all patterns
            // sort solutions
            solutions.Sort();

            if (ConstraintSet.AllowTwoLayerOrientations && solutions.Count > 0)
            {
                // get best solution count
                int iBestSolutionCount = solutions[0].CaseCount;
                // if solutions exceeds
                List <CasePalletSolution> multiOrientSolution = GenerateOptimizedCombinationOfLayers();
                foreach (CasePalletSolution sol in multiOrientSolution)
                {
                    if (sol.CaseCount > iBestSolutionCount)
                    {
                        solutions.Add(sol);
                    }
                }
                solutions.Sort();
            }

            // remove unwanted solutions
            if (_constraintSet.UseNumberOfSolutionsKept && solutions.Count > _constraintSet.NumberOfSolutionsKept)
            {
                // get minimum box count
                int minBoxCount = solutions[_constraintSet.NumberOfSolutionsKept].CaseCount;
                // remove any solution with less boxes than minBoxCount
                while (solutions[solutions.Count - 1].CaseCount < minBoxCount)
                {
                    solutions.RemoveAt(solutions.Count - 1);
                }
            }
            return(solutions);
        }