public IFeatureClass Intsect(IFeatureClass _pFtClass, IFeatureClass _pFtOverlay, string _FilePath, string _pFileName)
{
IFeatureClassName pOutPut = new FeatureClassNameClass();
pOutPut.ShapeType = _pFtClass.ShapeType;
pOutPut.ShapeFieldName = _pFtClass.ShapeFieldName;
pOutPut.FeatureType = esriFeatureType.esriFTSimple;
IWorkspaceName pWsN = new WorkspaceNameClass();
pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";
pWsN.PathName = _FilePath;
IDatasetName pDatasetName = pOutPut as IDatasetName;
pDatasetName.Name = _pFileName;
pDatasetName.WorkspaceName = pWsN;
IBasicGeoprocessor pBasicGeo = new BasicGeoprocessorClass();
IFeatureClass pFeatureClass = pBasicGeo.Intersect(_pFtClass as ITable, false, _pFtOverlay as ITable, false, 0.1, pOutPut);
return pFeatureClass;
}
/// <summary>
/// Deletes the dataset.
/// </summary>
/// <param name="targetWorkspace">The target workspace.</param>
/// <param name="sTargetName">Name of the s target.</param>
/// <param name="type">The type.</param>
public static void DeleteDataset(IWorkspace targetWorkspace, string sTargetName, esriDatasetType type = esriDatasetType.esriDTFeatureClass)
{
IDatasetName datasetName = null;
switch (type)
{
case esriDatasetType.esriDTFeatureDataset:
datasetName = new FeatureDatasetNameClass();
break;
case esriDatasetType.esriDTFeatureClass:
datasetName = new FeatureClassNameClass();
break;
default:
if (type == esriDatasetType.esriDTTable)
{
datasetName = new TableNameClass();
}
break;
}
if (datasetName != null)
{
datasetName.Name = sTargetName;
datasetName.WorkspaceName = ((targetWorkspace as IDataset).FullName as IWorkspaceName);
EngineAPI.DeleteDataset(targetWorkspace, datasetName);
}
}
/// <summary>
/// 导出要素类到目标工作空间
/// </summary>
/// <param name="featureClass"></param>
/// <param name="workspace"></param>
/// <param name="queryGeometry"></param>
/// <param name="spatialRelEnum"></param>
/// <param name="whereClause"></param>
/// <returns></returns>
public static Boolean ExportToWorkspace(IFeatureClass featureClass, IWorkspace workspace, IGeometry queryGeometry = null, esriSpatialRelEnum spatialRelEnum = esriSpatialRelEnum.esriSpatialRelIntersects, string whereClause = "")
{
IDataset inDataSet = featureClass as IDataset;
IFeatureClassName inFCName = inDataSet.FullName as IFeatureClassName;
IWorkspace inWorkspace = inDataSet.Workspace;
IDataset outDataSet = workspace as IDataset;
IWorkspaceName outWorkspaceName = outDataSet.FullName as IWorkspaceName;
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName dataSetName = outFCName as IDatasetName;
dataSetName.WorkspaceName = outWorkspaceName;
dataSetName.Name = inDataSet.Name;
IFieldChecker fieldChecker = new FieldCheckerClass
{
InputWorkspace = inWorkspace,
ValidateWorkspace = workspace
};
IFields fields = featureClass.Fields;
fieldChecker.Validate(fields, out IEnumFieldError enumFieldError, out IFields outFields);
IFeatureDataConverter featureDataConverter = null;
IField geometryField;
try
{
IGeometryDef geometryDef = null;
ISpatialFilter pSF = new SpatialFilterClass();
for (int i = 0; i < outFields.FieldCount; i++)
{
if (outFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = outFields.get_Field(i);
geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
pSF.Geometry = queryGeometry;
pSF.GeometryField = featureClass.ShapeFieldName;
pSF.SpatialRel = spatialRelEnum;
pSF.WhereClause = whereClause;
break;
}
}
featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inFCName, pSF, null, outFCName, geometryDef, outFields, " ", 1000, 0);
return(true);
}
catch (Exception ex)
{
LOG.Error("图层数据导出出错！" + ex.Message);
throw ex;
}
}
public void ExportFeature(IFeatureClass pInFeatureClass, string pPath)
{
// create a new Access workspace factory
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
string parentPath = pPath.Substring(0, pPath.LastIndexOf('\\'));
string fileName = pPath.Substring(pPath.LastIndexOf('\\') + 1, pPath.Length - pPath.LastIndexOf('\\') - 1);
IWorkspaceName pWorkspaceName = pWorkspaceFactory.Create(parentPath, fileName, null, 0);
// Cast for IName
IName name = (IName)pWorkspaceName;
//Open a reference to the access workspace through the name object
IWorkspace pOutWorkspace = (IWorkspace)name.Open();
IDataset pInDataset = pInFeatureClass as IDataset;
IFeatureClassName pInFCName = pInDataset.FullName as IFeatureClassName;
IWorkspace pInWorkspace = pInDataset.Workspace;
IDataset pOutDataset = pOutWorkspace as IDataset;
IWorkspaceName pOutWorkspaceName = pOutDataset.FullName as IWorkspaceName;
IFeatureClassName pOutFCName = new FeatureClassNameClass();
IDatasetName pDatasetName = pOutFCName as IDatasetName;
pDatasetName.WorkspaceName = pOutWorkspaceName;
pDatasetName.Name = pInFeatureClass.AliasName;
IFieldChecker pFieldChecker = new FieldCheckerClass();
pFieldChecker.InputWorkspace = pInWorkspace;
pFieldChecker.ValidateWorkspace = pOutWorkspace;
IFields pFields = pInFeatureClass.Fields;
IFields pOutFields;
IEnumFieldError pEnumFieldError;
pFieldChecker.Validate(pFields, out pEnumFieldError, out pOutFields);
IFeatureDataConverter pFeatureDataConverter = new FeatureDataConverterClass();
pFeatureDataConverter.ConvertFeatureClass(pInFCName, null, null, pOutFCName, null, pOutFields, "", 100, 0);
}
private void ExportFeature(IFeatureClass pInFeatureClass, string pPath)
{
//创建一个输出shp文件的工作空间
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
string parentPath = pPath.Substring(0, pPath.LastIndexOf("\\"));
string fileName = pPath.Substring(pPath.LastIndexOf("\\") + 1, pPath.Length - pPath.LastIndexOf("\\") - 1);
IWorkspaceName pWorkspaceName = pWorkspaceFactory.Create(parentPath, fileName, null, 0);
//创建一个要素类
IName name = (IName)pWorkspaceName;
IWorkspace pOutWorkspace = (IWorkspace)name.Open();
IDataset pInDataset = pInFeatureClass as IDataset;
IFeatureClassName pInFCName = pInDataset.FullName as IFeatureClassName;
IWorkspace pInWorkspace = pInDataset.Workspace;
IDataset pOutDataset = pOutWorkspace as IDataset;
IWorkspaceName pOutWorkspaceName = pOutDataset.FullName as IWorkspaceName;
IFeatureClassName pOutFCName = new FeatureClassNameClass();
IDatasetName pDatasetName = pOutFCName as IDatasetName;
pDatasetName.WorkspaceName = pOutWorkspaceName;
pDatasetName.Name = pInFeatureClass.AliasName;
IFieldChecker pFieldChecker = new FieldCheckerClass();
pFieldChecker.InputWorkspace = pInWorkspace;
pFieldChecker.ValidateWorkspace = pOutWorkspace;
IFields pFields = pInFeatureClass.Fields;
IFields pOutFields;
IEnumFieldError pEnumFieldError;
pFieldChecker.Validate(pFields, out pEnumFieldError, out pOutFields);
IFeatureDataConverter pFeatureDataConverter = new FeatureDataConverterClass();
pFeatureDataConverter.ConvertFeatureClass(pInFCName, null, null, pOutFCName, null, pOutFields, "", 100, 0);
}
public void SaveShpToFile(IFeatureClass pFeatureClass, string ExportFilePath, string ExportFileShortName)
{
//设置导出要素类的参数
IFeatureClassName pOutFeatureClassName = new FeatureClassNameClass();
IDataset pOutDataset = (IDataset)pFeatureClass;
pOutFeatureClassName = (IFeatureClassName)pOutDataset.FullName;
//创建一个输出shp文件的工作空间
IWorkspaceFactory pShpWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspaceName pInWorkspaceName = new WorkspaceNameClass();
pInWorkspaceName = pShpWorkspaceFactory.Create(ExportFilePath, ExportFileShortName, null, 0);
//创建一个要素类
IFeatureClassName pInFeatureClassName = new FeatureClassNameClass();
IDatasetName pInDatasetClassName;
pInDatasetClassName = (IDatasetName)pInFeatureClassName;
pInDatasetClassName.Name = ExportFileShortName;//作为输出参数
pInDatasetClassName.WorkspaceName = pInWorkspaceName;
IFeatureDataConverter pShpToClsConverter = new FeatureDataConverterClass();
pShpToClsConverter.ConvertFeatureClass(pOutFeatureClassName, null, null, pInFeatureClassName, null, null, "", 1000, 0);
MessageBox.Show("导出成功", "系统提示");
}
public IFeatureClass Intsect(IFeatureClass _pFtClass, IFeatureClass _pFtOverlay, string _FilePath, string _pFileName)
{
IFeatureClassName pOutPut = new FeatureClassNameClass();
pOutPut.ShapeType = _pFtClass.ShapeType;
pOutPut.ShapeFieldName = _pFtClass.ShapeFieldName;
pOutPut.FeatureType = esriFeatureType.esriFTSimple;
IWorkspaceName pWsN = new WorkspaceNameClass();
pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";
pWsN.PathName = _FilePath;
IDatasetName pDatasetName = pOutPut as IDatasetName;
pDatasetName.Name = _pFileName;
pDatasetName.WorkspaceName = pWsN;
IBasicGeoprocessor pBasicGeo = new BasicGeoprocessorClass();
IFeatureClass pFeatureClass = pBasicGeo.Intersect(_pFtClass as ITable, false, _pFtOverlay as ITable, false, 0.1, pOutPut);
return(pFeatureClass);
}
/// <summary>
/// 将一个要素类从一个工作空间转移到另外一个工作空间
/// 注意目标工作空间不能有改要素类，必须先清除
/// </summary>
/// <params name="sourceWorkspace">源工作空间</params>
/// <params name="targetWorkspace">目标工作空间</params>
/// <params name="nameOfSourceFeatureClass">源要素类名</params>
/// <params name="nameOfTargetFeatureClass">目标要素类名</params>
public bool IFeatureDataConverter_ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
bool change = false;
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
if (enumErrors.Next() == null)
change = true;
break;
}
}
return change;
}
/// <summary>
/// Saves as shpfile.
/// </summary>
/// <param name="inputFeatureClass">The input feature class.</param>
/// <param name="pInDataset">The p in dataset.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="pOutWorkspace">The p out workspace.</param>
private void SaveAsShpfile(IFeatureClass inputFeatureClass, IDataset pInDataset, string fileName, IWorkspace pOutWorkspace)
{
IFeatureClassName inputDatasetName = pInDataset.FullName as IFeatureClassName;
IWorkspace workspace = pInDataset.Workspace;
IDataset dataset = pOutWorkspace as IDataset;
IWorkspaceName workspaceName = dataset.FullName as IWorkspaceName;
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = featureClassName as IDatasetName;
datasetName.WorkspaceName = workspaceName;
datasetName.Name = fileName;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = workspace;
fieldChecker.ValidateWorkspace = pOutWorkspace;
IFields fields = inputFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFields outputFields;
fieldChecker.Validate(fields, out enumFieldError, out outputFields);
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inputDatasetName, null, null, featureClassName, null, outputFields, "", 100, 0);
XtraMessageBox.Show(AppMessage.MSG0029, AppMessage.MSG0000, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Asterisk);
}
/// <summary>
/// 求交,暂时未用
/// </summary>
/// <param name="_pFtClass"></param>
/// <param name="_pFtOverlay"></param>
/// <param name="_FilePath"></param>
/// <param name="_pFileName"></param>
/// <returns></returns>
public IFeatureClass Intsect(IFeatureClass _pFtClass, IFeatureClass _pFtOverlay, string _FilePath, string _pFileName)
{
//设置输出
IFeatureClassName pOutPut = new FeatureClassNameClass();
pOutPut.ShapeType = _pFtClass.ShapeType;
pOutPut.ShapeFieldName = _pFtClass.ShapeFieldName;
pOutPut.FeatureType = esriFeatureType.esriFTSimple;
//set output location and feature class name
IWorkspaceName pWsN = new WorkspaceNameClass();
pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";
pWsN.PathName = _FilePath;
//也可以用这种方法，IName 和IDataset的用法
// IWorkspaceFactory pWsFc = new ShapefileWorkspaceFactoryClass();
// IWorkspace pWs = pWsFc.OpenFromFile(_FilePath,0);
// IDataset pDataset = pWs as IDataset;
// IWorkspaceName pWsN = pDataset.FullName as IWorkspaceName;
IDatasetName pDatasetName = pOutPut as IDatasetName;
pDatasetName.Name = _pFileName;
pDatasetName.WorkspaceName = pWsN;
IBasicGeoprocessor pBasicGeo = new BasicGeoprocessorClass();
IFeatureClass pFeatureClass = pBasicGeo.Intersect(_pFtClass as ITable, false, _pFtOverlay as ITable, false, 0.1, pOutPut);
return(pFeatureClass);
}
/// <summary>
/// 相交分析，返回相交部分的要素（注意输入要素类和叠加要素类不能有空几何等问题）
/// </summary>
/// <param name="inClass">输入的要素类</param>
/// <param name="overlayClass">叠加的要素类</param>
/// <param name="outPath">保存分析结果的工作空间路径</param>
/// <param name="outName">保存分析结果的要素类名称</param>
/// <returns></returns>
public static IFeatureClass Intersect(this IFeatureClass inClass, IFeatureClass overlayClass, string outPath, string outName)
{
var workspaceType = WorkspaceEx.GetDefaultWorkspaceType(outPath);
if (workspaceType == EWorkspaceType.Default)
{
throw new Exception($"工作空间路径(outPath)不存在！{outPath} 该路径必须是已存在的mdb文件路径，或shp所在文件夹路径，或gdb文件夹路径，或sde连接字符串");
}
IFeatureClassName outClassName = new FeatureClassNameClass
{
ShapeType = inClass.ShapeType,
ShapeFieldName = inClass.ShapeFieldName,
FeatureType = esriFeatureType.esriFTSimple
};
IWorkspaceName workspaceName = new WorkspaceNameClass
{
WorkspaceFactoryProgID = workspaceType.GetDescription(1),
PathName = outPath
};
IDatasetName datasetName = (IDatasetName)outClassName;
datasetName.Name = outName;
datasetName.WorkspaceName = workspaceName;
return(new BasicGeoprocessorClass().Intersect((ITable)inClass, false, (ITable)overlayClass, false, 0.01, outClassName));
}
/// <summary>
/// SDE要素类导出mdb（要素集下要素类）
/// </summary>
/// <param name="IN_SourceWorkspace">源工作空间</param>
/// <param name="IN_TargetWorkspace">目标要素数据集</param>
/// <param name="IN_SourceFeatureClassName">源要素类名</param>
/// <param name="IN_TargetFeatureClassName">目标要素类名</param>
private void ConvertFeatureClass(IWorkspace IN_SourceWorkspace, IFeatureDataset IN_TargetWorkspace, string IN_SourceFeatureClassName, string IN_TargetFeatureClassName)
{
#region 环境配置
//创建源工作空间名
IDataset Temp_SourceWorkspaceDataset = (IDataset)IN_SourceWorkspace;
IWorkspaceName Temp_SourceWorkspaceName = (IWorkspaceName)Temp_SourceWorkspaceDataset.FullName;
//创建源要素数据集名
IFeatureClassName Temp_SourceFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_SourceDatasetName = (IDatasetName)Temp_SourceFeatureClassName;
Temp_SourceDatasetName.WorkspaceName = Temp_SourceWorkspaceName;
Temp_SourceDatasetName.Name = IN_SourceFeatureClassName;
//创建目标工作空间名
IDataset Temp_TargetWorkspaceDataset = (IDataset)IN_TargetWorkspace.Workspace;
IWorkspaceName Temp_TargetWorkspaceName = (IWorkspaceName)(Temp_TargetWorkspaceDataset.FullName);
//创建目标要素类名
IFeatureClassName Temp_TargetFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_TargetDatasetName = (IDatasetName)Temp_TargetFeatureClassName;
Temp_TargetDatasetName.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName.Name = IN_TargetFeatureClassName;
//创建目标要素数据集名
IFeatureDatasetName Temp_TargetFeatureDatasetName = new FeatureDatasetNameClass();
IDatasetName Temp_TargetDatasetName2 = (IDatasetName)Temp_TargetFeatureDatasetName;
Temp_TargetDatasetName2.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName2.Name = IN_TargetWorkspace.Name;
#endregion
//打开源要素类获取字段定义
ESRI.ArcGIS.esriSystem.IName Temp_SourceName = (ESRI.ArcGIS.esriSystem.IName)Temp_SourceFeatureClassName;
IFeatureClass Temp_SourceFeatureClass = (IFeatureClass)Temp_SourceName.Open();
//验证字段
IFieldChecker Temp_FieldChecker = new FieldCheckerClass();
IFields Temp_TargetFeatureClassFields;
IFields Temp_SourceFeatureClassFields = Temp_SourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
Temp_FieldChecker.InputWorkspace = IN_SourceWorkspace;
Temp_FieldChecker.ValidateWorkspace = IN_TargetWorkspace.Workspace;
Temp_FieldChecker.Validate(Temp_SourceFeatureClassFields, out enumFieldError, out Temp_TargetFeatureClassFields);
//批量导入
IField Temp_GeometryField;
for (int i = 0; i < Temp_TargetFeatureClassFields.FieldCount; i++)
{
if (Temp_TargetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
Temp_GeometryField = Temp_TargetFeatureClassFields.get_Field(i);
//获取空间定义
IGeometryDef Temp_GeometryDef = Temp_GeometryField.GeometryDef;
IGeometryDefEdit Temp_TargetFCGeoDefEdit = (IGeometryDefEdit)Temp_GeometryDef;
Temp_TargetFCGeoDefEdit.GridCount_2 = 1;
Temp_TargetFCGeoDefEdit.set_GridSize(0, 0);
Temp_TargetFCGeoDefEdit.SpatialReference_2 = Temp_GeometryField.GeometryDef.SpatialReference;
//定义筛选条件
IQueryFilter Temp_QueryFilter = new QueryFilterClass();
Temp_QueryFilter.WhereClause = "";
//导入要素类至要素数据集
IFeatureDataConverter Temp_FeatureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = Temp_FeatureDataConverter.ConvertFeatureClass(Temp_SourceFeatureClassName, Temp_QueryFilter, Temp_TargetFeatureDatasetName, Temp_TargetFeatureClassName, Temp_GeometryDef, Temp_TargetFeatureClassFields, "", 1000, 0);
break;
}
}
}
/// <summary>
/// 将一个要素类从一个工作空间转移到另外一个工作空间
/// 注意目标工作空间不能有改要素类，必须先清除
/// </summary>
/// <param name="sourceWorkspace">源工作空间</param>
/// <param name="targetWorkspace">目标工作空间</param>
/// <param name="nameOfSourceFeatureClass">源要素类名</param>
/// <param name="nameOfTargetFeatureClass">目标要素类名</param>
public void IFeatureDataConverter_ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
public void IFeatureDataConverter(IWorkspace pSourceWorkspace, IWorkspace pTargetWorkspace, string pSFeatureClass, string pDFeatureClass)
{
IDataset sourceWorkspaceDataset = (IDataset)pSourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = pSFeatureClass;
IDataset targetWorkspaceDataset = (IDataset)pTargetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = pDFeatureClass;
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = pSourceWorkspace;
fieldChecker.ValidateWorkspace = pTargetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
private IFeatureClassName getFeatureClassName(IWorkspaceName WorkspaceName, string Name)
{
// Create a name object for the dataset.
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = (IDatasetName)featureClassName;
datasetName.Name = Name;
datasetName.WorkspaceName = WorkspaceName;
return(featureClassName);
}
//批次报批研判
private static void pcbpJudge(IFeatureLayer pChangeFeaLayer, IFeatureLayer pcbpFeaLayer, IWorkspace pOutWorkSpace, bool useSelection,SysCommon.CProgress vProgress)
{
ITable pChangeTable = pChangeFeaLayer as ITable;
ITable pcbpTable = pcbpFeaLayer as ITable;
double rol = 0.0001;
IFeatureClass pcbpFeaClass = pcbpFeaLayer.FeatureClass;
//创建结果地物类名称
IFeatureClassName pResFeaClassName = new FeatureClassNameClass();
String fcName = pcbpFeaClass.AliasName.Trim().Substring(pcbpFeaClass.AliasName.Trim().IndexOf(".") + 1)+"_res";
IDataset pOutDataset = (IDataset)pOutWorkSpace;
IDatasetName pOutDatasetName = (IDatasetName)pResFeaClassName;
pOutDatasetName.WorkspaceName = (IWorkspaceName)pOutDataset.FullName;
pOutDatasetName.Name = fcName;
IBasicGeoprocessor pGeoProcessor = new BasicGeoprocessorClass();
//叠置分析
pGeoProcessor.Intersect(pChangeTable, useSelection, pcbpTable, false, rol, pResFeaClassName);
//从叠置结果生成报表
string connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + pOutDatasetName.WorkspaceName.PathName;
OleDbConnection oledbconn = new OleDbConnection(connstr);
oledbconn.Open();
ModTableFun.DropTable(oledbconn, "tmprel");
string sqlstr = "select "+g_XZQHDM+","+g_TBBH+","+g_MJ+" as jctbmj,"+g_PC +",shape_area as " +g_MJ+",shape_area as zb,"+g_GWYPFWH+" as bpwh,"+g_SGTTPFWH+","+g_SGTJPFWH+" into tmprel from " + fcName;
//行政区划代码，编号，监测图斑面积，报批名称，计算面积，占比，批准文号（三个批准文号的备选字段）
OleDbCommand oledbcomm = oledbconn.CreateCommand();
oledbcomm.CommandText = sqlstr;
oledbcomm.ExecuteNonQuery();
oledbcomm.CommandText = "update tmprel set zb="+g_MJ+"/jctbmj*100";
oledbcomm.ExecuteNonQuery();
//报批文号为空，则取省林业厅批复文号
oledbcomm.CommandText = "update tmprel set bpwh=" + g_SGTTPFWH + " where bpwh is null and " + g_SGTTPFWH + " is not null";
oledbcomm.ExecuteNonQuery();
//报批文号为空，则取省市林业局批复文号
oledbcomm.CommandText = "update tmprel set bpwh=" + g_SGTJPFWH + " where bpwh is null and " + g_SGTJPFWH + " is not null";
oledbcomm.ExecuteNonQuery();
//报表模板路径
string Templatepath = Application.StartupPath + "\\..\\Template\\批次报批研判模板.cel";
oledbconn.Close();
//生成报表对话框
FormFlexcell frm;
ModFlexcell.m_SpecialRow = -1;
ModFlexcell.m_SpecialRow_ex = -1;
ModFlexcell.m_SpecialRow_ex2 = -1;
frm = ModFlexcell.SendDataToFlexcell(connstr, "监测图斑报批情况表", "tmprel", g_XZQHDM + "," + g_TBBH + ",jctbmj," + g_PC + "," + g_MJ + "," + g_ZB + ",bpwh", "", Templatepath, 4, 2);
AxFlexCell.AxGrid pGrid = frm.GetGrid();
string excelPath = m_WorkPath + "\\监测图斑报批情况表.xls";
pGrid.ExportToExcel(excelPath);
//frm.SaveFile(m_WorkPath + "\\监测图斑报批情况表.cel");
//弹出报表
ModStatReport.OpenExcelFile(excelPath);
}
public static IFeatureClassName GetFeatureClassName(IDatasetName pDatasetName)
{
IFeatureClassName pFeatureClassName = new FeatureClassNameClass();
try
{
pFeatureClassName.FeatureDatasetName = pDatasetName;
}
catch { }
return(pFeatureClassName);
}
/// <summary>
/// 复制源图层到目标dataset中的目标图层
/// </summary>
/// <param name="sourceWorkspaceDataset">源图层集</param>
/// <param name="targetWorkspaceDataset">目标图层集</param>
/// <param name="sourceFeatureClass">源图层</param>
/// <param name="nameOfTargetFeatureClass">待创建的图层名</param>
public static bool ConvertFeatureClass(IDataset sourceWorkspaceDataset, IDataset targetWorkspaceDataset,
IFeatureClass sourceFeatureClass,
string nameOfTargetFeatureClass)
{
try
{
IFeatureClassName nameOfSourceFeatureClass =
((IDataset)sourceFeatureClass).FullName as IFeatureClassName;
IDatasetName pSourceDsName = (IDatasetName)sourceWorkspaceDataset.FullName;
IDatasetName pTargetDsName = (IDatasetName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
targetFeatureClassName.FeatureDatasetName = pTargetDsName;
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = nameOfTargetFeatureClass;
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspaceDataset.Workspace;
fieldChecker.ValidateWorkspace = targetWorkspaceDataset.Workspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
// {
//geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(nameOfSourceFeatureClass, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
// break;
// }
//}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static void ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
//create source workspace name
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
////Open input Featureclass to get field definitions.
//ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceDatasetName;
//ITable sourceTable = (ITable)sourceName.Open();
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
//森林资源/地类图斑研判
private static void dltbJudge(IFeatureLayer pChangeFeaLayer, IFeatureLayer dltbFeaLayer, IWorkspace pOutWorkSpace, bool useSelection,SysCommon.CProgress vProgress)
{
ITable pChangeTable = pChangeFeaLayer as ITable;
ITable pcbpTable = dltbFeaLayer as ITable;
IFeatureClass dltbFeaClass = dltbFeaLayer.FeatureClass;
double rol = 0.0001;
IFeatureClassName pResFeaClassName = new FeatureClassNameClass();
//创建结果地物类名称
String fcName = dltbFeaClass.AliasName.Trim().Substring(dltbFeaClass.AliasName.Trim().IndexOf(".") + 1)+"_res";
IDataset pOutDataset = (IDataset)pOutWorkSpace;
IDatasetName pOutDatasetName = (IDatasetName)pResFeaClassName;
pOutDatasetName.WorkspaceName = (IWorkspaceName)pOutDataset.FullName;
pOutDatasetName.Name = fcName;
IBasicGeoprocessor pGeoProcessor = new BasicGeoprocessorClass();
//叠置分析
pGeoProcessor.Intersect(pChangeTable, useSelection, pcbpTable, false, rol, pResFeaClassName);
//从叠置结果生成报表
string connstr = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + pOutDatasetName.WorkspaceName.PathName ;
OleDbConnection oledbconn = new OleDbConnection(connstr);
oledbconn.Open();
ModTableFun.DropTable(oledbconn, "tmprel");
string sqlstr = "select "+g_XZQHDM+","+g_TBBH+","+g_MJ+" as jctbmj,"+g_TBBH+"_1,"+g_DLBM+","+g_TBMJ+","+g_TBDLMJ+",shape_area as jsmj,shape_area as mj,shape_area as zb into tmprel from " + fcName;
//行政区划代码，编号，面积，图斑编号，地类编码，图斑面积，图斑地类面积，计算面积，占比
OleDbCommand oledbcomm = oledbconn.CreateCommand();
oledbcomm.CommandText = sqlstr;
oledbcomm.ExecuteNonQuery();
//叠置结果地类面积计算方法： 面积=叠置结果计算面积*地类图斑地类面积/地类图斑总面积
oledbcomm.CommandText = "update tmprel set mj=jsmj*"+g_TBDLMJ+"/"+g_TBMJ+"";
oledbcomm.ExecuteNonQuery();
//计算占比
oledbcomm.CommandText = "update tmprel set zb=mj/jctbmj*100";
oledbcomm.ExecuteNonQuery();
//报表模板路径
oledbconn.Close();
string Templatepath = Application.StartupPath + "\\..\\Template\\森林资源现状研判模板.cel";
//生成报表对话框
FormFlexcell frm;
ModFlexcell.m_SpecialRow = -1;
ModFlexcell.m_SpecialRow_ex = -1;
ModFlexcell.m_SpecialRow_ex2 = -1;
frm = ModFlexcell.SendDataToFlexcell(connstr, "监测图斑地类情况表", "tmprel", g_XZQHDM + "," + g_TBBH + ",jctbmj," + g_TBBH + "_1,"+g_DLBM+"," + g_MJ + "," + g_ZB, "", Templatepath, 4, 2);
AxFlexCell.AxGrid pGrid = frm.GetGrid();
string excelPath = m_WorkPath + "\\监测图斑地类情况表.xls";
pGrid.ExportToExcel(excelPath);
//frm.SaveFile(m_WorkPath + "\\监测图斑地类情况表.cel");
//弹出报表
ModStatReport.OpenExcelFile(excelPath);
}
public static IFeatureClassName GetFeatureClassName(IFeatureClass pfc)
{
IDataset pDS = pfc as IDataset;
IWorkspaceName workspaceName = new WorkspaceNameClass();
workspaceName = pDS.FullName as IWorkspaceName;
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = (IDatasetName)featureClassName;
datasetName.Name = pDS.Name;
datasetName.WorkspaceName = workspaceName;
return featureClassName;
}
public static IFeatureClassName GetFeatureClassName(IFeatureClass pfc)
{
IDataset pDS = pfc as IDataset;
IWorkspaceName workspaceName = new WorkspaceNameClass();
workspaceName = pDS.FullName as IWorkspaceName;
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = (IDatasetName)featureClassName;
datasetName.Name = pDS.Name;
datasetName.WorkspaceName = workspaceName;
return(featureClassName);
}
public void FclssToShp(IFeatureClass fteClss, string lsshp)
{
if (fteClss == null || string.IsNullOrEmpty(lsshp))
{
return;
}
string filename = System.IO.Path.GetFileName(lsshp);
string filepath = System.IO.Path.GetDirectoryName(lsshp);
if (!System.IO.Directory.Exists(filepath))
{
System.IO.Directory.CreateDirectory(filepath);
}
//释放空间
using (ComReleaser comreleaser = new ComReleaser())
{
IDataset indataset = fteClss as IDataset;
IWorkspaceFactory pWorkfactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace fteWsp = pWorkfactory.OpenFromFile(filepath, 0) as IFeatureWorkspace;
IWorkspace inwsp = indataset.Workspace;
IFeatureClassName inFCName = indataset.FullName as IFeatureClassName;
//
IWorkspace outWsp = fteWsp as IWorkspace;
IDataset outdataset = outWsp as IDataset;
IWorkspaceName outWspName = outdataset.FullName as IWorkspaceName;
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName outDstName = outFCName as IDatasetName;
outDstName.WorkspaceName = outWspName;
outDstName.Name = fteClss.AliasName.ToString();
//检查字段的合法性
IFieldChecker checker = new FieldCheckerClass();
checker.InputWorkspace = inwsp;
checker.ValidateWorkspace = outWsp;
IFields fileds = fteClss.Fields;
IFields outfields = null;
IEnumFieldError error = null;
checker.Validate(fileds, out error, out outfields);
//转换为SHP
IFeatureDataConverter convert = new FeatureDataConverterClass();
convert.ConvertFeatureClass(inFCName, null, null, outFCName, null, outfields, "", 100, 0);
}
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static bool ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
public void CreateRoutes(IFeatureClass pLineFC, string InputRouteIDFieldName, string fromMeasureField,
string toMeasureField)
{
try
{
IWorkspace selectionContainer = (pLineFC as IDataset).Workspace;
IFeatureClassName outputFClassName = new FeatureClassNameClass();
IDataset dataset = (IDataset)selectionContainer;
IWorkspaceName fullName = (IWorkspaceName)dataset.FullName;
IDatasetName name3 = (IDatasetName)outputFClassName;
name3.WorkspaceName = fullName;
name3.Name = "CreateRoutes";
IFields fields = pLineFC.Fields;
int index = fields.FindField(pLineFC.ShapeFieldName);
IClone geometryDef = (IClone)fields.get_Field(index).GeometryDef;
IGeometryDef outputGeometryDef = (IGeometryDef)geometryDef.Clone();
((ISpatialReference2)outputGeometryDef.SpatialReference).SetMFalseOriginAndUnits(-1000.0, 1000.0);
IQueryFilter queryFilter = new QueryFilterClass
{
WhereClause = "[ROUTE1] <> 0"
};
ISelectionSet2 set =
(ISelectionSet2)
pLineFC.Select(queryFilter, esriSelectionType.esriSelectionTypeIDSet,
esriSelectionOption.esriSelectionOptionNormal, selectionContainer);
IRouteMeasureCreator creator = new RouteMeasureCreatorClass
{
InputFeatureSelection = set,
InputRouteIDFieldName = InputRouteIDFieldName
};
IEnumBSTR mbstr = creator.CreateUsing2Fields(fromMeasureField, toMeasureField, outputFClassName,
outputGeometryDef, "", null);
for (string str = mbstr.Next(); str != null; str = mbstr.Next())
{
}
}
catch (COMException exception)
{
MessageBox.Show(exception.Message, "COM Error: " + exception.ErrorCode.ToString(), MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
catch (Exception exception2)
{
MessageBox.Show(exception2.Message, ".NET Error: ", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public static IFeatureClass LoadShapefile(string shapepath,string shapename)
{
IFeatureClass feacls=null;
// Create workspace name object
IWorkspaceName wsName=new WorkspaceNameClass();
wsName.PathName=shapepath;
wsName.WorkspaceFactoryProgID="esriDataSourcesFile.shapefileworkspacefactory";
// Create dataset name object
IDatasetName dsname=new FeatureClassNameClass();
dsname.Name=shapename;
dsname.WorkspaceName = wsName;
// Open shapfile
IName name = dsname as IName;
feacls = name.Open() as IFeatureClass;
return feacls;
}
/// <summary>
/// Gets the feature class name reference for the feature class specified in the workspace name reference.
/// </summary>
/// <param name="workspaceName">Workspace name reference.</param>
/// <param name="featureclassName">Name of the featureclass.</param>
/// <returns>FeatureClass name reference</returns>
public static IFeatureClassName GetFeatureClassName(IWorkspaceName workspaceName, string featureclassName)
{
if (string.IsNullOrEmpty(featureclassName))
{
throw new ArgumentException("A valid FeatureClass [featureclassName] name is required.");
}
if (workspaceName == null)
{
throw new ArgumentNullException("A [workspaceName] reference is required.");
}
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = (IDatasetName)featureClassName;
datasetName.WorkspaceName = workspaceName;
datasetName.Name = featureclassName;
return(featureClassName);
}
/// <summary>
/// 复制数据到另一张表
/// </summary>
/// <param name="outZWorkspace">目标工作空间</param>
/// <param name="name">目标图层名</param>
/// <param name="filter">查询条件</param>
public void CopyTo(ZWorkspace outZWorkspace, string name, ZFilter filter)
{
// 数据源
IFeatureClassName inputFClassName = ((IDataset)featureClass).FullName as IFeatureClassName;
// 目标数据集
IDataset outDataSet = outZWorkspace.workspace as IDataset;
IWorkspaceName outWorkspaceName = outDataSet.FullName as IWorkspaceName;
// 目标图层
IFeatureClassName outputFClassName = new FeatureClassNameClass();
IDatasetName dataSetName = outputFClassName as IDatasetName;
dataSetName.WorkspaceName = outWorkspaceName;
dataSetName.Name = name;
// 导出
FeatureDataConverterClass converter = new FeatureDataConverterClass();
converter.ConvertFeatureClass(inputFClassName, filter.Value, null, outputFClassName, null, featureClass.Fields, "", 100, 0);
// 释放资源
Marshal.ReleaseComObject(converter);
}
private IFeatureClass CopyFeatureClassIntoNewWorkspace(IFeatureClass inFeatureClass, IWorkspace outWorkspace,
string newName)
{
// get FeatureClassName for input
var inDataset = inFeatureClass as IDataset;
var inFeatureClassName = inDataset.FullName as IFeatureClassName;
var inWorkspace = inDataset.Workspace;
// get WorkSpaceName for output
var outDataset = outWorkspace as IDataset;
var outWorkspaceName = outDataset.FullName as IWorkspaceName;
// Create new FeatureClassName
IFeatureClassName outFeatureClassName = new FeatureClassNameClass();
// Assign it a name and a workspace
var datasetName = outFeatureClassName as IDatasetName;
datasetName.Name = newName == String.Empty ? (inFeatureClassName as IDatasetName).Name : newName;
datasetName.WorkspaceName = outWorkspaceName;
// Check for field conflicts.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields inFields = inFeatureClass.Fields;
IFields outFields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = inWorkspace;
fieldChecker.ValidateWorkspace = outWorkspace;
fieldChecker.Validate(inFields, out enumFieldError, out outFields);
// Check enumFieldError for field naming conflicts
//Convert the data.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inFeatureClassName, null, null,
outFeatureClassName, null, outFields, "", 100, 0);
var pFeatureWS = (IFeatureWorkspace)outWorkspace;
return(pFeatureWS.OpenFeatureClass(newName));
}
private void method_0(string string_1)
{
try
{
IGxObject obj2 = new GxCadDataset();
IDatasetName name = new FeatureClassNameClass();
IWorkspaceName name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesFile.CadWorkspaceFactory",
PathName = this.idatasetName_0.WorkspaceName.PathName
};
name.Name = this.idatasetName_0.Name + ":" + string_1;
name.WorkspaceName = name2;
(obj2 as IGxDataset).DatasetName = name;
obj2.Attach(this, this.igxCatalog_0);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
}
/// <summary>
/// 叠置分析
/// </summary>
/// <param name="axmapcontrol"></param>
/// <param name="i">图层索引</param>
/// <param name="name">输出图层名字</param>
/// <returns></returns>
public static FeatureLayer Stastic(AxMapControl axmapcontrol, int i, string name)
{
if (axmapcontrol == null || axmapcontrol.LayerCount < 2)
{
return(null);
}
// pLayer = axmapcontrol.Map.Layer(0);
ILayer pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(i);
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
ITable table = pFeatureClass as ITable;
pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(axmapcontrol.LayerCount - 1);
IFeatureLayer ppFeatureLayer = (IFeatureLayer)pLayer;
IFeatureClass ppFeatureClass = ppFeatureLayer.FeatureClass;
ITable ptable = (ITable)ppFeatureClass;
//Intersect intersect=new Intersect()
Double tol = 0.0;
IWorkspaceFactory wspfctry = new ShapefileWorkspaceFactory();
IWorkspace pWorkSpace = wspfctry.OpenFromFile(SystemSet.Base_Map + "\\处理数据库\\实验数据", 0);
IDataset pDataset = (IDataset)pWorkSpace;
IName pName = pDataset.FullName;
IDatasetName pDatasetName = new FeatureClassNameClass();
pDatasetName.Name = name;
pDatasetName.WorkspaceName = (IWorkspaceName)pName;
IFeatureClassName fcn = (IFeatureClassName)pDatasetName;
IBasicGeoprocessor pBG = new BasicGeoprocessor();
IFeatureClass pOutFeatureClass = pBG.Intersect(table, false, ptable, false, tol, fcn);
IFeatureLayer pOutFeatLayer = new FeatureLayerClass();
FeatureLayer featurelayer = (FeatureLayer)pOutFeatLayer;
featurelayer.FeatureClass = pOutFeatureClass;
featurelayer.Name = pOutFeatureClass.AliasName;
return(featurelayer);
}
internal static IName RicavaDatasetName(IDataset datasetInput, IWorkspaceName workspaceName)
{
IDatasetName datasetName = null;
switch (datasetInput.Type)
{
case esriDatasetType.esriDTFeatureDataset:
IFeatureDatasetName InFeatureDatasetName = new FeatureDatasetNameClass();
datasetName = (IDatasetName)InFeatureDatasetName;
break;
case esriDatasetType.esriDTFeatureClass:
IFeatureClassName InFeatureClassName = new FeatureClassNameClass();
datasetName = (IDatasetName)InFeatureClassName;
break;
case esriDatasetType.esriDTTable:
ITableName InTableName = new TableNameClass();
datasetName = (IDatasetName)InTableName;
break;
case esriDatasetType.esriDTGeometricNetwork:
IGeometricNetworkName InGeometricNetworkName = new GeometricNetworkNameClass();
datasetName = (IDatasetName)InGeometricNetworkName;
break;
default:
return(null);
}
// Set the name and workspace name of the new name object.
datasetName.Name = datasetInput.Name;
datasetName.WorkspaceName = workspaceName;
// Cast the object to the IName interface and return it.
IName name = (IName)datasetName;
return(name);
}
/// <summary>
/// performs a simple copy of database object
/// </summary>
/// <param name="parentObjClass">the parent object</param>
/// <param name="outWks">out Workspace</param>
/// <returns>the new feature object</returns>
public IObjectClass simpleCopyObj(object parentObjClass, IWorkspace outWks)
{
IObjectClass outCls = null;
IQueryFilter qyf = new QueryFilterClass();
IFeatureDataConverter2 fdConv2 = new FeatureDataConverterClass();
IDataset dSet = (IDataset)parentObjClass;
esriDatasetType pDsetType = dSet.Type;
string bn = dSet.BrowseName;
string sbn = bn.Substring(bn.LastIndexOf(".")+1);
IDatasetName dSetN = (IDatasetName)dSet.FullName;
IDatasetName dSetN2;
IWorkspaceName wksN = (IWorkspaceName)((IDataset)outWks).FullName;
IFields pfs;
if (pDsetType == esriDatasetType.esriDTTable)
{
ITableName tbn = new TableNameClass();
dSetN2 = (IDatasetName)tbn;
dSetN2.Name = sbn;
dSetN2.WorkspaceName = wksN;
pfs = (IFields)((IClone)((IObjectClass)parentObjClass).Fields).Clone();
updateDomains(ref pfs, outWks);
fdConv2.ConvertTable(dSetN,qyf, null, dSetN2, pfs, "",1000, 0);
outCls = (IObjectClass)((IName)dSetN2).Open();
}
else if (pDsetType == esriDatasetType.esriDTFeatureClass)
{
IFeatureClass pFtCls = (IFeatureClass)dSet;
IFeatureClassName fcn = new FeatureClassNameClass();
IFeatureDatasetName fdn = new FeatureDatasetNameClass();
IDatasetName dSetN3 = (IDatasetName)fdn;
dSetN3.WorkspaceName = wksN;
IFeatureDataset pFtDs = pFtCls.FeatureDataset;
if (pFtDs == null)
{
dSetN3 = null;
fdn = null;
}
else
{
string ftDN = pFtCls.FeatureDataset.Name;
string ftDNs = ftDN.Substring(ftDN.LastIndexOf(".") + 1);
dSetN3.Name = ftDNs;
}
dSetN2 = (IDatasetName)fcn;
dSetN2.Name = sbn;
dSetN2.WorkspaceName = wksN;
IField pSf = pFtCls.Fields.get_Field(pFtCls.FindField(pFtCls.ShapeFieldName));
pfs = (IFields)((IClone)pFtCls.Fields).Clone();
updateDomains(ref pfs, outWks);
fdConv2.ConvertFeatureClass(dSetN, qyf, null, fdn, fcn, (IGeometryDef)((IClone)pSf.GeometryDef).Clone(), pfs, "", 1000, 0);
outCls = (IObjectClass)((IName)dSetN2).Open();
}
else
{
}
return outCls;
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static bool ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
return true;
}
catch (Exception exp)
{
return false;
}
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace">源Workspace</param>
/// <param name="targetWorkspace">目标Workspace</param>
/// <param name="sourceClassName">源图层</param>
/// <param name="destClassName">待创建的图层名</param>
public static bool ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string sourceClassName, string destClassName)
{
try
{
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = sourceClassName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = destClassName;
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// geometryField = targetFeatureClassFields.get_Field(i);
// if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
// {
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
null, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
// break;
// }
//}
return true;
}
catch (Exception exp)
{
return false;
}
}
private void Export(string tempMdbPathName, string attributeDatasetName, bool selectedOnly)
{
IRelationshipClass relClass = null;
IFeatureClass outFeatureClass = null;
IFeatureClass joinFeatureClass = null;
IFeatureLayer joinLayer = null;
IDataset attributeDataset;
ITable exportAttributes;
IWorkspaceFactory joinWorkspaceFactory = new OLEDBWorkspaceFactoryClass();
object outWS = null;
try
{
SetCursor(true);
OpenOleDbWorkspace(tempMdbPathName, attributeDatasetName, ref joinWorkspaceFactory,
out attributeDataset, out exportAttributes);
IDisplayTable hluDisplayTable = (IDisplayTable)_hluLayer;
IFeatureClass hluDisplayTableFeatureClass = (IFeatureClass)hluDisplayTable.DisplayTable;
// Set the selected and total feature counts.
int selectedFeatureCount = _hluFeatureSelection.SelectionSet.Count;
int totalFeatureCount = _hluLayer.FeatureClass.FeatureCount(null);
int exportFeatureCount = 0;
// Prompt the user for where to save the export layer.
IExportOperation exportOp = new ExportOperation();
bool saveProjection;
esriExportTableOptions exportOptions;
IDatasetName exportDatasetName = exportOp.GetOptions(hluDisplayTableFeatureClass,
_hluLayer.Name, _hluFeatureSelection != null && _hluFeatureSelection.SelectionSet.Count > 0,
true, _application.hWnd, out saveProjection, out exportOptions);
// If no export dataset name was chosen by the user then cancel the export.
if (exportDatasetName == null)
{
_pipeData.Add("cancelled");
return;
}
// Open the export dataset workspace.
outWS = ((IName)exportDatasetName.WorkspaceName).Open();
// Determine if the export layer is a shapefile.
bool isShp = IsShp(outWS as IWorkspace);
//---------------------------------------------------------------------
// FIX: 050 Warn ArcGIS users if field names may be truncated or
// renamed exporting to shapefiles.
//
// If the export layer is a shapefile check if any of
// the attribute field names will be truncated.
if (isShp)
{
bool fieldNamesTruncated = false;
for (int i = 0; i < exportAttributes.Fields.FieldCount; i++)
{
IField attributeField = exportAttributes.Fields.get_Field(i);
if (attributeField.Name.Length > 10)
{
fieldNamesTruncated = true;
break;
}
}
// Warn the user that some field names may get truncated.
if (fieldNamesTruncated)
{
MessageBoxResult userResponse = MessageBoxResult.No;
userResponse = MessageBox.Show("Some field names may get truncated or renamed exporting to a shapefile.\n\nDo you wish to proceed?", "HLU: Export",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (userResponse != MessageBoxResult.Yes)
{
_pipeData.Add("cancelled");
return;
}
}
}
//---------------------------------------------------------------------
// Get the geometry definition for the feature layer.
IGeometryDef geomDef = _hluFeatureClass.Fields.get_Field(_hluFeatureClass.FindField(
_hluFeatureClass.ShapeFieldName)).GeometryDef;
ITable joinLayerTable;
IDisplayTable joinDisplayTable;
//---------------------------------------------------------------------
// CHANGED: CR13 (Export features performance)
//
// If only a sub-set of features are being exported then
// export the sub-set to a temporary feature class before
// joining the temporary layer to the attribute dataset.
if (selectedOnly)
{
// Set the export options for which records to export.
exportOptions = esriExportTableOptions.esriExportSelectedRecords;
// Set the input DataSet name
IDataset inDataset;
inDataset = (IDataset)hluDisplayTable.DisplayTable;
IDatasetName inDatasetName;
inDatasetName = (IDatasetName)inDataset.FullName;
// set the output temporary DataSet name
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName outDatasetName = (IDatasetName)outFCName;
outDatasetName.Name = String.Format("{0}_temp", exportDatasetName.Name);
outDatasetName.WorkspaceName = exportDatasetName.WorkspaceName;
// Get the selected features for export
ISelectionSet selectionSet = _hluFeatureSelection.SelectionSet;
// If there is no selection cancel the export.
if (_hluFeatureSelection.SelectionSet.Count == 0)
{
_pipeData.Add("noselection");
return;
}
// Export the selected features to the temporary dataset.
exportOp.ExportFeatureClass(inDatasetName, null, selectionSet, geomDef, (IFeatureClassName)outDatasetName, _application.hWnd);
// Cast the workspace to IFeatureWorkspace and open the feature class.
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)outWS;
joinFeatureClass = featureWorkspace.OpenFeatureClass(outDatasetName.Name);
// Add an attribute index to the incid field.
AddFieldIndex(joinFeatureClass, String.Format("IX_{0}",
_hluLayerStructure.incidColumn.ColumnName),
_hluLayerStructure.incidColumn.ColumnName);
// Set the join layer to the temporary feature class.
joinLayer = new FeatureLayerClass();
joinLayer.FeatureClass = joinFeatureClass;
joinLayer.Name = joinFeatureClass.AliasName;
// Set the join layer table to the temporary feature class.
joinDisplayTable = (IDisplayTable)joinLayer;
//IFeatureClass joinDisplayTableFC = (IFeatureClass)joinDisplayTable.DisplayTable;
IFeatureClass joinDisplayTableFC = joinFeatureClass;
joinLayerTable = (ITable)joinDisplayTableFC;
// Set the count for the number of features to be exported.
exportFeatureCount = selectedFeatureCount;
}
// Otherwise, join the whole feature layer to the
// attribute dataset.
else
{
// Clear any current selection.
_hluFeatureSelection.SelectionSet = null;
// Set the export options for which records to export.
exportOptions = esriExportTableOptions.esriExportAllRecords;
// Set the join feature class to the current HLU feature class.
joinFeatureClass = _hluFeatureClass;
// Set the join layer to the current HLU feature layer.
joinLayer = _hluLayer;
joinLayerTable = (ITable)hluDisplayTableFeatureClass;
joinDisplayTable = hluDisplayTable;
// Set the count for the number of features to be exported.
exportFeatureCount = totalFeatureCount;
}
//---------------------------------------------------------------------
// Get the field names to be used when joining the attribute data and the feature layer
string originPKJoinField = _hluLayerStructure.incidColumn.ColumnName;
string originFKJoinField =
_hluFeatureClass.Fields.get_Field(_hluFieldMap[_hluLayerStructure.incidColumn.Ordinal]).Name;
// Get a list of all the fields to be used in the export layer (plus separate lists of all
// those fields that will come from the attribute table and those that will come from the
// feature layer).
List<IField> attributeFields;
List<IField> featClassFields;
List<IField> exportFields = ExportFieldLists(isShp, originPKJoinField, originFKJoinField, joinFeatureClass,
exportAttributes, out attributeFields, out featClassFields);
// Add x/y, length, or area and length fields to the list of fields in the export layer
// if the export layer is a shapefile.
ExportAddGeometryPropertyFields(isShp, exportFields);
// Create a virtual relationship between the feature class
// and the attribute dataset.
IMemoryRelationshipClassFactory memoryRelFactory = new MemoryRelationshipClassFactoryClass();
relClass = memoryRelFactory.Open("ExportRelClass", (IObjectClass)exportAttributes,
originPKJoinField, (IObjectClass)joinLayerTable, originFKJoinField, "forward", "backward",
esriRelCardinality.esriRelCardinalityOneToMany);
// Use the relationship to perform a join.
IDisplayRelationshipClass displayRelClass = (IDisplayRelationshipClass)joinLayer;
displayRelClass.DisplayRelationshipClass(relClass, esriJoinType.esriLeftInnerJoin);
// Create query filter for the export cursor so that
// only the required fields are retrieved.
bool featClassFieldsQualified;
bool attributeFieldsQualified;
IQueryFilter exportQueryFilter = ExportQueryFilter(originPKJoinField, joinLayer, joinFeatureClass, joinDisplayTable,
attributeDataset, featClassFields, attributeFields, out featClassFieldsQualified,
out attributeFieldsQualified);
// Create a collection of fields for the output feature class.
// Adds OID and SHAPE at beginning.
IFields outFields = CreateFieldsCollection(true, geomDef.HasZ, geomDef.HasM, outWS,
joinFeatureClass.ShapeType, exportFields.Select(f => f.Length).ToArray(),
exportFields.Select(f => f.Name).ToArray(), exportFields.Select(f => f.Name).ToArray(),
exportFields.Select(f => f.Type).ToArray(), exportFields.Select(f => f.Type !=
esriFieldType.esriFieldTypeOID).ToArray(), geomDef.SpatialReference);
// Create the output feature class.
outFeatureClass = CreateFeatureClass(exportDatasetName.Name, null, outWS,
outFields, esriFeatureType.esriFTSimple, joinFeatureClass.ShapeType, null, null);
// Map the fields between the display and table and the output feature
// class as the display table always includes all fields.
// The first two fields are always OID and SHAPE.
int[] exportFieldMap = new int[] { 0, 1 }.Concat(featClassFields
.Select(f => joinDisplayTable.DisplayTable.Fields.FindField(featClassFieldsQualified ?
joinLayer.Name + "." + f.Name : f.Name))).Concat(attributeFields
.Select(f => joinDisplayTable.DisplayTable.Fields.FindField(attributeFieldsQualified ?
attributeDataset.Name + "." + f.Name : f.Name))).ToArray();
//---------------------------------------------------------------------
// FIX: 038 Display the export progress bar correctly when exporting
// from ArcGIS.
// Pass the number of features to be exported, not the number of incids,
// so that the export progress is displayed corectly
//
// Insert the features and attributes into the new feature class.
ExportInsertFeatures(joinDisplayTable, exportQueryFilter, exportFeatureCount,
exportFieldMap, isShp, outWS, outFeatureClass);
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// CHANGED: CR16 (Adding exported features)
// Ask the user if they want to add the new export layer
// to the active map.
MessageBoxResult addResponse = MessageBoxResult.No;
addResponse = MessageBox.Show("The export operation succeeded.\n\nAdd the exported layer to the current map?", "HLU: Export",
MessageBoxButton.YesNo, MessageBoxImage.Question);
if (addResponse == MessageBoxResult.Yes)
{
// Add the exported feature layer to the active map.
IFeatureLayer hluExportLayer;
hluExportLayer = new FeatureLayer();
hluExportLayer.FeatureClass = outFeatureClass;
hluExportLayer.Name = outFeatureClass.AliasName;
_focusMap.AddLayer(hluExportLayer);
}
//---------------------------------------------------------------------
}
catch (Exception ex) { _pipeData.Add(ex.Message); }
finally
{
// Remove the virtual relationship.
if (relClass != null)
{
//IRelationshipClassCollectionEdit relClassEdit = (IRelationshipClassCollectionEdit)joinLayer;
//relClassEdit.RemoveAllRelationshipClasses();
((IDisplayRelationshipClass)joinLayer).DisplayRelationshipClass(
null, esriJoinType.esriLeftInnerJoin);
}
// Destroy workspace factory so the attribute dataset can
// be deleted later.
attributeDataset = null;
exportAttributes = null;
joinWorkspaceFactory = null;
// Delete the temporary feature class.
try
{
if (joinFeatureClass != _hluFeatureClass)
{
IDataset tempDataset = (IDataset)joinFeatureClass;
if (tempDataset != null) tempDataset.Delete();
}
}
catch { }
SetCursor(false);
}
}
/// <summary>
/// 转格式
/// </summary>
/// <param name="sourceWorkspacePath"></param>
/// <param name="targetWorkspacePath"></param>
/// <param name="sourceDataName"></param>
/// <param name="targetDataName"></param>
public static void ConvertFeatureClassToShapefile(string sourceWorkspacePath, string targetWorkspacePath, string sourceDataName, string targetDataName)
{
// Open the source and target workspaces.
IWorkspaceFactory sourceWorkspaceFactory = new FileGDBWorkspaceFactoryClass();
IWorkspaceFactory targetWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace sourceWorkspace = sourceWorkspaceFactory.OpenFromFile(sourceWorkspacePath, 0);
IWorkspace targetWorkspace = targetWorkspaceFactory.OpenFromFile(targetWorkspacePath, 0);
// Cast the workspaces to the IDataset interface and get name objects.
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IName sourceWorkspaceDatasetName = sourceWorkspaceDataset.FullName;
IName targetWorkspaceDatasetName = targetWorkspaceDataset.FullName;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDatasetName;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDatasetName;
// Create a name object for the shapefile and cast it to the IDatasetName interface.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = sourceDataName;//"streets";
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
// Create a name object for the FGDB feature class and cast it to the IDatasetName interface.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = targetDataName;// "AtlantaStreets";
targetDatasetName.WorkspaceName = targetWorkspaceName;
// Open source feature class to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Create a query filter to remove ramps, interstates and highways.
IQueryFilter queryFilter = new QueryFilterClass();
//queryFilter.WhereClause = "NAME <> 'Ramp' AND PRE_TYPE NOT IN ('I', 'Hwy')";
queryFilter.WhereClause = "1=1";
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject =
featureDataConverter.ConvertFeatureClass(sourceFeatureClassName,
queryFilter, null, targetFeatureClassName, targetGeometryDef, targetFields,
"", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}",
invalidObjectInfo.InvalidObjectID);
}
}
/// <summary>
/// 复制源图层到目标dataset中的目标图层
/// </summary>
/// <param name="sourceWorkspaceDataset">源图层集</param>
/// <param name="targetWorkspaceDataset">目标图层集</param>
/// <param name="sourceFeatureClass">源图层</param>
/// <param name="nameOfTargetFeatureClass">待创建的图层名</param>
public static bool ConvertFeatureClass(IDataset sourceWorkspaceDataset, IDataset targetWorkspaceDataset,
IFeatureClass sourceFeatureClass,
string nameOfTargetFeatureClass)
{
try
{
IFeatureClassName nameOfSourceFeatureClass =
((IDataset)sourceFeatureClass).FullName as IFeatureClassName;
IDatasetName pSourceDsName = (IDatasetName)sourceWorkspaceDataset.FullName;
IDatasetName pTargetDsName = (IDatasetName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
targetFeatureClassName.FeatureDatasetName = pTargetDsName;
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = nameOfTargetFeatureClass;
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspaceDataset.Workspace;
fieldChecker.ValidateWorkspace = targetWorkspaceDataset.Workspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
// {
//geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(nameOfSourceFeatureClass, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
// break;
// }
//}
return true;
}
catch (Exception exp)
{
return false;
}
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="nameOfSourceFeatureClass"></param>
/// <param name="nameOfTargetFeatureClass"></param>
public static void ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
try
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
geometryField = targetFeatureClassFields.get_Field(i);
if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
{
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
//targetFCGeoDefEdit.GridCount_2 = 1;
//targetFCGeoDefEdit.set_GridSize(0, 1000);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataset ipDataset = (IFeatureDataset)pEnumDataset.Next();
IDatasetName pTargetDsName = (IDatasetName)ipDataset.FullName;
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
break;
}
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
public void CreateRoutesUsing2Fields(string pAccessWS, string sLineFC, string sOutRouteFC, string sWhereClause, string sRouteIDField, string sFromMeasureField, string sToMeasureField)
{
try
{
IWorkspaceFactory wsf = new AccessWorkspaceFactoryClass();
IWorkspace ws = wsf.OpenFromFile(pAccessWS, 0);
IFeatureWorkspace fws = (IFeatureWorkspace)ws;
IFeatureClass lineFC = fws.OpenFeatureClass(sLineFC);
// Create an output feature class name object. We'll write to a stand alone feature class in the
// the same workspace as the inputs
IDataset ds = (IDataset)ws;
IWorkspaceName outWSN = (IWorkspaceName)ds.FullName;
IFeatureClassName outFCN = new FeatureClassNameClass();
IDatasetName outDSN = (IDatasetName)outFCN;
outDSN.WorkspaceName = outWSN;
outDSN.Name = sOutRouteFC;
//This name should not already exist
// Create a geometry definition for the new feature class. For the most part, we will copy the geometry
// definition from the input lines. We'll explicitly set the M Domain, however. You should always set an
// M Domain that is appropriate to your data. What is below is just a sample.
IFields flds = lineFC.Fields;
Int32 i = flds.FindField(lineFC.ShapeFieldName);
IField fld = flds.get_Field(i);
IClone GDefclone = (IClone)fld.GeometryDef;
IGeometryDef gDef = (IGeometryDef)GDefclone.Clone();
ISpatialReference2 srRef = (ISpatialReference2)gDef.SpatialReference;
srRef.SetMFalseOriginAndUnits(-1000, 10000);
// Create a selection set to limit the number of lines that will be used to create routes
IQueryFilter qFilt = new QueryFilterClass();
qFilt.WhereClause = sWhereClause;
ISelectionSet2 selSet = (ISelectionSet2)lineFC.Select(qFilt, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, ws);
// Create a new RouteMeasureCreator object. Note that below, we use the selection set and not the
// InputFeatureClass property
IRouteMeasureCreator routeCreator = new RouteMeasureCreatorClass();
routeCreator.InputFeatureSelection = selSet;
routeCreator.InputRouteIDFieldName = sRouteIDField;
IEnumBSTR errors = routeCreator.CreateUsing2Fields(sFromMeasureField, sToMeasureField, outFCN, gDef, "", null);
// The results of running CreatingUsing2Fields returns IEnumBSTR, which is a container
// for a list of error strings indicating why certain lines could not be used to create routes.
string sError = errors.Next();
do
{
System.Windows.Forms.MessageBox.Show(sError);
sError = errors.Next();
} while (sError.Length != 0);
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.Message);
}
}
public IFeatureClass Intsect(IFeatureClass _pFtClass,IFeatureClass _pFtOverlay,string _FilePath,string _pFileName)
{
IFeatureClassName pOutPut = new FeatureClassNameClass();
pOutPut.ShapeType = _pFtClass.ShapeType;
pOutPut.ShapeFieldName = _pFtClass.ShapeFieldName;
pOutPut.FeatureType = esriFeatureType.esriFTSimple;
//set output location and feature class name
IWorkspaceName pWsN = new WorkspaceNameClass();
pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";
pWsN.PathName = _FilePath;
//也可以用这种方法,IName 和IDataset的用法
/* IWorkspaceFactory pWsFc = new ShapefileWorkspaceFactoryClass();
IWorkspace pWs = pWsFc.OpenFromFile(_FilePath, 0);
IDataset pDataset = pWs as IDataset;
IWorkspaceName pWsN = pDataset.FullName as IWorkspaceName;
*/
IDatasetName pDatasetName = pOutPut as IDatasetName;
pDatasetName.Name = _pFileName;
pDatasetName.WorkspaceName =pWsN;
IBasicGeoprocessor pBasicGeo = new BasicGeoprocessorClass();
IFeatureClass pFeatureClass = pBasicGeo.Intersect(_pFtClass as ITable , false, _pFtOverlay as ITable , false, 0.1, pOutPut);
return pFeatureClass;
}
/// <summary>
/// shape图层入库
/// </summary>
/// <params name="sourceworkspace"></params>
/// <params name="targetworkspace"></params>
/// <params name="nameOfsourceFeatureClass"></params>
/// <params name="nameOftargetFeatureClass"></params>
/// <returns></returns>
public IFeatureClass ShapeFileIntoGDB(IWorkspace sourceworkspace,IWorkspace targetworkspace,
string nameOfsourceFeatureClass, string nameOftargetFeatureClass)
{
try
{
//创建源工作空间
IDataset sourceWorkspaceDataset = (IDataset)sourceworkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//创建源数据集
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfsourceFeatureClass;
//创建目标工作空间
IDataset targetWorkspaceDataset = (IDataset)targetworkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//创建目标数据集
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOftargetFeatureClass;
//源数据集的字段集
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//验证字段
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
//设置验证的对象
fieldChecker.InputWorkspace = sourceworkspace;
fieldChecker.ValidateWorkspace = targetworkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
//找到空间对象字段
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
//得到空间字段的定义
IGeometryDef geometryDef = geometryField.GeometryDef;
//得到空间字段的索引
IGeometryDefEdit targetFCGeometryDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeometryDefEdit.GridCount_2 = 1;
targetFCGeometryDefEdit.set_GridSize(0, 0);
//targetFCGeometryDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference spatialReference = DataEditCommon.g_pMap.SpatialReference;
//spatialReferenceFactory.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_NAD1983UTM_20N);
ISpatialReferenceResolution spatialReferenceResolution = (ISpatialReferenceResolution)spatialReference;
spatialReferenceResolution.ConstructFromHorizon();
spatialReferenceResolution.SetDefaultXYResolution();
spatialReferenceResolution.SetDefaultZResolution();
ISpatialReferenceTolerance spatialReferenceTolerance = (ISpatialReferenceTolerance)spatialReference;
spatialReferenceTolerance.SetMinimumXYTolerance();
spatialReferenceTolerance.SetMinimumZTolerance();
double XMin, XMax, YMin, YMax, ZMin, ZMax, MinXYTolerance, MinZTolerance;
XMin = 4054.3603997438;
XMax = 78088.6926632544;
YMin = 14424.8510028409;
YMax = 59609.4812606697;
ZMin = 30330.1483519995;
ZMax = 38389.3283520005;
//spatialReference.SetDomain(XMin, XMax, YMin, YMax);
//spatialReference.SetZDomain(ZMin, ZMax);
MinXYTolerance = 0.000000000008219;
MinZTolerance = 0.000000000007629;
//spatialReferenceTolerance.SetMinimumZTolerance( MinXYTolerance);
//spatialReference.GetDomain(out XMin, out XMax, out YMin, out YMax);
//spatialReference.GetZDomain(out ZMin, out ZMax);
targetFCGeometryDefEdit.SpatialReference_2 = spatialReference;
//开始导入
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//导入所有的输入对象
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(sourceFeatureClassName,
queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
//导入后数据集的字段集
IName targetName = (IName)targetFeatureClassName;
IFeatureClass targetFeatureClass = (IFeatureClass)targetName.Open();
return targetFeatureClass;
}
catch (Exception ex)
{
return null;
}
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="nameOfSourceFeatureClass"></param>
/// <param name="nameOfTargetFeatureClass"></param>
public static void ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
try
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
geometryField = targetFeatureClassFields.get_Field(i);
if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
{
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
//targetFCGeoDefEdit.GridCount_2 = 1;
//targetFCGeoDefEdit.set_GridSize(0, 1000);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataset ipDataset = (IFeatureDataset)pEnumDataset.Next();
IDatasetName pTargetDsName = (IDatasetName)ipDataset.FullName;
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
break;
}
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static void ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
//create source workspace name
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
////Open input Featureclass to get field definitions.
//ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceDatasetName;
//ITable sourceTable = (ITable)sourceName.Open();
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
//internal void ExportFeatureClassToShp(ESRI.ArcGIS.Geodatabase.IFeatureClass pFeatureClass, string strFullPath, string filePath)
//{
// //throw new NotImplementedException();
public void ExportFeatureClassToShp(IFeatureClass apFeatureClass, string ExportShapeFileName, string ExportFilePath)
{
if (apFeatureClass == null)
{
MessageBox.Show("请选择", "系统提示");
return;
}
if (ExportShapeFileName == "")
return;
string ExportFileShortName = System.IO.Path.GetFileNameWithoutExtension(ExportShapeFileName);
ExportFilePath = System.IO.Path.GetDirectoryName(ExportShapeFileName);
shpPath = ExportFilePath + "\\" + ExportFileShortName + "\\" + ExportFileShortName + ".shp";
//设置导出要素类的参数
IFeatureClassName pOutFeatureClassName = new FeatureClassNameClass();
IDataset pOutDataset = (IDataset)apFeatureClass;
pOutFeatureClassName = (IFeatureClassName)pOutDataset.FullName;
//创建一个输出shp文件的工作空间
IWorkspaceFactory pShpWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspaceName pInWorkspaceName = new WorkspaceNameClass();
pInWorkspaceName = pShpWorkspaceFactory.Create(ExportFilePath, ExportFileShortName, null, 0);
//创建一个要素集合
IFeatureDatasetName pInFeatureDatasetName = null;
//创建一个要素类
IFeatureClassName pInFeatureClassName = new FeatureClassNameClass();
IDatasetName pInDatasetClassName;
pInDatasetClassName = (IDatasetName)pInFeatureClassName;
pInDatasetClassName.Name = ExportFileShortName;//作为输出参数
pInDatasetClassName.WorkspaceName = pInWorkspaceName;
//通过FIELDCHECKER检查字段的合法性，为输出SHP获得字段集合
long iCounter;
IFields pOutFields, pInFields;
IFieldChecker pFieldChecker;
IField pGeoField;
IEnumFieldError pEnumFieldError = null;
pInFields = apFeatureClass.Fields;
pFieldChecker = new FieldChecker();
pFieldChecker.Validate(pInFields, out pEnumFieldError, out pOutFields);
//通过循环查找几何字段
pGeoField = null;
for (iCounter = 0; iCounter < pOutFields.FieldCount; iCounter++)
{
if (pOutFields.get_Field((int)iCounter).Type == esriFieldType.esriFieldTypeGeometry)
{
pGeoField = pOutFields.get_Field((int)iCounter);
break;
}
}
//得到几何字段的几何定义
IGeometryDef pOutGeometryDef;
IGeometryDefEdit pOutGeometryDefEdit;
pOutGeometryDef = pGeoField.GeometryDef;
//设置几何字段的空间参考和网格
pOutGeometryDefEdit = (IGeometryDefEdit)pOutGeometryDef;
pOutGeometryDefEdit.GridCount_2 = 1;
pOutGeometryDefEdit.set_GridSize(0, 1500000);
try
{
//开始导入
IFeatureDataConverter pShpToClsConverter = new FeatureDataConverterClass();
//pShpToClsConverter.ConvertFeatureClass(pOutFeatureClassName, null, pInFeatureDatasetName, pInFeatureClassName, pOutGeometryDef, pOutFields, "", 1000, 0);
pShpToClsConverter.ConvertFeatureClass(pOutFeatureClassName, null, pInFeatureDatasetName, pInFeatureClassName, pOutGeometryDef, pOutFields, "", 1000, 0);
MessageBox.Show("导出成功", "系统提示");
}
catch (Exception ex)
{
MessageBox.Show("the following exception occurred:" + ex.ToString());
}
}
/// <summary>
/// 复制源图层到目标dataset中的目标图层
/// </summary>
/// <param name="sourceWorkspaceDataset">源图层集</param>
/// <param name="targetWorkspaceDataset">目标图层集</param>
/// <param name="sourceFeatureClass">源图层</param>
/// <param name="nameOfTargetFeatureClass">待创建的图层名</param>
public static IFeatureClass ConvertFeatureClass(IDataset sourceWorkspaceDataset, IDataset targetWorkspaceDataset,
IFeatureClass sourceFeatureClass,
string nameOfTargetFeatureClass)
{
IFeatureClass TragetFeatureClass = null;
try
{
IFeatureClassName nameOfSourceFeatureClass =
((IDataset)sourceFeatureClass).FullName as IFeatureClassName;
IDatasetName pSourceDsName = (IDatasetName)sourceWorkspaceDataset.FullName;
IDatasetName pTargetDsName = (IDatasetName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
targetFeatureClassName.FeatureDatasetName = pTargetDsName;
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspaceDataset.Workspace;
fieldChecker.ValidateWorkspace = targetWorkspaceDataset.Workspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
//targetFCGeoDefEdit.GridCount_2 = 1;
//targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(nameOfSourceFeatureClass, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
string strTargetFtCls = ((IDatasetName)targetFeatureClassName).Name;
TragetFeatureClass =
((IFeatureWorkspace)targetWorkspaceDataset.Workspace).OpenFeatureClass(strTargetFtCls);
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return null;
}
return TragetFeatureClass;
}
public void OutPut(AxMapControl pMapControl, String Path,String Name)
{
// set output featureclass name and shape type
IFeatureClassName pOutName;
pOutName = new FeatureClassNameClass();
pOutName.FeatureType = esriFeatureType.esriFTSimple;
pOutName.ShapeFieldName = "Shape";
pOutName.ShapeType = this.pFeatureClass1.ShapeType;
//set output location and feature class name
IWorkspaceName pWsN;
pWsN = new WorkspaceNameClass();
pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";
//IWorkspaceFactory pWFC;����Factoryʵ�֣�����Щ�����Ĺ�ϵ���е�ģ����
// pWFC = new WorkspaceFactoryClass();
// pWsN = pWFC.Create(Path, "Test", null, 0);
// IFeatureWorkspace pShape;
pWsN.PathName = Path;
IDatasetName pDN;
pDN = pOutName as IDatasetName;
pDN.Name = Name;
pDN.WorkspaceName = pWsN;
//set tolerence
double tol = 0.1;
IBasicGeoprocessor pBGP;
pBGP = new BasicGeoprocessorClass();
pBGP.SpatialReference = pMapControl.Map.SpatialReference;
IFeatureClass pOutClass;
pOutClass = pBGP.Intersect(this.pTable1, false, this.pTable2, false, tol, pOutName);
// pOutClass = pBGP.Union(this.pTable1, false, this.pTable2, false, tol, pOutName);
// pOutClass= pBGP.Clip(this.pTable1, false, this.pTable2, false, tol, pOutName);
/* IArray pArry;
pArry = new ArrayClass();
pArry.Add(pTable1);
pArry.Add(this.pTable2);
pOutClass = pBGP.Merge(pArry, this.pTable1, pOutName);
*/
//ITable pToutTable;
// pToutTable = new TableClass();
//IField pField;
// pField =pFeatureLayer1 .FeatureClass .Fields .get_Field (pFeatureClass1 .FindField ("name"));
IFeatureLayer pOutLayer;
pOutLayer = new FeatureLayerClass();
pOutLayer.FeatureClass = pOutClass;
pOutLayer.Name = pOutClass.AliasName;
pMapControl.AddLayer(pOutLayer);
}
/// <summary>
/// 叠置分析
/// </summary>
/// <param name="axmapcontrol"></param>
/// <param name="i">图层索引</param>
/// <param name="name">输出图层名字</param>
/// <returns></returns>
public static FeatureLayer Stastic(AxMapControl axmapcontrol,int i,string name)
{
if (axmapcontrol == null || axmapcontrol.LayerCount < 2)
{
return null;
}
// pLayer = axmapcontrol.Map.Layer(0);
ILayer pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(i);
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
ITable table = pFeatureClass as ITable;
pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(axmapcontrol.LayerCount - 1);
IFeatureLayer ppFeatureLayer=(IFeatureLayer)pLayer;
IFeatureClass ppFeatureClass=ppFeatureLayer.FeatureClass;
ITable ptable = (ITable)ppFeatureClass;
//Intersect intersect=new Intersect()
Double tol=0.0;
IWorkspaceFactory wspfctry = new ShapefileWorkspaceFactory();
IWorkspace pWorkSpace = wspfctry.OpenFromFile(SystemSet.Base_Map + "\\处理数据库\\实验数据", 0);
IDataset pDataset = (IDataset)pWorkSpace;
IName pName=pDataset.FullName;
IDatasetName pDatasetName = new FeatureClassNameClass();
pDatasetName.Name = name;
pDatasetName.WorkspaceName = (IWorkspaceName)pName;
IFeatureClassName fcn = (IFeatureClassName)pDatasetName;
IBasicGeoprocessor pBG=new BasicGeoprocessor();
IFeatureClass pOutFeatureClass = pBG.Intersect(table, false, ptable, false, tol, fcn);
IFeatureLayer pOutFeatLayer = new FeatureLayerClass();
FeatureLayer featurelayer = (FeatureLayer)pOutFeatLayer;
featurelayer.FeatureClass = pOutFeatureClass;
featurelayer.Name = pOutFeatureClass.AliasName;
return featurelayer;
}
public void IFeatureDataConverter(IWorkspace pSourceWorkspace, IWorkspace pTargetWorkspace, string pSFeatureClass, string pDFeatureClass)
{
IDataset sourceWorkspaceDataset = (IDataset)pSourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = pSFeatureClass;
IDataset targetWorkspaceDataset = (IDataset)pTargetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = pDFeatureClass;
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = pSourceWorkspace;
fieldChecker.ValidateWorkspace = pTargetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
/// <summary>
/// 要素类转Shape
/// </summary>
/// <param name="apFeatureClass"></param>
private void ExportFeatureClassToConTempShp(IFeatureClass apFeatureClass)
{
if (Directory.Exists(System.Windows.Forms.Application.StartupPath + "\\Convert\\DWGConvert\\ConTempShp"))
{
Directory.Delete(System.Windows.Forms.Application.StartupPath + "\\Convert\\DWGConvert\\ConTempShp", true);
}
//设置导出要素类的参数
IFeatureClassName pOutFeatureClassName = new FeatureClassNameClass();
IDataset pOutDataset = (IDataset)apFeatureClass;
pOutFeatureClassName = (IFeatureClassName)pOutDataset.FullName;
//创建一个输出shp文件的工作空间
IWorkspaceFactory pShpWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspaceName pInWorkspaceName = new WorkspaceNameClass();
pInWorkspaceName = pShpWorkspaceFactory.Create(System.Windows.Forms.Application.StartupPath + "\\Convert\\DWGConvert", "ConTempShp", null, 0);
//创建一个要素集合
IFeatureDatasetName pInFeatureDatasetName = null;
//创建一个要素类
IFeatureClassName pInFeatureClassName = new FeatureClassNameClass();
IDatasetName pInDatasetClassName;
pInDatasetClassName = (IDatasetName)pInFeatureClassName;
pInDatasetClassName.Name = "ConTempShp";//作为输出参数
pInDatasetClassName.WorkspaceName = pInWorkspaceName;
//通过FIELDCHECKER检查字段的合法性，为输出SHP获得字段集合
long iCounter;
IFields pOutFields, pInFields;
IFieldChecker pFieldChecker;
IField pGeoField;
IEnumFieldError pEnumFieldError = null;
pInFields = apFeatureClass.Fields;
pFieldChecker = new FieldChecker();
pFieldChecker.Validate(pInFields, out pEnumFieldError, out pOutFields);
//通过循环查找几何字段
pGeoField = null;
for (iCounter = 0; iCounter < pOutFields.FieldCount; iCounter++)
{
if (pOutFields.get_Field((int)iCounter).Type == esriFieldType.esriFieldTypeGeometry)
{
pGeoField = pOutFields.get_Field((int)iCounter);
break;
}
}
//得到几何字段的几何定义
IGeometryDef pOutGeometryDef;
IGeometryDefEdit pOutGeometryDefEdit;
pOutGeometryDef = pGeoField.GeometryDef;
//设置几何字段的空间参考和网格
pOutGeometryDefEdit = (IGeometryDefEdit)pOutGeometryDef;
pOutGeometryDefEdit.GridCount_2 = 1;
pOutGeometryDefEdit.set_GridSize(0, 1500000);
//try
//{
IFeatureDataConverter pShpToClsConverter = new FeatureDataConverterClass();
pShpToClsConverter.ConvertFeatureClass(pOutFeatureClassName, null, pInFeatureDatasetName, pInFeatureClassName, pOutGeometryDef, pOutFields, "", 1000, 0);
// MessageBox.Show("导出成功", "系统提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
//}
//catch (Exception ex)
//{
//}
/*****20130227杨漾(去掉trycatch，上层trycatch(MainForm)处理)*****/
}
public IFeatureClass exportFeatures(IFeatureClass inputFeatureClass, string outPath, ISpatialFilter filter)
{
// Create a name object for the source (shapefile) workspace and open it.
IDataset inDset = (IDataset)inputFeatureClass;
IWorkspace sourceWorkspace = (inDset).Workspace;
// Create a name object for the target (file GDB) workspace and open it.
string outDbStr = geoUtil.parseDbStr(outPath);
string outName = System.IO.Path.GetFileName(outPath);
IWorkspace targetWorkspace = geoUtil.OpenWorkSpace(outDbStr);
outName = geoUtil.getSafeOutputNameNonRaster(targetWorkspace, outName);
// Create a name object for the source dataset.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = inDset.Name;
sourceDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)sourceWorkspace).FullName;
// Create a name object for the target dataset.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = outName;
targetDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)targetWorkspace).FullName; ;
// Open source feature class to get field definitions.
//IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = inputFeatureClass;
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Cast the IGeometryDef to the IGeometryDefEdit interface.
IGeometryDefEdit targetGeometryDefEdit = (IGeometryDefEdit)targetGeometryDef;
// Set the IGeometryDefEdit properties.
targetGeometryDefEdit.GridCount_2 = 1;
targetGeometryDefEdit.set_GridSize(0, 0.75);
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(sourceFeatureClassName, filter, null, targetFeatureClassName, targetGeometryDef, targetFields, "", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}", invalidObjectInfo.InvalidObjectID);
}
return (IFeatureClass)((IName)targetFeatureClassName).Open();
}
/// <summary>
/// Shape数据导入SDE现有数据源
/// </summary>
/// <params name="sourceworkspace"></params>
/// <params name="targetworkspace"></params>
/// <params name="nameOfsourceFeatureClass"></params>
/// <params name="nameOftargetFeatureClass"></params>
/// <returns></returns>
public bool ShapeImportGDB(IWorkspace sourceworkspace, IWorkspace targetworkspace,
string nameOfsourceFeatureClass, string nameOftargetFeatureClass,List<ziduan> list)
{
try
{
//创建源工作空间
IDataset sourceWorkspaceDataset = (IDataset)sourceworkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//创建源数据集
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfsourceFeatureClass;
//源数据集的字段集
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//创建目标工作空间
IDataset targetWorkspaceDataset = (IDataset)targetworkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//创建目标数据集
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOftargetFeatureClass;
//目标数据集的字段集
IName targetName = (IName)targetFeatureClassName;
IFeatureClass targetFeatureClass = (IFeatureClass)targetName.Open();
IFeatureCursor pCursor = sourceFeatureClass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
if (DataEditCommon.g_CurWorkspaceEdit==null)
DataEditCommon.g_CurWorkspaceEdit = (IWorkspaceEdit)DataEditCommon.g_pCurrentWorkSpace;
DataEditCommon.g_CurWorkspaceEdit.StartEditing(true);
DataEditCommon.g_CurWorkspaceEdit.StartEditOperation();
}
IField pField=null;
object pValue = null;
while (pFeature != null)
{
IFeature tFeature=targetFeatureClass.CreateFeature();
tFeature.Shape = pFeature.ShapeCopy;
for (int i = 0; i < pFeature.Fields.FieldCount; i++)
{
pField = pFeature.Fields.get_Field(i);
if (pField.Type == esriFieldType.esriFieldTypeGeometry || pField.Type == esriFieldType.esriFieldTypeGlobalID || pField.Type == esriFieldType.esriFieldTypeOID)
continue;
pValue = pFeature.get_Value(i);
if (tFeature.Fields.FindField(pField.Name) > 0)
{
tFeature.set_Value(tFeature.Fields.FindField(pField.Name), pValue);
}
}
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
if (tFeature.Fields.FindField(list[i].name) > 0)
{
tFeature.set_Value(tFeature.Fields.FindField(list[i].name), list[i].value);
}
}
}
tFeature.Store();
pFeature = pCursor.NextFeature();
}
if (DataEditCommon.g_CurWorkspaceEdit.IsBeingEdited())
{
DataEditCommon.g_CurWorkspaceEdit.StopEditOperation();
DataEditCommon.g_CurWorkspaceEdit.StopEditing(true);
}
return true;
}
catch (Exception ex)
{
return false;
}
}
public static void TranferBetweenGeodatabase(string featureClass, string targetPath, string sourcePath)
{
// Create new workspace name objects.
IWorkspaceName sourceWorkspaceName = new WorkspaceNameClass();
IWorkspaceName targetWorkspaceName = new WorkspaceNameClass();
IName targetName = (IName)targetWorkspaceName;
// Set the workspace name properties.
sourceWorkspaceName.PathName = @sourcePath;//"C:\arcgis\ArcTutor\BuildingaGeodatabase\Montgomery.gdb";
sourceWorkspaceName.WorkspaceFactoryProgID = "esriDataSourcesGDB.FileGDBWorkspaceFactory";
targetWorkspaceName.PathName = @targetPath;//"PartialMontgomery.gdb";
targetWorkspaceName.WorkspaceFactoryProgID = "esriDataSourcesGDB.FileGDBWorkspaceFactory";
// Create a name object for the source feature class.
IFeatureClassName featureClassName = new FeatureClassNameClass();
// Set the featureClassName properties.
IDatasetName sourceDatasetName = (IDatasetName)featureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = featureClass;//"Blocks";
IName sourceName = (IName)sourceDatasetName;
// Create an enumerator for source datasets.
IEnumName sourceEnumName = new NamesEnumeratorClass();
IEnumNameEdit sourceEnumNameEdit = (IEnumNameEdit)sourceEnumName;
// Add the name object for the source class to the enumerator.
sourceEnumNameEdit.Add(sourceName);
// Create a GeoDBDataTransfer object and a null name mapping enumerator.
IGeoDBDataTransfer geoDBDataTransfer = new GeoDBDataTransferClass();
IEnumNameMapping enumNameMapping = null;
// Use the data transfer object to create a name mapping enumerator.
Boolean conflictsFound = geoDBDataTransfer.GenerateNameMapping(sourceEnumName,
targetName, out enumNameMapping);
enumNameMapping.Reset();
// Check for conflicts.
if (conflictsFound)
{
// Iterate through each name mapping.
INameMapping nameMapping = null;
while ((nameMapping = enumNameMapping.Next()) != null)
{
// Resolve the mapping's conflict (if there is one).
if (nameMapping.NameConflicts)
{
nameMapping.TargetName = nameMapping.GetSuggestedName(targetName);
}
// See if the mapping's children have conflicts.
IEnumNameMapping childEnumNameMapping = nameMapping.Children;
if (childEnumNameMapping != null)
{
childEnumNameMapping.Reset();
// Iterate through each child mapping.
INameMapping childNameMapping = null;
while ((childNameMapping = childEnumNameMapping.Next()) != null)
{
if (childNameMapping.NameConflicts)
{
childNameMapping.TargetName = childNameMapping.GetSuggestedName
(targetName);
}
}
}
}
}
// Start the transfer.
geoDBDataTransfer.Transfer(enumNameMapping, targetName);
}
private bool method_0(string string_1, string string_2, bool bool_0)
{
IGxObject obj2 = null;
IDatasetName name;
IWorkspaceName name2;
switch (string_2.ToLower())
{
case ".bmp":
case ".png":
case ".jpg":
case ".tif":
case ".img":
case ".sid":
obj2 = new GxRasterDataset();
name = new RasterDatasetNameClass();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesFile.RasterWorkspaceFactory",
PathName = Path.GetDirectoryName(string_1)
};
name.Name = Path.GetFileName(string_1);
name.WorkspaceName = name2;
(obj2 as IGxDataset).DatasetName = name;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".mdb":
obj2 = new GxDatabase();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesGDB.AccessWorkspaceFactory",
PathName = string_1
};
(obj2 as IGxDatabase).WorkspaceName = name2;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".shp":
obj2 = new GxShapefileDataset();
name = new FeatureClassNameClass();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory",
PathName = Path.GetDirectoryName(string_1)
};
name.Name = Path.GetFileName(string_1);
name.WorkspaceName = name2;
(obj2 as IGxDataset).DatasetName = name;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".dbf":
if (
!File.Exists(Path.Combine(Path.GetDirectoryName(string_1),
Path.GetFileNameWithoutExtension(string_1) + ".shp")))
{
obj2 = new GxDataset();
name = new TableNameClass();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory",
PathName = Path.GetDirectoryName(string_1)
};
name.Name = Path.GetFileName(string_1);
name.WorkspaceName = name2;
(obj2 as IGxDataset).DatasetName = name;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
}
return(false);
case ".sde":
obj2 = new GxDatabase();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesGDB.SdeWorkspaceFactory",
PathName = string_1
};
(obj2 as IGxDatabase).WorkspaceName = name2;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".lyr":
obj2 = new GxLayer();
(obj2 as IGxFile).Path = string_1;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".dwg":
case ".dxf":
obj2 = new GxCadDataset();
name = new CadDrawingNameClass();
name2 = new WorkspaceNameClass
{
WorkspaceFactoryProgID = "esriDataSourcesFile.CadWorkspaceFactory",
PathName = Path.GetDirectoryName(string_1)
};
name.Name = Path.GetFileName(string_1);
name.WorkspaceName = name2;
(obj2 as IGxDataset).DatasetName = name;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
case ".doc":
case ".xls":
obj2 = new GxOfficeFile();
(obj2 as IGxFile).Path = string_1;
obj2.Attach(this.igxObject_0, this.igxCatalog_0);
if (bool_0)
{
this.igxCatalog_0.ObjectAdded(obj2);
}
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="pSourceFeatureClass"></param>
/// <param name="_pTWorkspaceFactory"></param>
/// <param name="_pTWs"></param>
/// <param name="_pTName"></param>
public void ConvertQuery2FeatureClass( IFeatureClass pSourceFeatureClass , IWorkspaceFactory _pTWorkspaceFactory, String _pTWs, string _pTName)
{
IWorkspace pTWorkspace = _pTWorkspaceFactory.OpenFromFile(_pTWs, 0);
IDataset pSDataset = pSourceFeatureClass as IDataset;
IFeatureClassName pSourceFeatureClassName = pSDataset.FullName as IFeatureClassName;
IDataset pTDataset = (IDataset)pTWorkspace;
IName pTDatasetName = pTDataset.FullName;
IWorkspaceName pTargetWorkspaceName = (IWorkspaceName)pTDatasetName;
IFeatureClassName pTargetFeatureClassName = new FeatureClassNameClass();
IDatasetName pTargetDatasetName = (IDatasetName)pTargetFeatureClassName;
// 验证要素类的名称是否合法，但是并没有对这个名称是否存在做检查
string pTableName = null;
IFieldChecker pNameChecker = new FieldCheckerClass();
pNameChecker.ValidateWorkspace = pTWorkspace;
int pFlag = pNameChecker.ValidateTableName(_pTName, out pTableName);
pTargetDatasetName.Name = pTableName;
pTargetDatasetName.WorkspaceName = pTargetWorkspaceName;
// 创建字段检查对象
IFieldChecker pFieldChecker = new FieldCheckerClass();
IFields sourceFields = pSourceFeatureClass.Fields;
IFields pTargetFields = null;
IEnumFieldError pEnumFieldError = null;
pFieldChecker.InputWorkspace = ((IDataset)pSourceFeatureClass).Workspace;
pFieldChecker.ValidateWorkspace = pTWorkspace;
// 验证字段
pFieldChecker.Validate(sourceFields, out pEnumFieldError, out pTargetFields);
if (pEnumFieldError != null)
{
// 报错提示
Console.WriteLine("Errors were encountered during field validation.");
}
String pShapeFieldName = pSourceFeatureClass.ShapeFieldName;
int pFieldIndex = pSourceFeatureClass.FindField(pShapeFieldName);
IField pShapeField = sourceFields.get_Field(pFieldIndex);
IGeometryDef pTargetGeometryDef = pShapeField.GeometryDef;
// 创建要素转换对象
IFeatureDataConverter pFDConverter = new FeatureDataConverterClass();
IEnumInvalidObject pEnumInvalidObject = pFDConverter.ConvertFeatureClass(pSourceFeatureClassName, null, null, pTargetFeatureClassName,
pTargetGeometryDef, pTargetFields, "", 1000, 0);
// 检查是否有错误
IInvalidObjectInfo pInvalidInfo = null;
pEnumInvalidObject.Reset();
while ((pInvalidInfo = pEnumInvalidObject.Next()) != null)
{
// 报错提示.
Console.WriteLine("Errors occurred for the following feature: {0}",
pInvalidInfo.InvalidObjectID);
}
}
