/// <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; } }
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 static string ConvertPagesToFeatureClass(string filepath, string layerName, string prefix = "GBDX") { try { var json = MergeJsonStrings(filepath); json = MergeProperties(json); var jsonOutput = json.ToString(Formatting.None); var workspace = Jarvis.OpenWorkspace(Settings.Default.geoDatabase); IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.ValidateWorkspace = workspace; var proposedTableName = string.Format("{0}{1}", prefix, Guid.NewGuid()); string tableName; fieldChecker.ValidateTableName(proposedTableName, out tableName); WriteToTable(workspace, jsonOutput, tableName); return(tableName); } catch (Exception error) { Jarvis.Logger.Error(error); } return(string.Empty); }
/// <summary> /// Converts the spatialite table to a featureclass in a temporary, scratch workspace. /// </summary> /// <returns>IFeatureClass copy of the spatialite table</returns> public IFeatureClass ConvertToFeatureclass() { try { CreateTemporaryGeodatabase(); IWorkspaceFactory factory = new AccessWorkspaceFactoryClass(); IWorkspace workspace = factory.OpenFromFile(this.PGDBPath, 0); IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace; IFields fields = CreateFields(); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(this.TableName, validatedFields, null, null, esriFeatureType.esriFTSimple, "Shape", ""); LoadFeatureclass(featureClass); return(featureClass); } catch (Exception ex) { Trace.WriteLine(ex.StackTrace); throw; } }
/// <summary> /// 创建表 /// </summary> /// <param name="workspace"></param> /// <param name="tableName"></param> /// <param name="fields"></param> /// <returns></returns> public ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields) { UID uid = new UIDClass(); if (workspace == null) { return(null); } IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace; ITable table; if (workspace.get_NameExists(esriDatasetType.esriDTTable, tableName)) { table = featureWorkspace.OpenTable(tableName); return(table); } uid.Value = "esriGeoDatabase.Object"; if (fields == null) { return(null); } IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); table = featureWorkspace.CreateTable(tableName, validatedFields, uid, null, ""); return(table); }
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); }
/// <summary> /// 创建一个要素集 /// </summary> /// <param name="shpfolder"></param> /// <param name="shpname"></param> /// <returns></returns> public static IFeatureClass CreatePolygonFeatureClass(string shpfolder, string shpname) { IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass(); IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace; //创建字段集2 IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段 IFields fields = ocDescription.RequiredFields; int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName); IField field = fields.get_Field(shapeFieldIndex); IGeometryDef geometryDef = field.GeometryDef; IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; //geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; //geometryDefEdit.SpatialReference_2 = spatialReference; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline; ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass(); IProjectedCoordinateSystem pcsSys = pSpatialRefFac.CreateProjectedCoordinateSystem((int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_39); geometryDefEdit.SpatialReference_2 = pcsSys; IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; //将传入字段 转成 validatedFields fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); IFeatureClass featureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); AddField(featureClass, "BuildID", "自带id", 50); return(featureClass); }
/// <summary> /// Exports the source table using the query filter to the table in the output workspace. /// </summary> /// <param name="source">The source.</param> /// <param name="filter">The filter.</param> /// <param name="tableName">Name of the output table.</param> /// <param name="workspace">The output workspace.</param> /// <param name="requiredFields">The required fields.</param> /// <param name="handle">The handle.</param> /// <param name="surrogate">The surrogate for the event handler.</param> /// <param name="invalid">The errors that occured during the export.</param> /// <param name="errors">The field errors.</param> /// <returns> /// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported. /// </returns> public static ITable Export(this ITable source, IQueryFilter filter, string tableName, IWorkspace workspace, IFields requiredFields, int handle, FeatureProgress surrogate, out IEnumInvalidObject invalid, out IEnumFieldError errors) { var ds = (IDataset)source; var input = ds.Workspace.Define(ds.Name, new TableNameClass()); var output = workspace.Define(tableName, new TableNameClass()); workspace.Delete(output); IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.InputWorkspace = ds.Workspace; fieldChecker.ValidateWorkspace = workspace; IFields targetFields; fieldChecker.Validate(requiredFields, out errors, out targetFields); var featureDataConverter = new FeatureDataConverterClass(); if (surrogate != null) { surrogate.Advise(featureDataConverter); } invalid = featureDataConverter.ConvertTable(input, filter, null, output, targetFields, "", 1000, handle); return(((IName)output).Open() as ITable); }
private static ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields) { UID uid = new UIDClass { Value = "esriGeoDatabase.Object" }; if (workspace == null) { return(null); } IFeatureWorkspace featWorkspace = (IFeatureWorkspace)workspace; if (workspace.NameExists[esriDatasetType.esriDTTable, tableName]) { using (ComReleaser releaser = new ComReleaser()) { ITable table = featWorkspace.OpenTable(tableName); releaser.ManageLifetime(table); ((IDataset)table).Delete(); } } IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = workspace as IWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); return(featWorkspace.CreateTable(tableName, validatedFields, uid, null, string.Empty)); }
public static IFeatureClass CreateFeatureClass(IWorkspace workspace, string featureClassName, esriGeometryType type, ISpatialReference spatialReference) { IFeatureWorkspace pFeatureWorkspace = workspace as IFeatureWorkspace; IFeatureClassDescription pFeatureClassDescription = new FeatureClassDescriptionClass(); IObjectClassDescription pObjectClassDescription = pFeatureClassDescription as IObjectClassDescription; IFields pFields = pObjectClassDescription.RequiredFields; IFieldsEdit pFieldsEdit = pFields as IFieldsEdit; for (int i = 0; i < pFields.FieldCount; i++) { if (pFieldsEdit.Field[i].Type == esriFieldType.esriFieldTypeGeometry) { IFieldEdit pFieldEdit = pFieldsEdit.Field[i] as IFieldEdit; IGeometryDef pGeometryDef = new GeometryDefClass(); IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit; pGeometryDefEdit.GeometryType_2 = type; pGeometryDefEdit.SpatialReference_2 = spatialReference; pFieldEdit.GeometryDef_2 = pGeometryDef; } } IFieldChecker pFieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; pFieldChecker.ValidateWorkspace = workspace; pFieldChecker.Validate(pFields, out enumFieldError, out validatedFields); return(pFeatureWorkspace.CreateFeatureClass(featureClassName, validatedFields, pObjectClassDescription.InstanceCLSID, pObjectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, "SHAPE", "")); }
/// <summary> /// Creates fields for BaseStation table. /// </summary> /// <param name="GDBWorkspace"></param> /// <returns></returns> public static IFields createBaseStationFields(IWorkspace GDBWorkspace) { try { IFields pFields = new FieldsClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields; pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID)); //pFieldsEdit.AddField(createIntegerField("VesselID")); pFieldsEdit.AddField(createField("MMSI", esriFieldType.esriFieldTypeInteger)); pFieldsEdit.AddField(createField("Longitude", esriFieldType.esriFieldTypeDouble)); pFieldsEdit.AddField(createField("Latitude", esriFieldType.esriFieldTypeDouble)); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)GDBWorkspace; fieldChecker.Validate(pFields, out enumFieldError, out validatedFields); return(pFields); } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "AIS_Menu:Utilities:createVesselFields"); return(null); } }
/// <summary> /// Creates fields for Voyage table. /// </summary> /// <param name="GDBWorkspace"></param> /// <returns></returns> public static IFields createVoyageFields(IWorkspace GDBWorkspace) { try { IFields pFields = new FieldsClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields; pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID)); pFieldsEdit.AddField(createField("VoyageID", esriFieldType.esriFieldTypeInteger)); pFieldsEdit.AddField(createField("Destination", esriFieldType.esriFieldTypeString)); pFieldsEdit.AddField(createField("Cargo", esriFieldType.esriFieldTypeInteger)); pFieldsEdit.AddField(createField("Draught", esriFieldType.esriFieldTypeInteger)); pFieldsEdit.AddField(createField("ETA", esriFieldType.esriFieldTypeDate)); pFieldsEdit.AddField(createField("StartTime", esriFieldType.esriFieldTypeDate)); pFieldsEdit.AddField(createField("EndTime", esriFieldType.esriFieldTypeDate)); pFieldsEdit.AddField(createField("MMSI", esriFieldType.esriFieldTypeInteger)); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)GDBWorkspace; fieldChecker.Validate(pFields, out enumFieldError, out validatedFields); return(pFields); } catch (Exception ex) { MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "AIS_Menu:Utilities:createVoyageFields"); return(null); } }
/// <summary> /// Creates the fields for the AttributeUnits table. /// </summary> /// <param name="pWorkspace">FileGeodatabase workspace.</param> /// <returns>List of fields.</returns> private IFields CreateUnitsFields(IWorkspace pWorkspace) { try { IFields pFields = new FieldsClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields; pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID)); pFieldsEdit.AddField(createField("Attribute", esriFieldType.esriFieldTypeString)); pFieldsEdit.AddField(createField("Unit", esriFieldType.esriFieldTypeString)); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)pWorkspace; fieldChecker.Validate(pFields, out enumFieldError, out validatedFields); return(pFields); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return(null); } }
/// <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> /// Converts the event route source to a stand-alone feature class. /// </summary> /// <param name="outputTableName">The name of the output feature class.</param> /// <param name="filter">The filter used to limit the number of features converted.</param> /// <param name="workspace">The workspace that will contain the feature class.</param> /// <returns> /// Returns a <see cref="IFeatureClass" /> representing the results of the conversion. /// </returns> public IFeatureClass Convert(string outputTableName, IQueryFilter filter, IWorkspace workspace) { var source = (IFeatureClass)this.FeatureClass; var geometryDef = ((IClone)source.GetGeometryDef()) as IGeometryDef; IFieldChecker checker = new FieldCheckerClass(); IEnumFieldError errors; IFields fields; checker.InputWorkspace = workspace; checker.ValidateWorkspace = workspace; checker.Validate(source.Fields, out errors, out fields); var outputClassName = workspace.Define(outputTableName, new FeatureClassNameClass()); workspace.Delete(outputClassName); var dataConverter = new FeatureDataConverterClass(); var invalidObjects = dataConverter.ConvertFeatureClass((IDatasetName)this.Name, filter, null, null, outputClassName, geometryDef, fields, "", 1000, 0); if (invalidObjects.AsEnumerable().Any()) { return(null); } var route = workspace.GetFeatureClass(outputTableName); return(route); }
/// <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; } } }
/// <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; } } }
// // PUBLIC METHODS // /// <summary> /// Validates a table name /// </summary> /// <param name="name">The table name to validate</param> /// <param name="message">If table name fails then this variable will contain a description</param> /// <returns>True if passed. False if failed.</returns> public bool ValidateTableName(string name, out string message) { // Check Arguments if (string.IsNullOrEmpty(name)) { throw new NullReferenceException("<name> argument cannot be null"); } // Get Table Name string tableName = GeodatabaseUtility.GetTableName(name); // Validate Table Name IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.ValidateWorkspace = this._workspace; string newName = null; int error = fieldChecker.ValidateTableName(tableName, out newName); // Create Message switch (error) { case 0: message = null; break; case 1: message = string.Format("Table name [{0}] contains a reserved word.", name); break; case 2: message = string.Format("Table name [{0}] contains an invalid character.", name); break; case 4: message = string.Format("Table name [{0}] has invalid starting character.", name); break; default: message = string.Format("Table name [{0}] is invalid.", name); break; } // Append Recommended Name switch (error) { case 0: return(true); default: if (!(string.IsNullOrEmpty(newName))) { if (newName != name) { message += string.Format(" Try [{0}].", newName); } } return(false); } }
/// <summary> /// Transfers data from an input FeatureClass to an output FeatureClass with data filtered with the specified query filter. /// </summary> /// <param name="inputWorkspace">The input workspace.</param> /// <param name="inputFeatureClassName">Name of the input feature class.</param> /// <param name="outputWorkspace">The output workspace.</param> /// <param name="outputFeatureClassName">Name of the output feature class.</param> /// <param name="outputFeatureDatasetName">The output FeatureDataset</param> /// <param name="queryFilter">The query filter used to filter data to be transfered.</param> public static IEnumInvalidObject TransferData(IFeatureWorkspace inputWorkspace, IFeatureClass inputFeatureClass, IFeatureWorkspace outputWorkspace, IFeatureClassName outputFeatureClassName, IFeatureDatasetName outputFeatureDatasetName, IQueryFilter queryFilter, ISpatialReference outputSpatialReference) { if (inputWorkspace == null) { throw new ArgumentNullException("A valid input feature workspace reference [inputWorkspace] is required."); } if (inputFeatureClass == null) { throw new ArgumentNullException("A valid input featureclass [inputFeatureClass] is required."); } if (outputWorkspace == null) { throw new ArgumentNullException("A valid output feature workspace reference [outputWorkspace] is required."); } if (outputFeatureClassName == null) { throw new ArgumentNullException("A valid output featureclass name reference [outputFeatureClassName] is required."); } IDataset dataset = (IDataset)inputFeatureClass; IFeatureClassName inputFeatureClassName = (IFeatureClassName)dataset.FullName; IEnumFieldError error = null; IFields outFields = null; IFields inFields = inputFeatureClass.Fields; FieldCheckerClass fieldChecker = new FieldCheckerClass(); fieldChecker.InputWorkspace = (IWorkspace)inputWorkspace; fieldChecker.ValidateWorkspace = (IWorkspace)outputWorkspace; fieldChecker.Validate(inFields, out error, out outFields); IField shapeField = null; for (int i = 0; i < outFields.FieldCount; i++) { if (outFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry) { shapeField = outFields.get_Field(i); break; } } IGeometryDef shapeGeoDef = shapeField.GeometryDef; IGeometryDefEdit shapeGeoDefEdit = shapeGeoDef as IGeometryDefEdit; shapeGeoDefEdit.GridCount_2 = 1; shapeGeoDefEdit.set_GridSize(0, DefaultIndexGrid(ref inputFeatureClass)); shapeGeoDefEdit.SpatialReference_2 = outputSpatialReference; FeatureDataConverterClass fdc = new FeatureDataConverterClass(); return(fdc.ConvertFeatureClass(inputFeatureClassName, queryFilter, outputFeatureDatasetName, outputFeatureClassName, shapeGeoDefEdit, outFields, "", 1000, 0)); }
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> /// create a feature class in workspace with type geometry /// </summary> /// <param name="geometry">geometry of feature class</param> /// <param name="featureWorkspace">workspace for store feature class</param> /// <returns>feature class created</returns> private IFeatureClass CreateFeatureClass(IGeometry geometry, IFeatureWorkspace featureWorkspace) { // Create a fields collection for the feature class. IFields fields = new FieldsClass(); IFieldsEdit fieldsEdit = (IFieldsEdit)fields; // Add an object ID field to the fields collection. This is mandatory for feature classes. IField oidField = new FieldClass(); IFieldEdit oidFieldEdit = (IFieldEdit)oidField; oidFieldEdit.Name_2 = "OID"; oidFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID; fieldsEdit.AddField(oidField); IField idField = new FieldClass(); IFieldEdit idFieldEdit = (IFieldEdit)idField; idFieldEdit.Name_2 = SAUtility.FieldNameIdWatershed; idFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(idField); // Create a geometry definition (and spatial reference) for the feature class. IGeometryDef geometryDef = new GeometryDefClass(); IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = geometry.GeometryType; geometryDefEdit.SpatialReference_2 = geometry.SpatialReference; IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass(); IObjectClassDescription objectClassDescription = (IObjectClassDescription)featureClassDescription; // Add a geometry field to the fields collection. This is where the geometry definition is applied. IField geometryField = new FieldClass(); IFieldEdit geometryFieldEdit = (IFieldEdit)geometryField; geometryFieldEdit.Name_2 = featureClassDescription.ShapeFieldName; geometryFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry; geometryFieldEdit.GeometryDef_2 = geometryDef; fieldsEdit.AddField(geometryField); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); // The enumFieldError enumerator can be inspected at this point to determine // which fields were modified during validation. // Create the feature class. Note that the CLSID parameter is null - this indicates to use the // default CLSID, esriGeodatabase.Feature (acceptable in most cases for feature classes). IFeatureClass featureClass = featureWorkspace.CreateFeatureClass("pourPoint", validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, featureClassDescription.ShapeFieldName, string.Empty); return(featureClass); }
public static IFeatureClass CreateFeatureClassByAxfFeatureLayer(IWorkspace workspace, IFeatureLayer axfFeatureLayer, bool isConvertToPoint = false, string className = "") { IFeatureWorkspace pFeatureWorkspace = workspace as IFeatureWorkspace; if (pFeatureWorkspace == null) { return(null); } IFields pFields = GetFields(axfFeatureLayer.FeatureClass); if (pFields == null) { return(null); } IFieldsEdit pFieldsEdit = pFields as IFieldsEdit; if (pFieldsEdit == null) { return(null); } IField pField = new FieldClass(); IFieldEdit pFieldEdit = pField as IFieldEdit; pFieldEdit.Name_2 = "AXF_STATUS"; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger; pFieldsEdit.AddField(pField); if (isConvertToPoint && axfFeatureLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryMultipoint) { for (int i = 0; i < pFieldsEdit.FieldCount; i++) { if (pFieldsEdit.Field[i].Type == esriFieldType.esriFieldTypeGeometry) { IFieldEdit geoFieldEdit = pFieldsEdit.Field[i] as IFieldEdit; IGeometryDefEdit pGeometryDefEdit = geoFieldEdit.GeometryDef as IGeometryDefEdit; pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; geoFieldEdit.GeometryDef_2 = pGeometryDefEdit; } } } IFieldChecker pFieldChecker = new FieldCheckerClass(); IEnumFieldError pEnumFieldError = null; IFields validateFields = null; pFieldChecker.ValidateWorkspace = workspace; pFieldChecker.Validate(pFieldsEdit, out pEnumFieldError, out validateFields); if (string.IsNullOrEmpty(className)) { return(pFeatureWorkspace.CreateFeatureClass(className, validateFields, axfFeatureLayer.FeatureClass.CLSID, axfFeatureLayer.FeatureClass.EXTCLSID, axfFeatureLayer.FeatureClass.FeatureType, "SHAPE", null)); } else { return(pFeatureWorkspace.CreateFeatureClass(axfFeatureLayer.Name, validateFields, axfFeatureLayer.FeatureClass.CLSID, axfFeatureLayer.FeatureClass.EXTCLSID, axfFeatureLayer.FeatureClass.FeatureType, "SHAPE", null)); } }
private void validateFields(ref IFields shpFields, ref IFields covFields, ref IEnumFieldError enumError) { IFieldChecker fChecker = new FieldCheckerClass(); fChecker.Validate(shpFields, out enumError, out covFields); if (enumError != null) { System.Windows.Forms.MessageBox.Show("error on validate fields"); } }
/// <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); } }
private void btnSelectIn_Click(object sender, EventArgs e) { frmOpenFile file = new frmOpenFile { AllowMultiSelect = false, Text = "选择要素" }; file.RemoveAllFilters(); file.AddFilter(new MyGxFilterDatasets(), true); if (file.DoModalOpen() == DialogResult.OK) { IArray items = file.Items; if (items.Count != 0) { this.igxDataset_0 = items.get_Element(0) as IGxDataset; this.idataset_0 = this.igxDataset_0.Dataset; this.txtInputFeat.Text = (this.igxDataset_0 as IGxObject).FullName; this.iworkspace_0 = this.idataset_0.Workspace; string tableName = this.idataset_0.Name + "_Project1"; IFieldChecker checker = new FieldCheckerClass { InputWorkspace = this.iworkspace_0 }; checker.ValidateTableName(tableName, out this.string_0); this.txtOutFeat.Text = this.iworkspace_0.PathName + @"\" + this.string_0; if ((this.iworkspace_0.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace) || (this.iworkspace_0.Type == esriWorkspaceType.esriLocalDatabaseWorkspace)) { if (((IWorkspace2)this.iworkspace_0).get_NameExists(esriDatasetType.esriDTFeatureClass, this.string_0)) { this.bool_0 = true; } else { this.bool_0 = false; } } else if (this.iworkspace_0.Type == esriWorkspaceType.esriFileSystemWorkspace) { if (File.Exists(this.txtOutFeat.Text + ".shp")) { this.bool_0 = true; } else { this.bool_0 = 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 void button2_Click(object sender, EventArgs e) { //工作空间 IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass(); IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(pFilePath, 0) as IFeatureWorkspace; //创建字段集2 IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); //创建必要字段 IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription; //必要字段 IFields pFields = new FieldsClass(); pFields = ocDescription.RequiredFields; //要素类的几何类型、坐标系 int shapeFileIndex = pFields.FindField(fcDescription.ShapeFieldName); IField pField = pFields.get_Field(shapeFileIndex); IGeometryDef pGeometryDef = pField.GeometryDef; IGeometryDefEdit pGeometryDefEdit = (IGeometryDefEdit)pGeometryDef; pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; ISpatialReferenceFactory pSpatialReferenceFactory = new SpatialReferenceEnvironmentClass(); //更改为可选的坐标系 IProjectedCoordinateSystem pProjectedCoordinateSystem = pSpatialReferenceFactory.CreateProjectedCoordinateSystem( (int)esriSRProjCS4Type.esriSRProjCS_Xian1980_GK_Zone_21); pGeometryDefEdit.SpatialReference_2 = pProjectedCoordinateSystem; //自定义字段 IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields; addField(pFieldsEdit, "FID"); addField(pFieldsEdit, "Row"); addField(pFieldsEdit, "Column"); addField(pFieldsEdit, "Number"); //传入字段 IFieldChecker pFieldChecker = new FieldCheckerClass(); IEnumFieldError pEnumFieldError = null; IFields validatedFields = null; pFieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkspace; pFieldChecker.Validate(pFields, out pEnumFieldError, out validatedFields); //创建要素类 IFeatureClass pFeatureClass = pFeatureWorkspace.CreateFeatureClass(pFileName, validatedFields , ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); MessageBox.Show("创建要素类成功"); }
/// <summary> /// 对表MatchedPolygonFCSettingDif进行判断处理 /// </summary> /// <param name="workspace"></param> /// <param name="table"></param> /// <param name="featureWorkspace"></param> /// <returns></returns> private ITable TableExist(IWorkspace2 workspace, ITable table, IFeatureWorkspace featureWorkspace) { IFields fields; //匹配参数表是否存在,存在则打开表并删除相关记录 if (workspace.get_NameExists(esriDatasetType.esriDTTable, ClsConstant.polygonSettingTable)) { table = featureWorkspace.OpenTable(ClsConstant.polygonSettingTable); IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit; workspaceEdit.StartEditing(true); workspaceEdit.StartEditOperation(); ICursor cursor = table.Search(null, false); IRow r = cursor.NextRow(); while (r != null) { r.Delete(); r = cursor.NextRow(); } workspaceEdit.StopEditOperation(); workspaceEdit.StopEditing(true); //ClsDeleteTables.DeleteFeatureClass(gdbPath, ClsConstant.lineSettingTable); //fields = CreateMatchedPolylineFCSettingFields(workspace); //UID uid = new UIDClass(); //uid.Value = "esriGeoDatabase.Object"; //IFieldChecker fieldChecker = new FieldCheckerClass(); //IEnumFieldError enumFieldError = null; //IFields validatedFields = null; //fieldChecker.ValidateWorkspace = (IWorkspace)workspace; //fieldChecker.Validate(fields, out enumFieldError, out validatedFields); //table = featureWorkspace.CreateTable(ClsConstant.lineSettingTable, validatedFields, uid, null, ""); } //匹配参数表是否存在,不存在则创建表 else { //返回MatchedPolygonFCSettingDif的所有字段集 fields = CreateMatchedPolygonFCSettingFields(workspace); UID uid = new UIDClass(); uid.Value = "esriGeoDatabase.Object"; IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); //创建表MatchedPolygonFCSettingDif table = featureWorkspace.CreateTable(ClsConstant.polygonSettingTable, validatedFields, uid, null, ""); } return(table); }
/// <summary> /// 将Shapefile导入到数据库 /// </summary> /// <param name="pFeaClass"></param> /// <param name="pWorkspace"></param> /// <param name="tFeatureClass"></param> private void importToDB(IFeatureClass pFeaClass, IWorkspace pWorkspace, IFeatureDataset tFeatureClass, string SHPName) { IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass(); IObjectClassDescription objectClassDescription = featureClassDescription as IObjectClassDescription; IFields pFields = pFeaClass.Fields; IFieldChecker pFieldChecker = new FieldCheckerClass(); IEnumFieldError pEnumFieldError = null; IFields vFields = null; pFieldChecker.ValidateWorkspace = pWorkspace as IWorkspace; pFieldChecker.Validate(pFields, out pEnumFieldError, out vFields); IFeatureWorkspace featureWorkspace = pWorkspace as IFeatureWorkspace; IFeatureClass sdeFeatureClass = null; if (sdeFeatureClass == null) { sdeFeatureClass = tFeatureClass.CreateFeatureClass(SHPName, vFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, pFeaClass.FeatureType, pFeaClass.ShapeFieldName, ""); IFeatureCursor featureCursor = pFeaClass.Search(null, true); IFeature feature = featureCursor.NextFeature(); IFeatureCursor sdeFeatureCursor = sdeFeatureClass.Insert(true); IFeatureBuffer sdeFeatureBuffer; while (feature != null) { sdeFeatureBuffer = sdeFeatureClass.CreateFeatureBuffer(); IField shpField = new FieldClass(); IFields shpFields = feature.Fields; for (int i = 0; i < shpFields.FieldCount; i++) { shpField = shpFields.get_Field(i); if (shpField.Name.Contains("Area") || shpField.Name.Contains("Leng") || shpField.Name.Contains("FID")) { continue; } int index = sdeFeatureBuffer.Fields.FindField(shpField.Name); if (index != -1) { sdeFeatureBuffer.set_Value(index, feature.get_Value(i)); } } sdeFeatureCursor.InsertFeature(sdeFeatureBuffer); sdeFeatureCursor.Flush(); feature = featureCursor.NextFeature(); } featureCursor.Flush(); Marshal.ReleaseComObject(feature); Marshal.ReleaseComObject(featureCursor); } }
public static bool CreateLogTable() { if (m_sysTable == null) { return(false); } //InitStaticFields(); Exception err; ITable pTable = m_sysTable.OpenTable(m_LogNAME, out err); if (pTable != null) { return(true);//若日志表已存在,返回true } IFields pFields = new FieldsClass(); IFieldsEdit pFieldsEdit = pFields as IFieldsEdit; IField pField = new FieldClass(); IFieldEdit pEdit = pField as IFieldEdit; pEdit.Name_2 = "logTime"; pEdit.Type_2 = esriFieldType.esriFieldTypeString; pEdit.Length_2 = 30; pFieldsEdit.AddField(pField); pField = new FieldClass(); pEdit = pField as IFieldEdit; pEdit.Name_2 = "logUser"; pEdit.Type_2 = esriFieldType.esriFieldTypeString; pEdit.Length_2 = 50; pFieldsEdit.AddField(pField); pField = new FieldClass(); pEdit = pField as IFieldEdit; pEdit.Name_2 = "logIP"; pEdit.Type_2 = esriFieldType.esriFieldTypeString; pEdit.Length_2 = 30; pFieldsEdit.AddField(pField); pField = new FieldClass(); pEdit = pField as IFieldEdit; pEdit.Name_2 = "logEVENT"; pEdit.Type_2 = esriFieldType.esriFieldTypeString; pEdit.Length_2 = 255; pFieldsEdit.AddField(pField); IFieldChecker pFieldChecker = new FieldCheckerClass();//检查字段有效性 pFieldChecker.ValidateWorkspace = m_gisDb.WorkSpace; IFields pValidFields = null; IEnumFieldError pEFE = null; pFieldChecker.Validate(pFields, out pEFE, out pValidFields); return(m_sysTable.CreateTable(m_LogNAME, pValidFields, out err)); }
// // PUBLIC METHODS // /// <summary> /// Validates a table name /// </summary> /// <param name="name">The table name to validate</param> /// <param name="message">If table name fails then this variable will contain a description</param> /// <returns>True if passed. False if failed.</returns> public bool ValidateTableName(string name, out string message) { // Check Arguments if (string.IsNullOrEmpty(name)) { throw new NullReferenceException("<name> argument cannot be null"); } // Get Table Name string tableName = GeodatabaseUtility.GetTableName(name); // Validate Table Name IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.ValidateWorkspace = this._workspace; string newName = null; int error = fieldChecker.ValidateTableName(tableName, out newName); // Create Message switch (error) { case 0: message = null; break; case 1: message = string.Format("Table name [{0}] contains a reserved word.", name); break; case 2: message = string.Format("Table name [{0}] contains an invalid character.", name); break; case 4: message = string.Format("Table name [{0}] has invalid starting character.", name); break; default: message = string.Format("Table name [{0}] is invalid.", name); break; } // Append Recommended Name switch (error) { case 0: return true; default: if (!(string.IsNullOrEmpty(newName))) { if (newName != name) { message += string.Format(" Try [{0}].", newName); } } return false; } }
/// <summary>return a validated set of fields</summary> /// <param name="workspace">the input workspace</param> /// <param name="fields">the input fields</param> /// <returns></returns> public static IFields validateFields( IWorkspace workspace, IFields fields) { // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); return validatedFields; }
///<summary>Simple helper to create a featureclass in a geodatabase.</summary> /// ///<param name="workspace">An IWorkspace2 interface</param> ///<param name="featureDataset">An IFeatureDataset interface or Nothing</param> ///<param name="featureClassName">A System.String that contains the name of the feature class to open or create. Example: "states"</param> ///<param name="fields">An IFields interface</param> ///<param name="clsid">A UID value or Nothing. Example "esriGeoDatabase.Feature" or Nothing</param> ///<param name="clsext">A UID value or Nothing (this is the class extension if you want to reference a class extension when creating the feature class).</param> ///<param name="strConfigKeyword">An empty System.String or RDBMS table string for ArcSDE. Example: "myTable" or ""</param> /// ///<returns>An IFeatureClass interface or a Nothing</returns> /// ///<remarks> /// (1) If a 'featureClassName' already exists in the workspace a reference to that feature class /// object will be returned. /// (2) If an IFeatureDataset is passed in for the 'featureDataset' argument the feature class /// will be created in the dataset. If a Nothing is passed in for the 'featureDataset' /// argument the feature class will be created in the workspace. /// (3) When creating a feature class in a dataset the spatial reference is inherited /// from the dataset object. /// (4) If an IFields interface is supplied for the 'fields' collection it will be used to create the /// table. If a Nothing value is supplied for the 'fields' collection, a table will be created using /// default values in the method. /// (5) The 'strConfigurationKeyword' parameter allows the application to control the physical layout /// for this table in the underlying RDBMSfor example, in the case of an Oracle database, the /// configuration keyword controls the tablespace in which the table is created, the initial and /// next extents, and other properties. The 'strConfigurationKeywords' for an ArcSDE instance are /// set up by the ArcSDE data administrator, the list of available keywords supported by a workspace /// may be obtained using the IWorkspaceConfiguration interface. For more information on configuration /// keywords, refer to the ArcSDE documentation. When not using an ArcSDE table use an empty /// string (ex: ""). ///</remarks> internal IFeatureClass CreateFeatureClass(IWorkspace2 workspace, IFeatureDataset featureDataset, string featureClassName, IFields fields, ESRI.ArcGIS.esriSystem.UID clsid, ESRI.ArcGIS.esriSystem.UID clsext, string strConfigKeyword) { if (string.IsNullOrEmpty(featureClassName)) return null; IFeatureClass featureClass; var featureWorkspace = (IFeatureWorkspace)workspace; // Cast may throw exception if (workspace.NameExists[esriDatasetType.esriDTFeatureClass, featureClassName]) //feature class with that name already exists { featureClass = featureWorkspace.OpenFeatureClass(featureClassName); return featureClass; } // assign the class id value if not assigned if (clsid == null) { clsid = new ESRI.ArcGIS.esriSystem.UIDClass { Value = "esriGeoDatabase.Feature" }; //Works for shapefiles as well } IObjectClassDescription objectClassDescription = new FeatureClassDescriptionClass(); // if a fields collection is not passed in then supply our own if (fields == null) { // create the fields using the required fields method fields = objectClassDescription.RequiredFields; var fieldsEdit = (IFieldsEdit)fields; // Explicit Cast IField field = new FieldClass(); // create a user defined text field var fieldEdit = (IFieldEdit)field; // Explicit Cast // setup field properties fieldEdit.Name_2 = "SampleField"; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = "Sample Field Column"; fieldEdit.DefaultValue_2 = "test"; fieldEdit.Editable_2 = true; fieldEdit.Length_2 = 100; // add field to field collection fieldsEdit.AddField(field); fields = fieldsEdit; } string strShapeField = ""; // locate the shape field for (int j = 0; j < fields.FieldCount; j++) { if (fields.Field[j].Type != esriFieldType.esriFieldTypeGeometry) continue; strShapeField = fields.Field[j].Name; break; } // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError; IFields validatedFields; fieldChecker.ValidateWorkspace = (IWorkspace)workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); // The enumFieldError enumerator can be inspected at this point to determine // which fields were modified during validation. // finally create and return the feature class featureClass = featureDataset == null ? featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, clsid, clsext, esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword) : featureDataset.CreateFeatureClass(featureClassName, validatedFields, clsid, clsext, esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword); return featureClass; }
/// <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; }
private void ConvertPagesToFeatureClass(string filepath, string layerName) { try { var json = MergeJsonStrings(filepath); json = MergeProperties(json); var jsonOutput = json.ToString(Formatting.None); var workspace = Jarvis.OpenWorkspace(Settings.Default.geoDatabase); IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.ValidateWorkspace = workspace; var proposedTableName = string.Format("AnswerFactory{0}", Guid.NewGuid()); string tableName; fieldChecker.ValidateTableName(proposedTableName, out tableName); WriteToTable(workspace, jsonOutput, tableName); this.Invoke((MethodInvoker)(() => { this.loadingCircle.Active = false; this.loadingCircle.Visible = false; AddLayerToMap(tableName, layerName); })); if (File.Exists(filepath)) { File.Delete(filepath); } } catch (Exception error) { Jarvis.Logger.Error(error); } }
/// <summary> /// Creates the field collection for a new feature class or standalone table. /// </summary> /// <param name="bSpatial">True if the new fields collection is for a feature class, false if a table.</param> /// <param name="bHasZ">True if the geometry field of the fields collection to be created is to be Z aware.</param> /// <param name="bHasM">True if the geometry field of the fields collection to be created is to be M aware.</param> /// <param name="oWorkspace">The workspace in which a new feature class will be created from the fields collection.</param> /// <param name="geomType">The geometry type of the feature class to be created from the new fields collection.</param> /// <param name="aFldLengths">An array of field lengths of the fields collection to be created.</param> /// <param name="aFldNames">An array of field names of the fields collection to be created.</param> /// <param name="aFldAliases">An array of field aliases of the fields collection to be created.</param> /// <param name="aFldTypes">An array of field types of the fields collection to be created.</param> /// <param name="spatialReference">The coordinate system to be assigned to the new feature class.</param> /// <returns>Returns the new field collection. Throws an error if no field collection can be created.</returns> private IFields CreateFieldsCollection(bool hasGeom, bool hasZ, bool hasM, object outWorkspace, esriGeometryType geometryType, int[] fieldLengths, string[] fieldNames, string[] fieldAliases, esriFieldType[] fieldTypes, bool[] fieldNullable, ISpatialReference spatialReference) { if ((hasGeom) && (outWorkspace is IWorkspace) && (spatialReference == null)) throw new Exception("Spatial reference must be defined for standalone feature classes"); IWorkspace outputWorkspace = null; if (outWorkspace is IWorkspace) { outputWorkspace = outWorkspace as IWorkspace; } else if (outWorkspace is IFeatureDataset) { outputWorkspace = ((IDataset)((IFeatureDataset)outWorkspace)).Workspace; } IFields fields = new FieldsClass(); IFieldsEdit fieldsEdit = (IFieldsEdit)fields; if (hasGeom) { IGeometryDef geometryDef = new GeometryDefClass(); IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = geometryType; geometryDefEdit.GridCount_2 = 1; geometryDefEdit.set_GridSize(0, 0); // (0, 0.5); geometryDefEdit.AvgNumPoints_2 = 2; geometryDefEdit.HasM_2 = hasM; geometryDefEdit.HasZ_2 = hasZ; if (outWorkspace is IWorkspace) geometryDefEdit.SpatialReference_2 = spatialReference; IField fieldOID = new FieldClass(); IFieldEdit fieldEditOID = (IFieldEdit)fieldOID; fieldEditOID.Name_2 = "OBJECTID"; fieldEditOID.AliasName_2 = "OBJECTID"; fieldEditOID.Type_2 = esriFieldType.esriFieldTypeOID; fieldsEdit.AddField(fieldOID); IField fieldShape = new FieldClass(); IFieldEdit fieldEditShape = (IFieldEdit)fieldShape; fieldEditShape.Name_2 = "SHAPE"; fieldEditShape.AliasName_2 = "SHAPE"; fieldEditShape.Type_2 = esriFieldType.esriFieldTypeGeometry; fieldEditShape.GeometryDef_2 = geometryDef; fieldsEdit.AddField(fieldShape); } else { IField fieldOID = new FieldClass(); IFieldEdit fieldEditOID = (IFieldEdit)fieldOID; fieldEditOID.Name_2 = "OBJECTID"; fieldEditOID.AliasName_2 = "OBJECTID"; fieldEditOID.Type_2 = esriFieldType.esriFieldTypeOID; fieldsEdit.AddField(fieldOID); } if (fieldAliases == null) fieldAliases = fieldNames; IField fieldAtt; IFieldEdit fieldEditAtt; for (int i = 0; i < fieldTypes.Length; i++) { if (String.IsNullOrEmpty(fieldNames[i])) throw new Exception(String.Format("Error creating field {0}", i)); if ((fieldTypes[i] == esriFieldType.esriFieldTypeOID) || (fieldTypes[i] == esriFieldType.esriFieldTypeGeometry)) continue; fieldAtt = new FieldClass(); fieldEditAtt = (IFieldEdit)fieldAtt; fieldEditAtt.Name_2 = fieldNames[i]; if (!String.IsNullOrEmpty(fieldAliases[i])) fieldEditAtt.AliasName_2 = fieldAliases[i]; fieldEditAtt.Type_2 = fieldTypes[i]; fieldEditAtt.Editable_2 = true; fieldEditAtt.Required_2 = false; fieldEditAtt.IsNullable_2 = fieldNullable[i];// true; if (fieldTypes[i] == esriFieldType.esriFieldTypeString) { //if ((fieldLengths[i] == -1) || ((fieldLengths[i] > 0) && (fieldLengths[i] < 256))) fieldEditAtt.Length_2 = fieldLengths[i]; //else // fieldEditAtt.Length_2 = 255; } fieldsEdit.AddField(fieldAtt); } IFieldChecker fldChk = new FieldCheckerClass(); fldChk.ValidateWorkspace = outputWorkspace; IFields outFields; IEnumFieldError fieldErrors; fldChk.Validate(fields, out fieldErrors, out outFields); return outFields; }
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> /// Validates a field name /// </summary> /// <param name="name">The field name to validate</param> /// <param name="message">If field name fails then this variable will contain a description</param> /// <returns>True if passed. False if failed.</returns> public bool ValidateFieldName(string name, out string message) { // Validate Input Arguments if (string.IsNullOrEmpty(name)) { throw new NullReferenceException("<name> argument cannot be null"); } // Create Field Checker IFieldChecker fieldChecker = new FieldCheckerClass(); fieldChecker.ValidateWorkspace = this._workspace; // Create Field IFieldEdit fieldEdit = new FieldClass(); fieldEdit.Name_2 = name; fieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger; // Create Fields IFieldsEdit fieldsEdit = new FieldsClass(); fieldsEdit.AddField((IField)fieldEdit); // Create Field Error Enumerator IEnumFieldError enumFieldError = null; IFields fieldsFixed = null; // Validate Field Name fieldChecker.ValidateField(0, (IFields)fieldsEdit, out enumFieldError, out fieldsFixed); // Get Validated Name (if any) string newName = null; if (fieldsFixed != null) { IField fieldFixed = fieldsFixed.get_Field(0); newName = fieldFixed.Name; } // Get Errors (if any) if (enumFieldError != null) { enumFieldError.Reset(); IFieldError fieldError = enumFieldError.Next(); if (fieldError != null) { switch (fieldError.FieldError) { case esriFieldNameErrorType.esriDuplicatedFieldName: message = "is duplicated"; return false; case esriFieldNameErrorType.esriInvalidCharacter: message = "contains one or more invalid characters"; return false; case esriFieldNameErrorType.esriInvalidFieldNameLength: message = "is too long"; return false; case esriFieldNameErrorType.esriNoFieldError: message = "has no field error"; return false; case esriFieldNameErrorType.esriSQLReservedWord: message = "contains one or more reserved word"; return false; default: message = "contains an unknown error"; return false; } } } // The FieldChecker may have renamed the field without returning an error. if (newName != null) { if (newName != name) { message = "has an invalid field name"; return false; } } // No Errors message = null; return true; }
/// <summary>returns a validated table name</summary> /// <param name="workspace">the input workspace of the tablenaam</param> /// <param name="tableName">the input tablename</param> /// <returns>the output laundered tablenaam</returns> public static String ValidateTableName(IWorkspace workspace, String tableName) { // Create a field checker to validate the table name. IFieldChecker fieldChecker = new FieldCheckerClass(); String validatedName = null; fieldChecker.ValidateWorkspace = workspace; fieldChecker.ValidateTableName(tableName, out validatedName); validatedName = validatedName.Replace("\"", "_").Replace("\'", "_"); return validatedName; }
private IFeatureClass CreateFeatureClass(IFeatureDataset featureDataset,TableStructureNode tableStructureNode, FeatureCodeNode featureCodeNode) { try { if (featureDataset != null) { IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass(); IObjectClassDescription ocDesc = (IObjectClassDescription)fcDesc; ///�������ݱ��ֶ� IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = CreateFileds(tableStructureNode, featureCodeNode); ///�ֶ���Ϣ��֤ IFields fixFields = null; fieldChecker.ValidateWorkspace = featureDataset.Workspace; fieldChecker.Validate(validatedFields, out enumFieldError, out fixFields); ////����FeatureClass IFeatureClass featureClass = null; if (tableStructureNode.IsGeometryTable) { ////������ע��FeatureClass if (featureCodeNode.GeometryType != "") { featureClass = featureDataset.CreateFeatureClass(featureCodeNode.TableName, fixFields, ocDesc.InstanceCLSID, ocDesc.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDesc.ShapeFieldName, ""); } else { ///����ע�� IFormattedTextSymbol pTxtSymbo=new TextSymbolClass(); IFeatureWorkspaceAnno pFeatureWorkspaceAnno = this.m_pIDataset.Workspace as IFeatureWorkspaceAnno; IGraphicsLayerScale pGraphSacle = new GraphicsLayerScaleClass(); pGraphSacle.Units = ESRI.ArcGIS.esriSystem.esriUnits.esriFeet; //pGraphSacle.ReferenceScale=1000; ISymbolCollection pSymbolCollection = new SymbolCollectionClass(); IAnnotateLayerProperties pAnnoLayerProp = new LabelEngineLayerPropertiesClass(); pAnnoLayerProp.FeatureLinked = true; pAnnoLayerProp.CreateUnplacedElements = false; pAnnoLayerProp.DisplayAnnotation = true; pAnnoLayerProp.UseOutput = true; IAnnotationExpressionEngine pAnnoExpressionEngine =new AnnotationVBScriptEngineClass(); ILabelEngineLayerProperties pLabelEngineLayerProperties = pAnnoLayerProp as ILabelEngineLayerProperties; pLabelEngineLayerProperties.ExpressionParser = pAnnoExpressionEngine; pLabelEngineLayerProperties.Expression = "[DESCRIPTION]"; pLabelEngineLayerProperties.IsExpressionSimple = true; pLabelEngineLayerProperties.Offset = 0; pLabelEngineLayerProperties.SymbolID = 0; pLabelEngineLayerProperties.Symbol = pTxtSymbo; IAnnotateLayerTransformationProperties pAnnoLayerTransProp = pAnnoLayerProp as IAnnotateLayerTransformationProperties; pAnnoLayerTransProp.ReferenceScale=200; pAnnoLayerTransProp.Units= ESRI.ArcGIS.esriSystem.esriUnits.esriFeet; pAnnoLayerTransProp.ScaleRatio=1; IAnnotateLayerPropertiesCollection pAnnoLayerProptyCollection =new AnnotateLayerPropertiesCollectionClass(); pAnnoLayerProptyCollection.Add(pAnnoLayerProp); featureClass= pFeatureWorkspaceAnno.CreateAnnotationClass(featureCodeNode.TableName,fixFields,ocDesc.InstanceCLSID ,ocDesc.ClassExtensionCLSID,fcDesc.ShapeFieldName,"",featureDataset,null, pAnnoLayerProptyCollection, pGraphSacle, pSymbolCollection,true); } } else { ///�����ǿռ����� } return featureClass; } return null; } catch(Exception ex) { LogAPI.WriteErrorLog(ex); return null; } }
/// <summary> /// �������Ա� /// </summary> /// <param name="pFeatureWorkspace"></param> /// <param name="tableStructureNode"></param> /// <param name="featureCodeNode"></param> /// <returns></returns> private TableLayer CreateTableLayer(IFeatureWorkspace pFeatureWorkspace, TableStructureNode tableStructureNode, FeatureCodeNode featureCodeNode) { try { if (pFeatureWorkspace != null&&tableStructureNode!=null&&featureCodeNode!=null) { IObjectClassDescription ocDescription = new ObjectClassDescriptionClass(); ///�������ݱ��ֶ� IFieldChecker fieldChecker = new FieldCheckerClass(); IFields validatedFields = CreateFileds(tableStructureNode, featureCodeNode); ///�ֶ���Ϣ��֤ IFields fixFields = null; fieldChecker.ValidateWorkspace = pFeatureWorkspace as IWorkspace; IEnumFieldError enumFieldError = null; fieldChecker.Validate(validatedFields, out enumFieldError, out fixFields); ITable pTable = pFeatureWorkspace.CreateTable(tableStructureNode.TableName, fixFields, ocDescription.InstanceCLSID, null, ""); if (pTable != null) { TableLayer pTableLayer = new TableLayer(); //�������ļ���ȡͼ������ string sGeometryType = ""; Metadata.MetaTable pMetaTalbe = Metadata.MetaDataFile.MetaTabls[tableStructureNode.TableName] as Metadata.MetaTable; if (pMetaTalbe != null) { sGeometryType = pMetaTalbe.Type; } else return null; pTableLayer.GeometryType = sGeometryType; pTableLayer.Table = pTable; pTableLayer.UpdateFieldIndex(); return pTableLayer; } return null; } return null; } catch (Exception ex) { LogAPI.WriteErrorLog(ex); return null; } }
private void CreateAndPopulateTurnFeatureClass(string outputFileGdbPath, string fdsName, string ProhibRdmsTableName, string tempStatsTableName, IGPMessages messages, ITrackCancel trackcancel) { // Determine the number of AltID fields we need (one more than the MAX_SEQ_NUMBER value). Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory"); var wsf = Activator.CreateInstance(factoryType) as IWorkspaceFactory; var fws = wsf.OpenFromFile(outputFileGdbPath, 0) as IFeatureWorkspace; ITable tempStatsTable = fws.OpenTable(tempStatsTableName); short numAltIDFields = 2; if (tempStatsTable.RowCount(null) == 1) numAltIDFields = (short)(1 + (double)(tempStatsTable.GetRow(1).get_Value(tempStatsTable.FindField("MAX_SEQ_NUMBER")))); // Open the Rdms table and find the fields we need ITable rdmsTable = fws.OpenTable(ProhibRdmsTableName); int seqNumberField = rdmsTable.FindField("SEQ_NUMBER"); int linkIDFieldOnRdms = rdmsTable.FindField("LINK_ID"); int manLinkIDField = rdmsTable.FindField("MAN_LINKID"); int condIDFieldOnRdms = rdmsTable.FindField("COND_ID"); int endOfLkFieldOnRdms = rdmsTable.FindField("END_OF_LK"); // Create a temporary template feature class var fcd = new FeatureClassDescriptionClass() as IFeatureClassDescription; var ocd = fcd as IObjectClassDescription; var fieldsEdit = ocd.RequiredFields as IFieldsEdit; IField fieldOnRdmsTable = rdmsTable.Fields.get_Field(linkIDFieldOnRdms); // use the LINK_ID field as a template for the AltID fields for (short i = 1; i <= numAltIDFields; i++) { IFieldEdit newField = new FieldClass(); newField.Name_2 = "AltID" + i; newField.Precision_2 = fieldOnRdmsTable.Precision; newField.Scale_2 = fieldOnRdmsTable.Scale; newField.Type_2 = fieldOnRdmsTable.Type; fieldsEdit.AddField(newField as IField); } fieldOnRdmsTable = rdmsTable.Fields.get_Field(condIDFieldOnRdms); fieldsEdit.AddField(fieldOnRdmsTable); var fieldChk = new FieldCheckerClass() as IFieldChecker; IEnumFieldError enumFieldErr = null; IFields validatedFields = null; fieldChk.ValidateWorkspace = fws as IWorkspace; fieldChk.Validate(fieldsEdit as IFields, out enumFieldErr, out validatedFields); var tempFC = fws.CreateFeatureClass("TheTemplate", validatedFields, ocd.InstanceCLSID, ocd.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcd.ShapeFieldName, "") as IDataset; // Create the turn feature class from the template, then delete the template Geoprocessor gp = new Geoprocessor(); CreateTurnFeatureClass createTurnFCTool = new CreateTurnFeatureClass(); string pathToFds = outputFileGdbPath + "\\" + fdsName; createTurnFCTool.out_location = pathToFds; createTurnFCTool.out_feature_class_name = TurnFCName; createTurnFCTool.maximum_edges = numAltIDFields; createTurnFCTool.in_template_feature_class = outputFileGdbPath + "\\TheTemplate"; gp.Execute(createTurnFCTool, trackcancel); tempFC.Delete(); // Open the new turn feature class and find all the fields on it IFeatureClass turnFC = fws.OpenFeatureClass(TurnFCName); int[] altIDFields = new int[numAltIDFields]; int[] edgeFCIDFields = new int[numAltIDFields]; int[] edgeFIDFields = new int[numAltIDFields]; int[] edgePosFields = new int[numAltIDFields]; for (short i = 0; i < numAltIDFields; i++) { altIDFields[i] = turnFC.FindField("AltID" + (i + 1)); edgeFCIDFields[i] = turnFC.FindField("Edge" + (i + 1) + "FCID"); edgeFIDFields[i] = turnFC.FindField("Edge" + (i + 1) + "FID"); edgePosFields[i] = turnFC.FindField("Edge" + (i + 1) + "Pos"); } int edge1endField = turnFC.FindField("Edge1End"); int condIDFieldOnTurnFC = turnFC.FindField("COND_ID"); // Look up the FCID of the Streets feature class IFeatureClass streetsFC = fws.OpenFeatureClass(StreetsFCName); int streetsFCID = streetsFC.FeatureClassID; // Set up queries var ts = new TableSortClass() as ITableSort; ts.Fields = "COND_ID, SEQ_NUMBER"; ts.set_Ascending("COND_ID", true); ts.set_Ascending("SEQ_NUMBER", true); ts.QueryFilter = new QueryFilterClass(); ts.Table = rdmsTable; ts.Sort(null); ICursor rdmsCursor = ts.Rows; IFeatureCursor turnFCCursor = turnFC.Insert(true); IFeatureBuffer turnBuffer = turnFC.CreateFeatureBuffer(); // Write the field values to the turn feature class accordingly int numFeatures = 0; IRow rdmsRow = rdmsCursor.NextRow(); while (rdmsRow != null) { // Transfer the non-edge identifying field values to the buffer turnBuffer.set_Value(condIDFieldOnTurnFC, rdmsRow.get_Value(condIDFieldOnRdms)); // Write the Edge1End field value to the buffer switch ((string)(rdmsRow.get_Value(endOfLkFieldOnRdms))) { case "N": turnBuffer.set_Value(edge1endField, "Y"); break; case "R": turnBuffer.set_Value(edge1endField, "N"); break; default: break; // not expected } // Write the AltID values to the buffer turnBuffer.set_Value(altIDFields[0], rdmsRow.get_Value(linkIDFieldOnRdms)); short seq = (short)(rdmsRow.get_Value(seqNumberField)); short lastEntry; do { lastEntry = seq; turnBuffer.set_Value(altIDFields[lastEntry], rdmsRow.get_Value(manLinkIDField)); rdmsRow = rdmsCursor.NextRow(); if (rdmsRow == null) break; seq = (short)(rdmsRow.get_Value(seqNumberField)); } while (seq != 1); // Zero-out the unused fields for (int i = lastEntry + 1; i < numAltIDFields; i++) turnBuffer.set_Value(altIDFields[i], 0); // Write the FCID and Pos field values to the buffer for (short i = 0; i < numAltIDFields; i++) { int altID = (int)(turnBuffer.get_Value(altIDFields[i])); if (altID != 0) { turnBuffer.set_Value(edgeFCIDFields[i], streetsFCID); turnBuffer.set_Value(edgeFIDFields[i], 1); turnBuffer.set_Value(edgePosFields[i], 0.5); } else { turnBuffer.set_Value(edgeFCIDFields[i], 0); turnBuffer.set_Value(edgeFIDFields[i], 0); turnBuffer.set_Value(edgePosFields[i], 0); } } // Create the turn feature turnFCCursor.InsertFeature(turnBuffer); numFeatures++; if ((numFeatures % 100) == 0) { // check for user cancel if (trackcancel != null && !trackcancel.Continue()) throw (new COMException("Function cancelled.")); } } // Flush any outstanding writes to the turn feature class turnFCCursor.Flush(); messages.AddMessage("Updating the EdgeFID values..."); // Create a temporary network dataset for updating the EdgeFID values IDENetworkDataset dends = new DENetworkDatasetClass(); dends.SupportsTurns = true; dends.Buildable = true; (dends as IDataElement).Name = StreetsFCName; (dends as IDEGeoDataset).SpatialReference = (streetsFC as IGeoDataset).SpatialReference; IArray sourceArray = new ArrayClass(); var efs = new EdgeFeatureSourceClass() as IEdgeFeatureSource; (efs as INetworkSource).Name = StreetsFCName; efs.UsesSubtypes = false; efs.ClassConnectivityGroup = 1; efs.ClassConnectivityPolicy = esriNetworkEdgeConnectivityPolicy.esriNECPEndVertex; sourceArray.Add(efs); var tfs = new TurnFeatureSourceClass() as INetworkSource; tfs.Name = TurnFCName; sourceArray.Add(tfs); dends.Sources = sourceArray; var fdxc = fws.OpenFeatureDataset(fdsName) as IFeatureDatasetExtensionContainer; var dsCont = fdxc.FindExtension(esriDatasetType.esriDTNetworkDataset) as IDatasetContainer2; var tempNDS = dsCont.CreateDataset(dends as IDEDataset) as IDataset; // Set the EdgeFID field values by running UpdateByAlternateIDFields UpdateByAlternateIDFields updateByAltIDTool = new UpdateByAlternateIDFields(); updateByAltIDTool.in_network_dataset = pathToFds + "\\" + StreetsFCName; updateByAltIDTool.alternate_ID_field_name = "LINK_ID"; gp.Execute(updateByAltIDTool, trackcancel); // Delete the temporary network dataset tempNDS.Delete(); // Write the turn geometries TurnGeometryUtilities.WriteTurnGeometry(outputFileGdbPath, StreetsFCName, TurnFCName, numAltIDFields, 0.3, messages, trackcancel); // Index the turn geometries messages.AddMessage("Creating spatial index on the turn feature class..."); AddSpatialIndex addSpatialIndexTool = new AddSpatialIndex(); addSpatialIndexTool.in_features = pathToFds + "\\" + TurnFCName; gp.Execute(addSpatialIndexTool, trackcancel); return; }
private void CreateRoadSplitsTable(string inputRdmsTable, string outputFileGdbPath, IGPMessages messages, ITrackCancel trackcancel) { // Open the Rdms table and find all the fields we need Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.FileGDBWorkspaceFactory"); var wsf = Activator.CreateInstance(factoryType) as IWorkspaceFactory; var fws = wsf.OpenFromFile(outputFileGdbPath, 0) as IFeatureWorkspace; ITable rdmsTable = fws.OpenTable(inputRdmsTable); int seqNumberField = rdmsTable.FindField("SEQ_NUMBER"); int linkIDFieldOnRdms = rdmsTable.FindField("LINK_ID"); int manLinkIDField = rdmsTable.FindField("MAN_LINKID"); int condIDFieldOnRdms = rdmsTable.FindField("COND_ID"); int endOfLkFieldOnRdms = rdmsTable.FindField("END_OF_LK"); // Open the Streets feature class and get its feature class ID IFeatureClass inputLineFeatures = fws.OpenFeatureClass(StreetsFCName); int streetsFCID = inputLineFeatures.FeatureClassID; // Define the fields for the RoadSplits table var ocd = new ObjectClassDescriptionClass() as IObjectClassDescription; var fieldsEdit = ocd.RequiredFields as IFieldsEdit; IFieldEdit field; // Add the anchor edge fields to the table field = new FieldClass(); field.Name_2 = "EdgeFCID"; field.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "EdgeFID"; field.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "EdgeFrmPos"; field.Type_2 = esriFieldType.esriFieldTypeDouble; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "EdgeToPos"; field.Type_2 = esriFieldType.esriFieldTypeDouble; fieldsEdit.AddField(field); // Add the branch edge fields to the table for (int i = 0; i < 3; i++) { field = new FieldClass(); field.Name_2 = "Branch" + i + "FCID"; field.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "Branch" + i + "FID"; field.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "Branch" + i + "FrmPos"; field.Type_2 = esriFieldType.esriFieldTypeDouble; fieldsEdit.AddField(field); field = new FieldClass(); field.Name_2 = "Branch" + i + "ToPos"; field.Type_2 = esriFieldType.esriFieldTypeDouble; fieldsEdit.AddField(field); } // Check the fields and create the RoadSplits table var fieldChk = new FieldCheckerClass() as IFieldChecker; IEnumFieldError enumFieldErr = null; IFields validatedFields = null; fieldChk.ValidateWorkspace = fws as IWorkspace; fieldChk.Validate(fieldsEdit as IFields, out enumFieldErr, out validatedFields); var roadSplitsTable = fws.CreateTable(RoadSplitsTableName, validatedFields, ocd.InstanceCLSID, ocd.ClassExtensionCLSID, "") as ITable; // Find all the fields int EdgeFCIDFI = roadSplitsTable.FindField("EdgeFCID"); int EdgeFIDFI = roadSplitsTable.FindField("EdgeFID"); int EdgeFrmPosFI = roadSplitsTable.FindField("EdgeFrmPos"); int EdgeToPosFI = roadSplitsTable.FindField("EdgeToPos"); int Branch0FCIDFI = roadSplitsTable.FindField("Branch0FCID"); int Branch0FIDFI = roadSplitsTable.FindField("Branch0FID"); int Branch0FrmPosFI = roadSplitsTable.FindField("Branch0FrmPos"); int Branch0ToPosFI = roadSplitsTable.FindField("Branch0ToPos"); int Branch1FCIDFI = roadSplitsTable.FindField("Branch1FCID"); int Branch1FIDFI = roadSplitsTable.FindField("Branch1FID"); int Branch1FrmPosFI = roadSplitsTable.FindField("Branch1FrmPos"); int Branch1ToPosFI = roadSplitsTable.FindField("Branch1ToPos"); int Branch2FCIDFI = roadSplitsTable.FindField("Branch2FCID"); int Branch2FIDFI = roadSplitsTable.FindField("Branch2FID"); int Branch2FrmPosFI = roadSplitsTable.FindField("Branch2FrmPos"); int Branch2ToPosFI = roadSplitsTable.FindField("Branch2ToPos"); // Fetch all line features referenced by the input Rdms table. We do the // "join" this hard way to support all data sources in the sample. // Also, for large numbers of special explications, this strategy of fetching all // related features and holding them in RAM could be a problem. To fix // this, one could process the input records from the Rdms table in batches. System.Collections.Hashtable lineFeaturesList = SignpostUtilities.FillFeatureCache(rdmsTable, linkIDFieldOnRdms, manLinkIDField, inputLineFeatures, "LINK_ID", trackcancel); // Create insert cursor and row buffer for output ICursor tableInsertCursor = roadSplitsTable.Insert(true); IRowBuffer tableBuffer = roadSplitsTable.CreateRowBuffer(); IRow row = tableBuffer as IRow; // Create input cursor for the Rdms table we are importing ITableSort tableSort = new TableSortClass(); tableSort.Fields = "LINK_ID, COND_ID, SEQ_NUMBER"; tableSort.set_Ascending("LINK_ID", true); tableSort.set_Ascending("COND_ID", true); tableSort.set_Ascending("SEQ_NUMBER", true); tableSort.QueryFilter = null; tableSort.Table = rdmsTable; tableSort.Sort(null); ICursor inputCursor = tableSort.Rows; IRow inputTableRow = inputCursor.NextRow(); if (inputTableRow == null) return; // if Rdms table is empty, there's nothing to do // these are initialized to prevent uninitialized variable compiler error SignpostUtilities.FeatureData linkFeatureData = new SignpostUtilities.FeatureData(-1, null); SignpostUtilities.FeatureData manLinkFeatureData = new SignpostUtilities.FeatureData(-1, null); ICurve fromEdgeCurve, toEdgeCurve; IPoint fromEdgeStart, fromEdgeEnd, toEdgeStart, toEdgeEnd; double fromEdgeFromPos = 0.0; double fromEdgeToPos = 1.0; double toEdgeFromPos = 0.0; double toEdgeToPos = 1.0; long currentLinkID = Convert.ToInt64(inputTableRow.get_Value(linkIDFieldOnRdms)); long manLinkID = Convert.ToInt64(inputTableRow.get_Value(manLinkIDField)); try { linkFeatureData = (SignpostUtilities.FeatureData)lineFeaturesList[currentLinkID]; manLinkFeatureData = (SignpostUtilities.FeatureData)lineFeaturesList[manLinkID]; // To set from and to position in the output table, we need see where and // if the two edge features connect to figure out their digitized direction. fromEdgeCurve = linkFeatureData.feature as ICurve; toEdgeCurve = manLinkFeatureData.feature as ICurve; fromEdgeStart = fromEdgeCurve.FromPoint; fromEdgeEnd = fromEdgeCurve.ToPoint; toEdgeStart = toEdgeCurve.FromPoint; toEdgeEnd = toEdgeCurve.ToPoint; // flip the from edge? if (TurnGeometryUtilities.EqualPoints(fromEdgeStart, toEdgeStart) || TurnGeometryUtilities.EqualPoints(fromEdgeStart, toEdgeEnd)) { fromEdgeFromPos = 1.0; fromEdgeToPos = 0.0; } // flip the to edge? if (TurnGeometryUtilities.EqualPoints(toEdgeEnd, fromEdgeStart) || TurnGeometryUtilities.EqualPoints(toEdgeEnd, fromEdgeEnd)) { toEdgeFromPos = 1.0; toEdgeToPos = 0.0; } // set the field values in the buffer tableBuffer.set_Value(EdgeFCIDFI, streetsFCID); tableBuffer.set_Value(EdgeFIDFI, linkFeatureData.OID); tableBuffer.set_Value(EdgeFrmPosFI, fromEdgeFromPos); tableBuffer.set_Value(EdgeToPosFI, fromEdgeToPos); tableBuffer.set_Value(Branch0FCIDFI, streetsFCID); tableBuffer.set_Value(Branch0FIDFI, manLinkFeatureData.OID); tableBuffer.set_Value(Branch0FrmPosFI, toEdgeFromPos); tableBuffer.set_Value(Branch0ToPosFI, toEdgeToPos); tableBuffer.set_Value(Branch1FCIDFI, null); tableBuffer.set_Value(Branch1FIDFI, null); tableBuffer.set_Value(Branch1FrmPosFI, null); tableBuffer.set_Value(Branch1ToPosFI, null); tableBuffer.set_Value(Branch2FCIDFI, null); tableBuffer.set_Value(Branch2FIDFI, null); tableBuffer.set_Value(Branch2FrmPosFI, null); tableBuffer.set_Value(Branch2ToPosFI, null); } catch { messages.AddWarning("Line feature not found for explication with from ID: " + Convert.ToString(currentLinkID, System.Globalization.CultureInfo.InvariantCulture) + ", To ID: " + Convert.ToString(manLinkID, System.Globalization.CultureInfo.InvariantCulture)); } long previousLinkID = currentLinkID; int nextBranch = 1; while ((inputTableRow = inputCursor.NextRow()) != null) { currentLinkID = Convert.ToInt64(inputTableRow.get_Value(linkIDFieldOnRdms)); manLinkID = Convert.ToInt64(inputTableRow.get_Value(manLinkIDField)); try { linkFeatureData = (SignpostUtilities.FeatureData)lineFeaturesList[currentLinkID]; manLinkFeatureData = (SignpostUtilities.FeatureData)lineFeaturesList[manLinkID]; } catch { messages.AddWarning("Line feature not found for explication with from ID: " + Convert.ToString(currentLinkID, System.Globalization.CultureInfo.InvariantCulture) + ", To ID: " + Convert.ToString(manLinkID, System.Globalization.CultureInfo.InvariantCulture)); continue; } // To set from and to position in the output table, we need see where and // if the two edge features connect to figure out their digitized direction. fromEdgeCurve = linkFeatureData.feature as ICurve; toEdgeCurve = manLinkFeatureData.feature as ICurve; fromEdgeStart = fromEdgeCurve.FromPoint; fromEdgeEnd = fromEdgeCurve.ToPoint; toEdgeStart = toEdgeCurve.FromPoint; toEdgeEnd = toEdgeCurve.ToPoint; fromEdgeFromPos = 0.0; fromEdgeToPos = 1.0; toEdgeFromPos = 0.0; toEdgeToPos = 1.0; // flip the from edge? if (TurnGeometryUtilities.EqualPoints(fromEdgeStart, toEdgeStart) || TurnGeometryUtilities.EqualPoints(fromEdgeStart, toEdgeEnd)) { fromEdgeFromPos = 1.0; fromEdgeToPos = 0.0; } // flip the to edge? if (TurnGeometryUtilities.EqualPoints(toEdgeEnd, fromEdgeStart) || TurnGeometryUtilities.EqualPoints(toEdgeEnd, fromEdgeEnd)) { toEdgeFromPos = 1.0; toEdgeToPos = 0.0; } // set the field values in the buffer if (previousLinkID == currentLinkID) { switch (nextBranch) { case 1: tableBuffer.set_Value(Branch1FCIDFI, streetsFCID); tableBuffer.set_Value(Branch1FIDFI, manLinkFeatureData.OID); tableBuffer.set_Value(Branch1FrmPosFI, toEdgeFromPos); tableBuffer.set_Value(Branch1ToPosFI, toEdgeToPos); nextBranch = 2; break; case 2: tableBuffer.set_Value(Branch2FCIDFI, streetsFCID); tableBuffer.set_Value(Branch2FIDFI, manLinkFeatureData.OID); tableBuffer.set_Value(Branch2FrmPosFI, toEdgeFromPos); tableBuffer.set_Value(Branch2ToPosFI, toEdgeToPos); nextBranch = 3; break; case 3: messages.AddWarning("There are more than three road splits for From ID: " + Convert.ToString(currentLinkID, System.Globalization.CultureInfo.InvariantCulture)); nextBranch = 4; break; case 4: // do nothing here, as there's no need to repeat the warning message. break; } } else { // write out the previous buffered row... tableInsertCursor.InsertRow(tableBuffer); // ...and then set field values in the fresh buffer tableBuffer.set_Value(EdgeFCIDFI, streetsFCID); tableBuffer.set_Value(EdgeFIDFI, linkFeatureData.OID); tableBuffer.set_Value(EdgeFrmPosFI, fromEdgeFromPos); tableBuffer.set_Value(EdgeToPosFI, fromEdgeToPos); tableBuffer.set_Value(Branch0FCIDFI, streetsFCID); tableBuffer.set_Value(Branch0FIDFI, manLinkFeatureData.OID); tableBuffer.set_Value(Branch0FrmPosFI, toEdgeFromPos); tableBuffer.set_Value(Branch0ToPosFI, toEdgeToPos); tableBuffer.set_Value(Branch1FCIDFI, null); tableBuffer.set_Value(Branch1FIDFI, null); tableBuffer.set_Value(Branch1FrmPosFI, null); tableBuffer.set_Value(Branch1ToPosFI, null); tableBuffer.set_Value(Branch2FCIDFI, null); tableBuffer.set_Value(Branch2FIDFI, null); tableBuffer.set_Value(Branch2FrmPosFI, null); tableBuffer.set_Value(Branch2ToPosFI, null); nextBranch = 1; } previousLinkID = currentLinkID; } // Write out the final row and flush tableInsertCursor.InsertRow(tableBuffer); tableInsertCursor.Flush(); }
/// <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); } }
public static IFeatureClass CreateFeatureClass(IWorkspace workspace, IFeatureDataset featureDataset, String featureClassName, IFields fields) { IFeatureClass featureClass; String strShapeField = ""; var featureWorkspace = workspace as IFeatureWorkspace; IObjectClassDescription objectClassDescription = new FeatureClassDescriptionClass(); #region 简单校验 if (featureClassName == "") return null; //if (workspace.get_NameExists(esriDatasetType.esriDTFeatureClass, featureClassName)) //{ // featureClass = featureWorkspace.OpenFeatureClass(featureClassName); // return featureClass; //} if (fields == null) { fields = objectClassDescription.RequiredFields; IFieldsEdit fieldsEdit = (IFieldsEdit)fields; IField field = new FieldClass(); IFieldEdit fieldEdit = (IFieldEdit)field; fieldEdit.Name_2 = "Name"; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldsEdit.AddField(field); fields = (IFields)fieldsEdit; } var feaClsDes = objectClassDescription as IFeatureClassDescription; strShapeField = feaClsDes.ShapeFieldName; #endregion //查询几何字段 if (strShapeField == "") { for (int j = 0; j < fields.FieldCount; j++) { if (fields.get_Field(j).Type == esriFieldType.esriFieldTypeGeometry) { strShapeField = fields.get_Field(j).Name; } } } // 字段检查 IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); //创建要素类 if (featureDataset == null) { featureClass = featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, strShapeField, ""); } else { featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, strShapeField, ""); } return featureClass; }
private static ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields) { UID uid = new UIDClass {Value = "esriGeoDatabase.Object"}; if (workspace == null) return null; IFeatureWorkspace featWorkspace = (IFeatureWorkspace) workspace; if (workspace.NameExists[esriDatasetType.esriDTTable, tableName]) { using (ComReleaser releaser = new ComReleaser()) { ITable table = featWorkspace.OpenTable(tableName); releaser.ManageLifetime(table); ((IDataset) table).Delete(); } } IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = workspace as IWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); return featWorkspace.CreateTable(tableName, validatedFields, uid, null, string.Empty); }
public static void CreatePolygonFeature(IPolygon pPolygon, string shpfolder, string shpname) { IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass(); IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace; try {//如果图层存在则删除 FileInfo fFile = new FileInfo(shpfolder + @"\" + shpname + ".shp");// if (fFile.Exists) { DirectoryInfo fold = new DirectoryInfo(shpfolder); FileInfo[] files = fold.GetFiles(shpname + ".*"); foreach (FileInfo f in files) { f.Delete(); } } } catch (Exception ex) { MessageBox.Show(ex.Message); } //创建字段集2 IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段 IFields fields = ocDescription.RequiredFields; int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName); IField field = fields.get_Field(shapeFieldIndex); IGeometryDef geometryDef = field.GeometryDef; IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon; ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass(); IGeographicCoordinateSystem pcsSys = pSpatialRefFac.CreateGeographicCoordinateSystem(4490); geometryDefEdit.SpatialReference_2 = pcsSys; IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; //将传入字段 转成 validatedFields fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); /* field = new FieldClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)fields; IFieldEdit pFieldEdit = (IFieldEdit)field; pFieldEdit = (IFieldEdit)field; pFieldEdit.Name_2 = "面积"; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; pFieldsEdit.AddField(field);*/ IArea s = pPolygon as IArea; double area = Math.Abs(s.Area * 10000); double length = Math.Abs(pPolygon.Length * 100); MessageBox.Show("该区域面积为:" + Convert.ToDouble(area).ToString("0.000") + "平方公里(km2)" + "\r\n" + "边长为:" + Convert.ToDouble(length).ToString("0.000") + "千米(KM)"); try { IFeatureClass pFeatureClass; pFeatureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); IFeature pFeature = pFeatureClass.CreateFeature(); pFeature.Shape = pPolygon; //pFeature.set_Value(pFeature.Fields.FindField("面积"), area); pFeature.Store(); } catch(Exception ex) { MessageBox.Show(ex.Message); } }
public ITable exportTable(ITable inputTable, string outPath, IQueryFilter filter) { // Create a name object for the source workspace and open it. IDataset inDset = (IDataset)inputTable; 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. ITableName sourceTableName = new TableNameClass(); IDatasetName sourceDatasetName = (IDatasetName)sourceTableName; sourceDatasetName.Name = inDset.Name; sourceDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)sourceWorkspace).FullName; // Create a name object for the target dataset. ITableName targetTableName = new TableNameClass(); IDatasetName targetDatasetName = (IDatasetName)targetTableName; targetDatasetName.Name = outName; targetDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)targetWorkspace).FullName; ; // Open source feature class to get field definitions. //IName sourceName = (IName)sourceFeatureClassName; ITable sourceTable = inputTable; // Create the objects and references necessary for field validation. IFieldChecker fieldChecker = new FieldCheckerClass(); IFields sourceFields = sourceTable.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."); } // Create the converter and run the conversion. IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass(); IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertTable(sourceDatasetName, filter, targetDatasetName, 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 (Table)((IName)targetTableName).Open(); }
//coordinate 点坐标创建shp图层。 public static void CreatePolygonFeatureclass(IPolygon pPolygon, string shpfolder, string shpname) { IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass(); IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace; try {//如果图层存在则删除 FileInfo fFile = new FileInfo(shpfolder + @"\" + shpname+ ".shp");// if (fFile.Exists) { if (MessageBox.Show("此文件名已经存在,要覆盖吗?", "覆盖文件", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK) { DirectoryInfo fold = new DirectoryInfo(shpfolder); FileInfo[] files = fold.GetFiles(shpname + ".*"); foreach (FileInfo f in files) { f.Delete(); } } else return; } } catch (Exception ex) { MessageBox.Show(ex.Message); } //if (File.Exists(shpfolder+shpname))//如果shp存在则替换它。 //{ // if (MessageBox.Show("发现同名文件,是否覆盖源文件?", "询问", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK) // { // IFeatureClass featureclass = pFeatureWorkSpace.OpenFeatureClass(shpname); // IDataset pDataset = featureclass as IDataset; // pDataset.Delete(); // } // else // return; //} //创建字段集2 IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段 IFields fields = ocDescription.RequiredFields; int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName); IField field = fields.get_Field(shapeFieldIndex); IGeometryDef geometryDef = field.GeometryDef; IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; //geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; //geometryDefEdit.SpatialReference_2 = spatialReference; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon; ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass(); // IProjectedCoordinateSystem pcsSys = pSpatialRefFac.CreateProjectedCoordinateSystem((int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_39); IGeographicCoordinateSystem pcsSys = pSpatialRefFac.CreateGeographicCoordinateSystem(4490); geometryDefEdit.SpatialReference_2 = pcsSys; IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; //将传入字段 转成 validatedFields fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); field = new FieldClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)fields; IFieldEdit pFieldEdit = (IFieldEdit)field; pFieldEdit = (IFieldEdit)field; pFieldEdit.Name_2 = "面积"; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; pFieldsEdit.AddField(field); IArea s = pPolygon as IArea; double area = s.Area*100; double length=pPolygon.Length*100; MessageBox.Show("该区域面积为:" + Convert.ToDouble(area).ToString("0.000") + "平方公里(km2)" +"\r\n" + "边长为:" + Convert.ToDouble(length).ToString("0.000") + "千米(KM)"); try { IFeatureClass pFeatureClass; //pFeatureClass = pFeatureWorkSpace.OpenFeatureClass(shpname); pFeatureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); IFeature pFeature = pFeatureClass.CreateFeature(); pFeature.Shape = pPolygon; // pFeature.set_Value(pFeature.Fields.FindField("面积"), area); pFeature.Store(); } catch { // MessageBox.Show("存储失败!请检查目录下是否有同名文件···", "提示"); //return; } }
private void AggregationResponse(IRestResponse<MotherOfGodAggregations> response, int attempts = 0) { Jarvis.Logger.Info(response.ResponseUri.ToString()); // If we are getting timeouts retry up to MAX ATTEMPTS and log that a timeout occurred attempting the following URL if (response.StatusCode == HttpStatusCode.GatewayTimeout && attempts <= MaxAttempts) { IRestClient restClient = new RestClient(Settings.Default.AuthBase); restClient.ExecuteAsync<MotherOfGodAggregations>( response.Request, resp => this.AggregationResponse(response, attempts + 1)); Jarvis.Logger.Warning(string.Format("{0} :: {1}", response.StatusCode, response.ResponseUri)); return; } if (response.Data != null && response.StatusCode == HttpStatusCode.OK) { var workspace = Jarvis.OpenWorkspace(Settings.Default.geoDatabase); var resultDictionary = new Dictionary<string, Dictionary<string, double>>(); var uniqueFieldNames = new Dictionary<string, string>(); AggregationHelper.ProcessAggregations( response.Data.aggregations, 0, ref resultDictionary, string.Empty, false, ref uniqueFieldNames); if (resultDictionary.Count == 0 && uniqueFieldNames.Count == 0) { MessageBox.Show(GbdxResources.NoDataFound); this.Invoke((MethodInvoker)delegate { this.goButton.Enabled = true; }); return; } FieldChecker checker = new FieldCheckerClass(); // Create a unique name for the feature class based on name. var featureClassName = "Agg_" + Guid.NewGuid(); checker.ValidateTableName(featureClassName, out featureClassName); // Function being called really says it all but ... lets CREATE A FEATURE CLASS var featureClass = Jarvis.CreateStandaloneFeatureClass( workspace, featureClassName, uniqueFieldNames, false, 0); this.WriteToFeatureClass(featureClass, resultDictionary, uniqueFieldNames, workspace); // Use the dispatcher to make sure the following calls occur on the MAIN thread. this.Invoke( (MethodInvoker)delegate { this.AddLayerToArcMap(featureClassName); this.goButton.Enabled = true; }); } else { var error = string.Format( "STATUS: {0}\n{1}\n\n{2}", response.StatusCode, response.ResponseUri.AbsoluteUri, response.Content); Jarvis.Logger.Error(error); this.Invoke((MethodInvoker)delegate { this.goButton.Enabled = true; }); MessageBox.Show(GbdxResources.Source_ErrorMessage); } }
/// <summary> /// 创建多边形shp /// </summary> /// <param name="pPolygon"></param> /// <param name="shpPath"></param> public static void CreatePolygonFeatureClass(IPolygon pPolygon, string shpfolder, string shpname) { IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass(); IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkSpaceFac; IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace; //创建字段集2 IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段 IFields fields = ocDescription.RequiredFields; int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName); IField field = fields.get_Field(shapeFieldIndex); IGeometryDef geometryDef = field.GeometryDef; IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; //geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; //geometryDefEdit.SpatialReference_2 = spatialReference; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon; ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass(); IProjectedCoordinateSystem pcsSys = pSpatialRefFac.CreateProjectedCoordinateSystem((int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_39); geometryDefEdit.SpatialReference_2 = pcsSys; IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; //将传入字段 转成 validatedFields fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); field = new FieldClass(); IFieldsEdit pFieldsEdit = (IFieldsEdit)fields; IFieldEdit pFieldEdit = (IFieldEdit)field; pFieldEdit = (IFieldEdit)field; pFieldEdit.Name_2 = "面积"; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble; pFieldsEdit.AddField(field); pWorkspaceEdit.StartEditOperation(); IFeatureClass pFeatureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); pPolygon = new PolygonClass(); IArea s = pPolygon as IArea; double area = s.Area; IFeature pfeature = pFeatureClass.CreateFeature(); pfeature.Shape = pPolygon; try { pfeature.set_Value(pfeature.Fields.FindField("面积"), area.ToString()); pfeature.Store(); } catch { MessageBox.Show(area.ToString()); } pWorkspaceEdit.StopEditOperation(); }
public IFeatureClass CreateFeatureClassWithFieldsGeoRef(String featureClassName, IFeatureWorkspace featureWorkspace) { GeoJson geoJson = new GeoJson(); try { // Instantiate a feature class description to get the required fields. IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription) fcDescription; IFields fields = ocDescription.RequiredFields; IFieldsEdit fieldsEdit = (IFieldsEdit)fields; addFeatureFeild("URI", "URI", esriFieldType.esriFieldTypeString, fieldsEdit); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); // The enumFieldError enumerator can be inspected at this point to determine // which fields were modified during validation. // Create the feature class. IFeatureClass featureClass = featureWorkspace.CreateFeatureClass (featureClassName, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); return featureClass; } catch (Exception e) { Log.WriteLine("CreateFeatureClassWithFields: " + e.Message); } return null; }
public IFeatureClass CreateWithoutDescription(String featureClassName, UID classExtensionUID, IFeatureWorkspace featureWorkspace, esriGeometryType geoType, IFields fields) { // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); IFeatureClass featureClass = featureWorkspace.CreateFeatureClass (featureClassName, validatedFields, null, classExtensionUID, esriFeatureType.esriFTSimple, "Shape", ""); return featureClass; }
public ITable createTable(IWorkspace wks, string tableName, IFields atrflds) { IWorkspace2 wks2 = (IWorkspace2)wks; IFeatureWorkspace ftrWks = (IFeatureWorkspace)wks; ITable tbl = null; try { if (wks2.get_NameExists(esriDatasetType.esriDTTable, tableName)) { return tbl; } IObjectClassDescription ocDescription = new ObjectClassDescriptionClass(); IFields fields = ocDescription.RequiredFields; IFieldsEdit fieldsEdit = (IFieldsEdit)fields; if (atrflds != null) { for (int i = 0; i < atrflds.FieldCount; i++) { IField fld = atrflds.get_Field(i); fieldsEdit.AddField(fld); } } // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)wks; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); tbl = ftrWks.CreateTable(tableName, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, ""); } catch (Exception e) { Console.WriteLine("Error: " + e.ToString()); } return tbl; }
/// <summary> /// creates a new featrue class /// </summary> /// <param name="wks">the workspace to create from</param> /// <param name="polyFtrClsName">name of the feature class</param> /// <param name="atrflds">name of the fields</param> /// <param name="geoType">the geotype</param> /// <param name="sr">spatial reference</param> /// <returns>newly created featureclass</returns> public IFeatureClass createFeatureClass(IWorkspace2 wks, string polyFtrClsName, IFields atrflds, esriGeometryType geoType, ISpatialReference sr) { IFeatureClass tFtr = null; try { IFeatureWorkspace ftrWks = (IFeatureWorkspace)wks; polyFtrClsName = getSafeOutputNameNonRaster((IWorkspace)wks, polyFtrClsName); IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass(); IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription; IFields fields = ocDescription.RequiredFields; if (atrflds != null) { IFieldsEdit fieldsEdit = (IFieldsEdit)fields; for (int i = 0; i < atrflds.FieldCount; i++) { IField fld = atrflds.get_Field(i); IField nFld = new FieldClass(); IFieldEdit nFldE = (IFieldEdit)nFld; nFldE.Name_2 = fld.Name; if (fld.Type != esriFieldType.esriFieldTypeOID) { nFldE.Type_2 = fld.Type; fieldsEdit.AddField(nFld); } } } // Find the shape field in the required fields and modify its GeometryDef to// use point geometry and to set the spatial reference.int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName); IField field = fields.get_Field(fields.FindField(fcDescription.ShapeFieldName)); IGeometryDef geometryDef = field.GeometryDef; IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = geoType; geometryDefEdit.SpatialReference_2 = sr; // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)wks; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); tFtr = ftrWks.CreateFeatureClass(polyFtrClsName, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, ""); } catch(Exception e) { Console.WriteLine("Error: " + e.ToString()); } return tFtr; }
/// <summary> /// create feature class of output /// </summary> /// <param name="workspace">object workspace</param> /// <param name="spatialReference">spatial reference of feature class of output</param> /// <param name="nameFeatureClass">name of feature class</param> /// <returns>object feature class</returns> private static IFeatureClass CreateFeatureClassOutput(IWorkspace workspace, ISpatialReference spatialReference, string nameFeatureClass) { IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass(); IObjectClassDescription objectClassDescription = (IObjectClassDescription)featureClassDescription; IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace; // Create the fields collection. IFields fields = new FieldsClass(); IFieldsEdit fieldsEdit = (IFieldsEdit)fields; IField oidField = new FieldClass(); IFieldEdit oidFieldEdit = (IFieldEdit)oidField; oidFieldEdit.Name_2 = "OBJECTID"; oidFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID; fieldsEdit.AddField(oidField); // Create the Shape field. IField shapeField = new Field(); IFieldEdit shapeFieldEdit = (IFieldEdit)shapeField; // Set up the geometry definition for the Shape field. IGeometryDef geometryDef = new GeometryDefClass(); IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon; // By setting the grid size to 0, you're allowing ArcGIS to determine the appropriate grid sizes for the feature class. // If in a personal geodatabase, the grid size will be 1000. If in a file or ArcSDE geodatabase, the grid size // will be based on the initial loading or inserting of features. geometryDefEdit.HasM_2 = false; geometryDefEdit.HasZ_2 = false; geometryDefEdit.SpatialReference_2 = spatialReference; // Set standard field properties. shapeFieldEdit.Name_2 = featureClassDescription.ShapeFieldName; shapeFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry; shapeFieldEdit.GeometryDef_2 = geometryDef; shapeFieldEdit.IsNullable_2 = true; shapeFieldEdit.Required_2 = true; fieldsEdit.AddField(shapeField); IField idField = new FieldClass(); IFieldEdit idIsolaFieldEdit = (IFieldEdit)idField; idIsolaFieldEdit.Name_2 = Program.nameFieldIdOutput; idIsolaFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger; fieldsEdit.AddField(idField); // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = workspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); return featureWorkspace.CreateFeatureClass(nameFeatureClass, fields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, featureClassDescription.ShapeFieldName, string.Empty); }
/// <summary> /// 创建要素图层 /// 也可以利用现有要素图层创建:IFeatureLayer featurelayer, /// </summary> /// <params name="map"></params> /// <params name="workspace"></params> /// <params name="layername"></params> /// <params name="aliasname"></params> /// <returns></returns> public IFeatureLayer CreateFeatureLayer(IMap map, IWorkspace workspace, string layername, string aliasname) { try { IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace; //IFields fields = featurelayer.FeatureClass.Fields; // 创建要素类的字段集 IFields fields = new FieldsClass(); IFieldsEdit fieldsEdit = (IFieldsEdit)fields; // 添加要素类必须字段:object ID 字段 IField oidField = new FieldClass(); IFieldEdit oidFieldEdit = (IFieldEdit)oidField; oidFieldEdit.Name_2 = "OBJECTID"; oidFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID; fieldsEdit.AddField(oidField); // 创建几何定义(和空间参考) IGeometryDef geometryDef = new GeometryDefClass(); IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef; geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint; //ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass(); //ISpatialReference spatialReference = //spatialReferenceFactory.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_NAD1983UTM_20N); //ISpatialReferenceResolution spatialReferenceResolution = (ISpatialReferenceResolution)spatialReference; //spatialReferenceResolution.ConstructFromHorizon(); //ISpatialReferenceTolerance spatialReferenceTolerance = (ISpatialReferenceTolerance)spatialReference; //spatialReferenceTolerance.SetDefaultXYTolerance(); geometryDefEdit.SpatialReference_2 = map.SpatialReference; //添加几何字段 IField geometryField = new FieldClass(); IFieldEdit geometryFieldEdit = (IFieldEdit)geometryField; geometryFieldEdit.Name_2 = "Shape"; geometryFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry; geometryFieldEdit.GeometryDef_2 = geometryDef; fieldsEdit.AddField(geometryField); //新建字段 IField pField = new FieldClass(); IFieldEdit pFieldEdit = pField as IFieldEdit; pFieldEdit.Length_2 = 50; pFieldEdit.Name_2 = "ID"; pFieldEdit.AliasName_2 = "ID"; pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldsEdit.AddField(pField); //检查字段的有效性 IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(layername, validatedFields, null, null, esriFeatureType.esriFTSimple, "Shape", ""); //用创建的要素类生成要素图层 IFeatureLayer newFeaLayer = new FeatureLayerClass(); newFeaLayer.FeatureClass = featureClass; newFeaLayer.Name = aliasname; //添加新建图层到相应图层组中 IGroupLayer groupLayer = new GroupLayerClass(); string groupLayerName = aliasname.Split("-".ToCharArray())[1].Trim(); groupLayer = GetGroupLayerByName(groupLayerName); groupLayer.Add(newFeaLayer as ILayer); DataEditCommon.g_axTocControl.Update(); DataEditCommon.g_pAxMapControl.Refresh(); return newFeaLayer; } catch (Exception ex) { Log.Debug(ex.ToString()); return null; } }
private static IFields CreateNewFields(fulcrumform form, IFields fields, ISpatialReference sr) { try { IFieldsEdit fieldsEdit = (IFieldsEdit)fields; foreach (fulcrumelement element in form.elements) { //!!! ToDo: Add data types as needed (numeric, etc) if (element.data_name != "") { IField field = new FieldClass(); IFieldEdit2 fieldEdit = (IFieldEdit2)field; switch (element.type) { case "Section": //a Section is a whole different animal it will have sub elements (children) like so, element.elements //!!!~but not dealing with them for now fieldEdit.Name_2 = element.data_name; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 100; // add field to field collection fieldsEdit.AddField(field); break; case "ClassificationField": fieldEdit.Name_2 = element.data_name; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 100; fieldsEdit.AddField(field); break; case "ChoiceField": fieldEdit.Name_2 = element.data_name; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 100; fieldsEdit.AddField(field); break; case "TextField": fieldEdit.Name_2 = element.data_name; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 255; fieldsEdit.AddField(field); break; case "DateTimeField": //if the name happens to be Date we need to override it if (element.data_name == "date") { fieldEdit.Name_2 = "record_date"; } else { fieldEdit.Name_2 = element.data_name; } fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 50; fieldsEdit.AddField(field); break; case "PhotoField": fieldEdit.Name_2 = photoFieldName; fieldEdit.IsNullable_2 = true; fieldEdit.AliasName_2 = element.label; fieldEdit.Type_2 = esriFieldType.esriFieldTypeString; fieldEdit.Length_2 = 200; //If we want to stuff the image in a raster field, here's a start /*!!! IRasterDef rasterDef = new RasterDefClass(); rasterDef.Description = "PictureField"; rasterDef.IsManaged = true; rasterDef.IsRasterDataset = true; //rasterDef.SpatialReference = sr; This is throwing an error fieldEdit.RasterDef = rasterDef; fieldEdit.Type_2 = esriFieldType.esriFieldTypeRaster; */ fieldsEdit.AddField(field); break; case "Label": //skip it default: //a data type we haven't accounted for... //don't create a field for it break; } field = null; fieldEdit = null; } } fields = (IFields)fieldsEdit; // Use IFieldChecker to create a validated fields collection. IFieldChecker fieldChecker = new FieldCheckerClass(); IEnumFieldError enumFieldError = null; IFields validatedFields = null; fieldChecker.Validate(fields, out enumFieldError, out validatedFields); // The enumFieldError enumerator can be inspected at this point to determine // which fields were modified during validation. if (enumFieldError != null) { enumFieldError.Reset(); IFieldError err = enumFieldError.Next(); while (!(err == null)) { //!!!ToDo: //we need to do something here cause the feature class will not be created with invalid fields Console.WriteLine(err.FieldError + " at index " + err.FieldIndex); err = enumFieldError.Next(); } } return validatedFields; } catch (Exception e) { string choke = e.Message; return null; } }
/// <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; } }