public override byte[] GetTile(Capabilities capabilities, string path, GetTile getTile)
        {
            byte[] buffer = null;
            if (capabilities == null || string.IsNullOrEmpty(path) || getTile == null)
            {
                return(buffer);
            }
            LayerFactory layerFactory = new LayerFactory();

            #region 验证getTile参数
            LayerType layerType = capabilities.GetLayerType(getTile.Layer);
            if (layerType == null)
            {
                return(buffer);
            }
            TileMatrixSet tileMatrixSet = capabilities.GetTileMatrixSet(getTile.TileMatrixSet);
            if (tileMatrixSet == null)
            {
                return(buffer);
            }
            TileMatrix tileMatrix = tileMatrixSet.GetTileMatrix(getTile.TileMatrix);
            if (tileMatrix == null)
            {
                return(buffer);
            }
            BoundingBoxType boundingBoxType = layerType.BoundingBox.FirstOrDefault();
            if (boundingBoxType == null)
            {
                return(buffer);
            }
            bool ret = boundingBoxType.LowerCorner.ToPosition(out double xMin, out double yMin);
            if (!ret)
            {
                return(buffer);
            }
            ret = boundingBoxType.UpperCorner.ToPosition(out double xMax, out double yMax);
            if (!ret)
            {
                return(buffer);
            }
            bool isDegree = tileMatrixSet.GetIsDegreeByLocalDb();
            tileMatrix.GetTileIndex(isDegree, xMin, yMax, out int startCol, out int startRow);
            int matrixWidth  = Convert.ToInt32(tileMatrix.MatrixWidth);
            int matrixHeight = Convert.ToInt32(tileMatrix.MatrixHeight);
            if (getTile.TileCol < startCol || getTile.TileCol >= startCol + matrixWidth || getTile.TileRow < startRow || getTile.TileRow >= startRow + matrixHeight)
            {
                return(buffer);
            }
            if (!layerType.Style.Any(x => x.Identifier.Value == getTile.Style))
            {
                return(buffer);
            }
            if (!layerType.Format.Contains(getTile.Format))
            {
                return(buffer);
            }
            #endregion

            using (var layer = layerFactory.OpenLayer(path))
            {
                if (layer == null)
                {
                    return(buffer);
                }
                tileMatrix.GetTileBoundary(isDegree, getTile.TileRow, getTile.TileCol, out double tileXMin, out double tileYMin, out double tileXMax, out double tileYMax);
                using (Envelope envelope = new Envelope())
                {
                    envelope.MinX = tileXMin;
                    envelope.MinY = tileYMin;
                    envelope.MaxX = tileXMax;
                    envelope.MaxY = tileYMax;
                    int       tileWidth  = Convert.ToInt32(tileMatrix.TileWidth);
                    int       tileHeight = Convert.ToInt32(tileMatrix.TileHeight);
                    Rectangle rectangle  = new Rectangle(0, 0, tileWidth, tileHeight);
                    using (var image = new Image <Rgba32>(rectangle.Width, rectangle.Height))
                    {
                        layer.DrawReagion(image, rectangle, envelope, false, null, null);
                        using (MemoryStream ms = new MemoryStream())
                        {
                            string formatName = getTile.Format.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[1];
                            switch (formatName)
                            {
                            case "png":
                                image.SaveAsPng(ms);
                                break;

                            case "jpeg":
                                image.SaveAsJpeg(ms);
                                break;

                            default:
                                return(buffer);
                            }
                            buffer = ms.ToArray();
                        }
                    }
                }
            }
            return(buffer);
        }