public static string ExportLayerImage(IRaster pRaster, string[] bbox, string[] size,string outputUrl,string serveroutDir)
        {
            //判断栅格文件是否已经存在，存在删除，原因是如果存在，不删除的话，保存图片出错

            //创建rasterlayer
            IRasterLayer pRasterLayer = new RasterLayerClass();

            //获取mapServer中所有的图层
            IMap pMap = new MapClass();
            pRasterLayer.CreateFromRaster(pRaster);
            pMap.AddLayer(pRasterLayer as ILayer);            //
            //
            Size pSize = new Size();
            pSize.Width = Convert.ToInt32(size[0]);
            pSize.Height = Convert.ToInt32(size[1]);

            //
            IEnvelope pEnvelop = new EnvelopeClass();
            pEnvelop.PutCoords(Convert.ToDouble(bbox[0]), Convert.ToDouble(bbox[1]), Convert.ToDouble(bbox[2]), Convert.ToDouble(bbox[3]));
            Image pImage = SaveCurrentToImage(pMap, pSize, pEnvelop);
            string imageName = System.DateTime.Now.ToString().Replace("/", "").Replace(":", "").Replace(" ", "") + ".png";
            //outputUrl="http://localhost:6080/arcgis/rest/directories/arcgisoutput/imageserver/miyunspot_ImageServer/"

            // serveroutDir="D:\arcgisserver\directories\arcgisoutput\imageserver\miyunspot_ImageServer";
            string url = outputUrl + imageName;
            string path = System.IO.Path.Combine(serveroutDir, imageName);
            pImage.Save(path);
            return url;
        }

 /// <summary>
 /// Expands the first envelope to include the second.
 /// </summary>
 /// <param name="input1">The first input raster to union the envelope for.</param>
 /// <param name="input2">The second input raster to union the envelope for.</param>
 /// <returns>The expanded envelope.</returns>
 private static Extent UnionEnvelope(IRaster input1, IRaster input2)
 {
     Extent e1 = input1.Bounds.Extent;
     Extent e2 = input2.Bounds.Extent;
     e1.ExpandToInclude(e2);
     return e1;
 }

        /// <summary>
        /// This function creates the HDR of Gridfile
        /// </summary>
        /// <param name="inExtents"> Extension of grid</param>
        /// <param name="cellSize">Size cell of the grid</param>
        /// <param name="projection">Projection (the same that shapefile)</param>
        /// <param name="noDataValue">No value definition</param>
        /// <param name="outGridPath">Path of the output</param>
        /// <param name="outGrid">Name of the output grid</param>
        public static void CreateGridFromExtents(
            Extent inExtents, double cellSize, ProjectionInfo projection, double noDataValue, string outGridPath, out IRaster outGrid)
        {

            double height = Math.Abs(inExtents.MaxY - inExtents.MinY);
            double width = Math.Abs(inExtents.MaxX - inExtents.MinX);
            int numberRows = Convert.ToInt32(Math.Ceiling(height / cellSize)) + 1;
            int numberCols = Convert.ToInt32(Math.Ceiling(width / cellSize)) + 1;

            // outGrid = Raster.CreateRaster(@outGridPath, null, demRaster.NumColumns, demRaster.NumRows, 1, demRaster.DataType, rasterOptions);
            outGrid = Raster.CreateRaster(@outGridPath, null, numberCols, numberRows, 1, typeof(float), new String[] { });
            outGrid.NoDataValue = noDataValue;
            outGrid.Projection = projection;
            outGrid.CellHeight = cellSize;
            outGrid.CellWidth = cellSize;
            //if (inExtents.MinX < 0)
            //    outGrid.Xllcenter = inExtents.MinX + (cellSize / 2.0);
            //else
            outGrid.Xllcenter = inExtents.MinX;// -(cellSize / 2.0);

            //if (inExtents.MinY < 0)
            //    outGrid.Yllcenter = inExtents.MinY + (cellSize / 2.0);
            //else
            outGrid.Yllcenter = inExtents.MinY;// -(cellSize / 2.0);
        }

        public void export(string name,IRaster raster)
        {
            //GATGrid grid = new GATGrid();
            //grid.DataFileName = name;
            //grid.WriteChangesToFile = true;
            //grid.West = raster.Bounds.Left();
            //grid.North = raster.Bounds.Top();
            //grid.South = raster.Bounds.Bottom();
            //grid.East = raster.Bounds.Right();
            //grid.GridResolution = raster.CellHeight;
            //grid.DataType = "float";
            //grid.DataScale = "continuous";
            //grid.InitializeGrid(raster.NumColumns, raster.NumRows);
            //grid.Maximum = (float)raster.Maximum;
            //grid.Minimum = (float)raster.Minimum;

            //grid.SetBlockData();
            //grid.HeaderFileName = name;
            //for (int row = 0; row < raster.NumRows; row++)
            //    for (int col = 0; col < raster.NumColumns; col++)
            //    {
            //        float v = (float)raster.Value[row, col];
            //        grid[col, row] = v;

            //    }


            //grid.WriteHeaderFile();
            //grid.WriteDataInMemoryToFile();
            //grid.ReleaseMemoryResources();
        }

        public static string ApplyMLClassifyFunction(IImageServer imageServer, IRaster pRaster, string signaturfile)
        {
            //Define a  function.
            IRasterFunction hillshadeFunction = new MLClassifyFunctionClass();

            IRasterFunctionArguments functionArgument = new MLClassifyFunctionArgumentsClass();
            functionArgument.PutValue("Raster", pRaster);
            functionArgument.PutValue("SignatureFile", signaturfile);

            //Attach the function to a rendering rule.
            IRenderingRule renderRule = new RenderingRuleClass();
            renderRule.Function = hillshadeFunction;
            renderRule.Arguments = functionArgument;
            renderRule.VariableName = "DEM";

            //Define the image description.
            IGeoImageDescription geoImageDesc = new GeoImageDescriptionClass();
            geoImageDesc.Compression = "LZ77";
            geoImageDesc.Extent = imageServer.ServiceInfo.Extent;
            geoImageDesc.Width = 800;
            geoImageDesc.Height = 600;
            geoImageDesc.Interpolation = rstResamplingTypes.RSP_BilinearInterpolation;
            IGeoImageDescription2 geoImageDesc2 = (IGeoImageDescription2)geoImageDesc;

            geoImageDesc2.RenderingRule = renderRule;

            //Define the return image type.
            IImageType imgType = new ImageTypeClass();
            imgType.Format = esriImageFormat.esriImagePNG;
            imgType.ReturnType = esriImageReturnType.esriImageReturnURL;

            //Export the image.
            IImageResult imgResult = imageServer.ExportImage(geoImageDesc2, imgType);
            return imgResult.URL;
        }

 public QueryRasterLayer(IMapLayerInfo mapLayerInfo, IRaster raster)
 {
     this.Name = mapLayerInfo.Name;
     this.ID = mapLayerInfo.ID;
     this.Extent = mapLayerInfo.Extent;
     this.Raster = raster;
 }

        public static void buildStats(IRaster inputRaster, string functionModelPath)
        {
            IRasterProps rsProps = (IRasterProps)inputRaster;
            double[] noDataArr = (double[])rsProps.NoDataValue;
            IRasterBandCollection rsBc = (IRasterBandCollection)inputRaster;
            string statPath = functionModelPath.Replace(".fds",".sta");
            using (System.IO.StreamWriter sw = new System.IO.StreamWriter(statPath))
            {
                for (int i = 0; i < rsBc.Count; i++)
                {
                    double ndVl = noDataArr[i];
                    IRasterBand rsBand = rsBc.Item(i);
                    IRasterStatistics rsStats = rsBand.Statistics;
                    double max = checkStatNumber(rsStats.Maximum,ndVl);
                    double min = checkStatNumber(rsStats.Minimum,ndVl);
                    double mean = checkStatNumber(rsStats.Mean,ndVl);
                    double std = checkStatNumber(rsStats.StandardDeviation,ndVl);
                    string bndStatsLn = max.ToString() + ":" + mean.ToString() + ":" + min.ToString() + ":" + std.ToString()+ ":"+rsStats.SkipFactorX.ToString()+":"+rsStats.SkipFactorY;
                    List<string> igVlLst = new List<string>();
                    if (!(rsStats.IgnoredValues == null))
                    {
                        System.Array ignoredVl = (System.Array)rsStats.IgnoredValues;

                        for (int j = 0; j < ignoredVl.Length; j++)
                        {
                            string vl = checkStatNumber((double)ignoredVl.GetValue(j),ndVl).ToString();
                            igVlLst.Add(vl);
                        }
                    }
                    bndStatsLn = bndStatsLn + ":" + String.Join(",", igVlLst.ToArray());
                    sw.WriteLine(bndStatsLn);
                }
                sw.Close();
            }
        }

        /// <summary>
        /// This will resample the cells.
        /// If the cell size is zero, this will default to the shorter of the width or height
        /// divided by 256.
        /// </summary>
        /// <param name="input1">Input Raster.</param>
        /// <param name="cellHeight">New Cell Height or Null.</param>
        /// <param name="cellWidth">New Cell Width or Null.</param>
        /// <param name="destFilename">Output Raster Name.</param>
        /// <param name="progressHandler">An interface for handling the progress messages.</param>
        /// <returns>Resampled raster.</returns>
        public static IRaster ReSample(IRaster input1,double cellHeight, double cellWidth, string destFilename, IProgressHandler progressHandler)
        {
            if (input1 == null)
                return null;

            IEnvelope envelope = input1.Bounds.Envelope;

            if (cellHeight == 0)
            {
                cellHeight = envelope.Height / 256;
            }
            if(cellWidth==0)
            {
                cellWidth = envelope.Width / 256;
            }
                
            //Calculate new number of columns and rows
            int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / cellWidth));
            int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / cellHeight));


            IRaster output = Raster.Create(destFilename, "", noOfCol, noOfRow, 1, input1.DataType, new[] { "" });
            RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope);
            output.Bounds = bound;

            output.NoDataValue = input1.NoDataValue;

            RcIndex index1;
            int max = (output.Bounds.NumRows);
            ProgressMeter pm = new ProgressMeter(progressHandler, "ReSize Cells", max);
            //Loop throug every cell for new value

            for (int i = 0; i < max; i++)
            {
                for (int j = 0; j < output.Bounds.NumColumns; j++)
                {
                    //Projet the cell position to Map
                    Coordinate cellCenter = output.CellToProj(i, j);
                    index1 = input1.ProjToCell(cellCenter);

                    double val;
                    if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 && index1.Column > -1)
                    {
                        if (input1.Value[index1.Row, index1.Column] == input1.NoDataValue)
                            val = output.NoDataValue;
                        else
                            val = input1.Value[index1.Row, index1.Column];
                    }
                    else
                        val = output.NoDataValue;

                    output.Value[i, j] = val;
                }
                pm.CurrentPercent = i;
            }

            output.Save();
            pm.Reset();
            return output;
        }

 public void addRasterToComboBox(string rstName, IRaster rst)
 {
     if (!cmbInRaster1.Items.Contains(rstName))
     {
         cmbInRaster1.Items.Add(rstName);
         rstDic[rstName] = rst;
     }
 }

 public void addRasterToComboBox(string rstName, IRaster rst)
 {
     if (!cmbRaster.Items.Contains(rstName))
     {
         cmbRaster.Items.Add(rstName);
         rstDic.Add(rstName, rst);
     }
 }

 public dataPrepAdjustAccuracyAssessment(IFeatureClass ProjectArea, IRaster Map, string originalAccuracyAssessmentModel, string adjustedAccuracyAssessmentModel)
 {
     projectArea = ProjectArea;
     rstMap = Map;
     oModel = originalAccuracyAssessmentModel;
     aModel = adjustedAccuracyAssessmentModel;
     rsUtil = new rasterUtil();
 }

        /// <summary>
        /// Finds the first raster column corresponding to the left-most edge of the poly
        /// </summary>
        /// <param name="polygon">the polygon</param>
        /// <param name="inputRaster">the input raster</param>
        /// <returns>The raster column corresponding to the left-most edge of the poly 
        /// (if raster starts before left edge of the poly)
        /// or the first raster column (if raster starts after left edge of the poly)</returns>
        /// <remarks>If the poly sits to the left of the raster then the first column of the raster is returned.</remarks>
        private static int GetStartColumn(IFeature polygon, IRaster inputRaster)
        {
            double rasterMinXCenter = inputRaster.Xllcenter;

            // Does the poly sit to the left of the raster or does the raster start before the left edge of the poly
            if (polygon.Envelope.Minimum.X < rasterMinXCenter)
                return 0;
            else
                return ColumnIndexToProcess(polygon.Envelope.Minimum.X, rasterMinXCenter, inputRaster.CellWidth);
        }

        /// <summary>
        /// Finds the last raster column corresponding to the right-most edge of the poly
        /// </summary>
        /// <param name="polygon">the polygon</param>
        /// <param name="inputRaster">the input raster</param>
        /// <returns>The raster column corresponding to the right-most edge of the poly 
        /// (if raster ends after the right edge of the poly)
        /// or the last raster column (if raster ends before right edge of the poly)</returns>
        private static int GetEndColumn(IFeature polygon, IRaster inputRaster)
        {
            double rasterMaxXCenter = inputRaster.Extent.MaxX - inputRaster.CellWidth / 2;

            // Does the poly sit to the right of the raster or does the raster end after the right edge of the poly
            if (polygon.Envelope.Right() > rasterMaxXCenter)
                return inputRaster.NumColumns - 1;
            else
                return ColumnIndexToProcess(polygon.Envelope.Right(), rasterMaxXCenter, inputRaster.CellWidth);
        }

        public IRasterRenderer CreateDefaultRasterRenderer(IRaster raster)
        {

            //Get raster dataset
            IRasterBandCollection rasterBandCollection = (IRasterBandCollection)raster;
            IRasterBand rasterBand = rasterBandCollection.Item(0);
            IRasterDataset rasterDataset = (IRasterDataset)rasterBand;

            //Check for TIFF format
            string format_Renamed = rasterDataset.Format;
            if (format_Renamed.Substring(0, 4) != "TIFF")
            {
                return null;
            }

            //check for bit depth
            IRasterProps rasterProps = (IRasterProps)rasterBand;
            if (rasterProps.PixelType != rstPixelType.PT_U1)
            {
                return null;
            }

            //create renderer for 1 bit raster
            //Create a unique value renderer and associate it with raster
            IRasterUniqueValueRenderer rasterUniqueValueRenderer = new RasterUniqueValueRendererClass();
            IRasterRenderer rasterRenderer = (IRasterRenderer)rasterUniqueValueRenderer;
            rasterRenderer.Raster = raster;
            rasterRenderer.Update();

            //Define the renderer
            rasterUniqueValueRenderer.HeadingCount = 1;
            rasterUniqueValueRenderer.set_Heading(0, "");
            rasterUniqueValueRenderer.set_ClassCount(0, 2);
            rasterUniqueValueRenderer.Field = "VALUE";
            rasterUniqueValueRenderer.AddValue(0, 0, 0);
            rasterUniqueValueRenderer.AddValue(0, 1, 1);
            rasterUniqueValueRenderer.set_Label(0, 0, "0");
            rasterUniqueValueRenderer.set_Label(0, 1, "1");

            // Define symbology for rendering value 0
            IColor color1 = (IColor)(CreateRGBColor(200, 50, 0)); //Brown color

            ISimpleFillSymbol simpleFillSymbol1 = new SimpleFillSymbolClass();
            simpleFillSymbol1.Color = color1;
            rasterUniqueValueRenderer.set_Symbol(0, 0, (ISymbol)simpleFillSymbol1);

            IColor color2 = new RgbColorClass();
            color2.NullColor = true;

            ISimpleFillSymbol simpleFillSymbol2 = new SimpleFillSymbolClass();
            simpleFillSymbol2.Color = color2;

            rasterUniqueValueRenderer.set_Symbol(0, 1, (ISymbol)simpleFillSymbol2);
            return rasterRenderer;
        }

        public Dictionary<int, HashSet<Point>> Process(IRaster input)
        {
            _input = input;

            _width = input.NumColumns;
            _height = input.NumRows;
            _board = new int[_width, _height];

            Dictionary<int, HashSet<Point>> patterns = Find(_width, _height);
            return patterns;
        }

 public dataPrepStrata(IRaster VariableRaster, IRaster strataRaster)
 {
     InValueRaster = VariableRaster;
     InStrataRaster = strataRaster;
     VariableFieldNames = new string[((IRasterBandCollection)InValueRaster).Count];
     for (int i = 0; i < VariableFieldNames.Length; i++)
     {
         VariableFieldNames[i] = (i + 1).ToString();
     }
     buildModel();
 }

        public Coordinate GetXYCell(IRaster raster, int col, int row)
        {
            double xmin = raster.Xllcenter;
            double ymin = raster.Yllcenter;
            double cell = raster.CellWidth;
            int numColumns = raster.NumColumns;
            int numRows = raster.NumRows;

            double y = ((numRows - row) * cell) + ymin;
            double x = (col * cell) + xmin;
            return new Coordinate(x, y);
        }

 public dataPrepPrincipleComponents(IRaster raster,string varianceCovariancePath=null)
 {
     inraster = raster;
     IRasterBandCollection bc = (IRasterBandCollection)inraster;
     int bcCnt = bc.Count;
     VariableFieldNames = new string[bcCnt];
     for (int i = 0; i < bcCnt; i++)
     {
         VariableFieldNames[i] = "band_" + (i + 1).ToString();
     }
     varcovpath = varianceCovariancePath;
     buildModel();
 }

 /// <summary>
 /// Export data from a raster layer.
 /// </summary>
 /// <param name="e"></param>
 public void ExportData(IRaster e)
 {
     using (var sfd = new SaveFileDialog
         {
             Filter = DataManager.DefaultDataManager.RasterWriteFilter
         })
     {
         if (ShowDialog(sfd) == DialogResult.OK)
         {
             e.SaveAs(sfd.FileName);        
         }
     }
 }

 public dataPrepCluster(IRaster raster, int numberOfClasses)
 {
     inraster = raster;
     IRasterBandCollection bc = (IRasterBandCollection)inraster;
     int bcCnt = bc.Count;
     VariableFieldNames = new string[bcCnt];
     for (int i = 0; i < bcCnt; i++)
     {
         VariableFieldNames[i] = "band_" + (i + 1).ToString();
     }
     k = numberOfClasses;
     buildModel();
 }