private IFunctionRasterDataset createBarrierRaster()
{
IFeatureClassDescriptor ftrDesc = new FeatureClassDescriptorClass();
IQueryFilter qf = new QueryFilterClass();
ftrDesc.Create(BarriersFeatureClass, qf, BarriersFeatureClass.OIDFieldName);
IConversionOp convOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment rasterAnalysisEnvironment = (IRasterAnalysisEnvironment)convOp;
IRasterAnalysisGlobalEnvironment rasterAnalysisGlobalEnvironment = (IRasterAnalysisGlobalEnvironment)convOp;
rasterAnalysisGlobalEnvironment.AvoidDataConversion = true;
rasterAnalysisEnvironment.OutSpatialReference = sp;
rasterAnalysisEnvironment.OutWorkspace = OutWorkspace;
//object cells = Dem.RasterInfo.CellSize;
object ext = ((IGeoDataset)Dem).Extent;
object snap = ((IGeoDataset)Dem);
rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, Dem);
rasterAnalysisEnvironment.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ext, Dem);
string outRdName = rsUtil.getSafeOutputName(OutWorkspace, "sBarrier");
IRasterDataset geoDset = convOp.ToRasterDataset((IGeoDataset)ftrDesc, "GRID", OutWorkspace, outRdName);
IGeoDatasetSchemaEdit2 geoSch = (IGeoDatasetSchemaEdit2)geoDset;
if (geoSch.CanAlterSpatialReference)
{
geoSch.AlterSpatialReference(rasterAnalysisEnvironment.OutSpatialReference);
}
return(rsUtil.createIdentityRaster(geoDset));
}
/// <summary>
/// 转换
/// </summary>
/// <param name="pFeatureClass">要素类</param>
/// <param name="fieldName">栅格采用的字段</param>
/// <param name="rasterWorkSpace">输出栅格的工作空间</param>
/// <param name="newRasterName">新的栅格名称</param>
public void Convert(IFeatureClass pFeatureClass,
string fieldName,
string rasterWorkSpace,
string newRasterName)
{
FileHelper.DeleteFile(rasterWorkSpace, newRasterName, ".tif", ".tfw",".tif.aux");
IFeatureClassDescriptor featureClassDescriptor = new FeatureClassDescriptorClass();
featureClassDescriptor.Create(pFeatureClass, null, fieldName);
IGeoDataset geoDataset = (IGeoDataset)featureClassDescriptor;
IWorkspaceFactory workspaceFactory = new RasterWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(rasterWorkSpace, 0);
IConversionOp conversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment rasterAnalysisEnvironment = (IRasterAnalysisEnvironment)conversionOp;
rasterAnalysisEnvironment.OutWorkspace = workspace;
//set cell size
rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _cellSize);
//set output extent
object objectMissing = Type.Missing;
rasterAnalysisEnvironment.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _extentEnvelope, ref objectMissing);
//set output spatial reference
rasterAnalysisEnvironment.OutSpatialReference = ((IGeoDataset)pFeatureClass).SpatialReference;
//convertion
conversionOp.ToRasterDataset(geoDataset, _rasterType, workspace, newRasterName);
}
private void button1_Click(object sender, EventArgs e)
{
IGeoDataset inGeoDataSet;
IGeoDataset outGeoDataSet;
IConversionOp conversionOp = new RasterConversionOpClass();
// 构造inGeoDataSet
ILayer layer = GetLayerByName(comboBox1.SelectedItem.ToString());
IRasterLayer rasterLayer = layer as IRasterLayer;
IRaster raster = rasterLayer.Raster;
inGeoDataSet = raster as IGeoDataset;
IWorkspaceFactory2 pWorkspaceFactoryShp = new ShapefileWorkspaceFactoryClass();
IWorkspace pWorkspace = pWorkspaceFactoryShp.OpenFromFile(textBox1.Text, 0);
ISpatialReference pSpatialReference = inGeoDataSet.SpatialReference;
outGeoDataSet = conversionOp.RasterDataToPolygonFeatureData(
inGeoDataSet,
pWorkspace,
textBox2.Text,
true
);
IDataset pDataset1 = outGeoDataSet as IDataset;
IFeatureClass pFeatureClass = pDataset1 as IFeatureClass;
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pFeatureClass;
pFeatureLayer.Name = textBox2.Text;
mainForm.axMapControl1.AddLayer(pFeatureLayer);
mainForm.axMapControl1.Refresh();
}
/// <summary>
/// 执行矢量转栅格
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FtoR_backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
//设置CancellationPending可以退出任务线程
if (worker.CancellationPending == true)
{
e.Cancel = true;
}
else
{
try
{
FileInfo inputinfo = new FileInfo(featuretoraster_inputcombox.Text);
FileInfo outputinfo = new FileInfo(featuretoraster_output.Text);
IWorkspaceFactory outputworkspaceFactory = new RasterWorkspaceFactoryClass();
IWorkspace outputworkspaceop = outputworkspaceFactory.OpenFromFile(outputinfo.DirectoryName, 0);//创建输出工作空间
IWorkspaceFactory workspacefactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace featureworkspace = workspacefactory.OpenFromFile(inputinfo.DirectoryName, 0) as IFeatureWorkspace;
IFeatureClass featureclass = featureworkspace.OpenFeatureClass(inputinfo.Name);
IFeatureClassDescriptor featureClassDescriptor = new FeatureClassDescriptorClass();
featureClassDescriptor.Create(featureclass, null, featuretoraster_fieldcombox.Text);
IGeoDataset geodatasetop = featureClassDescriptor as IGeoDataset;
IConversionOp conversionOp = new RasterConversionOpClass();
//转换设置
IRasterAnalysisEnvironment rasterAnalysisEnvironment = conversionOp as IRasterAnalysisEnvironment;
//栅格的大小
double dCellSize = Convert.ToDouble(featuretoraster_cellsize.Text);
object oCellSize = dCellSize as object;
//设置栅格大小
rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref oCellSize);
string format = "";
if (outputinfo.Extension == ".tif")
{
format = "TIFF";
}
else if (outputinfo.Extension == ".img")
{
format = "IMAGINE Image";
}
else
{
format = "GRID";
}
//启动预处理计时
watch = new Stopwatch();
watch.Start();
//执行转换
conversionOp.ToRasterDataset(geodatasetop, format, outputworkspaceop, outputinfo.Name);
}
catch (Exception erro)
{
MessageBox.Show(erro.Message, "错误");
}
}
}
//裁剪
private IRaster ShpLayerClipRaster(IFeatureLayer featureLayer, IRaster raster)
{
IFeatureLayer pFeaLyr;
IRasterAnalysisEnvironment pEnv;
IGeoDataset pTempDS;
pFeaLyr = featureLayer;
pTempDS = pFeaLyr.FeatureClass as IGeoDataset;
IConversionOp pConOp = new RasterConversionOpClass();
pEnv = pConOp as IRasterAnalysisEnvironment;
IRasterProps pProp = raster as IRasterProps;
object cellSize = 0.01;
pEnv.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref cellSize);
IRasterConvertHelper rsh = new RasterConvertHelperClass();
IRaster tempRaster = rsh.ToRaster1(pTempDS, "Grid", pEnv);
IRaster pOutRaster;
IExtractionOp pExtrOp = new RasterExtractionOpClass();
pOutRaster = (IRaster)pExtrOp.Raster((IGeoDataset)raster, (IGeoDataset)tempRaster);
return(pOutRaster);
}
/// <summary>
/// 转换
/// </summary>
/// <param name="pFeatureClass">要素类</param>
/// <param name="fieldName">栅格采用的字段</param>
/// <param name="rasterWorkSpace">输出栅格的工作空间</param>
/// <param name="newRasterName">新的栅格名称</param>
public void Convert(IFeatureClass pFeatureClass,
string fieldName,
string rasterWorkSpace,
string newRasterName)
{
FileHelper.DeleteFile(rasterWorkSpace, newRasterName, ".tif", ".tfw", ".tif.aux");
IFeatureClassDescriptor featureClassDescriptor = new FeatureClassDescriptorClass();
featureClassDescriptor.Create(pFeatureClass, null, fieldName);
IGeoDataset geoDataset = (IGeoDataset)featureClassDescriptor;
IWorkspaceFactory workspaceFactory = new RasterWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(rasterWorkSpace, 0);
IConversionOp conversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment rasterAnalysisEnvironment = (IRasterAnalysisEnvironment)conversionOp;
rasterAnalysisEnvironment.OutWorkspace = workspace;
//set cell size
rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _cellSize);
//set output extent
object objectMissing = Type.Missing;
rasterAnalysisEnvironment.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _extentEnvelope, ref objectMissing);
//set output spatial reference
rasterAnalysisEnvironment.OutSpatialReference = ((IGeoDataset)pFeatureClass).SpatialReference;
//convertion
conversionOp.ToRasterDataset(geoDataset, _rasterType, workspace, newRasterName);
}
/// <summary>
/// 矢量点转栅格
/// </summary>
/// <param name="xjFeatureLayer">矢量图层</param>
/// <param name="RasterPath">栅格绝对路径</param>
/// <param name="CellSize">栅格边长</param>
/// <param name="SecletctedField">所选字段（高程等）</param>
/// <returns>返回栅格图层</returns>
private ILayer xjShpPointToRaster(IFeatureLayer xjFeatureLayer, string RasterPath, double CellSize, string SecletctedField)
{
IFeatureClass xjFeatureClass = xjFeatureLayer.FeatureClass;
IFeatureClassDescriptor xjFeatureClassDescriptor = new FeatureClassDescriptorClass();//using ESRI.ArcGIS.GeoAnalyst;
xjFeatureClassDescriptor.Create(xjFeatureClass, null, SecletctedField);
IGeoDataset xjGeoDataset = xjFeatureClassDescriptor as IGeoDataset;
IWorkspaceFactory xjwsf = new RasterWorkspaceFactoryClass(); //using ESRI.ArcGIS.DataSourcesRaster;
string xjRasterFolder = System.IO.Path.GetDirectoryName(RasterPath);
IWorkspace xjws = xjwsf.OpenFromFile(xjRasterFolder, 0);
IConversionOp xjConversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment xjRasteren = xjConversionOp as IRasterAnalysisEnvironment;
object xjCellSize = CellSize as object;
xjRasteren.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref xjCellSize);
string xjFileName = System.IO.Path.GetFileName(RasterPath);
IRasterDataset xjdaset2 = xjConversionOp.ToRasterDataset(xjGeoDataset, "TIFF", xjws, xjFileName);
IRasterLayer xjRasterLayer = new RasterLayerClass();
xjRasterLayer.CreateFromDataset(xjdaset2);
ILayer xjLayer = xjRasterLayer;
xjRasterLayer.Name = xjFileName;
return(xjLayer);
}
/// <summary>
/// 执行栅格转矢量
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RtoF_backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
//设置CancellationPending可以退出任务线程
if (worker.CancellationPending == true)
{
e.Cancel = true;
}
else
{
try
{
FileInfo inputfinfo = new FileInfo(rastertofeature_input.Text);
FileInfo outputinfo = new FileInfo(rastertofeature_output.Text);
IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(outputinfo.DirectoryName, 0);//创建输出工作空间
IWorkspaceFactory workspacefactory = new RasterWorkspaceFactoryClass();
IRasterWorkspace rasterworkspace = workspacefactory.OpenFromFile(inputfinfo.DirectoryName, 0) as IRasterWorkspace;
IRasterDataset rasterdataset = rasterworkspace.OpenRasterDataset(inputfinfo.Name);
IGeoDataset geodataset = rasterdataset as IGeoDataset;
watch = new Stopwatch();
watch.Start();
//执行转换
IConversionOp conversionOp = new RasterConversionOpClass();
IGeoDataset geodatasetresult = null;
if (rastertofeature_geometry.Text == "POINT")
{
geodatasetresult = conversionOp.ToFeatureData(geodataset, esriGeometryType.esriGeometryPoint, workspace, outputinfo.Name);
}
else
{
if (rastertofeature_geometry.Text == "POLYLINE")
{
geodatasetresult = conversionOp.ToFeatureData(geodataset, esriGeometryType.esriGeometryPolyline, workspace, outputinfo.Name);
}
else
{
geodatasetresult = conversionOp.ToFeatureData(geodataset, esriGeometryType.esriGeometryPolygon, workspace, outputinfo.Name);
}
}
}
catch (Exception erro)
{
MessageBox.Show(erro.Message, "错误");
}
}
}
/// <summary>
/// 矢量转栅格
/// </summary>
/// <param name="IFeatureClass">要转换的矢量数据</param>
/// <param name="eleField">转换的字段名</param>
/// <param name="cellsize">栅格大小,默认为null</param>
///<param name="rasterSavePath">保存路径</param>
///<param name="demName">dem名称</param>
/// <returns>返回ILayer类型的图层</returns>
public ILayer FeatureToRaster(IFeatureClass pFeatureClass, string eleField, object cellSize, string rasterSavePath, string demName)
{
IFeatureClassDescriptor pFeatureClassDescriptor = new FeatureClassDescriptorClass(); //获取转化的字段
pFeatureClassDescriptor.Create(pFeatureClass, null, eleField); //转换字段
IGeoDataset pGeoDataset = (IGeoDataset)pFeatureClassDescriptor; //获取第一个参数
//默认栅格大小
if (Convert.ToDouble(cellSize) <= 0)
{
IEnvelope envelope = pGeoDataset.Extent;
if (envelope.Width > envelope.Height)
{
cellSize = envelope.Height / 250;
}
else
{
cellSize = envelope.Width / 250;
}
}
IWorkspaceFactory workspaceFactory = new RasterWorkspaceFactoryClass();
IRasterWorkspace2 rasterWorkspace2 = workspaceFactory.OpenFromFile(rasterSavePath, 0) as IRasterWorkspace2;
//in case that there is already an existing raster with the raster name, try to delete it
if (System.IO.Directory.Exists(System.IO.Path.Combine(rasterSavePath, demName)))
{
IDataset dataset = rasterWorkspace2.OpenRasterDataset(demName) as IDataset;
dataset.Delete();
}
IConversionOp conversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment rasterAnalysisEnvironment = conversionOp as IRasterAnalysisEnvironment;
rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref cellSize);
IRasterDataset rasterDataset = null;
try
{ rasterDataset = conversionOp.ToRasterDataset(pGeoDataset, "TIFF", (IWorkspace)rasterWorkspace2, demName); }
catch (Exception ee)
{ MessageBox.Show(ee.Message); }
ILayer layer = null;
if (rasterDataset != null)
{
IRasterLayer pRlyr = new RasterLayerClass();
pRlyr.CreateFromDataset(rasterDataset);
layer = pRlyr as ILayer;
}
return(layer);
}
internal IFeatureClass RasterToPolygon(IRaster inputRaster, string outputName, string outputDir, bool smoothShapes)
{
IWorkspace workspace = SetupOp.OpenShapeFileWorkspace(outputDir);
IConversionOp conversionOp = new RasterConversionOpClass();
try
{
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
//Delete any existing
IEnumDatasetName datasets = workspace.get_DatasetNames(esriDatasetType.esriDTFeatureClass);
datasets.Reset();
IDataset existing = null;
IDatasetName datasetName = datasets.Next();
while (datasetName != null)
{
if (string.Compare(outputName, datasetName.Name, true) == 0)
{
existing = (IDataset)((IName)datasetName).Open();
break;
}
datasetName = datasets.Next();
}
if (existing != null)
{
try
{
existing.Delete();
}
finally
{
UrbanDelineationExtension.ReleaseComObject(existing);
}
}
//Convert to polygon feature
SetAnalysisEnvironment((IRasterAnalysisEnvironment)conversionOp);
IGeoDataset polygons = conversionOp.RasterDataToPolygonFeatureData((IGeoDataset)inputRaster, workspace, outputName, smoothShapes);
return((IFeatureClass)polygons);
}
finally
{
UrbanDelineationExtension.ReleaseComObject(workspace);
UrbanDelineationExtension.ReleaseComObject(conversionOp);
}
}
private void _PunchDEM()
{
OnProgress("Punching DEM with drainage points...");
IConversionOp conversionOp = new RasterConversionOpClass();
ILogicalOp logicalOp = new RasterMathOpsClass();
IGeoDataset inletLocations = null;
IWorkspace tempWorkspace = null;
try
{
tempWorkspace = GetTempRasterWorkspace();
SetAnalysisEnvironment((IRasterAnalysisEnvironment)conversionOp);
SetAnalysisEnvironment((IRasterAnalysisEnvironment)logicalOp);
IFeatureClassDescriptor sourceDescriptor = new FeatureClassDescriptorClass();
sourceDescriptor.Create(_drainClass, null, _drainClass.OIDFieldName);
string gridPath = SetupOp.CreateTempFileName(_GetTempDir(), "TmpInlets", null);
string gridName = System.IO.Path.GetFileName(gridPath);
IRasterDataset pRasterDataset = null;
try
{
pRasterDataset = conversionOp.ToRasterDataset((IGeoDataset)sourceDescriptor, "GRID", tempWorkspace, gridName);
inletLocations = logicalOp.BooleanNot(logicalOp.IsNull((IGeoDataset)pRasterDataset));
string outputPath = CreateTempFileName(_GetResultDir(), "punchdem", "");
_punchedDEM = GeoprocessingTools.SetNull((IRaster)inletLocations, _dem, outputPath);
}
finally
{
_MarkForDisposal((IDataset)pRasterDataset);
}
}
finally
{
UrbanDelineationExtension.ReleaseComObject(tempWorkspace);
UrbanDelineationExtension.ReleaseComObject(conversionOp);
UrbanDelineationExtension.ReleaseComObject(logicalOp);
}
OnProgress("DEM punched.");
}
public void convertToPolygon()
{
if (modelrs == null)
{
Console.WriteLine("You must segment landfire data before you can covert to polygons");
return;
}
try
{
if (modelrs != null)
{
string rgNm = rsUtil.getSafeOutputName(landfireworkspace, "RG");
IRaster rgRs = rsUtil.createRaster(rsUtil.regionGroup(modelrs));
IRasterProps modelrsProps = (IRasterProps)modelrs;
IPnt pnt = modelrsProps.MeanCellSize();
double meanCellSize = pnt.X * pnt.Y;
//Console.WriteLine(meanCellSize);
int mincell = System.Convert.ToInt32((minarea / meanCellSize) + .5);
int maxcell = System.Convert.ToInt32((maxarea / meanCellSize) + .5);
//Console.WriteLine("number of cells = " + mincell.ToString());
Console.WriteLine("Eliminating slivers");
//IRaster rsE = rsUtil.eliminateSlivers(rgRs,mincell,maxcell);
Console.WriteLine("Splitting Polygons");
//IRaster rsS = rsUtil.splitRegions(rsE, mincell, maxcell);
string outNm = "LandFireStands";
outNm = returnSafeName(outNm);
//Console.WriteLine("Converting to polygon");
IConversionOp convOp = new RasterConversionOpClass();
//IGeoDataset geoDset = convOp.RasterDataToPolygonFeatureData((IGeoDataset)rsS, LandFireWorkspace, outNm, false);
//LandFireFeatureClass = (IFeatureClass)geoDset;
}
//Console.WriteLine("Finished Converting Polygons");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
// Konverterar raster till vektor.
public IFeatureLayer convertRasterToVector(string outPath, string fileName)
{
IGeoDataset pLayerDataset = (IGeoDataset)dest;
IConversionOp conversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment env = (IRasterAnalysisEnvironment)conversionOp;
IWorkspaceFactory workspaceFactory = new RasterWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(outPath, 0);
env.OutWorkspace = workspace;
IWorkspaceFactory wsFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace shapeWS = wsFactory.OpenFromFile(outPath, 0);
IFeatureWorkspace fWorkspace = (IFeatureWorkspace)wsFactory.OpenFromFile(outPath, 0);
IWorkspace2 workTemp = (IWorkspace2)fWorkspace;
if (workTemp.NameExists[esriDatasetType.esriDTFeatureClass, fileName])
{
IDataset dataset = (IDataset)fWorkspace.OpenFeatureClass(fileName);
dataset.Delete();
}
IGeoDataset featPolClassOut = conversionOp.RasterDataToPolygonFeatureData(pLayerDataset, shapeWS, fileName + ".shp", true);
IFeatureClass fClass = fWorkspace.OpenFeatureClass(fileName);
IFeatureLayer fLayer = new FeatureLayerClass();
fLayer.FeatureClass = fClass;
fLayer.Name = fClass.AliasName;
fLayer.Visible = true;
map.AddLayer(fLayer);
return(fLayer);
}
/// <summary>
/// 栅格转矢量
/// </summary>
/// <param name="pRasterWs"></param>
/// <param name="pRasterDatasetName"></param>
/// <param name="pShapeFileName"></param>
public void ConvertRaterToLineFeature(string pRasterWs,string pRasterDatasetName,string pShapeFileName)
{
IRasterDataset pRasterDataset = GetRasterWorkspace(pRasterWs).OpenRasterDataset(pRasterDatasetName);
IConversionOp pConversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment pEnv = (IRasterAnalysisEnvironment)pConversionOp;
IWorkspaceFactory pWorkspaceFactory = new RasterWorkspaceFactoryClass();
IWorkspace pWorkspace = pWorkspaceFactory.OpenFromFile(pRasterWs, 0);
pEnv.OutWorkspace = pWorkspace;
IWorkspaceFactory pShapeFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace pShapeWS = pShapeFactory.OpenFromFile(pRasterWs, 0);
System.Object pDangle = (System.Object)1.0;
IGeoDataset pFeatClassOutput = pConversionOp.RasterDataToLineFeatureData((IGeoDataset)pRasterDataset,
pShapeWS, pShapeFileName, false, false, ref pDangle);
}
public void convertToPolygon()
{
if (modelrs == null)
{
Console.WriteLine("You must segment landfire data before you can covert to polygons");
return;
}
try
{
if (modelrs != null)
{
string rgNm = rsUtil.getSafeOutputName(landfireworkspace,"RG");
IRaster rgRs = rsUtil.createRaster(rsUtil.regionGroup(modelrs));
IRasterProps modelrsProps = (IRasterProps)modelrs;
IPnt pnt = modelrsProps.MeanCellSize();
double meanCellSize = pnt.X*pnt.Y;
//Console.WriteLine(meanCellSize);
int mincell = System.Convert.ToInt32((minarea/meanCellSize)+.5);
int maxcell = System.Convert.ToInt32((maxarea/meanCellSize)+.5);
//Console.WriteLine("number of cells = " + mincell.ToString());
Console.WriteLine("Eliminating slivers");
//IRaster rsE = rsUtil.eliminateSlivers(rgRs,mincell,maxcell);
Console.WriteLine("Splitting Polygons");
//IRaster rsS = rsUtil.splitRegions(rsE, mincell, maxcell);
string outNm = "LandFireStands";
outNm = returnSafeName(outNm);
//Console.WriteLine("Converting to polygon");
IConversionOp convOp = new RasterConversionOpClass();
//IGeoDataset geoDset = convOp.RasterDataToPolygonFeatureData((IGeoDataset)rsS, LandFireWorkspace, outNm, false);
//LandFireFeatureClass = (IFeatureClass)geoDset;
}
//Console.WriteLine("Finished Converting Polygons");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private void btnGO_Click(object sender, EventArgs e)
{
string fileName;
string shpFile;
int startX, endX;
string shpDir;
object Missing = Type.Missing;
//if (bFeatDataPath == true)
//{
// fileName = comboBoxInData.Text;
// shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
// startX = fileName.LastIndexOf("\\");
// endX = fileName.Length;
// shpFile = fileName.Substring(startX + 1, endX - startX - 1);
// pFClass = Utility.OpenFeatureClassFromShapefile(shpDir, shpFile);
//}
//else
//{
// pFClass = GetFeatureFromMapLyr(comboBoxInData.Text);
//}
if (bRasterDataPath == true)
{
fileName = txtOutPath.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
}
else
{
shpDir = txtOutPath.Text;
shpFile = "դ��ת����";
}
try
{
//ɾ����ʱ�����ļ�
DelFeatFile(shpDir, shpFile);
//���դ�����ݼ�
IRasterDescriptor pRsDescriptor = new RasterDescriptorClass();
pRsDescriptor.Create(m_pInRaster, new QueryFilterClass(), comboBoxField.Text);
//�����������ռ�
IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass();
IWorkspace pWS = pWSF.OpenFromFile(shpDir, 0);
//ת��դ��Ϊ������
IConversionOp pConversionOp = new RasterConversionOpClass();
IFeatureClass pOutFeatCls = null;
switch (comboBoxGeomeryType.Text)
{
case "��":
pOutFeatCls = pConversionOp.RasterDataToPointFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile) as IFeatureClass;
break;
case "��":
pOutFeatCls = pConversionOp.RasterDataToLineFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile, false, false, ref Missing) as IFeatureClass;
break;
case "��":
pOutFeatCls = pConversionOp.RasterDataToPolygonFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile, false) as IFeatureClass;
break;
}
IFeatureLayer pFeatLyr = new FeatureLayerClass();
pFeatLyr.FeatureClass = pOutFeatCls;
pMap.AddLayer(pFeatLyr);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
//
//��������ת��դ���������
//
public static IConversionOp SetFeatToRasterAnalysisEnv(string rasterpath, double cellsize, IFeatureLayer pFeatLayer)
{
object Missing = Type.Missing;
IWorkspace pWorkspace = UtilityFunction.setRasterWorkspace(rasterpath);
IConversionOp pConversionOp = new RasterConversionOpClass();
IRasterAnalysisEnvironment pRsEnv = pConversionOp as IRasterAnalysisEnvironment;
pRsEnv.OutWorkspace = pWorkspace;
//װ�����
object objCellSize = cellsize;
pRsEnv.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref objCellSize);
IEnvelope pEnv = new EnvelopeClass();
pEnv.XMin = pFeatLayer.AreaOfInterest.XMin;
pEnv.XMax = pFeatLayer.AreaOfInterest.XMax;
pEnv.YMin = pFeatLayer.AreaOfInterest.YMin;
pEnv.YMax = pFeatLayer.AreaOfInterest.YMax;
object objExtent = pEnv;
pRsEnv.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ref objExtent, ref Missing);
return pConversionOp;
}
//
//
//
public static void ConvertShape2Raster(string fullPathToShape, double inCellSize, string outRasterName)
{
//��������������õ��ļ�����·��
string pathToWorkspace = System.IO.Path.GetDirectoryName(fullPathToShape);
string shapefileName = System.IO.Path.GetFileNameWithoutExtension(fullPathToShape);
IFeatureClass pFClass = OpenFeatureClassFromShapefile(pathToWorkspace, shapefileName);
IGeoDataset geoDataset = (IGeoDataset)pFClass;
IWorkspace pWSpace = setRasterWorkspace(pathToWorkspace);
// Create raster conversion operator and set up analysis environment,
// then use it to make the output raster.
IConversionOp rasterConversionOp = new RasterConversionOpClass();
try
{
// Again, an interface that has to be present on the object.
IRasterAnalysisEnvironment rasterAnalysisEnvironment = (IRasterAnalysisEnvironment)rasterConversionOp;
rasterAnalysisEnvironment.OutWorkspace = pWSpace;
esriRasterEnvSettingEnum envType = esriRasterEnvSettingEnum.esriRasterEnvValue;
System.Object inCellSizeObj = inCellSize;
rasterAnalysisEnvironment.SetCellSize(envType, ref inCellSizeObj);
IEnvelope rasterExtent = geoDataset.Extent;
// SetExtent can take an Envelope or another Raster as the
// second parameter, C# does this by passing the generic Object with
// the keyword "ref" in front. Same for the Raster to be used for
// the grid cell registration - which in this case is null, i.e. a void*
System.Object inExtent = rasterExtent;
System.Object inSnapRaster = 0;
rasterAnalysisEnvironment.SetExtent(envType, ref inExtent, ref inSnapRaster);
}
catch
{
}
rasterConversionOp.ToRasterDataset(geoDataset, "TIFF", pWSpace, outRasterName);
}
/// <summary>
/// return operation watershed handler
/// </summary>
/// <param name="boundVariables">>bound Variables</param>
/// <param name="operationInput">operation Input</param>
/// <param name="outputFormat">output Format</param>
/// <param name="requestProperties">request Properties</param>
/// <param name="responseProperties">response Properties</param>
/// <returns>operation watershed handler</returns>
private byte[] OperationWatershedHandler(NameValueCollection boundVariables, JsonObject operationInput, string outputFormat, string requestProperties, out string responseProperties)
{
responseProperties = null;
long?idWatershed;
if (operationInput.Exists("idWatershed"))
{
if (!operationInput.TryGetAsLong("idWatershed", out idWatershed))
{
throw new ArgumentNullException("idWatershed");
}
}
else
{
idWatershed = 0;
}
JsonObject jsonObjectPoint;
if (!operationInput.TryGetJsonObject("location", out jsonObjectPoint))
{
throw new ArgumentNullException("location");
}
IPoint location = Conversion.ToGeometry(jsonObjectPoint, esriGeometryType.esriGeometryPoint) as IPoint;
if (location == null)
{
throw new ArgumentException("Invalid location", "location");
}
double?snapDistance;
if (!operationInput.TryGetAsDouble("snapDistance", out snapDistance))
{
throw new ArgumentNullException("snapDistance");
}
snapDistance = snapDistance ?? 0.0;
long?idAccumulation;
if (!operationInput.TryGetAsLong("idAccumulation", out idAccumulation) || !idAccumulation.HasValue)
{
throw new ArgumentNullException("idAccumulation");
}
long?idDirection;
if (!operationInput.TryGetAsLong("idDirection", out idDirection) || !idDirection.HasValue)
{
throw new ArgumentNullException("idDirection");
}
string methodName = MethodBase.GetCurrentMethod().Name;
try
{
IFeatureWorkspace featureWorkspace = Helper.CreateInMemoryWorkspace() as IFeatureWorkspace;
IFeatureClass featureClass = this.CreateFeatureClass(location, featureWorkspace);
IFeature feature = featureClass.CreateFeature();
feature.Shape = location;
feature.set_Value(featureClass.FindField(SAUtility.FieldNameIdWatershed), (int)idWatershed.Value);
feature.Store();
IHydrologyOp hydrologyOp = new RasterHydrologyOp() as IHydrologyOp;
IGeoDataset accumulation = this.GetGeodataset((int)idAccumulation.Value);
IGeoDataset direction = this.GetGeodataset((int)idDirection.Value);
IFeatureClassDescriptor featureClassDescriptor = new FeatureClassDescriptorClass();
featureClassDescriptor.Create(featureClass, null, SAUtility.FieldNameIdWatershed);
IGeoDataset pourPoint = featureClassDescriptor as IGeoDataset;
IRasterAnalysisEnvironment rasterAnalysisEnvironment = new RasterAnalysisClass();
object extentProvider = Type.Missing;
object snapRasterData = Type.Missing;
rasterAnalysisEnvironment.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvMaxOf, ref extentProvider, ref snapRasterData);
IGeoDataset snapRaster = hydrologyOp.SnapPourPoint(pourPoint, accumulation, snapDistance.Value);
IGeoDataset watershed = hydrologyOp.Watershed(direction, snapRaster);
IConversionOp conversionOp = new RasterConversionOpClass() as IConversionOp;
IGeoDataset featureClassWatershed = conversionOp.RasterDataToPolygonFeatureData(watershed, featureWorkspace as IWorkspace, "WatershedPolygon", true);
IRecordSetInit recordset = new RecordSetClass();
recordset.SetSourceTable(featureClassWatershed as ITable, null);
byte[] recorset = Conversion.ToJson(recordset as IRecordSet);
this.logger.LogMessage(ServerLogger.msgType.infoDetailed, methodName, SAUtility.MessageCodeSOE, string.Format("Watershed created with succcess. IdWatershed {0}", (int)idWatershed.Value));
return(recorset);
}
catch (Exception ex)
{
this.logger.LogMessage(ServerLogger.msgType.error, methodName, SAUtility.MessageCodeSOE, ex.Message);
return(new ObjectError("error create watershed").ToJsonObject().JsonByte());
}
}
private void btnGO_Click(object sender, EventArgs e)
{
string fileName;
string shpFile;
int startX, endX;
string shpDir;
object Missing = Type.Missing;
//if (bFeatDataPath == true)
//{
// fileName = comboBoxInData.Text;
// shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
// startX = fileName.LastIndexOf("\\");
// endX = fileName.Length;
// shpFile = fileName.Substring(startX + 1, endX - startX - 1);
// pFClass = Utility.OpenFeatureClassFromShapefile(shpDir, shpFile);
//}
//else
//{
// pFClass = GetFeatureFromMapLyr(comboBoxInData.Text);
//}
if (bRasterDataPath == true)
{
fileName = txtOutPath.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
}
else
{
shpDir = txtOutPath.Text;
shpFile = "栅格转特征";
}
try
{
//删除临时特征文件
DelFeatFile(shpDir, shpFile);
//获得栅格数据集
IRasterDescriptor pRsDescriptor = new RasterDescriptorClass();
pRsDescriptor.Create(m_pInRaster, new QueryFilterClass(), comboBoxField.Text);
//获得输出工作空间
IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass();
IWorkspace pWS = pWSF.OpenFromFile(shpDir, 0);
//转换栅格为特征类
IConversionOp pConversionOp = new RasterConversionOpClass();
IFeatureClass pOutFeatCls = null;
switch (comboBoxGeomeryType.Text)
{
case "点":
pOutFeatCls = pConversionOp.RasterDataToPointFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile) as IFeatureClass;
break;
case "线":
pOutFeatCls = pConversionOp.RasterDataToLineFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile, false, false, ref Missing) as IFeatureClass;
break;
case "面":
pOutFeatCls = pConversionOp.RasterDataToPolygonFeatureData(pRsDescriptor as IGeoDataset, pWS, shpFile, false) as IFeatureClass;
break;
}
IFeatureLayer pFeatLyr = new FeatureLayerClass();
pFeatLyr.FeatureClass = pOutFeatCls;
pMainFrm.getMapControl().AddLayer(pFeatLyr, 0);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnGO_Click(object sender, EventArgs e)
{
string fileName;
string shpFile;
int startX, endX;
string shpDir;
IFeatureClass pFClass = null;
if (bFeatDataPath == true)
{
fileName = comboBoxInData.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
pFClass = UtilityFunction.OpenFeatureClassFromShapefile(shpDir, shpFile);
}
else
{
pFClass = GetFeatureFromMapLyr(comboBoxInData.Text);
}
if (bRasterDataPath == true)
{
fileName = txtOutPath.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
}
else
{
shpDir = txtOutPath.Text;
shpFile = "����תդ��";
}
IGeoDataset pTempDS = pFClass as IGeoDataset;
IFeatureLayer pFeatLayer = new FeatureLayerClass();
pFeatLayer.FeatureClass = pFClass;
IFeatureClassDescriptor pFeatClsDes = new FeatureClassDescriptorClass();
if (comboBoxField.Text != "��")
pFeatClsDes.Create(pFClass, null, comboBoxField.Text);
else
pFeatClsDes.Create(pFClass, null, "");
pTempDS = pFeatClsDes as IGeoDataset;
try
{
IConversionOp pConversionOp = new RasterConversionOpClass();
string sCellSize = txtCellSize.Text;
double dCellSize = Convert.ToDouble(sCellSize);
pConversionOp = UtilityFunction.SetFeatToRasterAnalysisEnv(shpDir, dCellSize, pFeatLayer);
if (File.Exists(shpDir + "\\" + shpFile + ".img") == true)
File.Delete(shpDir + "\\" + shpFile + ".img");
IWorkspace pWS = UtilityFunction.setRasterWorkspace(shpDir);
IRasterDataset pRasterDs = pConversionOp.ToRasterDataset(pTempDS, "IMAGINE Image", pWS, shpFile);
ITemporaryDataset pTempRaster = pRasterDs as ITemporaryDataset;
if (pTempRaster.IsTemporary() == true)
pTempRaster.MakePermanent();
IRaster pOutRaster = pRasterDs.CreateDefaultRaster();
IRasterLayer pRasterLayer = UtilityFunction.SetStretchRenderer(pOutRaster);
pMap.AddLayer(pRasterLayer);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnGO_Click(object sender, EventArgs e)
{
string fileName;
string shpFile;
int startX, endX;
string shpDir;
IFeatureClass pFClass = null;
if (bFeatDataPath == true)
{
fileName = comboBoxInData.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
pFClass = Utility.OpenFeatureClassFromShapefile(shpDir, shpFile);
}
else
{
pFClass = GetFeatureFromMapLyr(comboBoxInData.Text);
}
if (bRasterDataPath == true)
{
fileName = txtOutPath.Text;
shpDir = fileName.Substring(0, fileName.LastIndexOf("\\"));
startX = fileName.LastIndexOf("\\");
endX = fileName.Length;
shpFile = fileName.Substring(startX + 1, endX - startX - 1);
}
else
{
shpDir = txtOutPath.Text;
shpFile = "特征转栅格";
}
IGeoDataset pTempDS = pFClass as IGeoDataset;
IFeatureLayer pFeatLayer = new FeatureLayerClass();
pFeatLayer.FeatureClass = pFClass;
IFeatureClassDescriptor pFeatClsDes = new FeatureClassDescriptorClass();
if (comboBoxField.Text != "无")
{
pFeatClsDes.Create(pFClass, null, comboBoxField.Text);
}
else
{
pFeatClsDes.Create(pFClass, null, "");
}
pTempDS = pFeatClsDes as IGeoDataset;
try
{
IConversionOp pConversionOp = new RasterConversionOpClass();
string sCellSize = txtCellSize.Text;
double dCellSize = Convert.ToDouble(sCellSize);
pConversionOp = Utility.SetFeatToRasterAnalysisEnv(shpDir, dCellSize, pFeatLayer);
if (File.Exists(shpDir + "\\" + shpFile + ".img") == true)
{
File.Delete(shpDir + "\\" + shpFile + ".img");
}
IWorkspace pWS = Utility.setRasterWorkspace(shpDir);
IRasterDataset pRasterDs = pConversionOp.ToRasterDataset(pTempDS, "IMAGINE Image", pWS, shpFile);
ITemporaryDataset pTempRaster = pRasterDs as ITemporaryDataset;
if (pTempRaster.IsTemporary() == true)
{
pTempRaster.MakePermanent();
}
IRaster pOutRaster = pRasterDs.CreateDefaultRaster();
IRasterLayer pRasterLayer = Utility.SetStretchRenderer(pOutRaster);
pMainFrm.getMapControl().AddLayer(pRasterLayer, 0);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void Rater2Ascii(IGeoDataset mask,int cellsize,IGeoDataset inData,string ascFileName)
{
if (mask == null)
return;
if (inData == null)
return;
if (ascFileName.Trim() == "")
return;
IRasterExportOp rexp=new RasterConversionOpClass();
IRasterAnalysisEnvironment pEnv = (IRasterAnalysisEnvironment)rexp;
object dCellSize = cellsize; //栅格大小
pEnv.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref dCellSize);
pEnv.Mask=mask;
//cov1_0.0 con1_(land use type)_(simulation year)
//string ascFile=this.txtProjectPath.Text="\\DLS\\DLS\\Input\\con1_0.0";
//文件存在就删除
FileInfo file = new FileInfo(ascFileName);
if (file.Exists)
{
file.Delete();
}
rexp.ExportToASCII(inData, ascFileName);
//IRasterextrac rexp = new RasterConversionOpClass();
}
