栅格数据裁剪

栅格数据裁剪

  public static void RasterClip(IRasterLayer pRasterLayer, IPolygon clipGeo, string FileName)
        {
            try
            {
                IRaster pRaster = pRasterLayer.Raster;
                IRasterProps pProps = pRaster as IRasterProps;
                object cellSizeProvider = pProps.MeanCellSize().X;
                IGeoDataset pInputDataset = pRaster as IGeoDataset;
                IExtractionOp pExtractionOp = new RasterExtractionOpClass();
                IRasterAnalysisEnvironment pRasterAnaEnvir = pExtractionOp as IRasterAnalysisEnvironment;
                pRasterAnaEnvir.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref cellSizeProvider);
                object extentProvider = clipGeo.Envelope;
                object snapRasterData = Type.Missing;
                pRasterAnaEnvir.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ref extentProvider, ref snapRasterData);
                IGeoDataset pOutputDataset = pExtractionOp.Polygon(pInputDataset, clipGeo as IPolygon, true);
                IRaster clipRaster;  //裁切后得到的IRaster
                if (pOutputDataset is IRasterLayer)
                {
                    IRasterLayer rasterLayer = pOutputDataset as IRasterLayer;
                    clipRaster = rasterLayer.Raster;
                }
                else if (pOutputDataset is IRasterDataset)
                {
                    IRasterDataset rasterDataset = pOutputDataset as IRasterDataset;
                    clipRaster = rasterDataset.CreateDefaultRaster();
                }
                else if (pOutputDataset is IRaster)
                {
                    clipRaster = pOutputDataset as IRaster;
                }
                else
                {
                    return;
                }

                //保存裁切后得到的clipRaster

                //如果直接保存为img影像文件
                IWorkspaceFactory pWKSF = new RasterWorkspaceFactoryClass();
                IWorkspace pWorkspace = pWKSF.OpenFromFile(System.IO.Path.GetDirectoryName(FileName), 0);
                ISaveAs2 pSaveAs = clipRaster as ISaveAs2;
                IRasterStorageDef rasterStorageDef = new RasterStorageDefClass();
                IRasterStorageDef2 rasterStorageDef2 = (IRasterStorageDef2)rasterStorageDef;
                pSaveAs.SaveAsRasterDataset(System.IO.Path.GetFileName(FileName), pWorkspace, "TIFF", rasterStorageDef);
                System.Runtime.InteropServices.Marshal.ReleaseComObject(pSaveAs); pSaveAs = null;
            }
            catch(Exception ex)
            {
               
            }
        }

使用上述方法财经影像，裁剪得到的结果是黑白的，如果又大神看到影像才将结果不是黑白的一定要告诉我问题出在哪里了，否则我诅咒你女朋和你分手。

最后使用了一下裁剪方式：

 public static void ReClipRaster(IRasterLayer rasterlayer,IPolygon polygon,string fileName)
        {
            try
            {
                IRaster raster = rasterlayer.Raster;
                IRasterProps rasterProps = (IRasterProps)raster;
                double cellSizeProvider = rasterProps.MeanCellSize().X;
                //rasterProps.SpatialReference = outSR;
                IEnvelope envelop = new EnvelopeClass();
                envelop.XMin = polygon.Envelope.XMin;
                envelop.YMin = polygon.Envelope.YMin;
                envelop.XMax = polygon.Envelope.XMax + cellSizeProvider;
                envelop.YMax = polygon.Envelope.YMax + cellSizeProvider;
                rasterProps.Extent = envelop;
                IRasterGeometryProc ReSample = new RasterGeometryProcClass();
                ReSample.Resample(rstResamplingTypes.RSP_NearestNeighbor, cellSizeProvider, raster);//重采样
                ISaveAs saveas = (ISaveAs)raster;
                // saveas.SaveAs(fileName, null, "tif");//此处会报错，报错内容为
                saveas.SaveAs(fileName, null, "TIFF");//此处会报错，报错内容为对 COM 组件的调用返回了错误 HRESULT E_FAIL
                if (saveas != null)
                {
                    Marshal.FinalReleaseComObject(saveas);
                    saveas = null;
                }
            }
            catch { }
        }

使用该方法，裁剪成功。

另外在裁剪影像时报错，大概是缺少授权的意思，我在空间属性中修改，没有实现个，最后使用代码的方式是想

分两步，第一步创建一个类。内容如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ESRI.ArcGIS.esriSystem;

using System.Windows.Forms;

namespace EarthView.Desktop.Class
{
    /// <summary>
    /// 定义 AO注册初始化接口
    /// </summary>
    public interface IAOLicenseInitializer
    {
        bool AddExtensions(params ESRI.ArcGIS.esriSystem.esriLicenseExtensionCode[] requestCodes);
        void AOUninitialize();
        bool InitializeApplication(ESRI.ArcGIS.esriSystem.esriLicenseProductCode[] productCodes, ESRI.ArcGIS.esriSystem.esriLicenseExtensionCode[] extensionLics);
        ESRI.ArcGIS.esriSystem.esriLicenseProductCode InitializedProduct { get; }
        bool InitializeLowerProductFirst { get; set; }
        bool IsExtensionCheckedOut(ESRI.ArcGIS.esriSystem.esriLicenseExtensionCode code);
        string LicenseMessage();
        void RemoveExtensions(params ESRI.ArcGIS.esriSystem.esriLicenseExtensionCode[] requestCodes);
        void ShutdownApplication();
    }

    /// <summary>
    /// 工厂类
    /// </summary>
    public sealed class AOLicenseInitializerFactory
    {
        public static IAOLicenseInitializer CreateAOLicenseInitializerClass()
        {
            return new AOLicenseInitializer();
        }

    }

    /// <summary>
    /// AO初始化管理类  internal
    /// </summary>
    internal sealed class AOLicenseInitializer : IAOLicenseInitializer
    {
        private IAoInitialize m_AoInit = new AoInitializeClass();

        #region Private members
        private const string MessageNoLicensesRequested = "Product: No licenses were requested";
        private const string MessageProductAvailable = "Product: {0}: Available";
        private const string MessageProductNotLicensed = "Product: {0}: Not Licensed";
        private const string MessageExtensionAvailable = " Extension: {0}: Available";
        private const string MessageExtensionNotLicensed = " Extension: {0}: Not Licensed";
        private const string MessageExtensionFailed = " Extension: {0}: Failed";
        private const string MessageExtensionUnavailable = " Extension: {0}: Unavailable";

        private bool m_hasShutDown = false;
        private bool m_hasInitializeProduct = false;

        private List<int> m_requestedProducts;
        //扩展功能集合
        private List<esriLicenseExtensionCode> m_requestedExtensions;
        //ArcGIS产品代码及状态
        private Dictionary<esriLicenseProductCode, esriLicenseStatus> m_productStatus = new Dictionary<esriLicenseProductCode, esriLicenseStatus>();
        //找展功能及状态
        private Dictionary<esriLicenseExtensionCode, esriLicenseStatus> m_extensionStatus = new Dictionary<esriLicenseExtensionCode, esriLicenseStatus>();
        //产品检查顺序
        private bool m_productCheckOrdering = true; //default from low to high
        #endregion

        //初始化应用程序
        public bool InitializeApplication(esriLicenseProductCode[] productCodes, esriLicenseExtensionCode[] extensionLics)
        {
            //Cache product codes by enum int so can be sorted without custom sorter
            //添加产品代码
            m_requestedProducts = new List<int>();
            foreach (esriLicenseProductCode code in productCodes)
            {
                int requestCodeNum = Convert.ToInt32(code);
                if (!m_requestedProducts.Contains(requestCodeNum))
                {
                    m_requestedProducts.Add(requestCodeNum);
                }
            }
            //添加扩展功能
            this.AddExtensions(extensionLics);
            return this.Initialize();
        }

        /// <summary>
        /// A summary of the status of product and extensions initialization.
        /// </summary>
        public string LicenseMessage()
        {
            string prodStatus = string.Empty;
            if (m_productStatus == null || m_productStatus.Count == 0)
            {
                prodStatus = MessageNoLicensesRequested + Environment.NewLine;
            }
            else if (m_productStatus.ContainsValue(esriLicenseStatus.esriLicenseAlreadyInitialized)
                || m_productStatus.ContainsValue(esriLicenseStatus.esriLicenseCheckedOut))
            {
                prodStatus = ReportInformation(m_AoInit as ILicenseInformation,
                    m_AoInit.InitializedProduct(),
                    esriLicenseStatus.esriLicenseCheckedOut) + Environment.NewLine;
            }
            else
            {
                //Failed...
                foreach (KeyValuePair<esriLicenseProductCode, esriLicenseStatus> item in m_productStatus)
                {
                    prodStatus += ReportInformation(m_AoInit as ILicenseInformation,
                        item.Key, item.Value) + Environment.NewLine;
                }
            }

            string extStatus = string.Empty;
            foreach (KeyValuePair<esriLicenseExtensionCode, esriLicenseStatus> item in m_extensionStatus)
            {
                string info = ReportInformation(m_AoInit as ILicenseInformation, item.Key, item.Value);
                if (!string.IsNullOrEmpty(info))
                    extStatus += info + Environment.NewLine;
            }

            string status = prodStatus + extStatus;
            return status.Trim();
        }

        /// <summary>
        /// Shuts down AoInitialize object and check back in extensions to ensure
        /// any ESRI libraries that have been used are unloaded in the correct order.
        /// </summary>
        /// <remarks>Once Shutdown has been called, you cannot re-initialize the product license
        /// and should not make any ArcObjects call.</remarks>
        public void ShutdownApplication()
        {
            if (m_hasShutDown)
            {
                return;
            }

            //Check back in extensions
            foreach (KeyValuePair<esriLicenseExtensionCode, esriLicenseStatus> item in m_extensionStatus)
            {
                if (item.Value == esriLicenseStatus.esriLicenseCheckedOut)
                {
                    m_AoInit.CheckInExtension(item.Key);
                }
            }

            m_requestedProducts.Clear();
            m_requestedExtensions.Clear();
            m_extensionStatus.Clear();
            m_productStatus.Clear();
            m_AoInit.Shutdown();
            m_hasShutDown = true;
            //m_hasInitializeProduct = false;
        }

        /// <summary>
        /// 释放COM对象并关闭AoInitialize对象
        /// </summary>
        public void AOUninitialize()
        {
            try
            {
                // 释放COM对象并关闭AoInitialize对象
                ESRI.ArcGIS.ADF.COMSupport.AOUninitialize.Shutdown();
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }

        /// <summary>
        /// Indicates if the extension is currently checked out.
        /// </summary>
        public bool IsExtensionCheckedOut(esriLicenseExtensionCode code)
        {
            return m_AoInit.IsExtensionCheckedOut(code);
        }

        /// <summary>
        /// Set the extension(s) to be checked out for your ArcObjects code. 
        /// </summary>
        public bool AddExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_requestedExtensions == null)
            {
                m_requestedExtensions = new List<esriLicenseExtensionCode>();
            }
            foreach (esriLicenseExtensionCode code in requestCodes)
            {
                if (!m_requestedExtensions.Contains(code))
                {
                    m_requestedExtensions.Add(code);
                }
            }

            if (m_hasInitializeProduct)
            {
                return CheckOutLicenses(this.InitializedProduct);
            }

            return false;
        }

        /// <summary>
        /// Check in extension(s) when it is no longer needed.
        /// </summary>
        public void RemoveExtensions(params esriLicenseExtensionCode[] requestCodes)
        {
            if (m_extensionStatus == null || m_extensionStatus.Count == 0)
            {
                return;
            }

            foreach (esriLicenseExtensionCode code in requestCodes)
            {
                if (m_extensionStatus.ContainsKey(code))
                {
                    if (m_AoInit.CheckInExtension(code) == esriLicenseStatus.esriLicenseCheckedIn)
                    {
                        m_extensionStatus[code] = esriLicenseStatus.esriLicenseCheckedIn;
                    }
                }
            }
        }

        /// <summary>
        /// Get/Set the ordering of product code checking. If true, check from lowest to 
        /// highest license. True by default.
        /// </summary>
        public bool InitializeLowerProductFirst
        {
            get
            {
                return m_productCheckOrdering;
            }
            set
            {
                m_productCheckOrdering = value;
            }
        }

        /// <summary>
        /// Retrieves the product code initialized in the ArcObjects application
        /// </summary>
        public esriLicenseProductCode InitializedProduct
        {
            get
            {
                try
                {
                    return m_AoInit.InitializedProduct();
                }
                catch
                {
                    return 0;
                }
            }
        }

        #region Helper methods
        /// <summary>
        /// 初始化AO
        /// </summary>
        /// <returns></returns>
        private bool Initialize()
        {
            if (m_requestedProducts == null || m_requestedProducts.Count == 0)
            {
                return false;
            }

            esriLicenseProductCode currentProduct = new esriLicenseProductCode();
            bool productInitialized = false;

            //Try to initialize a product
            ILicenseInformation licInfo = (ILicenseInformation)m_AoInit;

            m_requestedProducts.Sort();
            if (!InitializeLowerProductFirst) //Request license from highest to lowest
            {
                m_requestedProducts.Reverse();
            }

            foreach (int prodNumber in m_requestedProducts)
            {
                esriLicenseProductCode prod = (esriLicenseProductCode)Enum.ToObject(typeof(esriLicenseProductCode), prodNumber);
                esriLicenseStatus status = m_AoInit.IsProductCodeAvailable(prod);
                if (status == esriLicenseStatus.esriLicenseAvailable)
                {
                    status = m_AoInit.Initialize(prod);
                    if (status == esriLicenseStatus.esriLicenseAlreadyInitialized ||
                        status == esriLicenseStatus.esriLicenseCheckedOut)
                    {
                        productInitialized = true;
                        currentProduct = m_AoInit.InitializedProduct();
                    }
                }

                m_productStatus.Add(prod, status);

                if (productInitialized)
                {
                    break;
                }
            }

            m_hasInitializeProduct = productInitialized;
            m_requestedProducts.Clear();

            //No product is initialized after trying all requested licenses, quit
            if (!productInitialized)
            {
                return false;
            }

            //Check out extension licenses
            return CheckOutLicenses(currentProduct);
        }

        //签出扩展功能
        private bool CheckOutLicenses(esriLicenseProductCode currentProduct)
        {
            bool allSuccessful = true;
            //Request extensions
            if (m_requestedExtensions != null && currentProduct != 0)
            {
                foreach (esriLicenseExtensionCode ext in m_requestedExtensions)
                {
                    esriLicenseStatus licenseStatus = m_AoInit.IsExtensionCodeAvailable(currentProduct, ext);
                    if (licenseStatus == esriLicenseStatus.esriLicenseAvailable)//skip unavailable extensions
                    {
                        licenseStatus = m_AoInit.CheckOutExtension(ext);
                    }
                    allSuccessful = (allSuccessful && licenseStatus == esriLicenseStatus.esriLicenseCheckedOut);
                    if (m_extensionStatus.ContainsKey(ext))
                        m_extensionStatus[ext] = licenseStatus;
                    else
                        m_extensionStatus.Add(ext, licenseStatus);
                }

                m_requestedExtensions.Clear();
            }

            return allSuccessful;
        }


        private string ReportInformation(ILicenseInformation licInfo,
           esriLicenseProductCode code, esriLicenseStatus status)
        {
            string prodName = string.Empty;
            try
            {
                prodName = licInfo.GetLicenseProductName(code);
            }
            catch
            {
                prodName = code.ToString();
            }

            string statusInfo = string.Empty;

            switch (status)
            {
                case esriLicenseStatus.esriLicenseAlreadyInitialized:
                case esriLicenseStatus.esriLicenseCheckedOut:
                    statusInfo = string.Format(MessageProductAvailable, prodName);
                    break;
                default:
                    statusInfo = string.Format(MessageProductNotLicensed, prodName);
                    break;
            }

            return statusInfo;
        }
        private string ReportInformation(ILicenseInformation licInfo,
            esriLicenseExtensionCode code, esriLicenseStatus status)
        {
            string extensionName = string.Empty;
            try
            {
                extensionName = licInfo.GetLicenseExtensionName(code);
            }
            catch
            {
                extensionName = code.ToString();
            }

            string statusInfo = string.Empty;

            switch (status)
            {
                case esriLicenseStatus.esriLicenseAlreadyInitialized:
                case esriLicenseStatus.esriLicenseCheckedOut:
                    statusInfo = string.Format(MessageExtensionAvailable, extensionName);
                    break;
                case esriLicenseStatus.esriLicenseCheckedIn:
                    break;
                case esriLicenseStatus.esriLicenseUnavailable:
                    statusInfo = string.Format(MessageExtensionUnavailable, extensionName);
                    break;
                case esriLicenseStatus.esriLicenseFailure:
                    statusInfo = string.Format(MessageExtensionFailed, extensionName);
                    break;
                default:
                    statusInfo = string.Format(MessageExtensionNotLicensed, extensionName);
                    break;
            }

            return statusInfo;
        }
        #endregion

    }

    //初始化AO方法
    ESRI License Initializer generated code.
    //m_AOLicenseInitializer.InitializeApplication(
    //    new esriLicenseProductCode[] 
    //{ 
    //    esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB, 
    //    //esriLicenseProductCode.esriLicenseProductCodeEngine, 
    //    esriLicenseProductCode.esriLicenseProductCodeArcView, 
    //    esriLicenseProductCode.esriLicenseProductCodeArcEditor, 
    //    esriLicenseProductCode.esriLicenseProductCodeArcInfo 
    //},
    //    new esriLicenseExtensionCode[] 
    //{ 
    //    esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst, 
    //    esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst, 
    //    esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability 
    //});

    //关闭AO方法
    ESRI License Initializer generated code.
    Do not make any call to ArcObjects after ShutDownApplication()
    //m_AOLicenseInitializer.ShutdownApplication();
}

第二步，在program中引入一下代码片段

            ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
            //IAoInitialize m_AoInitialize = new AoInitializeClass();
            //esriLicenseStatus licenseStatus = esriLicenseStatus.esriLicenseUnavailable;
            //licenseStatus = m_AoInitialize.Initialize(esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB);

            IAOLicenseInitializer AoInit = AOLicenseInitializerFactory.CreateAOLicenseInitializerClass();
            bool result = AoInit.InitializeApplication(
                new esriLicenseProductCode[]
                {
                    esriLicenseProductCode.esriLicenseProductCodeEngineGeoDB,
                    esriLicenseProductCode.esriLicenseProductCodeEngine,
                    esriLicenseProductCode.esriLicenseProductCodeAdvanced
                },
                new esriLicenseExtensionCode[]
                {
                    esriLicenseExtensionCode.esriLicenseExtensionCode3DAnalyst,
                    esriLicenseExtensionCode.esriLicenseExtensionCodeSpatialAnalyst,
                    esriLicenseExtensionCode.esriLicenseExtensionCodeRuntimeBasic,
                    esriLicenseExtensionCode.esriLicenseExtensionCodeRuntimeStandard,
                    esriLicenseExtensionCode.esriLicenseExtensionCodeDataInteroperability
                });
           

然后就再也不谈下面这句话了。

There is no Spatial Analyst license currently available or enabled