//http://resources.esri.com/help/9.3/arcgisengine/arcobjects/esriGeoDatabase/IFeatureWorkspace.CreateFeatureClass_Example.htm
static IFeatureClass CreateFeatureClass(string name, IFeatureWorkspace ftrSpc, esriGeometryType type, int epsg, List<dynamic> extraFields)
{
IFeatureClass ftrc = null;
if(null != ftrSpc && null != name)
{
IFieldsEdit flds = new FieldsClass();
flds.FieldCount_2 = 2 + (extraFields == null ? 0 : extraFields.Count);
IFieldEdit fld = new FieldClass();
fld.Name_2 = OBJECT_ID;
fld.Type_2 = esriFieldType.esriFieldTypeOID;
flds.Field_2[0] = fld;
fld = new FieldClass();
fld.Name_2 = SHP_NAME;
fld.Type_2 = esriFieldType.esriFieldTypeGeometry;
fld.GeometryDef_2 = CreateGeometryDef(type, epsg);
flds.Field_2[1] = fld;
int eidx = 2;
foreach(var efld in extraFields)
{
fld = new FieldClass();
fld.Name_2 = efld.Name;
fld.Type_2 = efld.Type;
flds.Field_2[eidx++] = fld;
}
ftrc = ftrSpc.CreateFeatureClass(name, flds, null, null, esriFeatureType.esriFTSimple, SHP_NAME, null);
}
return ftrc;
}
static IGeometryDefEdit CreateGeometryDef(esriGeometryType type, int epsg)
{
IGeometryDefEdit geomDef = new GeometryDefClass();
geomDef.GeometryType_2 = type;
geomDef.SpatialReference_2 = CreateSpatialRef(epsg);
return geomDef;
}
public static IFeatureClass CreateFClassInPDB(IWorkspace accessworkspace, string feaDSname, string FCname, esriGeometryType esriGeometryType,ISpatialReference sprf)
{
try
{
IFeatureDataset featureDataset = ((IFeatureWorkspace)accessworkspace).OpenFeatureDataset(feaDSname);
//IGeoDataset geoDataset = featureDataset as IGeoDataset;
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
IFeatureClass fc = featureDataset.CreateFeatureClass(FCname, pFields, null, null, esriFeatureType.esriFTSimple, "Shape", "");
return fc;
}
catch (Exception ee)
{
MessageBox.Show(ee.Message.ToString());
return null;
}
}
public SimplePointCursor(string filePath, IFields fields, int OID,
System.Array fieldMap, IEnvelope queryEnv, esriGeometryType geomType)
{
//HIGHLIGHT: 0 - Set up cursor
m_bIsFinished = false;
m_pStreamReader = new System.IO.StreamReader(filePath);
m_fields = fields;
m_iOID = OID;
m_fieldMap = fieldMap;
m_searchEnv = queryEnv;
switch (geomType)
{
case esriGeometryType.esriGeometryPolygon:
m_wkGeom = new Polygon() as IGeometry;
m_workPts = new PointClass[5];
for (int i = 0; i < m_workPts.Length; i++)
m_workPts[i] = new PointClass();
break;
case esriGeometryType.esriGeometryPolyline:
m_wkGeom = new PolylineClass() as IGeometry;
m_workPts = new PointClass[5];
for (int i = 0; i < m_workPts.Length; i++)
m_workPts[i] = new PointClass();
break;
case esriGeometryType.esriGeometryPoint:
m_wkGeom = new PointClass() as IGeometry;
break;
default: //doesn't need to set worker geometry if it is table
break;
}
//advance cursor so data is readily available
this.NextRecord();
}
public FeatureExtractionResult(string ParamName, int TotalCount, double? TotalMeasure, double? TotalValue,
Dictionary<string,int> CategoryCounts, Dictionary<string,double> CategoryMeasures,
Dictionary<string,double> CategoryTotals,esriGeometryType ExtractionType)
{
this.m_successful = true;
this.m_paramName = ParamName;
// all parameters except for totalcount can be null
// i.e. in the case where we have just counted the total number of points with no categories
// or values
this.m_totalcount = TotalCount;
if (TotalMeasure.HasValue)
{
this.m_totalmeasure = TotalMeasure.Value;
this.m_hasmeasures = true;
}
else
{
this.m_totalmeasure = -1;
this.m_hasmeasures = false;
}
if (TotalValue.HasValue)
{
this.m_totalvalue = TotalValue.Value;
this.m_hasvalues = true;
}
else
{
this.m_totalvalue = -1;
this.m_hasvalues = false;
}
this.m_categorycounts = CategoryCounts;
if (CategoryCounts != null)
{
this.m_hascategories = true;
}
else
{
this.m_hascategories = false;
}
this.m_categorymeasures = CategoryMeasures;
if (CategoryMeasures != null)
{
this.m_hasmeasures = true;
}
else
{
// it must be points
this.m_hasmeasures=false;
}
this.m_ExtractionType = ExtractionType;
this.m_categorytotals = CategoryTotals;
this.m_errormessage = "No errors occurred";
}
public GeometryDef(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <AvgNumPoints></AvgNumPoints>
XPathNavigator navigatorAvgNumPoints = navigator.SelectSingleNode(Xml.AVGNUMPOINTS);
if (navigatorAvgNumPoints != null) {
this._avgNumPoints = navigatorAvgNumPoints.ValueAsInt;
}
// <GeometryType></GeometryType>
XPathNavigator navigatorGeometryType = navigator.SelectSingleNode(Xml.GEOMETRYTYPE);
if (navigatorGeometryType != null) {
this._geometryType = (esriGeometryType)Enum.Parse(typeof(esriGeometryType), navigatorGeometryType.Value, true);
}
// <HasM></HasM>
XPathNavigator navigatorHasM = navigator.SelectSingleNode(Xml.HASM);
if (navigatorHasM != null) {
this._hasM = navigatorHasM.ValueAsBoolean;
}
// <HasZ></HasZ>
XPathNavigator navigatorHasZ = navigator.SelectSingleNode(Xml.HASZ);
if (navigatorHasZ != null) {
this._hasZ = navigatorHasZ.ValueAsBoolean;
}
// <SpatialReference></SpatialReference>
XPathNavigator navigatorSpatialReference = navigator.SelectSingleNode(Xml.SPATIALREFERENCE);
this._spatialReference = new SpatialReference(navigatorSpatialReference);
// <GridSize0></GridSize0>
XPathNavigator navigatorGridSize0 = navigator.SelectSingleNode(Xml.GRIDSIZE0);
if (navigatorGridSize0 != null) {
this._gridSize0 = navigatorGridSize0.ValueAsDouble;
}
// <GridSize1></GridSize1>
XPathNavigator navigatorGridSize1 = navigator.SelectSingleNode(Xml.GRIDSIZE1);
if (navigatorGridSize1 != null) {
this._gridSize1 = navigatorGridSize1.ValueAsDouble;
}
// <GridSize2></GridSize2>
XPathNavigator navigatorGridSize2 = navigator.SelectSingleNode(Xml.GRIDSIZE2);
if (navigatorGridSize2 != null) {
this._gridSize2 = navigatorGridSize2.ValueAsDouble;
}
}
public static IField CreateGeometryField(esriGeometryType pGT, ISpatialReference pSR, bool pHasZ)
{
FieldClass class2 = new FieldClass();
IFieldEdit edit = class2;
edit.Name_2 = "SHAPE";
edit.AliasName_2 = "图形对象";
edit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeoDef = new GeometryDefClass();
IGeometryDefEdit class3 = (IGeometryDefEdit)pGeoDef;
class3.GeometryType_2 = pGT;
class3.HasM_2 = false;
class3.HasZ_2 = pHasZ;
class3.GridCount_2 = 1;
class3.set_GridSize(0, 1000.0);
class3.SpatialReference_2 = pSR;
edit.GeometryDef_2 = class3;
return class2;
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType type,
bool zAware = false)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000,
0.0001, 0.001);
IFields fields = FieldUtils.CreateFields(
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField(
"Shape",
type,
sref, 1000, zAware));
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name, fields));
}
public ShapeVertexCountAliasColumnInfo([NotNull] ITable table,
[NotNull] string columnName)
: base(table, columnName, typeof(int))
{
Assert.ArgumentNotNull(table, nameof(table));
Assert.ArgumentNotNullOrEmpty(columnName, nameof(columnName));
var featureClass = table as IFeatureClass;
if (featureClass == null)
{
_shapeType = esriGeometryType.esriGeometryNull;
}
else
{
_baseFieldNames.Add(featureClass.ShapeFieldName);
_shapeType = featureClass.ShapeType;
}
}
/// <summary>
/// 根据点击位置和需要的element类型，取得在该位置的给类型的element
/// </summary>
/// <param name="pPoint"></param>
/// <param name="geometryType"></param>
/// <returns></returns>
private IElement getElement(IPoint pPoint, esriGeometryType geometryType)
{
IEnumElement pEnumElement = this.pGraphicContainer.LocateElements(pPoint, this.axMapControl1.ActiveView.Extent.Width / 100);
if (pEnumElement != null)
{
pEnumElement.Reset();
IElement pElement;
for (pElement = pEnumElement.Next(); pElement != null; pElement = pEnumElement.Next())
{
if (pElement.Geometry.GeometryType == geometryType)
{
this.hitElement = pElement;
return(pElement);
}
}
return(null);
}
return(null);
}
public static IField CreateGeometryField(esriGeometryType pGT, ISpatialReference pSR, bool pHasZ)
{
Field class2 = new Field();
IFieldEdit edit = class2 as IFieldEdit;
edit.Name_2 = "SHAPE";
edit.AliasName_2 = "图形对象";
edit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeoDef = new GeometryDef();
IGeometryDefEdit class3 = (IGeometryDefEdit)pGeoDef;
class3.GeometryType_2 = pGT;
class3.HasM_2 = false;
class3.HasZ_2 = pHasZ;
class3.GridCount_2 = 1;
class3.set_GridSize(0, 1000.0);
class3.SpatialReference_2 = pSR;
edit.GeometryDef_2 = class3;
return(class2);
}
private static IssueFeatureWriter CreateFeatureWriter(
[NotNull] string className,
[NotNull] IFeatureWorkspace featureWorkspace,
[NotNull] IIssueTableFieldManagement fields,
esriGeometryType geometryType,
[NotNull] ISpatialReference spatialReference,
double gridSize1, double gridSize2, double gridSize3,
[NotNull] string aliasName)
{
IFeatureClass featureClass = CreateFeatureClass(className, featureWorkspace,
fields, geometryType,
spatialReference,
gridSize1, gridSize2, gridSize3);
DatasetUtils.TrySetAliasName(featureClass, aliasName);
var attributeWriter = new IssueAttributeWriter((ITable)featureClass, fields);
return(new IssueFeatureWriter(featureClass, attributeWriter));
}
/// <summary>
/// pstrFieldNameLt should not contain "FID" and "Shape", these two attributes will be generated automatically
/// </summary>
public static IFeatureLayer SaveCGeoEb <T>(IEnumerable <T> CGeoEb, esriGeometryType pesriGeometryType, string strFileName,
List <string> pstrFieldNameLt = null, List <esriFieldType> pesriFieldTypeLt = null, List <List <object> > pobjectValueLtLt = null,
int intRed = _intColor, int intGreen = _intColor, int intBlue = _intColor, double dblWidth = 1,
int intOutlineRed = _intColor, int intOutlineGreen = _intColor, int intOutlineBlue = _intColor,
esriSimpleLineStyle pesriSimpleLineStyle = esriSimpleLineStyle.esriSLSSolid,
esriSimpleFillStyle pesriSimpleFillStyle = esriSimpleFillStyle.esriSFSSolid, string strSymbolLayerPath = null, bool blnVisible = true)
where T : CGeoBase
{
if (CGeoEb.GetEnumerator().MoveNext() == false)
{
return(null);
}
CSaveFeature pSaveFeature = new CSaveFeature(pesriGeometryType, strFileName, pstrFieldNameLt, pesriFieldTypeLt,
intRed, intGreen, intBlue, dblWidth, intOutlineRed, intOutlineGreen, intOutlineBlue,
pesriSimpleLineStyle, pesriSimpleFillStyle, strSymbolLayerPath, blnVisible);
IFeatureLayer pFLayer = pSaveFeature.SaveCGeosToLayer(CGeoEb, pstrFieldNameLt, pobjectValueLtLt);
return(pFLayer);
}
private IFeatureLayer CreateFeatureLayer(esriGeometryType pesriGeometryType, string pstrLayerName,
List <string> pstrFieldNameLt = null, List <esriFieldType> pesriFieldTypeLt = null,
int intRed = _intColor, int intGreen = _intColor, int intBlue = _intColor, double dblWidth = 1,
int intOutlineRed = _intColor, int intOutlineGreen = _intColor, int intOutlineBlue = _intColor,
esriSimpleFillStyle pesriSimpleFillStyle = esriSimpleFillStyle.esriSFSSolid,
string strSymbolLayerPath = null, bool blnVisible = true)
{
var pWorkspace = CConstants.ParameterInitialize.pWorkspace;
var pm_mapControl = CConstants.ParameterInitialize.m_mapControl;
pstrLayerName += CHelpFunc.GetTimeStampWithPrefix();
IFeatureClass pFeatureClass = CreateFeatureClass(pesriGeometryType, pstrLayerName, pWorkspace, pm_mapControl,
pstrFieldNameLt, pesriFieldTypeLt);
IFeatureLayer pFLayer = new FeatureLayerClass();
pFLayer.FeatureClass = pFeatureClass;
pFLayer.Name = pFeatureClass.AliasName;
pFLayer.SpatialReference = pm_mapControl.SpatialReference;
RenderLayer(ref pFLayer, pesriGeometryType, intRed, intGreen, intBlue, dblWidth,
intOutlineRed, intOutlineGreen, intOutlineBlue, pesriSimpleFillStyle, strSymbolLayerPath);
//save Layer as layer file ".lyr"
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(pWorkspace.PathName + "\\" + pstrLayerName + ".lyr");
//attach the layer file with the actual layer
layerFile.ReplaceContents((ILayer)pFLayer);
//save the layer file
layerFile.Save();
//***********************************************是否添加到当前文档中来***********************************************//
//m_mapControl.AddLayer(pFLayer,m_mapControl .LayerCount);
pm_mapControl.AddLayer(pFLayer);
pFLayer.Visible = blnVisible;
pm_mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
return(pFLayer);
}
public SimplePointCursor(string filePath, IFields fields, int OID,
System.Array fieldMap, IEnvelope queryEnv, esriGeometryType geomType)
{
//HIGHLIGHT: 0 - Set up cursor
m_bIsFinished = false;
m_pStreamReader = new System.IO.StreamReader(filePath);
m_fields = fields;
m_iOID = OID;
m_fieldMap = fieldMap;
m_searchEnv = queryEnv;
switch (geomType)
{
case esriGeometryType.esriGeometryPolygon:
m_wkGeom = new Polygon() as IGeometry;
m_workPts = new PointClass[5];
for (int i = 0; i < m_workPts.Length; i++)
{
m_workPts[i] = new PointClass();
}
break;
case esriGeometryType.esriGeometryPolyline:
m_wkGeom = new PolylineClass() as IGeometry;
m_workPts = new PointClass[5];
for (int i = 0; i < m_workPts.Length; i++)
{
m_workPts[i] = new PointClass();
}
break;
case esriGeometryType.esriGeometryPoint:
m_wkGeom = new PointClass() as IGeometry;
break;
default: //doesn't need to set worker geometry if it is table
break;
}
//advance cursor so data is readily available
this.NextRecord();
}
private Geometry Buffer(Geometry geom, esriGeometryType shapeType, double margin,
MaskKind maskKind, bool isAnno = false)
{
var poly_outline = geom as Polygon;
if (poly_outline.HasCurves)
{
poly_outline =
GeometryEngine.Instance.DensifyByDeviation(geom, 0.1 * margin) as Polygon;
}
if (margin > 0.0)
{
if (maskKind == MaskKind.Box || maskKind == MaskKind.ConvexHull)
{
//strip out interior polygons
var ext_poly = PolygonBuilderEx.CreatePolygon(poly_outline.GetExteriorRings(true), AttributeFlags.None);
var joins = maskKind == MaskKind.Box ?
LineJoinType.Miter : LineJoinType.Bevel;
var buff_out = GeometryEngine.Instance.GraphicBuffer(ext_poly, margin, joins,
LineCapType.Butt, 4, 0.05 * margin, 64);
poly_outline = GeometryEngine.Instance.Generalize(buff_out, 0.01 * margin) as Polygon;
}
else
{
var buff_out = GeometryEngine.Instance.Buffer(poly_outline, margin);
if (maskKind == MaskKind.ExactSimplified)
{
poly_outline = GeometryEngine.Instance.Generalize(buff_out, 0.05 * margin) as Polygon;
}
else
{
poly_outline = buff_out as Polygon;
}
}
}
//simplify if needed
//return GeometryEngine.Instance.SimplifyAsFeature(poly_outline);
return(poly_outline);
}
private int ReportError([NotNull] IRow row,
[NotNull] IPolyline consecutiveErrorSegments)
{
var segments = (ISegmentCollection)consecutiveErrorSegments;
int segmentCount = segments.SegmentCount;
string description;
string issueCode;
if (GroupIssuesBySegmentType)
{
esriGeometryType geometryType = segments.Segment[0].GeometryType;
SegmentTypeInfo segmentType = _segmentTypes[geometryType];
description = segmentCount > 1
? string.Format("{0} consecutive {1} segments",
segmentCount,
segmentType.Description.ToLower())
: string.Format("{0} segment",
segmentType.Description);
issueCode = segmentType.IssueCode;
}
else
{
description = segmentCount > 1
? string.Format("{0} consecutive non-linear segments",
segmentCount)
: "Non-linear segment";
issueCode = Code.NonLinearSegments;
}
// use from point of sequence as error geometry, if Simplify caused the
// polyline to become empty (short segments)
IGeometry errorGeometry = GetErrorGeometry(consecutiveErrorSegments);
return(ReportError(description, errorGeometry,
Codes[issueCode], _shapeFieldName,
row));
}
public QaValidNonLinearSegments(
[Doc(nameof(DocStrings.QaValidNonLinearSegments_featureClass))][NotNull]
IFeatureClass featureClass,
[Doc(nameof(DocStrings.QaValidNonLinearSegments_minimumChordHeight))]
double minimumChordHeight)
: base(new[] { (ITable)featureClass })
{
Assert.ArgumentNotNull(featureClass, nameof(featureClass));
_featureClass = featureClass;
_minimumChordHeight = minimumChordHeight;
esriGeometryType shapeType = featureClass.ShapeType;
_canHaveNonLinearSegments =
shapeType == esriGeometryType.esriGeometryPolyline ||
shapeType == esriGeometryType.esriGeometryPolygon;
_spatialReference = ((IGeoDataset)featureClass).SpatialReference;
_xyTolerance = GeometryUtils.GetXyTolerance(featureClass);
}
private IFields CreateFieldsCollection(ISpatialReference spatialReference, esriGeometryType geometryType)
{
IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = fcDesc as IObjectClassDescription;
IFields fields = ocDesc.RequiredFields;
IFieldsEdit fieldsEdit = fields as IFieldsEdit;
int shapeFieldIndex = fields.FindField(fcDesc.ShapeFieldName);
IField shapeField = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = shapeField.GeometryDef;
IGeometryDefEdit geometryDefEdit = geometryDef as IGeometryDefEdit;
geometryDefEdit.GeometryType_2 = geometryType;
geometryDefEdit.GridCount_2 = 1;
geometryDefEdit.set_GridSize(0, 0);
geometryDefEdit.SpatialReference_2 = spatialReference;
return(fields);
}
private int CheckSegment([NotNull] ISegment segment, [NotNull] IRow row)
{
esriGeometryType segmentType = segment.GeometryType;
switch (segmentType)
{
case esriGeometryType.esriGeometryCircularArc:
return(CheckCircularArc((ICircularArc)segment, row));
case esriGeometryType.esriGeometryEllipticArc:
// add checks as needed
return(NoError);
case esriGeometryType.esriGeometryBezier3Curve:
// add checks as needed
return(NoError);
default:
return(NoError);
}
}
private void createFeatureClass(string fcPath, ISpatialReference srs, esriGeometryType geomType)
{
List <IField> attr = new List <IField>();
attr.Add(geopuntHelper.createField("naam", esriFieldType.esriFieldTypeString, 255));
if (geomType == esriGeometryType.esriGeometryPoint)
{
attr.Add(geopuntHelper.createField("Afstand", esriFieldType.esriFieldTypeDouble));
attr.Add(geopuntHelper.createField("Hoogte", esriFieldType.esriFieldTypeDouble));
}
FileInfo fcInfo = new FileInfo(fcPath);
IFeatureClass lyr = null;
if (fcInfo.Extension == ".shp")
{
lyr = geopuntHelper.createShapeFile(fcInfo.FullName, attr, map.SpatialReference, geomType, true);
}
else if (fcInfo.DirectoryName.ToLowerInvariant().EndsWith(".gdb"))
{
lyr = geopuntHelper.createFeatureClass(fcInfo.DirectoryName, fcInfo.Name, attr, srs, geomType, true);
}
else
{
throw new Exception("Bestand is geen shapefile of FileGeodatabase Feature Class");
}
if (geomType == esriGeometryType.esriGeometryPolyline)
{
lineFC = lyr;
gpExtension.profileLineLayer = lineFC;
geopuntHelper.addFeatureClassToMap(view, lineFC);
}
else if (geomType == esriGeometryType.esriGeometryPoint)
{
pointsFC = lyr;
gpExtension.profilePointsLayer = pointsFC;
geopuntHelper.addFeatureClassToMap(view, pointsFC);
}
}
/// <summary>
/// create a filter that gets the lines crossing the current row,
/// with the same attribute constraints as the table
/// </summary>
private void InitFilters()
{
_filters = new Dictionary <int, ISpatialFilter>();
_helpers = new Dictionary <int, QueryFilterHelper>();
bool caseSensitive = GetSqlCaseSensitivity();
foreach (int tableIndex in NonNetworkClassIndexList)
{
ITable nonNetworkClass = InvolvedTables[tableIndex];
ISpatialFilter filter = new SpatialFilterClass();
var helper = new QueryFilterHelper(nonNetworkClass,
GetConstraint(tableIndex),
caseSensitive);
ConfigureQueryFilter(tableIndex, filter);
esriGeometryType geometryType =
((IFeatureClass)nonNetworkClass).ShapeType;
switch (geometryType)
{
case esriGeometryType.esriGeometryPolyline:
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
case esriGeometryType.esriGeometryPolygon:
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
break;
default:
throw new NotImplementedException("Unhandled geometry type " +
geometryType);
}
_filters.Add(tableIndex, filter);
_helpers.Add(tableIndex, helper);
}
}
/// <summary>
/// Opens a dialog so the user can select an existing shapefile or file geodatabase
/// feature class.
/// </summary>
/// <param name="title">title for dialog</param>
/// <returns>dataset name object for the selected feature class or null </returns>
private IDatasetName SelectFeatureClass(string title, esriGeometryType geom)
{
try
{
IGxObjectFilter shpFilter = new GxFilterShapefilesClass();
IGxObjectFilter gdbFilter = new GxFilterFGDBFeatureClassesClass();
IGxDialog dlg = new GxDialogClass();
IGxObjectFilterCollection filters = (IGxObjectFilterCollection)dlg;
filters.AddFilter(shpFilter, false);
filters.AddFilter(gdbFilter, true);
dlg.Title = title;
IDatasetName dsName = null;
IEnumGxObject objects = null;
if (dlg.DoModalOpen(0, out objects))
{
IGPUtilities2 util = new GPUtilitiesClass();
string name = objects.Next().FullName;
dsName = (IDatasetName)util.CreateFeatureClassName(name);
IFeatureWorkspace ws = (IFeatureWorkspace)((IName)dsName.WorkspaceName).Open();
IFeatureClass fc = ws.OpenFeatureClass(System.IO.Path.GetFileName(name));
esriGeometryType shp = fc.ShapeType;
if (!(geom == esriGeometryType.esriGeometryAny &&
(shp == esriGeometryType.esriGeometryPoint ||
shp == esriGeometryType.esriGeometryPolyline ||
shp == esriGeometryType.esriGeometryPolygon)) &&
shp != geom)
{
ShowError("Wrong geometry type.");
dsName = null;
}
dsName = (IDatasetName)((IDataset)fc).FullName;
}
return(dsName);
}
catch (Exception ex)
{
ShowError(ex.Message);
return(null);
}
}
public FeatureClassMock(int objectClassId, string name, string aliasName,
esriGeometryType shapeType,
esriFeatureType featureType,
[NotNull] ISpatialReference spatialReference,
bool hasZ = true,
bool hasM = false)
: base(objectClassId, name, aliasName)
{
Assert.ArgumentNotNull(spatialReference, nameof(spatialReference));
ShapeType = shapeType;
FeatureType = featureType;
_spatialReference = spatialReference;
_hasZ = hasZ;
_hasM = hasM;
_geometryBuilder =
new GeometryBuilder(spatialReference, shapeType, hasZ, hasM);
ShapeField = CreateShapeField();
AddFields(ShapeField);
}
private ISymbol CreateSymbol(esriGeometryType pGeometryType, int intR, int intG, int intB)
{
ISymbol pSymbol = null;
ISimpleLineSymbol pSimpleLineSymbol = null;
IColor pColor = SysCommon.Gis.ModGisPub.GetRGBColor(intR, intG, intB);
switch (pGeometryType)
{
case esriGeometryType.esriGeometryPolygon:
pSimpleLineSymbol = new SimpleLineSymbolClass();
pSimpleLineSymbol.Style = esriSimpleLineStyle.esriSLSSolid;
pSimpleLineSymbol.Color = SysCommon.Gis.ModGisPub.GetRGBColor(156, 156, 156);
pSimpleLineSymbol.Width = 0.01;
ISimpleFillSymbol pSimpleFillSymbol = new SimpleFillSymbolClass();
pSimpleFillSymbol.Outline = pSimpleLineSymbol;
pSimpleFillSymbol.Color = pColor;
pSimpleFillSymbol.Style = esriSimpleFillStyle.esriSFSSolid;
pSymbol = pSimpleFillSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPoint:
ISimpleMarkerSymbol pSimpleMarkerSymbol = new SimpleMarkerSymbolClass();
pSimpleMarkerSymbol.Style = esriSimpleMarkerStyle.esriSMSCircle;
pSimpleMarkerSymbol.Color = pColor;
pSimpleMarkerSymbol.Size = 2;
pSymbol = pSimpleMarkerSymbol as ISymbol;
break;
case esriGeometryType.esriGeometryPolyline:
pSimpleLineSymbol = new SimpleLineSymbolClass();
pSimpleLineSymbol.Style = esriSimpleLineStyle.esriSLSSolid;
pSimpleLineSymbol.Color = pColor;
pSimpleLineSymbol.Width = 0.1;
pSymbol = pSimpleLineSymbol as ISymbol;
break;
}
return(pSymbol);
}
private bool IsAllowedCurveType(esriGeometryType geometryType)
{
if (geometryType == esriGeometryType.esriGeometryLine)
{
return(true);
}
if (AllowedNonLinearSegmentTypes == null)
{
return(false);
}
SegmentTypeInfo segmentType;
if (!_segmentTypes.TryGetValue(geometryType, out segmentType))
{
throw new InvalidOperationException("Unhandled geometry type: " + geometryType);
}
return(AllowedNonLinearSegmentTypes.Any(
nonLinearSegmentType => nonLinearSegmentType == segmentType.Type));
}
public static SegmentsPlaneProvider Create(
[NotNull] IFeature feature,
esriGeometryType shapeType,
bool includeAssociatedParts)
{
if (shapeType == esriGeometryType.esriGeometryMultiPatch)
{
IIndexedMultiPatch indexedMultiPatch = GetIndexedMultiPatch(feature);
return(includeAssociatedParts
? (SegmentsPlaneProvider)
new SurfaceSegmentsPlaneProvider(indexedMultiPatch)
: new PartSegmentsPlaneProvider(indexedMultiPatch, shapeType));
}
IIndexedSegments indexedSegments = GetIndexedSegments(feature);
return(includeAssociatedParts
? (SegmentsPlaneProvider)
new FullSegmentsPlaneProvider(indexedSegments, shapeType)
: new PartSegmentsPlaneProvider(indexedSegments, shapeType));
}
/// <summary>
/// 根据图层的几何类型，获取需要加载的符号类别
/// </summary>
/// <param name="shapeType"></param>
/// <returns></returns>
private esriSymbologyStyleClass GetSymbologyStyleClassType(esriGeometryType shapeType)
{
esriSymbologyStyleClass eType = esriSymbologyStyleClass.esriStyleClassMarkerSymbols;
if (shapeType == esriGeometryType.esriGeometryPoint)
{
eType = esriSymbologyStyleClass.esriStyleClassMarkerSymbols;
}
else if (shapeType == esriGeometryType.esriGeometryPolyline)
{
eType = esriSymbologyStyleClass.esriStyleClassLineSymbols;
}
else if (shapeType == esriGeometryType.esriGeometryPolygon)
{
eType = esriSymbologyStyleClass.esriStyleClassFillSymbols;
}
else if (shapeType == esriGeometryType.esriGeometryMultiPatch)
{
eType = esriSymbologyStyleClass.esriStyleClassFillSymbols;
}
return(eType);
}
private static int ProcessReplacedExceptions(
[NotNull] ITable targetTable,
[NotNull] IIssueTableFields targetFields,
[NotNull] IDictionary <esriGeometryType, HashSet <int> > replacedExceptionObjects,
DateTime importDate,
out int fixedStatusCount)
{
esriGeometryType shapeType = GetShapeType(targetTable);
HashSet <int> replacedOids;
if (!replacedExceptionObjects.TryGetValue(shapeType, out replacedOids))
{
// no replaced exception objects for this shape type
fixedStatusCount = 0;
return(0);
}
return(ProcessReplacedExceptions(targetTable, targetFields,
importDate, replacedOids,
out fixedStatusCount));
}
public void InitBitmap()
{
this.bitmap_0 = null;
if (this.Symbol != null)
{
IStyleDraw styleDraw = StyleDrawFactory.CreateStyleDraw(this.Symbol);
if (styleDraw != null)
{
this.bitmap_0 = styleDraw.StyleGalleryItemToBmp(new Size(16, 16), 96, 1);
this.string_0 = Guid.NewGuid().ToString();
}
}
if (this.bitmap_0 == null)
{
esriGeometryType shapeType = this.FeatureLayer.FeatureClass.ShapeType;
if (this.FeatureLayer.FeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
this.bitmap_0 = BitmapResources.Anno;
this.string_0 = "A1DD7E5C-E48D-49D2-962C-AC98FF5BD25D";
}
else if (shapeType == esriGeometryType.esriGeometryPolyline)
{
this.bitmap_0 = BitmapResources.Line;
this.string_0 = "BF5BE334-1BD8-49B4-BAF9-41292C0D74ED";
}
else if (shapeType == esriGeometryType.esriGeometryPolygon)
{
this.bitmap_0 = BitmapResources.Area;
this.string_0 = "830C9A6D-AA74-49A8-9794-3B2AD01613AF";
}
else if ((shapeType == esriGeometryType.esriGeometryPoint
? true
: shapeType == esriGeometryType.esriGeometryMultipoint))
{
this.bitmap_0 = BitmapResources.Point;
this.string_0 = "6D20F51F-BBB0-4551-91CB-24B7F2216B40";
}
}
}
public override void OnClick()
{
Yutai.ArcGIS.Common.Editor.Editor.EditWorkspace.StartEditOperation();
IEnumFeature enumFeature = _context.FocusMap.FeatureSelection as IEnumFeature;
enumFeature.Reset();
for (IFeature feature = enumFeature.Next(); feature != null; feature = enumFeature.Next())
{
esriGeometryType geometryType = feature.Shape.GeometryType;
if ((geometryType == esriGeometryType.esriGeometryPolyline ||
geometryType == esriGeometryType.esriGeometryPolygon) &&
Yutai.ArcGIS.Common.Editor.Editor.CheckWorkspaceEdit(feature.Class as IDataset, "IsBeingEdited"))
{
IPolycurve polycurve = feature.Shape as IPolycurve;
polycurve.ReverseOrientation();
feature.Shape = polycurve;
feature.Store();
(_context.FocusMap as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
}
}
Yutai.ArcGIS.Common.Editor.Editor.EditWorkspace.StopEditOperation();
}
public static bool IsMultipart([NotNull] IGeometry geometry)
{
Assert.ArgumentNotNull(geometry, nameof(geometry));
esriGeometryType geometryType = geometry.GeometryType;
if (geometryType == esriGeometryType.esriGeometryPoint)
{
return(false);
}
if (geometryType == esriGeometryType.esriGeometryPolygon)
{
var polygon = (IPolygon)geometry;
return(GetExteriorRingCount(polygon) > 1);
}
var geometryCollection = geometry as IGeometryCollection;
return(geometryCollection != null && geometryCollection.GeometryCount > 1);
}
/// <summary>
/// Gets the spatialite geometry type of the IFeatureClass
/// </summary>
/// <param name="fc">The IFeatureClass.</param>
/// <returns>geometry type string (e.g. POINT|LINESTRING|POLYGON|MULTIPOINT)</returns>
internal static string GetGeometryType(ref IFeatureClass fc)
{
esriGeometryType geomType = fc.ShapeType;
switch (geomType)
{
case esriGeometryType.esriGeometryPoint:
return("POINT");
case esriGeometryType.esriGeometryPath:
case esriGeometryType.esriGeometryPolyline:
case esriGeometryType.esriGeometryLine:
return("LINESTRING");
case esriGeometryType.esriGeometryEnvelope:
case esriGeometryType.esriGeometryPolygon:
return("POLYGON");
case esriGeometryType.esriGeometryMultipoint:
return("MULTIPOINT");
case esriGeometryType.esriGeometryAny:
case esriGeometryType.esriGeometryBag:
case esriGeometryType.esriGeometryBezier3Curve:
case esriGeometryType.esriGeometryCircularArc:
case esriGeometryType.esriGeometryEllipticArc:
case esriGeometryType.esriGeometryMultiPatch:
case esriGeometryType.esriGeometryNull:
case esriGeometryType.esriGeometryRay:
case esriGeometryType.esriGeometryRing:
case esriGeometryType.esriGeometrySphere:
case esriGeometryType.esriGeometryTriangleFan:
case esriGeometryType.esriGeometryTriangleStrip:
case esriGeometryType.esriGeometryTriangles:
default:
throw new ArgumentException(geomType.ToString() + " not supported with sde2spatialite.exe");
}
}
private static IFeatureClass BuildQueryFeatureClass(string connection, string query, string name, string oidFields, int? srid, esriGeometryType? geometryType)
{
var factory = new SqlWorkspaceFactoryClass();
var workspace = factory.OpenFromString(connection, 0);
//var workspace = factory.OpenFromFile(@"c:\tmp\AnimalMovement.sde", 0);
var sqlWorkspace = (ISqlWorkspace)workspace;
var queryDescription = sqlWorkspace.GetQueryDescription(query);
if (!String.IsNullOrEmpty(oidFields))
queryDescription.OIDFields = oidFields;
if (srid.HasValue)
{
queryDescription.Srid = srid.Value.ToString(CultureInfo.InvariantCulture);
var srEnv = new SpatialReferenceEnvironmentClass();
queryDescription.SpatialReference = srEnv.CreateSpatialReference(srid.Value);
}
if (geometryType.HasValue)
queryDescription.GeometryType = geometryType.Value;
sqlWorkspace.CheckDatasetName(name, queryDescription, out name);
var queryClass = sqlWorkspace.OpenQueryClass(name, queryDescription);
var featureClass = (IFeatureClass)queryClass;
return featureClass;
}
private IFeatureClass CreateFeatureClass([NotNull] string name,
esriGeometryType geometryType,
params IField[] attributeFields)
{
ISpatialReference sref = SpatialReferenceUtils.CreateSpatialReference
((int)esriSRProjCS2Type.esriSRProjCS_CH1903Plus_LV95,
true);
SpatialReferenceUtils.SetXYDomain(sref, -10000, -10000, 10000, 10000, 0.0001,
0.001);
var fields = new List <IField>
{
FieldUtils.CreateOIDField(),
FieldUtils.CreateShapeField("Shape", geometryType, sref, 1000)
};
fields.AddRange(attributeFields);
return(DatasetUtils.CreateSimpleFeatureClass(_testWs, name,
FieldUtils.CreateFields(fields)));
}
/// <summary>
/// 创建一个只包含几何字段的简单内存要素类
/// </summary>
/// <param name="geometryType"></param>
/// <param name="spatialReference"></param>
/// <param name="className"></param>
/// <returns></returns>
public static IFeatureClass CreateMemorySimpleFeatureClass(esriGeometryType geometryType, ISpatialReference spatialReference, string className)
{
// 创建内存工作空间
IWorkspaceFactory pWSF = new InMemoryWorkspaceFactoryClass();
IWorkspaceName pWSName = pWSF.Create("", "Temp", null, 0);
IName pName = (IName)pWSName;
IWorkspace memoryWS = (IWorkspace)pName.Open();
//创建字段集
IField field = new FieldClass();
IFields fields = new FieldsClass();
IFieldsEdit fieldsEdit = fields as IFieldsEdit;
IFieldEdit fieldEdit = field as IFieldEdit;
//创建图形字段
field = new FieldClass();
fieldEdit = field as IFieldEdit;
IGeometryDef geoDef = new GeometryDefClass();
IGeometryDefEdit geoDefEdit = (IGeometryDefEdit)geoDef;
geoDefEdit.AvgNumPoints_2 = 5;
geoDefEdit.GeometryType_2 = geometryType;
geoDefEdit.GridCount_2 = 1;
geoDefEdit.HasM_2 = false;
geoDefEdit.HasZ_2 = false;
geoDefEdit.SpatialReference_2 = spatialReference;
fieldEdit.Name_2 = "SHAPE";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
fieldEdit.GeometryDef_2 = geoDef;
fieldEdit.IsNullable_2 = true;
fieldEdit.Required_2 = true;
fieldsEdit.AddField(field);
//创建要素类
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)memoryWS;
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(
className, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return(featureClass);
}
public IFeatureClass CreateFeatureClassWithoutAttribute(string feaClassName, esriGeometryType enumGometryType)
{
string featureClassName = feaClassName + "Time" + DateTime.Now.ToString("yyyyMMddHHmmss");
//Basic field settings of FeatureClass
IFields fields = new FieldsClass();
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
ISpatialReferenceFactory spatialrefFactory = new SpatialReferenceEnvironmentClass();//SpatialReference settings
ISpatialReference spatialReference = spatialrefFactory.CreateProjectedCoordinateSystem(
(int)(esriSRProjCS4Type.esriSRProjCS_Xian1980_GK_CM_111E));
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;//Geometry field settings
geometryDefEdit.GeometryType_2 = enumGometryType;
geometryDefEdit.GridCount_2 = 1;
geometryDefEdit.set_GridSize(0, 0);
geometryDefEdit.SpatialReference_2 = spatialReference;
IField fieldUserDefined = new FieldClass();//Field creation
IFieldEdit fieldEdit = (IFieldEdit)fieldUserDefined;
fieldEdit.Name_2 = "Shape";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
fieldEdit.GeometryDef_2 = geometryDef;
fieldEdit.IsNullable_2 = true;
fieldEdit.Required_2 = true;
fieldsEdit.AddField(fieldUserDefined);
//Create FeatureClass
UID CLSID = new UIDClass();
CLSID.Value = "esriGeodatabase.Feature";
IFeatureClass createdFeatureClass = pFeaWorkspace.CreateFeatureClass(featureClassName, fields, CLSID, null, esriFeatureType.esriFTSimple, "Shape", " ");
return(createdFeatureClass);
}
private bool doesGeometryTypeEqualGeometryString(esriGeometryType geoType, string geometryString)
{
if ((geometryString == SicToFeatureClassMapper.POINT_STRING) &&
(geoType == esriGeometryType.esriGeometryPoint))
{
return(true);
}
if ((geometryString == SicToFeatureClassMapper.LINE_STRING) &&
((geoType == esriGeometryType.esriGeometryPolyline) ||
(geoType == esriGeometryType.esriGeometryMultipoint)))
{
return(true);
}
if ((geometryString == SicToFeatureClassMapper.AREA_STRING) &&
(geoType == esriGeometryType.esriGeometryPolygon))
{
return(true);
}
return(false);
}
private bool IsGeometryTypeEqual(esriGeometryType featureGeometryType, ESRI.ArcGIS.OSM.OSMClassExtension.geometrytype[] osmGeometryType)
{
bool geometryEquality = false;
try
{
for (int typeIndex = 0; typeIndex < osmGeometryType.Length; typeIndex++)
{
switch (osmGeometryType[typeIndex])
{
case ESRI.ArcGIS.OSM.OSMClassExtension.geometrytype.point:
if (featureGeometryType == esriGeometryType.esriGeometryPoint)
{
geometryEquality = true;
}
break;
case ESRI.ArcGIS.OSM.OSMClassExtension.geometrytype.line:
if (featureGeometryType == esriGeometryType.esriGeometryPolyline)
{
geometryEquality = true;
}
break;
case ESRI.ArcGIS.OSM.OSMClassExtension.geometrytype.mpolyline:
if (featureGeometryType == esriGeometryType.esriGeometryPolyline)
{
geometryEquality = true;
}
break;
case ESRI.ArcGIS.OSM.OSMClassExtension.geometrytype.polygon:
if (featureGeometryType == esriGeometryType.esriGeometryPolygon)
{
geometryEquality = true;
}
break;
default:
break;
}
}
}
catch { }
return geometryEquality;
}
public override bool SupportsGeometryType(esriGeometryType test)
{
return true;
}
private bool doesGeometryTypeEqualGeometryString(esriGeometryType geoType, string geometryString)
{
if ((geometryString == SicToFeatureClassMapper.POINT_STRING) &&
(geoType == esriGeometryType.esriGeometryPoint))
return true;
if ((geometryString == SicToFeatureClassMapper.LINE_STRING) &&
((geoType == esriGeometryType.esriGeometryPolyline) ||
(geoType == esriGeometryType.esriGeometryMultipoint)))
return true;
if ((geometryString == SicToFeatureClassMapper.AREA_STRING) &&
(geoType == esriGeometryType.esriGeometryPolygon))
return true;
return false;
}
public static bool ogr_geo_type_to_esri_geo_type(OSGeo.OGR.wkbGeometryType ogrType,
out esriGeometryType outGDBType, out bool outHasZ)
{
switch (ogrType)
{
case OSGeo.OGR.wkbGeometryType.wkbPoint25D:
{
outGDBType = esriGeometryType.esriGeometryPoint;
outHasZ = true;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbMultiPoint25D:
{
outGDBType = esriGeometryType.esriGeometryMultipoint;
outHasZ = true;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbLineString25D:
case OSGeo.OGR.wkbGeometryType.wkbMultiLineString25D:
{
outGDBType = esriGeometryType.esriGeometryPolyline;
outHasZ = true;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbPolygon25D:
case OSGeo.OGR.wkbGeometryType.wkbMultiPolygon25D:
{
outGDBType = esriGeometryType.esriGeometryPolygon;
outHasZ = true;
break;
}
/* 2D forms */
case OSGeo.OGR.wkbGeometryType.wkbPoint:
{
outGDBType = esriGeometryType.esriGeometryPoint;
outHasZ = false;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbMultiPoint:
{
outGDBType = esriGeometryType.esriGeometryMultipoint;
outHasZ = false;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbLineString:
case OSGeo.OGR.wkbGeometryType.wkbMultiLineString:
{
outGDBType = esriGeometryType.esriGeometryPolyline;
outHasZ = false;
break;
}
case OSGeo.OGR.wkbGeometryType.wkbPolygon:
case OSGeo.OGR.wkbGeometryType.wkbMultiPolygon:
{
outGDBType = esriGeometryType.esriGeometryPolygon;
outHasZ = false;
break;
}
default:
{
//CPLError( CE_Failure, CPLE_AppDefined, "Cannot map OGRwkbGeometryType (%s) to ESRI type",
// OGRGeometryTypeToName(ogrType));
outGDBType = esriGeometryType.esriGeometryNull;
outHasZ = false;
return false;
}
}
return true;
}
public void PrepareFilter(IFeatureClass fc, IQueryFilter queryFilter)
{
// prepare filter for drawing
// must add OID
queryFilter.AddField(fc.OIDFieldName);
m_ShapeType = fc.ShapeType;
if (m_ShapeType == esriGeometryType.esriGeometryPoint)
{
if (m_sRotationField != null)
{
if (m_sRotationField != "")
{
queryFilter.AddField(m_sRotationField);
}
}
}
// save the fc and the query filter so that multiple cursors can be built in DrawSymbols
m_pFeatureClass = fc;
m_pQueryFilter = queryFilter;
// prepare filters on constituent renderers so I can use SymbolByFeature in Draw
if (m_pShapePatternRend != null)
m_pShapePatternRend.PrepareFilter(fc, queryFilter);
if (m_pColorRend1 != null)
m_pColorRend1.PrepareFilter(fc, queryFilter);
if (m_pColorRend2 != null)
m_pColorRend2.PrepareFilter(fc, queryFilter);
if (m_pSizeRend != null)
m_pSizeRend.PrepareFilter(fc, queryFilter);
// if we're combining colors from two (sequential) quantitative schemes, build color matrix now
// this gives flexibility to extend in future
// in current impl. we determine combined color based on two colors, one from each constituent
// ClassBreaksRenderer. so, we could determine color on demand when drawing. but, by creating
// the color matrix here and storing for later use, we leave open the possibility of swapping in
// different logic for determining combined colors based on all known colors in each constituent
// renderer, not just the colors for the given feature
if ((m_pColorRend1 != null) & (m_pColorRend2 != null))
{
if (! (m_eColorCombinationMethod == EColorCombinationType.enuComponents))
BuildColorMatrix();
}
//implementation of IExportSupport
AddExportFields(fc, queryFilter);
}
public GeometryDef(GeometryDef prototype) : base(prototype) {
this._avgNumPoints = prototype.AvgNumPoints;
this._geometryType = prototype.GeometryType;
this._hasM = prototype.HasM;
this._hasZ = prototype.HasZ;
if (prototype.SpatialReference != null) {
this._spatialReference = prototype.SpatialReference.Clone() as SpatialReference;
}
this._gridSize0 = prototype.GridSize0;
this._gridSize1 = prototype.GridSize1;
this._gridSize2 = prototype.GridSize2;
}
public static IFeatureClass CreateFeatureClassInPGDB(IWorkspace2 workspace, IFeatureDataset featureDataset, string featureClassName, IFields fields, UID CLSID, UID CLSEXT, string strConfigKeyword, esriGeometryType esriGeometryType)
{
if (featureClassName == "") return null; // name was not passed in
ESRI.ArcGIS.Geodatabase.IFeatureClass featureClass;
ESRI.ArcGIS.Geodatabase.IFeatureWorkspace featureWorkspace = (ESRI.ArcGIS.Geodatabase.IFeatureWorkspace)workspace; // Explicit Cast
if (workspace.get_NameExists(ESRI.ArcGIS.Geodatabase.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();
CLSID.Value = "esriGeoDatabase.Feature";
}
ESRI.ArcGIS.Geodatabase.IObjectClassDescription objectClassDescription = new ESRI.ArcGIS.Geodatabase.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;
ESRI.ArcGIS.Geodatabase.IFieldsEdit fieldsEdit = (ESRI.ArcGIS.Geodatabase.IFieldsEdit)fields; // Explicit Cast
ESRI.ArcGIS.Geodatabase.IField field = new ESRI.ArcGIS.Geodatabase.FieldClass();
// create a user defined text field
ESRI.ArcGIS.Geodatabase.IFieldEdit fieldEdit = (ESRI.ArcGIS.Geodatabase.IFieldEdit)field; // Explicit Cast
// setup field properties
fieldEdit.Name_2 = "SampleField";
fieldEdit.Type_2 = ESRI.ArcGIS.Geodatabase.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 = (ESRI.ArcGIS.Geodatabase.IFields)fieldsEdit; // Explicit Cast
}
System.String strShapeField = "";
// locate the shape field
for (int j = 0; j < fields.FieldCount; j++)
{
if (fields.get_Field(j).Type == esriFieldType.esriFieldTypeGeometry)
{
strShapeField = fields.get_Field(j).Name;
((IGeometryDefEdit)fields.get_Field(j).GeometryDef).GeometryType_2 = esriGeometryType;
}
}
// Use IFieldChecker to create a validated fields collection.
ESRI.ArcGIS.Geodatabase.IFieldChecker fieldChecker = new ESRI.ArcGIS.Geodatabase.FieldCheckerClass();
ESRI.ArcGIS.Geodatabase.IEnumFieldError enumFieldError = null;
ESRI.ArcGIS.Geodatabase.IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (ESRI.ArcGIS.Geodatabase.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
if (featureDataset == null)// if no feature dataset passed in, create at the workspace level
{
featureClass = featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, CLSID, CLSEXT, ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword);
}
else
{
featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, CLSID, CLSEXT, ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword);
}
return featureClass;
}
bool IMarkerPlacement.get_AcceptGeometryType(esriGeometryType inputType)
{
if (inputType == esriGeometryType.esriGeometryPoint)
return true;
else
return false;
}
private ISymbol GetSymbolBySymbolSelector(esriGeometryType geometryType)
{
try
{
ISymbolSelector pSymbolSelector = new SymbolSelectorClass();
ISymbol symbol = null;
switch (geometryType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
symbol = new SimpleMarkerSymbolClass();
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
symbol = new SimpleLineSymbolClass();
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
symbol = new SimpleFillSymbolClass();
break;
default:
break;
}
pSymbolSelector.AddSymbol(symbol);
bool response = pSymbolSelector.SelectSymbol(0);
if (response)
{
symbol = pSymbolSelector.GetSymbolAt(0);
return symbol;
}
return null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
ISymbol symbol = null;
switch (geometryType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
symbol = new SimpleMarkerSymbolClass();
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
symbol = new SimpleLineSymbolClass();
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
symbol = new SimpleFillSymbolClass();
break;
default:
break;
}
return symbol;
}
}
public override bool SupportsGeometryType(esriGeometryType test)
{
return (test == esriGeometryType.esriGeometryPolygon
|| test == esriGeometryType.esriGeometryPolyline
|| test == esriGeometryType.esriGeometryPoint);
}
private Geometry GetFilterGeometry(string geometry,esriGeometryType geometryType)
{
Geometry resultGeometry = null;
switch (geometryType)
{
// todo: add other filter geometry types
case esriGeometryType.esriGeometryEnvelope:
resultGeometry = JsonConvert.DeserializeObject<Extent>(geometry);
break;
}
return resultGeometry;
}
public HttpResponseMessage GetQuery(string serviceName, string layerId, string operation = "",
bool returnGeometry=true,
string f = "json",
string objectids = "",
string where = "",
string time = "",
string geometry = "",
esriGeometryType geometryType = esriGeometryType.esriGeometryPoint,
string geometryPrecision = "",
string inSr = "",
esriSpatialRelType spatialRel = esriSpatialRelType.esriSpatialRelIntersects,
string outSr = "",
string returnIdsOnly = "",
string returnCountOnly = "",
string maxAllowableOffset = "",
string returnDistinctValues = "",
string groupByFieldsForStatistics = "",
string outStatistics = "",
string outFields = "",
string orderByFields="",
string objectIds ="",
bool returnZ = false,
bool returnM= false
)
{
FeatureCollection result = null;
// first let's read the server config file
var agsConfigDir = ConfigurationManager.AppSettings["AgsConfigDir"];
var serverconfigFile = agsConfigDir + @"FeatureServer\" + serviceName + @"\"+ serviceName + "_" + layerId + "_server.json";
if (File.Exists(serverconfigFile))
{
var content = File.ReadAllText(serverconfigFile);
dynamic serverConfig = JsonConvert.DeserializeObject(content);
// get client config
var featureLayerConfig = ConfigDataReader.GetFeatureLayerConfig(agsConfigDir, serviceName, layerId);
result = FeatureCollectionDataReader.GetFeatureCollection(serverConfig, featureLayerConfig);
// Get the geographic filter
if (!string.IsNullOrEmpty(geometry))
{
var filterGeometry = GetFilterGeometry(geometry, geometryType);
// todo convert filtergemotry to wgs84....
result.features = result.FilterFeatureCollection((Extent)filterGeometry);
}
}
return Request.CreateResponse(HttpStatusCode.OK, result);
}
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;
}
//---------------------------------------------------------------------
/// <summary>
/// Creates a new feature class. Returns the feature class or null if not successful. Throws but does not handle errors.
/// </summary>
/// <param name="sFeatName">Feature class name.</param>
/// <param name="configWord">Configuration keywords for the new feature class.</param>
/// <param name="oWorkspace">Workspace in which to create the new feature class.</param>
/// <param name="theFields">Fields collection of the new feature class.</param>
/// <param name="featureType">Feature type of the new feature class.</param>
/// <param name="geometryType">geometry type of the new feature class.</param>
/// <param name="CLSID">Class ID of the new feature class. May be null if featureType is not null.</param>
/// <param name="CLSEXT">Class extension ID of the new feature class. Pass null if none.</param>
/// <returns>Returns the cloned feature class. Throws an error if no feature class can be created.</returns>
private IFeatureClass CreateFeatureClass(string featureClassName, string configWord, object outWorkspace,
IFields fields, esriFeatureType featureType, esriGeometryType geometryType, UID CLSID, UID CLSEXT)
{
IFeatureClass featureClass = null;
if (outWorkspace == null) throw (new Exception("Workspace cannot be null"));
if (!((outWorkspace is IWorkspace) || (outWorkspace is IFeatureDataset)))
throw (new Exception("Workspace must be IWorkspace or IFeatureDataset"));
if (featureClassName == "") throw (new Exception("Feature class name cannot be empty string"));
UID uidCLSID = new UIDClass();
if (CLSID == null)
{
switch (featureType)
{
case (esriFeatureType.esriFTSimple):
uidCLSID.Value = "{52353152-891A-11D0-BEC6-00805F7C4268}";
break;
case (esriFeatureType.esriFTSimpleJunction):
geometryType = esriGeometryType.esriGeometryPoint;
uidCLSID.Value = "{CEE8D6B8-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexJunction):
uidCLSID.Value = "{DF9D71F4-DA32-11D1-AEBA-0000F80372B4}";
break;
case (esriFeatureType.esriFTSimpleEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{E7031C90-55FE-11D1-AE55-0000F80372B4}";
break;
case (esriFeatureType.esriFTComplexEdge):
geometryType = esriGeometryType.esriGeometryPolyline;
uidCLSID.Value = "{A30E8A2A-C50B-11D1-AEA9-0000F80372B4}";
break;
case (esriFeatureType.esriFTAnnotation):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{E3676993-C682-11D2-8A2A-006097AFF44E}";
break;
case (esriFeatureType.esriFTDimension):
geometryType = esriGeometryType.esriGeometryPolygon;
uidCLSID.Value = "{496764FC-E0C9-11D3-80CE-00C04F601565}";
break;
}
}
else
{
uidCLSID = CLSID;
}
UID uidCLSEXT = new UIDClass();
if (CLSEXT == null)
{
switch (featureType)
{
case (esriFeatureType.esriFTAnnotation):
uidCLSEXT.Value = "{24429589-D711-11D2-9F41-00C04F6BC6A5}";
break;
case (esriFeatureType.esriFTDimension):
uidCLSEXT.Value = "{48F935E2-DA66-11D3-80CE-00C04F601565}";
break;
default:
uidCLSEXT = null;
break;
}
}
else
uidCLSEXT = CLSEXT;
string shapeFieldName = "";
for (int i = 0; i <= fields.FieldCount - 1; i++)
{
if (fields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
shapeFieldName = fields.get_Field(i).Name;
break;
}
}
if (shapeFieldName == "") throw new Exception("Cannot locate geometry field");
if (outWorkspace is IWorkspace)
{
IWorkspace workspace = (IWorkspace)outWorkspace;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
featureClass = featureWorkspace.CreateFeatureClass(featureClassName, fields, uidCLSID, uidCLSEXT,
featureType, shapeFieldName, configWord);
}
else if (outWorkspace is IFeatureDataset)
{
IFeatureDataset featureDataset = (IFeatureDataset)outWorkspace;
featureClass = featureDataset.CreateFeatureClass(featureClassName, fields, uidCLSID, uidCLSEXT,
featureType, shapeFieldName, configWord);
}
return featureClass;
}
private void createFeatureClass(string fcPath, ISpatialReference srs, esriGeometryType geomType)
{
List<IField> attr = new List<IField>();
attr.Add(geopuntHelper.createField("naam", esriFieldType.esriFieldTypeString, 255));
if (geomType == esriGeometryType.esriGeometryPoint)
{
attr.Add(geopuntHelper.createField("Afstand", esriFieldType.esriFieldTypeDouble));
attr.Add(geopuntHelper.createField("Hoogte", esriFieldType.esriFieldTypeDouble));
}
FileInfo fcInfo = new FileInfo(fcPath);
IFeatureClass lyr = null;
if (fcInfo.Extension == ".shp")
{
lyr = geopuntHelper.createShapeFile(fcInfo.FullName, attr, map.SpatialReference, geomType, true);
}
else if (fcInfo.DirectoryName.ToLowerInvariant().EndsWith(".gdb"))
{
lyr = geopuntHelper.createFeatureClass(fcInfo.DirectoryName, fcInfo.Name, attr, srs, geomType, true);
}
else
{
throw new Exception("Bestand is geen shapefile of FileGeodatabase Feature Class");
}
if (geomType == esriGeometryType.esriGeometryPolyline)
{
lineFC = lyr;
gpExtension.profileLineLayer = lineFC;
geopuntHelper.addFeatureClassToMap(view, lineFC);
}
else if (geomType == esriGeometryType.esriGeometryPoint)
{
pointsFC = lyr;
gpExtension.profilePointsLayer = pointsFC;
geopuntHelper.addFeatureClassToMap(view, pointsFC);
}
}
public static FeatureClass CreateFeatureClass(esriFeatureType featureType, esriGeometryType geometryType) {
XPathNodeIterator iterator = null;
switch (featureType) {
case esriFeatureType.esriFTSimple:
switch (geometryType) {
case esriGeometryType.esriGeometryMultiPatch:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_MULTIPATCH, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPoint:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POINT, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPolygon:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POLYGON, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriGeometryType.esriGeometryPolyline:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_POLYLINE, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
}
break;
case esriFeatureType.esriFTAnnotation:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_ANNOTATION, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
case esriFeatureType.esriFTDimension:
iterator = Factory.LoadXml(Resources.FILE_FEATURECLASS_DIMENSION, "WorkspaceDefinition/DatasetDefinitions/DataElement");
break;
}
if (iterator == null) { return null; }
if (!iterator.MoveNext()) { return null; }
XPathNavigator navigator = iterator.Current;
FeatureClass featureClass = new FeatureClass(navigator); ;
return featureClass;
}
private static ILayer BuildQueryLayer(string connection, string query, string name, string oidFields, int? srid, esriGeometryType? geometryType)
{
var featureClass = BuildQueryFeatureClass(connection, query, name, oidFields, srid, geometryType);
var featureLayer = new FeatureLayerClass { FeatureClass = featureClass, Name = name };
return featureLayer;
}
private void LoadMap(string layerType, esriGeometryType targetType)
{
try
{
//如果存在,删除
if (_mapIndex.ContainsKey(layerType))
{
var pLayer = _axMapControl.Map.Layer[_mapIndex[layerType]];
_axMapControl.Map.DeleteLayer(pLayer);
_mapIndex.Remove(layerType);
}
//添加
var pFeatureClass = _shapeOp.OpenFeatureClass();
if (!pFeatureClass.GeometryTypeCheck(targetType))
{
throw new Exception("打开要素类型不正确");
}
_axMapControl.Map.AddLayer(new FeatureLayerClass()
{
FeatureClass = pFeatureClass
});
_mapIndex.Add(layerType, _axMapControl.Map.LayerCount - 1);
}
catch (Exception e)
{
Messenger.Default.Send(new GenericMessage<string>(e.Message),"Exception");
}
}
public GeometryDef(SerializationInfo info, StreamingContext context) : base(info, context) {
this._avgNumPoints = info.GetInt32(GeometryDef.AVGNUMPOINTS);
this._geometryType = (esriGeometryType)Enum.Parse(typeof(esriGeometryType), info.GetString(GeometryDef.GEOMETRYTYPE), true);
this._hasM = info.GetBoolean(GeometryDef.HASM);
this._hasZ = info.GetBoolean(GeometryDef.HASZ);
this._spatialReference = (SpatialReference)info.GetValue(GeometryDef.SPATIALREFERENCE, typeof(SpatialReference));
this._gridSize0 = info.GetDouble(GeometryDef.GRIDSIZE0);
this._gridSize1 = info.GetDouble(GeometryDef.GRIDSIZE1);
this._gridSize2 = info.GetDouble(GeometryDef.GRIDSIZE2);
}
public static string GetDescription(esriGeometryType type) {
switch (type) {
case esriGeometryType.esriGeometryAny: return "Any";
case esriGeometryType.esriGeometryBag: return "Bag";
case esriGeometryType.esriGeometryBezier3Curve: return "Bezier Curve";
case esriGeometryType.esriGeometryCircularArc: return "Circular Arc";
case esriGeometryType.esriGeometryEllipticArc: return "Elliptic Arc";
case esriGeometryType.esriGeometryEnvelope: return "Envelope";
case esriGeometryType.esriGeometryLine: return "Line";
case esriGeometryType.esriGeometryMultiPatch: return "MultiPatch";
case esriGeometryType.esriGeometryMultipoint: return "Multipoint";
case esriGeometryType.esriGeometryNull: return "Null";
case esriGeometryType.esriGeometryPath: return "Path";
case esriGeometryType.esriGeometryPoint: return "Point";
case esriGeometryType.esriGeometryPolygon: return "Polygon";
case esriGeometryType.esriGeometryPolyline: return "Polyline";
case esriGeometryType.esriGeometryRay: return "Ray";
case esriGeometryType.esriGeometryRing: return "Ring";
case esriGeometryType.esriGeometrySphere: return "Sphere";
case esriGeometryType.esriGeometryTriangleFan: return "Triangle Fan";
case esriGeometryType.esriGeometryTriangles: return "Triangles";
case esriGeometryType.esriGeometryTriangleStrip: return "Triangle Strip";
default:
return "UNKNOWN";
}
}
/// <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;
}
/// <summary>
/// 根据点击位置和需要的element类型，取得在该位置的给类型的element
/// </summary>
/// <param name="pPoint"></param>
/// <param name="geometryType"></param>
/// <returns></returns>
private IElement getElement(IPoint pPoint,esriGeometryType geometryType)
{
IEnumElement pEnumElement = this.pGraphicContainer.LocateElements(pPoint, this.axMapControl1.ActiveView.Extent.Width / 100);
if (pEnumElement != null)
{
pEnumElement.Reset();
IElement pElement;
for (pElement=pEnumElement.Next(); pElement!= null;pElement=pEnumElement.Next())
{
if (pElement.Geometry.GeometryType == geometryType)
{
this.hitElement = pElement;
return pElement;
}
}
return null;
}
return null;
}
