private void CreateFeautureLayer()
{
bool hasfly = false;
foreach (FeatureClass fc in _featureClassMapping.Keys)
{
List <string> geoNames = _featureClassMapping[fc];
foreach (string geoName in geoNames)
{
if (!geoName.Equals("Geometry"))
{
continue;
}
IFeatureLayer featureLayer = _axRenderControl.ObjectManager.CreateFeatureLayer(fc, geoName, null, null);
featureLayer.MaxVisibleDistance = 500000000;
_featureLayerMaps.Add(new FeatureLayerMap(featureLayer, fc));
if (!hasfly)
{
IFieldInfoCollection fieldinfos = fc.GetFields();
IFieldInfo fieldinfo = fieldinfos.Get(fieldinfos.IndexOf(geoName));
IGeometryDef geometryDef = fieldinfo.GeometryDef;
IEnvelope env = geometryDef.Envelope;
if (env == null || (env.MaxX == 0.0 && env.MaxY == 0.0 && env.MaxZ == 0.0 && env.MinX == 0.0 && env.MinY == 0.0 && env.MinZ == 0.0))
{
continue;
}
//var angle = SetAngle(0, -20, 0);
//SetCameraLookAt(env.Center, 1000, angle);
}
hasfly = true;
}
}
}
private static IGeometry GetInitialShape([NotNull] IFeatureClass schema)
{
int shapeIndex = schema.FindField(schema.ShapeFieldName);
if (shapeIndex < 0)
{
return(null);
}
IField shapeField = schema.Fields.Field[shapeIndex];
IGeometryDef geometryDef = shapeField.GeometryDef;
if (geometryDef == null)
{
return(null);
}
IGeometry shape = GetInitialShape(geometryDef.GeometryType);
shape.SpatialReference = geometryDef.SpatialReference;
if (shape is IZAware zAware)
{
zAware.ZAware = geometryDef.HasZ;
}
if (shape is IMAware mAware)
{
mAware.MAware = geometryDef.HasM;
}
return(shape);
}
private IGeometryDef method_0(IFeatureClass ifeatureClass_0)
{
IGeometryDef geometryDef =
ifeatureClass_0.Fields.Field[ifeatureClass_0.FindField(ifeatureClass_0.ShapeFieldName)].GeometryDef;
return(geometryDef);
}
async public Task <int> CreateFeatureClass(string dsname, string fcname, IGeometryDef geomDef, IFields fields)
{
try
{
if (_client == null || _spatialCollectionRef == null)
{
throw new Exception("No spatial collection reference. Open database before running CreateFeatureClass method");
}
var datasetElement = await Element(fcname);
if (datasetElement != null)
{
throw new Exception($"Featureclass {fcname} already exists");
}
var result = await _client.CreateDocumentAsync(_spatialCollectionRef.SelfLink,
new Json.SpatialCollectionItem(geomDef, fields)
{
Name = fcname
});
return(1);
}
catch (Exception ex)
{
lastException = ex;
LastErrorMessage = ex.Message;
return(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);
}
public MongoGeometryDef(IGeometryDef geomDef)
{
this.GeometryType = geomDef.GeometryType;
this.HasM = geomDef.HasM;
this.HasZ = geomDef.HasZ;
this.SpatialReference = geomDef.SpatialReference;
}
private static IFeatureClass CreateFeaturepointClass(String featureClassName, IFeatureWorkspace featureWorkspace, ISpatialReference spatialReference)
{
try
{
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;
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(featureClassName, fields,
ocDescription.ClassExtensionCLSID, ocDescription.InstanceCLSID, esriFeatureType.esriFTSimple,
fcDescription.ShapeFieldName, "");
return(featureClass);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "异常");
return(null);
}
}
public MemFeatureClass(MemDataset dataset, string name, IFields fields, IGeometryDef geometryDef)
{
_dataset = dataset;
_name = name;
_fields = fields;
_geometryDef = geometryDef;
}
/// <summary>
/// 导出要素类到目标工作空间
/// </summary>
/// <param name="featureClass"></param>
/// <param name="workspace"></param>
/// <param name="queryGeometry"></param>
/// <param name="spatialRelEnum"></param>
/// <param name="whereClause"></param>
/// <returns></returns>
public static Boolean ExportToWorkspace(IFeatureClass featureClass, IWorkspace workspace, IGeometry queryGeometry = null, esriSpatialRelEnum spatialRelEnum = esriSpatialRelEnum.esriSpatialRelIntersects, string whereClause = "")
{
IDataset inDataSet = featureClass as IDataset;
IFeatureClassName inFCName = inDataSet.FullName as IFeatureClassName;
IWorkspace inWorkspace = inDataSet.Workspace;
IDataset outDataSet = workspace as IDataset;
IWorkspaceName outWorkspaceName = outDataSet.FullName as IWorkspaceName;
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName dataSetName = outFCName as IDatasetName;
dataSetName.WorkspaceName = outWorkspaceName;
dataSetName.Name = inDataSet.Name;
IFieldChecker fieldChecker = new FieldCheckerClass
{
InputWorkspace = inWorkspace,
ValidateWorkspace = workspace
};
IFields fields = featureClass.Fields;
fieldChecker.Validate(fields, out IEnumFieldError enumFieldError, out IFields outFields);
IFeatureDataConverter featureDataConverter = null;
IField geometryField;
try
{
IGeometryDef geometryDef = null;
ISpatialFilter pSF = new SpatialFilterClass();
for (int i = 0; i < outFields.FieldCount; i++)
{
if (outFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = outFields.get_Field(i);
geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
pSF.Geometry = queryGeometry;
pSF.GeometryField = featureClass.ShapeFieldName;
pSF.SpatialRel = spatialRelEnum;
pSF.WhereClause = whereClause;
break;
}
}
featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inFCName, pSF, null, outFCName, geometryDef, outFields, " ", 1000, 0);
return(true);
}
catch (Exception ex)
{
LOG.Error("图层数据导出出错！" + ex.Message);
throw ex;
}
}
public IGeometryDef GetGeometryDef(IFeatureClass ifeatureClass_0)
{
IGeometryDef geometryDef =
ifeatureClass_0.Fields.Field[ifeatureClass_0.FindField(ifeatureClass_0.ShapeFieldName)].GeometryDef;
return(geometryDef);
}
IEnumInvalidObject ESRI.ArcGIS.Geodatabase.IFeatureDataConverter2.ConvertFeatureClass(
IDatasetName idatasetName_0, IQueryFilter iqueryFilter_0, ISelectionSet iselectionSet_0,
IFeatureDatasetName ifeatureDatasetName_0, IFeatureClassName ifeatureClassName_0,
IGeometryDef igeometryDef_0, IFields ifields_0, string string_0, int int_0, int int_1)
{
return(null);
}
public static IFields CreateFields(esriGeometryType geoType)
{
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 = geoType;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
var sr = spatialReferenceFactory.CreateGeographicCoordinateSystem(4326);
geometryDefEdit.SpatialReference_2 = sr;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
field = new FieldClass();
IFieldEdit fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Name";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
return(fields);
}
private void CreateFeature(IGeometry geo, IMap pMap, IFeatureClass fc)
{
try
{
if (geo == null || fc == null || pMap == null)
{
return;
}
IDataset pDataset = fc as IDataset;
IWorkspaceEdit pWorkspaceEdit = pDataset.Workspace as IWorkspaceEdit;
int index = fc.FindField(fc.ShapeFieldName);
IGeometryDef pGD = fc.Fields.get_Field(index).GeometryDef;
if (pGD.HasZ)
{
IZAware pZA = geo as IZAware;
pZA.ZAware = true;
IZ pZ = geo as IZ;
double zmin = -1000, zmax = 1000;
if (pGD.SpatialReference.HasZPrecision())
{
pGD.SpatialReference.GetZDomain(out zmin, out zmax);
}
if (pZ != null)
{
pZ.SetConstantZ(0);
}
else
{
IPoint p = geo as IPoint;
if (p.Z.ToString() == "非数字")
{
p.Z = 0;
}
}
}
if (pGD.HasM)
{
IMAware pMA = geo as IMAware;
pMA.MAware = true;
}
if (!pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
}
IFeature pFeature = fc.CreateFeature();
pFeature.Shape = geo;
pFeature.Store();
if (pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StartEditOperation();
pWorkspaceEdit.StopEditing(true);
}
pMap.ClearSelection();
}
catch (System.Exception ex)
{
return;
}
}
/// <summary>
/// From service fills list of layer with M
/// </summary>
private void GetRouteLayerInfos()
{
IMapServer3 serverObject = this.GetMapServer();
IMapLayerInfos mapLayerInfos = serverObject.GetServerInfo(serverObject.DefaultMapName).MapLayerInfos;
this.routeLayerInfos = new List <RouteLayerInfo>();
for (int i = 0; i < mapLayerInfos.Count; i++)
{
IMapLayerInfo mapLayerInfo = mapLayerInfos.get_Element(i);
if (mapLayerInfo.IsFeatureLayer)
{
IFields fields = mapLayerInfo.Fields;
for (int j = 0; j < fields.FieldCount; j++)
{
IField field = fields.get_Field(j);
if (field.Type == esriFieldType.esriFieldTypeGeometry)
{
IGeometryDef geometryDef = field.GeometryDef;
if (geometryDef.HasM)
{
this.routeLayerInfos.Add(new RouteLayerInfo(mapLayerInfo));
}
break;
}
}
}
}
}
private IFeatureClass method_2(IFeatureWorkspaceAnno ifeatureWorkspaceAnno_0, IFeatureDataset ifeatureDataset_0,
IFeatureClass ifeatureClass_0, double double_1, esriUnits esriUnits_0,
IAnnotateLayerPropertiesCollection iannotateLayerPropertiesCollection_0,
ISymbolCollection isymbolCollection_0, string string_0)
{
IObjectClassDescription description = new AnnotationFeatureClassDescriptionClass();
IFields requiredFields = description.RequiredFields;
int index = requiredFields.FindField((description as IFeatureClassDescription).ShapeFieldName);
if (index != -1)
{
IField field = requiredFields.get_Field(index);
IGeometryDef geometryDef = field.GeometryDef;
ISpatialReference spatialReference = geometryDef.SpatialReference;
SpatialReferenctOperator.ChangeCoordinateSystem(ifeatureWorkspaceAnno_0 as IGeodatabaseRelease,
spatialReference, false);
(geometryDef as IGeometryDefEdit).SpatialReference_2 = spatialReference;
(field as IFieldEdit).GeometryDef_2 = geometryDef;
}
IFeatureClassDescription description2 = description as IFeatureClassDescription;
IGraphicsLayerScale referenceScale = new GraphicsLayerScaleClass
{
ReferenceScale = double_1,
Units = esriUnits_0
};
UID instanceCLSID = description.InstanceCLSID;
UID classExtensionCLSID = description.ClassExtensionCLSID;
return(ifeatureWorkspaceAnno_0.CreateAnnotationClass(string_0, requiredFields, instanceCLSID,
classExtensionCLSID, description2.ShapeFieldName, "", ifeatureDataset_0, ifeatureClass_0,
iannotateLayerPropertiesCollection_0, referenceScale, isymbolCollection_0, true));
}
private void IndexSetCtrl_Load(object sender, EventArgs e)
{
int num;
if ((this.ifeatureClass_0 as IDataset).Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace)
{
this.groupBox2.Visible = true;
}
else
{
this.groupBox2.Visible = false;
}
IIndexes indexes = this.ifeatureClass_0.Indexes;
for (num = 0; num < indexes.IndexCount; num++)
{
IIndex index = indexes.get_Index(num);
if (index.Fields.get_Field(0).Type != esriFieldType.esriFieldTypeGeometry)
{
this.listBoxIndexName.Items.Add(new IndexWrap(index));
}
}
int num2 = this.ifeatureClass_0.FindField(this.ifeatureClass_0.ShapeFieldName);
IGeometryDef geometryDef = this.ifeatureClass_0.Fields.get_Field(num2).GeometryDef;
double[] numArray2 = new double[3];
for (num = 0; num < geometryDef.GridCount; num++)
{
numArray2[num] = geometryDef.get_GridSize(num);
}
this.lblGridSize1.Text = "Grid 1:" + numArray2[0].ToString("0.##");
this.lblGridSize2.Text = "Grid 2:" + numArray2[1].ToString("0.##");
this.lblGridSize3.Text = "Grid 3:" + numArray2[2].ToString("0.##");
this.btnAddGridIndex.Enabled = geometryDef.GridCount == 0;
}
private string GenerateTemp3DPolygonStorage()
{
string newFeatureClassName = $"Polygon3D_L{Helper.GetTemporaryNameSuffix()}";
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.HasZ_2 = true;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
geometryDefEdit.SpatialReference_2 = ArcMapInstance.Document.FocusMap.SpatialReference;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
IField isVisibleField = new FieldClass();
IFieldEdit isVisibleFieldEdit = (IFieldEdit)isVisibleField;
isVisibleFieldEdit.Name_2 = "IS_VISIBLE";
isVisibleFieldEdit.Type_2 = esriFieldType.esriFieldTypeSmallInteger;
fieldsEdit.AddField(isVisibleFieldEdit);
GenerateTempStorage(newFeatureClassName, fields, esriGeometryType.esriGeometryPolygon);
return(newFeatureClassName);
}
public static void SetGeometry(IGeometry pGeometry, IFeature pFeature)
{
double num;
double num1;
IFeatureClass @class = pFeature.Class as IFeatureClass;
try
{
int num2 = @class.FindField(@class.ShapeFieldName);
IGeometryDef geometryDef = @class.Fields.Field[num2].GeometryDef;
if (!geometryDef.HasZ)
{
((IZAware)pGeometry).ZAware = false;
}
else
{
((IZAware)pGeometry).ZAware = true;
if (pGeometry is IZ)
{
IZ igeometry0 = (IZ)pGeometry;
geometryDef.SpatialReference.GetZDomain(out num, out num1);
igeometry0.SetConstantZ(num);
}
else if (pGeometry is IPoint)
{
geometryDef.SpatialReference.GetZDomain(out num, out num1);
(pGeometry as IPoint).Z = num;
}
}
if (!geometryDef.HasM)
{
((IMAware)pGeometry).MAware = false;
}
else
{
((IMAware)pGeometry).MAware = true;
}
IFeature feature = @class.CreateFeature();
(pGeometry as ITopologicalOperator6).SimplifyAsFeature();
feature.Shape = pGeometry;
try
{
((IRowSubtypes)feature).InitDefaultValues();
}
catch (Exception exception)
{
Logger.Current.Error("", exception, null);
}
EditorEvent.NewRow(feature);
feature.Store();
}
catch (COMException cOMException)
{
Logger.Current.Error("", cOMException, null);
}
catch (Exception exception1)
{
Logger.Current.Error("", exception1, null);
}
}
/// <summary>
/// SDE要素类导出mdb（要素集下要素类）
/// </summary>
/// <param name="IN_SourceWorkspace">源工作空间</param>
/// <param name="IN_TargetWorkspace">目标要素数据集</param>
/// <param name="IN_SourceFeatureClassName">源要素类名</param>
/// <param name="IN_TargetFeatureClassName">目标要素类名</param>
private void ConvertFeatureClass(IWorkspace IN_SourceWorkspace, IFeatureDataset IN_TargetWorkspace, string IN_SourceFeatureClassName, string IN_TargetFeatureClassName)
{
#region 环境配置
//创建源工作空间名
IDataset Temp_SourceWorkspaceDataset = (IDataset)IN_SourceWorkspace;
IWorkspaceName Temp_SourceWorkspaceName = (IWorkspaceName)Temp_SourceWorkspaceDataset.FullName;
//创建源要素数据集名
IFeatureClassName Temp_SourceFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_SourceDatasetName = (IDatasetName)Temp_SourceFeatureClassName;
Temp_SourceDatasetName.WorkspaceName = Temp_SourceWorkspaceName;
Temp_SourceDatasetName.Name = IN_SourceFeatureClassName;
//创建目标工作空间名
IDataset Temp_TargetWorkspaceDataset = (IDataset)IN_TargetWorkspace.Workspace;
IWorkspaceName Temp_TargetWorkspaceName = (IWorkspaceName)(Temp_TargetWorkspaceDataset.FullName);
//创建目标要素类名
IFeatureClassName Temp_TargetFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_TargetDatasetName = (IDatasetName)Temp_TargetFeatureClassName;
Temp_TargetDatasetName.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName.Name = IN_TargetFeatureClassName;
//创建目标要素数据集名
IFeatureDatasetName Temp_TargetFeatureDatasetName = new FeatureDatasetNameClass();
IDatasetName Temp_TargetDatasetName2 = (IDatasetName)Temp_TargetFeatureDatasetName;
Temp_TargetDatasetName2.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName2.Name = IN_TargetWorkspace.Name;
#endregion
//打开源要素类获取字段定义
ESRI.ArcGIS.esriSystem.IName Temp_SourceName = (ESRI.ArcGIS.esriSystem.IName)Temp_SourceFeatureClassName;
IFeatureClass Temp_SourceFeatureClass = (IFeatureClass)Temp_SourceName.Open();
//验证字段
IFieldChecker Temp_FieldChecker = new FieldCheckerClass();
IFields Temp_TargetFeatureClassFields;
IFields Temp_SourceFeatureClassFields = Temp_SourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
Temp_FieldChecker.InputWorkspace = IN_SourceWorkspace;
Temp_FieldChecker.ValidateWorkspace = IN_TargetWorkspace.Workspace;
Temp_FieldChecker.Validate(Temp_SourceFeatureClassFields, out enumFieldError, out Temp_TargetFeatureClassFields);
//批量导入
IField Temp_GeometryField;
for (int i = 0; i < Temp_TargetFeatureClassFields.FieldCount; i++)
{
if (Temp_TargetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
Temp_GeometryField = Temp_TargetFeatureClassFields.get_Field(i);
//获取空间定义
IGeometryDef Temp_GeometryDef = Temp_GeometryField.GeometryDef;
IGeometryDefEdit Temp_TargetFCGeoDefEdit = (IGeometryDefEdit)Temp_GeometryDef;
Temp_TargetFCGeoDefEdit.GridCount_2 = 1;
Temp_TargetFCGeoDefEdit.set_GridSize(0, 0);
Temp_TargetFCGeoDefEdit.SpatialReference_2 = Temp_GeometryField.GeometryDef.SpatialReference;
//定义筛选条件
IQueryFilter Temp_QueryFilter = new QueryFilterClass();
Temp_QueryFilter.WhereClause = "";
//导入要素类至要素数据集
IFeatureDataConverter Temp_FeatureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = Temp_FeatureDataConverter.ConvertFeatureClass(Temp_SourceFeatureClassName, Temp_QueryFilter, Temp_TargetFeatureDatasetName, Temp_TargetFeatureClassName, Temp_GeometryDef, Temp_TargetFeatureClassFields, "", 1000, 0);
break;
}
}
}
/// <summary>
/// 将一个要素类从一个工作空间转移到另外一个工作空间
/// 注意目标工作空间不能有改要素类，必须先清除
/// </summary>
/// <param name="sourceWorkspace">源工作空间</param>
/// <param name="targetWorkspace">目标工作空间</param>
/// <param name="nameOfSourceFeatureClass">源要素类名</param>
/// <param name="nameOfTargetFeatureClass">目标要素类名</param>
public void IFeatureDataConverter_ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
public void IFeatureDataConverter(IWorkspace pSourceWorkspace, IWorkspace pTargetWorkspace, string pSFeatureClass, string pDFeatureClass)
{
IDataset sourceWorkspaceDataset = (IDataset)pSourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = pSFeatureClass;
IDataset targetWorkspaceDataset = (IDataset)pTargetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = pDFeatureClass;
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = pSourceWorkspace;
fieldChecker.ValidateWorkspace = pTargetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
protected override string AddGeometryColumn(string schemaName,
string tableName,
string colunName,
IGeometryDef geomDef,
string geomTypeString)
{
//return "CREATE SPATIAL INDEX SIndx_Postcodes_" + colunName + "_col1 ON " + tableName + "(" + colunName + ")";
return(String.Empty);
}
/// <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));
}
private void LoadLocalData()
{
try
{
ConnectionInfo ci = new ConnectionInfo
{
ConnectionType = i3dConnectionType.i3dConnectionFireBird2x
};
string rootPath = Path.GetFullPath(@"..//..//..");
string tmpFDBPath = Path.Combine(rootPath, "data\\3dm\\1.3DM");
ci.Database = tmpFDBPath;
IDataSourceFactory dsFactory = new DataSourceFactory();
IDataSource ds = dsFactory.OpenDataSource(ci);
string[] setnames = (string[])ds.GetFeatureDatasetNames();
if (setnames.Length == 0)
{
return;
}
IFeatureDataSet dataset = ds.OpenFeatureDataset(setnames[0]);
datasetCRS = dataset.SpatialReference;
string[] fcnames = (string[])dataset.GetNamesByType(i3dDataSetType.i3dDataSetFeatureClassTable);
if (fcnames.Length == 0)
{
return;
}
fcMap = new Hashtable(fcnames.Length);
foreach (string name in fcnames)
{
IFeatureClass fc = dataset.OpenFeatureClass(name);
// 找到空间列字段
List <string> geoNames = new List <string>();
IFieldInfoCollection fieldinfos = fc.GetFields();
for (int i = 0; i < fieldinfos.Count; i++)
{
IFieldInfo fieldinfo = fieldinfos.Get(i);
if (null == fieldinfo)
{
continue;
}
IGeometryDef geometryDef = fieldinfo.GeometryDef;
if (null == geometryDef)
{
continue;
}
geoNames.Add(fieldinfo.Name);
}
fcMap.Add(fc, geoNames);
}
}
catch (COMException ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
return;
}
}
/// <summary>
/// Check if feature class has M value enable.
/// </summary>
/// <param name="featureClass"></param>
/// <returns></returns>
public static bool HasMValue(this IFeatureClass featureClass)
{
string shapeFieldName = featureClass.ShapeFieldName;
IFields fields = featureClass.Fields;
int geometryIndex = fields.FindField(shapeFieldName);
IField field = fields.get_Field(geometryIndex);
IGeometryDef geometryDef = field.GeometryDef;
return(geometryDef.HasM);
}
public AnimalMap(string inName, string path, IGeometryDef inGeoDef) : this()
{
mLog.Debug("my name is " + inName);
mLog.Debug("my path is " + path + "\\" + inName);
this.myFileName = inName;
this.myPath = path + "\\" + inName;
this.FullFileName = this.myPath + "\\" + inName + ".shp";
this.mGeoDef = inGeoDef;
this.makeMap(path, inName, inGeoDef);
}
public static IField AlterGeometryFieldSR(IField pField, ISpatialReference sr)
{
IFieldEdit pEdit = pField as IFieldEdit;
IGeometryDef pGeoDef = pField.GeometryDef;
IGeometryDefEdit pDEdit = pGeoDef as IGeometryDefEdit;
pDEdit.SpatialReference_2 = sr;
pEdit.GeometryDef_2 = pGeoDef;
return(pField);
}
/// <summary>
/// Determines if the ILayer has Z in geometry definition
/// </summary>
/// <param name="layer">The layer.</param>
/// <returns>true if there is a z value in the geometry definition</returns>
public static bool Is3D(this ILayer layer)
{
IFeatureLayer featureLayer = (IFeatureLayer)layer;
IField field = featureLayer.FeatureClass.GetField(featureLayer.FeatureClass.ShapeFieldName);
IGeometryDef geometryDefinition = field.GeometryDef;
return(geometryDefinition.HasZ);
}
public static void Project(IFeatureClass ifeatureClass_0, ISpatialReference ispatialReference_0)
{
IFields fields = ifeatureClass_0.Fields;
IField field = fields.Field[fields.FindField(ifeatureClass_0.ShapeFieldName)];
IGeometryDef geometryDef = field.GeometryDef;
ISpatialReference spatialReference = geometryDef.SpatialReference;
((IGeometryDefEdit)geometryDef).SpatialReference_2 = ispatialReference_0;
((IFieldEdit)field).GeometryDef_2 = geometryDef;
}
public static int CreateFeature(IGeometry pGeometry, IFeatureClass pFeatureClass)
{
double num;
double num1;
int oID;
try
{
if ((pGeometry == null ? false : pFeatureClass != null))
{
int num2 = pFeatureClass.FindField(pFeatureClass.ShapeFieldName);
IGeometryDef geometryDef = pFeatureClass.Fields.Field[num2].GeometryDef;
if (geometryDef.HasZ)
{
((IZAware)pGeometry).ZAware = true;
if (pGeometry is IZ)
{
IZ igeometry0 = (IZ)pGeometry;
geometryDef.SpatialReference.GetZDomain(out num, out num1);
igeometry0.SetConstantZ(num);
}
else if (pGeometry is IPoint)
{
geometryDef.SpatialReference.GetZDomain(out num, out num1);
(pGeometry as IPoint).Z = num;
}
}
if (geometryDef.HasM)
{
((IMAware)pGeometry).MAware = true;
}
IFeature feature = pFeatureClass.CreateFeature();
feature.Shape = pGeometry;
try
{
((IRowSubtypes)feature).InitDefaultValues();
}
catch (Exception exception)
{
Logger.Current.Error("", exception, null);
}
EditorEvent.NewRow(feature);
feature.Store();
EditorEvent.AfterNewRow(feature);
oID = feature.OID;
return(oID);
}
}
catch (Exception exception1)
{
Logger.Current.Error("", exception1, null);
}
oID = -1;
return(oID);
}
private static void MakeZMValue(IGeometryDef pGeometryDef, IGeometry geometry)
{
try
{
IZAware pZAware = (IZAware)geometry;
IMAware pMAware = (IMAware)geometry;
if (pGeometryDef.HasZ)
{
pZAware.ZAware = true;
//if (geometry.Envelope.ZMax.ToString() == "������")
//{
// geometry.Envelope.ZMax = 0; //��Zֵ����Ϊ0
// geometry.Envelope.ZMin = 0; //��Zֵ����Ϊ0
//}
if (geometry.GeometryType == esriGeometryType.esriGeometryPoint)
{
IPoint pt = (IPoint)geometry;
if (pt.Z.ToString() == "������")
pt.Z = 0; //��Zֵ����Ϊ0
}
else
{
IZ iz1 = (IZ)geometry;
if (iz1.ZMax.ToString() == "������" || iz1.ZMax.ToString() == "NaN")
iz1.SetConstantZ(0); //��Zֵ����Ϊ0
}
}
else
{
pZAware.ZAware = false;
}
if (pGeometryDef.HasM)
{
pMAware.MAware = true;
}
else
{
pMAware.MAware = false;
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
