You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1592 lines
67 KiB
1592 lines
67 KiB
using System; |
|
using System.Collections.Generic; |
|
using System.Linq; |
|
using System.Runtime.InteropServices; |
|
using System.Text; |
|
using ESRI.ArcGIS.ADF; |
|
using ESRI.ArcGIS.Carto; |
|
using ESRI.ArcGIS.esriSystem; |
|
using ESRI.ArcGIS.Geodatabase; |
|
using ESRI.ArcGIS.Geometry; |
|
|
|
namespace Kingo.RuleCheck.AEHelper |
|
{ |
|
public static class FeatureAPI |
|
{ |
|
#region 面转线 |
|
/// <summary> |
|
/// 面转线 |
|
/// </summary> |
|
/// <param name="pFeature">多边形面要素</param> |
|
public static List<IGeometry> FeatureToLine(IFeature pFeature) |
|
{ |
|
List<IGeometry> result = new List<IGeometry>(); |
|
try |
|
{ |
|
if (pFeature != null && pFeature.Shape != null) |
|
{ |
|
IGeometry pGeometry = pFeature.ShapeCopy; |
|
result = PolygonToLine(pGeometry); |
|
} |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
/// <summary> |
|
/// 面转线 |
|
/// </summary> |
|
/// <param name="pGeometry">多边形面</param> |
|
public static List<IGeometry> PolygonToLine(IGeometry pGeometry) |
|
{ |
|
List<IGeometry> result = new List<IGeometry>(); |
|
try |
|
{ |
|
if (pGeometry != null && pGeometry.GeometryType == esriGeometryType.esriGeometryPolygon) |
|
{ |
|
ITopologicalOperator topologicalOperator = pGeometry as ITopologicalOperator; |
|
if (topologicalOperator == null) return result; |
|
topologicalOperator.Simplify(); |
|
//外环图形 |
|
GeometryBag ExterGeometryBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).ExteriorRingBag as GeometryBag; |
|
if (ExterGeometryBag == null) return result; |
|
IGeometryCollection ExterRingGeometryCollection = ExterGeometryBag as IGeometryCollection; |
|
IGeometryCollection geometry = new ESRI.ArcGIS.Geometry.PolygonClass() as IGeometryCollection; |
|
//List<IGeometry> geometry = new List<IGeometry>(); |
|
for (int g = 0; g < ExterRingGeometryCollection.GeometryCount; g++) |
|
{ |
|
IGeometry ExterGeometry = ExterRingGeometryCollection.get_Geometry(g); |
|
|
|
result.Add(PolygonToPolyline(ExterGeometry)); |
|
|
|
//内环图形 |
|
IGeometryBag InteriorBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).get_InteriorRingBag(ExterGeometry as IRing); |
|
if (InteriorBag == null) continue; |
|
IGeometryCollection InteriorRingGeometryCollection = InteriorBag as IGeometryCollection; |
|
if (InteriorRingGeometryCollection == null) continue; |
|
for (int IG = 0; IG < InteriorRingGeometryCollection.GeometryCount; IG++) |
|
{ |
|
IGeometry interiorGeo = InteriorRingGeometryCollection.get_Geometry(IG); |
|
result.Add(PolygonToPolyline(interiorGeo)); |
|
} |
|
} |
|
} |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
private static IGeometry PolygonToPolyline(IGeometry pGeo) |
|
{ |
|
try |
|
{ |
|
if (pGeo == null) return null; |
|
Ring ring = pGeo as Ring; |
|
if (ring == null) return null; |
|
IPointCollection pc = ring as IPointCollection; |
|
IGeometryCollection pPolyline = new PolylineClass(); |
|
for (int j = 1; j < pc.PointCount; j++) |
|
{ |
|
ILine pLine = new LineClass(); |
|
pLine.SpatialReference = pGeo.SpatialReference; |
|
pLine.PutCoords(pc.get_Point(j - 1), pc.get_Point(j)); |
|
ISegment pSegment = pLine as ISegment; |
|
// 创建一个Path对象 |
|
ISegmentCollection pPath = new PathClass(); |
|
object o = Type.Missing; |
|
// 通过Isegmentcoletcion接口为Path对象添加Segment对象 |
|
pPath.AddSegment(pSegment, ref o, ref o); |
|
// 创建一个Polyline对象 |
|
pPolyline.AddGeometry(pPath as IGeometry, ref o, ref o); |
|
} |
|
return pPolyline as IGeometry; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
#endregion |
|
|
|
/// <summary> |
|
/// 求两个图形相交部分 |
|
/// </summary> |
|
/// <param name="pGeo1">图形1</param> |
|
/// <param name="pGeo2">图形2</param> |
|
/// <returns></returns> |
|
public static IGeometry InterSect(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
try |
|
{ |
|
IGeometry result = null; |
|
if (pGeo1 == null || pGeo2 == null) |
|
return null; |
|
ITopologicalOperator topo = pGeo1 as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
topo.Simplify(); |
|
pGeo2.SpatialReference = pGeo1.SpatialReference; |
|
ITopologicalOperator topo2 = pGeo2 as ITopologicalOperator; |
|
topo2.Simplify(); |
|
if (pGeo1.GeometryType == esriGeometryType.esriGeometryPoint || pGeo2.GeometryType == esriGeometryType.esriGeometryPoint) |
|
{ |
|
result = topo.Intersect(pGeo2, esriGeometryDimension.esriGeometry0Dimension); |
|
} |
|
else if (pGeo1.GeometryType == esriGeometryType.esriGeometryPolyline || pGeo2.GeometryType == esriGeometryType.esriGeometryPolyline) |
|
{ |
|
result = topo.Intersect(pGeo2, esriGeometryDimension.esriGeometry1Dimension); |
|
} |
|
else |
|
{ |
|
result = topo.Intersect(pGeo2, pGeo2.Dimension); |
|
} |
|
if (result != null) |
|
{ |
|
ITopologicalOperator resultTopo = result as ITopologicalOperator; |
|
resultTopo.Simplify(); |
|
} |
|
return result; |
|
} |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 求目标图形与指定图形不相交部分 |
|
/// </summary> |
|
/// <param name="pGeo1">目标多边形</param> |
|
/// <param name="pGeo2">指定的图形</param> |
|
/// <returns></returns> |
|
public static IGeometry Difference(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
try |
|
{ |
|
IGeometry result = null; |
|
if (pGeo1 == null || pGeo2 == null) |
|
return null; |
|
ITopologicalOperator topo = pGeo1 as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
topo.Simplify(); |
|
result = topo.Difference(pGeo2); |
|
ITopologicalOperator resTopo = result as ITopologicalOperator; |
|
resTopo.Simplify(); |
|
return result; |
|
} |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 使用指定的线裁切目标多边形 |
|
/// </summary> |
|
/// <param name="pGeo1">目标多边形</param> |
|
/// <param name="pGeo2">指定的图形</param> |
|
/// <returns></returns> |
|
public static List<IGeometry> CutGeometry(IGeometry pGeo1, IPolyline pGeo2) |
|
{ |
|
List<IGeometry> result = new List<IGeometry>(); |
|
try |
|
{ |
|
if (pGeo1 == null || pGeo2 == null) |
|
return result; |
|
ITopologicalOperator topo = pGeo1 as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
topo.Simplify(); |
|
IGeometry leftGeo = null; |
|
IGeometry rightGeo = null; |
|
topo.Cut(pGeo2, out leftGeo, out rightGeo); |
|
if (leftGeo != null && !leftGeo.IsEmpty) |
|
result.Add(leftGeo); |
|
if (rightGeo != null && !rightGeo.IsEmpty) |
|
result.Add(rightGeo); |
|
} |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 判断两个图形是否是叠加关系（相邻的也算相交） |
|
/// </summary> |
|
/// <param name="pGeo1"></param> |
|
/// <param name="pGeo2"></param> |
|
/// <returns></returns> |
|
public static bool IsOverlaps(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
if (pGeo1.SpatialReference.FactoryCode != pGeo2.SpatialReference.FactoryCode) |
|
{ |
|
pGeo2.Project(pGeo1.SpatialReference); |
|
} |
|
ITopologicalOperator topological = pGeo1 as ITopologicalOperator; |
|
if (topological != null && !topological.IsKnownSimple) |
|
{ |
|
topological.Simplify(); |
|
} |
|
ITopologicalOperator topological2 = pGeo2 as ITopologicalOperator; |
|
if (topological2 != null && !topological2.IsKnownSimple) |
|
{ |
|
topological2.Simplify(); |
|
} |
|
IRelationalOperator relational = pGeo1 as IRelationalOperator; |
|
if (relational != null) |
|
{ |
|
bool b = relational.Overlaps(pGeo2); |
|
if (!b) |
|
{ |
|
relational = pGeo1 as IRelationalOperator; |
|
b = relational.Touches(pGeo2); |
|
} |
|
return b; |
|
} |
|
return false; |
|
} |
|
|
|
/// <summary> |
|
/// 判断两个图形是否相交（不包含相邻的） |
|
/// </summary> |
|
/// <param name="pGeo1"></param> |
|
/// <param name="pGeo2"></param> |
|
/// <returns></returns> |
|
public static bool IsInterSect(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
IGeometry geo = InterSect(pGeo1, pGeo2); |
|
if (geo == null || geo.IsEmpty) |
|
return false; |
|
if (geo.Dimension == esriGeometryDimension.esriGeometry2Dimension) |
|
{ |
|
IArea area = geo as IArea; |
|
if (area == null) |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
/// <summary> |
|
/// 判断两个图形是否相邻 |
|
/// </summary> |
|
/// <param name="pGeo1"></param> |
|
/// <param name="pGeo2"></param> |
|
/// <returns></returns> |
|
public static bool IsAdjacent(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
bool result = false; |
|
//IPolyline polyline; |
|
IRelationalOperator topoOper = pGeo1 as IRelationalOperator; |
|
result = topoOper.Touches(pGeo2); |
|
if (result) |
|
{ |
|
ITopologicalOperator topo = pGeo1 as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
topo.Simplify(); |
|
ITopologicalOperator topo2 = pGeo2 as ITopologicalOperator; |
|
topo2.Simplify(); |
|
IGeometry geo = topo.Intersect(pGeo2, esriGeometryDimension.esriGeometry1Dimension); |
|
if (geo == null) |
|
{ |
|
result = false; |
|
} |
|
else if (geo.IsEmpty) |
|
{ result = false; } |
|
} |
|
} |
|
return result; |
|
//IPolyline polyline; |
|
//ITopologicalOperator topoOper = pGeo1 as ITopologicalOperator; |
|
//polyline = topoOper.Intersect(pGeo2, esriGeometryDimension.esriGeometry1Dimension) as IPolyline; |
|
//if (polyline != null && !polyline.IsEmpty) |
|
//{ |
|
// return true; |
|
//} |
|
//return false; |
|
} |
|
|
|
/// <summary> |
|
/// 判断点pPoint是否与图形pGeo边界上的点重叠，如果重叠返回图形上重叠点的索引 |
|
/// </summary> |
|
/// <param name="pPoint"></param> |
|
/// <param name="pGeo"></param> |
|
/// <returns></returns> |
|
public static int IsInterSect(IPoint pPoint, IGeometry pGeo) |
|
{ |
|
int result = -1; |
|
if (pPoint.IsEmpty || pGeo.IsEmpty) |
|
return result; |
|
IGeometryCollection geoCollection = pGeo as IGeometryCollection; |
|
if (geoCollection != null) |
|
{ |
|
for (int i = 0; i < geoCollection.GeometryCount; i++) |
|
{ |
|
IPointCollection points = geoCollection.Geometry[i] as IPointCollection; |
|
for (int j = 0; j < points.PointCount; j++) |
|
{ |
|
IPoint p = points.Point[j]; |
|
ITopologicalOperator topo = p as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
IGeometry geo = topo.Intersect(pPoint, pPoint.Dimension); |
|
if (geo == null || geo.IsEmpty) |
|
continue; |
|
result = j; |
|
break; |
|
} |
|
} |
|
if (result != -1) |
|
break; |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
public static double GetInterArea(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
IGeometry geo = InterSect(pGeo1, pGeo2); |
|
if (geo == null || geo.IsEmpty) |
|
return 0; |
|
IArea area = geo as IArea; |
|
if (area == null || area.Area < 1) |
|
return 0; |
|
return area.Area; |
|
} |
|
|
|
/// <summary> |
|
/// 判断图形1是否包含图形2 |
|
/// </summary> |
|
/// <param name="pGeo1">图形1</param> |
|
/// <param name="pGeo2">图形2</param> |
|
/// <returns></returns> |
|
public static bool IsContains(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
try |
|
{ |
|
ITopologicalOperator topological = pGeo1 as ITopologicalOperator; |
|
if (topological != null && !topological.IsKnownSimple) |
|
{ |
|
topological.Simplify(); |
|
} |
|
ITopologicalOperator topological2 = pGeo2 as ITopologicalOperator; |
|
pGeo2.SpatialReference = pGeo1.SpatialReference; |
|
if (topological2 != null && !topological2.IsKnownSimple) |
|
{ |
|
topological2.Simplify(); |
|
} |
|
IRelationalOperator relational = pGeo1 as IRelationalOperator; |
|
if (relational != null) |
|
{ |
|
return relational.Contains(pGeo2); |
|
} |
|
return false; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 获取图形共边边长 |
|
/// </summary> |
|
/// <param name="iPolygon1"></param> |
|
/// <param name="iPolygon2"></param> |
|
/// <returns></returns> |
|
public static double LengthOfSide(IGeometry iPolygon1, IGeometry iPolygon2) |
|
{ |
|
IPolyline polyline; |
|
ITopologicalOperator topoOper = iPolygon1 as ITopologicalOperator; |
|
polyline = topoOper.Intersect(iPolygon2, esriGeometryDimension.esriGeometry1Dimension) as IPolyline; |
|
return polyline.Length; |
|
} |
|
/// <summary> |
|
/// 拷贝要素 |
|
/// </summary> |
|
/// <param name="source"></param> |
|
/// <param name="ignoreFields"></param> |
|
/// <returns></returns> |
|
public static IFeature FeatureCopy(IFeature source, List<string> ignoreFields = null) |
|
{ |
|
try |
|
{ |
|
IFeatureClass targetFeatureClass = (IFeatureClass)source.Class; |
|
IFeatureBuffer target = targetFeatureClass.CreateFeatureBuffer(); |
|
FeatureCopy(source, target, ignoreFields); |
|
return target as IFeature; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private static void FeatureCopy(IFeature source, IFeatureBuffer target, List<string> ignoreFields = null) |
|
{ |
|
for (int i = 0; i < target.Fields.FieldCount; i++) |
|
{ |
|
IField ft = target.Fields.get_Field(i); |
|
if (!ft.Editable || (ignoreFields != null && ignoreFields.Contains(ft.Name))) |
|
continue; |
|
int index = source.Fields.FindField(ft.Name); |
|
if (index > -1) |
|
{ |
|
try |
|
{ |
|
target.set_Value(i, source.get_Value(index)); |
|
} |
|
catch { } |
|
} |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 合并矢量图形，以第一条为基准,调用此方法之前需开启编辑，并控制会回滚，执行完成后会删除所有记录 |
|
/// </summary> |
|
/// <param name="features"></param> |
|
/// <returns></returns> |
|
public static IFeature MergeFeature(List<IFeature> features) |
|
{ |
|
try |
|
{ |
|
if (features == null || features.Count == 0) |
|
return null; |
|
if (features.Count == 1) |
|
return features[0]; |
|
|
|
IFeature baseFeature = features[0]; |
|
IFeature target = FeatureCopy(baseFeature); |
|
ITopologicalOperator2 topo = baseFeature.Shape as ITopologicalOperator2; |
|
foreach (IFeature f in features) |
|
{ |
|
if (f != baseFeature) |
|
{ |
|
ITopologicalOperator topo2 = f.Shape as ITopologicalOperator; |
|
topo2.Simplify(); |
|
topo.Simplify(); |
|
topo = topo.Union(f.Shape) as ITopologicalOperator2; |
|
} |
|
} |
|
if (!topo.IsSimple) |
|
{ |
|
topo.Simplify(); |
|
} |
|
target.Shape = topo as IGeometry; |
|
return target; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 合并矢量图形，以第一条为基准,调用此方法之前需开启编辑，并控制会回滚，执行完成后会删除所有记录 |
|
/// </summary> |
|
/// <param name="features"></param> |
|
/// <returns></returns> |
|
public static IGeometry MergeGeometry(List<IGeometry> pGeometry) |
|
{ |
|
try |
|
{ |
|
if (pGeometry == null || pGeometry.Count == 0) |
|
return null; |
|
if (pGeometry.Count == 1) |
|
return pGeometry[0]; |
|
|
|
IGeometry baseGeo = pGeometry[0]; |
|
//IGeometry target = FeatureCopy(baseFeature); |
|
ITopologicalOperator2 topo = baseGeo as ITopologicalOperator2; |
|
foreach (IGeometry f in pGeometry) |
|
{ |
|
if (f != baseGeo) |
|
{ |
|
ITopologicalOperator2 topolog = f as ITopologicalOperator2; |
|
topolog.Simplify(); |
|
topo.Simplify(); |
|
topo = topo.Union(f) as ITopologicalOperator2; |
|
} |
|
} |
|
if (!topo.IsSimple) |
|
{ |
|
topo.Simplify(); |
|
} |
|
//target.Shape = topo as IGeometry; |
|
return topo as IGeometry; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 分割 |
|
/// </summary> |
|
/// <param name="features"></param> |
|
/// <param name="splitLine"></param> |
|
/// <returns></returns> |
|
public static List<IFeature> SplitFeature(IFeature features, IPolyline splitLine) |
|
{ |
|
if (features.Shape.GeometryType != esriGeometryType.esriGeometryPolygon |
|
&& features.Shape.GeometryType != esriGeometryType.esriGeometryPolyline) |
|
{ |
|
throw new Exception("无法分割除面和线之外的图形"); |
|
} |
|
List<IFeature> result = new List<IFeature>(); |
|
ITopologicalOperator4 topo = features.Shape.Envelope as ITopologicalOperator4; |
|
//IGeometryCollection geos = null; |
|
try |
|
{ |
|
IGeometry leftGeo; |
|
IGeometry rightGeo; |
|
topo.Cut(splitLine, out leftGeo, out rightGeo); |
|
if (!leftGeo.IsEmpty) |
|
{ |
|
IFeature feature = FeatureCopy(features); |
|
feature.Shape = leftGeo; |
|
result.Add(feature); |
|
} |
|
if (!rightGeo.IsEmpty) |
|
{ |
|
IFeature feature = FeatureCopy(features); |
|
feature.Shape = rightGeo; |
|
result.Add(feature); |
|
} |
|
} |
|
catch |
|
{ |
|
result.Add(features); |
|
return result; |
|
} |
|
//for (int i = 0; i < geos.GeometryCount; i++) |
|
//{ |
|
// IPolygon polygon = geos.get_Geometry(i) as IPolygon; |
|
// if (polygon != null) |
|
// { |
|
// IFeature feature = FeatureCopy(features); |
|
// feature.Shape = polygon; |
|
// result.Add(feature); |
|
// } |
|
//} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 分割 |
|
/// </summary> |
|
/// <param name="features"></param> |
|
/// <param name="splitLine"></param> |
|
/// <returns></returns> |
|
public static List<IFeature> SplitFeature(List<IFeature> features, IPolyline splitLine, out List<IFeature> splitedList) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
splitedList = new List<IFeature>(); |
|
foreach (IFeature f in features) |
|
{ |
|
List<IFeature> subResults = SplitFeature(f, splitLine); |
|
result.AddRange(subResults); |
|
if (subResults.Count > 1) |
|
{ |
|
splitedList.Add(f); |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 根据点打断线 |
|
/// </summary> |
|
/// <param name="pPoint"></param> |
|
/// <param name="pLine"></param> |
|
/// <returns></returns> |
|
public static List<IPolyline> SplitLineAtPoint(IPoint pPoint, IPolyline pLine) |
|
{ |
|
List<IPolyline> result = new List<IPolyline>(); |
|
//对那条线在点击点处，进行打断 |
|
IPolycurve pPolycurve = (IPolycurve)pLine; |
|
bool HasSplitHappened; |
|
int newPartIndex; |
|
int newSegmentIndex; |
|
//打断 |
|
pPolycurve.SplitAtPoint(pPoint, false, true, out HasSplitHappened, out newPartIndex, out newSegmentIndex); |
|
if (HasSplitHappened) |
|
{ |
|
IGeometryCollection pGeometryCollection = (IGeometryCollection)pPolycurve; |
|
for (int i = 0; i < pGeometryCollection.GeometryCount; i++) |
|
{ |
|
IGeometryCollection line = new PolylineClass(); |
|
IGeometry pGeo = pGeometryCollection.get_Geometry(i); |
|
line.AddGeometries(1, ref pGeo); |
|
result.Add(line as IPolyline); |
|
} |
|
} |
|
else |
|
{ |
|
result.Add(pLine); |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 根据点捕捉要素 |
|
/// </summary> |
|
/// <param name="pPoint"></param> |
|
/// <param name="pLayers"></param> |
|
/// <returns></returns> |
|
public static List<IFeature> Snapping(IPoint pPoint, List<IFeatureLayer> pLayers, int buffer = 5) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
try |
|
{ |
|
if (pPoint != null && pLayers != null) |
|
{ |
|
foreach (IFeatureLayer item in pLayers) |
|
{ |
|
IIdentify identify = item as IIdentify; |
|
if (identify == null) |
|
continue; |
|
ITopologicalOperator pTopo = pPoint as ITopologicalOperator; |
|
IGeometry pGeometry = pTopo.Buffer(buffer).Envelope as IGeometry; |
|
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pGeometry); |
|
if (array == null) |
|
continue; |
|
for (int i = 0; i < array.Count; i++) |
|
{ |
|
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i); |
|
if (row == null) |
|
continue; |
|
IFeature f = row.Row as IFeature; |
|
result.Add(f); |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 根据线捕捉要素 |
|
/// </summary> |
|
/// <param name="pPoint"></param> |
|
/// <param name="pLayers"></param> |
|
/// <returns></returns> |
|
public static List<IFeature> Snapping(IGeometry pGeo, List<IFeatureLayer> pLayers, double buffer = 0.0001) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
try |
|
{ |
|
if (pGeo == null || pGeo.IsEmpty || pLayers == null) |
|
{ |
|
return result; |
|
} |
|
foreach (IFeatureLayer item in pLayers) |
|
{ |
|
IIdentify identify = item as IIdentify; |
|
if (identify == null) |
|
continue; |
|
ITopologicalOperator pTopo = pGeo as ITopologicalOperator; |
|
if (pTopo == null) |
|
{ |
|
continue; |
|
} |
|
pTopo.Simplify(); |
|
//修改人：李进营 修改时间：2018-09-18 注释缓冲代码，解决Gis10.2绘制慢的问题 |
|
//IGeometry bufferGeometry = pTopo.Buffer(buffer); |
|
IGeometry bufferGeometry = pGeo; |
|
if (bufferGeometry == null || bufferGeometry.IsEmpty) |
|
{ |
|
continue; |
|
} |
|
IGeometry pGeometry = bufferGeometry.Envelope as IGeometry; |
|
if (pGeometry == null || pGeometry.IsEmpty) |
|
{ |
|
continue; |
|
} |
|
pTopo = pGeometry as ITopologicalOperator; |
|
if (pTopo != null) |
|
{ |
|
pTopo.Simplify(); |
|
} |
|
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pGeometry); |
|
if (array == null || array.Count <= 0) |
|
continue; |
|
for (int i = 0; i < array.Count; i++) |
|
{ |
|
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i); |
|
if (row == null) |
|
continue; |
|
IFeature f = row.Row as IFeature; |
|
result.Add(f); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 识别要素 |
|
/// </summary> |
|
/// <param name="pPoint"></param> |
|
/// <param name="pLayers"></param> |
|
/// <returns></returns> |
|
public static List<IFeature> Identify(IGeometry pGeo, ILayer pLayer, double buffer = 0.0001) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
try |
|
{ |
|
if (pGeo == null || pGeo.IsEmpty || pLayer == null) |
|
{ |
|
return result; |
|
} |
|
IIdentify identify = pLayer as IIdentify; |
|
if (identify == null) |
|
{ |
|
return result; |
|
} |
|
//ITopologicalOperator pTopo = pGeo as ITopologicalOperator; |
|
//IGeometry pGeometry = pTopo.Buffer(buffer).Envelope as IGeometry; |
|
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pGeo); |
|
if (array == null) |
|
{ |
|
return result; |
|
} |
|
for (int i = 0; i < array.Count; i++) |
|
{ |
|
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i); |
|
if (row == null) |
|
continue; |
|
IFeature f = row.Row as IFeature; |
|
result.Add(f); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
/// <summary> |
|
/// 识别要素 |
|
/// </summary> |
|
/// <param name="pGeo">指定图形</param> |
|
/// <param name="pLayer">目标图层</param> |
|
/// <returns>返回目标图层中与指定图形有交集的要素集合（不包含相邻要素）</returns> |
|
public static List<IFeature> Identify2(IGeometry pGeo, ILayer pLayer) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
try |
|
{ |
|
if (pGeo != null && !pGeo.IsEmpty && pLayer != null) |
|
{ |
|
IIdentify identify = pLayer as IIdentify; |
|
if (identify == null) |
|
return result; |
|
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pGeo); |
|
if (array == null) |
|
return result; |
|
for (int i = 0; i < array.Count; i++) |
|
{ |
|
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i); |
|
if (row == null) |
|
continue; |
|
IFeature f = row.Row as IFeature; |
|
IGeometry geo = InterSect(f.ShapeCopy, pGeo); |
|
if (geo != null && !geo.IsEmpty) |
|
result.Add(f); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 识别要素 |
|
/// </summary> |
|
/// <param name="pGeo">指定图形</param> |
|
/// <param name="pLayer">目标图层</param> |
|
/// <returns>返回目标图层中与指定图形有交集的要素集合（不包含相邻要素）</returns> |
|
public static Dictionary<IGeometry, IFeature> IdentifyReturnIntersect(IGeometry pGeo, ILayer pLayer) |
|
{ |
|
Dictionary<IGeometry, IFeature> result = new Dictionary<IGeometry, IFeature>(); |
|
try |
|
{ |
|
if (pGeo != null && !pGeo.IsEmpty && pLayer != null) |
|
{ |
|
IIdentify identify = pLayer as IIdentify; |
|
if (identify == null) |
|
return result; |
|
ESRI.ArcGIS.esriSystem.IArray array = identify.Identify(pGeo); |
|
if (array == null) |
|
return result; |
|
for (int i = 0; i < array.Count; i++) |
|
{ |
|
IRowIdentifyObject row = (IRowIdentifyObject)array.get_Element(i); |
|
if (row == null) |
|
{ |
|
continue; |
|
} |
|
IFeature f = row.Row as IFeature; |
|
//pGeo.Project(((pLayer as IFeatureLayer).FeatureClass as IGeoDataset).SpatialReference); |
|
IGeometry geometry = f.ShapeCopy; |
|
if (!geometry.SpatialReference.Name.Equals(pGeo.SpatialReference.Name)) |
|
{ |
|
geometry.Project(pGeo.SpatialReference); |
|
} |
|
IGeometry geo = InterSect(geometry, pGeo); |
|
if (geo != null && !geo.IsEmpty) |
|
{ |
|
result.Add(geo, f); |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 属性自动赋值（对指定要素通过压盖指定图层方式进行属性继承，如果压盖多个则以面积大的要素属性为准） |
|
/// </summary> |
|
/// <param name="pFeature">指定要素</param> |
|
/// <param name="pLayer">指定图层</param> |
|
public static void AutoSetAttribute(IFeature pFeature, IFeatureLayer pLayer) |
|
{ |
|
try |
|
{ |
|
if (pFeature == null || pLayer == null) |
|
{ |
|
return; |
|
} |
|
IIdentify identify = pLayer as IIdentify; |
|
if (identify == null) |
|
return; |
|
ESRI.ArcGIS.esriSystem.IArray iarray = identify.Identify(pFeature.ShapeCopy as IGeometry); |
|
if (iarray == null) |
|
{ |
|
return; |
|
} |
|
//与之相交部分面积 |
|
double area = -1; |
|
IFeature s_Feature = null; |
|
for (int i = 0; i < iarray.Count; i++) |
|
{ |
|
IFeatureIdentifyObj pFeatIdObj = iarray.get_Element(i) as IFeatureIdentifyObj; |
|
IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject; |
|
IFeature newFeature = pRowObj.Row as IFeature; |
|
if (newFeature.Shape.SpatialReference != pFeature.Shape.SpatialReference) |
|
{ |
|
newFeature.Shape.SpatialReference = pFeature.Shape.SpatialReference; |
|
} |
|
IGeometry geo = FeatureAPI.InterSect(pFeature.ShapeCopy, newFeature.ShapeCopy); |
|
if (geo != null && !geo.IsEmpty) |
|
{ |
|
if (area < (geo as IArea).Area) |
|
{ |
|
area = (geo as IArea).Area; |
|
s_Feature = newFeature; |
|
} |
|
} |
|
} |
|
if (s_Feature != null) |
|
{ |
|
#region 属性继承 |
|
for (int i = 0; i < pFeature.Fields.FieldCount; i++) |
|
{ |
|
IField field = pFeature.Fields.get_Field(i); |
|
if (!field.Editable || field.Name.ToUpper() == "SHAPE" || field.Name.ToUpper() == "BSM") |
|
continue; |
|
int index = s_Feature.Fields.FindField(field.Name); |
|
if (index == -1) |
|
index = s_Feature.Fields.FindFieldByAliasName(field.Name); |
|
if (index == -1) |
|
continue; |
|
if (s_Feature.Fields.get_Field(index).Type == field.Type) |
|
{ |
|
if (!(s_Feature.get_Value(index) is DBNull)) |
|
{ |
|
pFeature.set_Value(i, s_Feature.get_Value(index)); |
|
} |
|
} |
|
} |
|
} |
|
#endregion |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 裁切要素（以指定的要素通过压盖指定图层的要素，将压盖到的要素进行裁切） |
|
/// </summary> |
|
/// <param name="pFeature">指定要素</param> |
|
/// <param name="pLayer">指定图层</param> |
|
public static List<IFeature> CutInterSectFeature(IFeature pFeature, IFeatureLayer pLayer) |
|
{ |
|
List<IFeature> result = new List<IFeature>(); |
|
try |
|
{ |
|
IIdentify identify = pLayer as IIdentify; |
|
ESRI.ArcGIS.esriSystem.IArray iarray = identify.Identify(pFeature.ShapeCopy as IGeometry); |
|
if (iarray != null) |
|
{ |
|
for (int i = 0; i < iarray.Count; i++) |
|
{ |
|
IFeatureIdentifyObj pFeatIdObj = iarray.get_Element(i) as IFeatureIdentifyObj; |
|
IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject; |
|
IFeature newFeature = pRowObj.Row as IFeature; |
|
if (newFeature.Shape.SpatialReference != pFeature.Shape.SpatialReference) |
|
{ |
|
newFeature.Shape.SpatialReference = pFeature.Shape.SpatialReference; |
|
} |
|
ITopologicalOperator topOper = newFeature.ShapeCopy as ITopologicalOperator; |
|
IGeometry geometryNew = topOper.Difference(pFeature.ShapeCopy as IGeometry); |
|
IGeometryCollection geoCollection = geometryNew as IGeometryCollection; |
|
//外环图形 |
|
IGeometryCollection ExterGeometryBag = (geometryNew as ESRI.ArcGIS.Geometry.IPolygon4).ExteriorRingBag as IGeometryCollection; |
|
if (geoCollection != null && geoCollection.GeometryCount > 1) |
|
{ |
|
if (geoCollection.GeometryCount == ExterGeometryBag.GeometryCount) |
|
{ |
|
IGeometryCollection geos = new PolygonClass(); |
|
geos.AddGeometry(geoCollection.get_Geometry(0)); |
|
newFeature.Shape = geos as IGeometry; |
|
for (int j = 1; j < geoCollection.GeometryCount; j++) |
|
{ |
|
IFeature f = pLayer.FeatureClass.CreateFeature(); |
|
geos = new PolygonClass(); |
|
geos.AddGeometry(geoCollection.get_Geometry(j)); |
|
f.Shape = geos as IGeometry; |
|
f.Store(); |
|
result.Add(f); |
|
} |
|
} |
|
else |
|
{ |
|
newFeature.Shape = geometryNew; |
|
} |
|
} |
|
else |
|
{ |
|
newFeature.Shape = geometryNew; |
|
} |
|
result.Add(newFeature); |
|
newFeature.Store(); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 将多环图形打散（不包含内环图形） |
|
/// </summary> |
|
/// <param name="pGeometry">多环多边形</param> |
|
/// <returns></returns> |
|
public static List<IGeometry> DissolveGeometryByRing(IGeometry pGeometry) |
|
{ |
|
try |
|
{ |
|
ISpatialReference sr = pGeometry.SpatialReference; |
|
List<IGeometry> result = null; |
|
if (pGeometry == null) return null; |
|
if (pGeometry.IsEmpty) return null; |
|
ITopologicalOperator topologicalOperator = pGeometry as ITopologicalOperator; |
|
if (topologicalOperator == null) return null; |
|
topologicalOperator.Simplify(); |
|
//外环图形 |
|
GeometryBag ExterGeometryBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).ExteriorRingBag as GeometryBag; |
|
if (ExterGeometryBag == null) return null; |
|
IGeometryCollection ExterRingGeometryCollection = ExterGeometryBag as IGeometryCollection; |
|
for (int g = 0; g < ExterRingGeometryCollection.GeometryCount; g++) |
|
{ |
|
IGeometryCollection geometry = new ESRI.ArcGIS.Geometry.PolygonClass() as IGeometryCollection; |
|
IGeometry ExterGeometry = ExterRingGeometryCollection.get_Geometry(g); |
|
if (ExterGeometry == null) continue; |
|
geometry.AddGeometry(ExterGeometry); |
|
|
|
//内环图形 |
|
IGeometryBag InteriorBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).get_InteriorRingBag(ExterGeometry as IRing); |
|
if (InteriorBag == null) continue; |
|
IGeometryCollection InteriorRingGeometryCollection = InteriorBag as IGeometryCollection; |
|
if (InteriorRingGeometryCollection == null) continue; |
|
for (int IG = 0; IG < InteriorRingGeometryCollection.GeometryCount; IG++) |
|
{ |
|
IGeometry interiorGeo = InteriorRingGeometryCollection.get_Geometry(IG); |
|
if (interiorGeo == null) continue; |
|
geometry.AddGeometry(interiorGeo); |
|
} |
|
if (result == null) |
|
{ |
|
result = new List<IGeometry>(); |
|
} |
|
(geometry as IGeometry).SpatialReference = sr; |
|
result.Add(geometry as IGeometry); |
|
} |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
#region 生成新的图斑（处理同属性要素分割/合并问题） |
|
/// <summary> |
|
/// 生成新的图斑（处理同权属、同坐落要素分割/合并问题） |
|
/// </summary> |
|
/// <param name="pFeature"></param> |
|
/// <param name="pFc"></param> |
|
/// <returns></returns> |
|
public static List<IGeometry> GenerateNewFeature(IGeometry pGeo, IFeatureClass pFc) |
|
{ |
|
List<IGeometry> result = new List<IGeometry>(); |
|
try |
|
{ |
|
#region |
|
IFeatureLayer layer = new FeatureLayerClass(); |
|
layer.FeatureClass = pFc; |
|
if (layer == null) |
|
return result; |
|
IIdentify indentify = layer as IIdentify; |
|
if (indentify == null) |
|
return result; |
|
IArray pIDs = indentify.Identify(pGeo); |
|
if (pIDs == null || pIDs.Count <= 0) |
|
{ |
|
return result; |
|
} |
|
int count = pIDs.Count; |
|
List<FeatureInfo> featureInfo = new List<FeatureInfo>(); |
|
for (int index = 0; index < pIDs.Count; index++) |
|
{ |
|
IFeatureIdentifyObj pFeatIdObj = pIDs.get_Element(index) as IFeatureIdentifyObj; |
|
IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject; |
|
IFeature dltbFeature = pRowObj.Row as IFeature; |
|
IGeometry newGeo = dltbFeature.ShapeCopy; |
|
newGeo.SpatialReference = pGeo.SpatialReference; |
|
if (!FeatureAPI.IsInterSect(pGeo, newGeo)) |
|
continue; |
|
int fieldIndex = dltbFeature.Fields.FindField("ZLDWDM"); |
|
if (fieldIndex == -1) |
|
{ |
|
throw new Exception("地类图斑要素类中未找到【ZLDWDM】字段！"); |
|
} |
|
object ZLDWDM = dltbFeature.get_Value(fieldIndex); |
|
if (ZLDWDM == null) |
|
throw new Exception("坐落单位代码为空！"); |
|
fieldIndex = dltbFeature.Fields.FindField("QSDWDM"); |
|
if (fieldIndex == -1) |
|
{ |
|
throw new Exception("地类图斑要素类中未找到【QSDWDM】字段！"); |
|
} |
|
object QSDWDM = dltbFeature.get_Value(fieldIndex); |
|
if (QSDWDM == null) |
|
throw new Exception("权属单位代码为空！"); |
|
if (featureInfo.Count == 0) |
|
{ |
|
FeatureInfo f = new FeatureInfo(); |
|
f.GeometryList = new List<IGeometry>(); |
|
f.ZLDWDM = ZLDWDM.ToString(); |
|
f.QSDWDM = QSDWDM.ToString(); |
|
f.GeometryList.Add(newGeo); |
|
featureInfo.Add(f); |
|
} |
|
else |
|
{ |
|
FeatureInfo f = featureInfo.FirstOrDefault(e => e.ZLDWDM == ZLDWDM.ToString() && e.QSDWDM == QSDWDM.ToString()); |
|
if (f != null) |
|
{ |
|
f.GeometryList.Add(newGeo); |
|
} |
|
else |
|
{ |
|
f = new FeatureInfo(); |
|
f.GeometryList = new List<IGeometry>(); |
|
f.ZLDWDM = ZLDWDM.ToString(); |
|
f.QSDWDM = QSDWDM.ToString(); |
|
f.GeometryList.Add(newGeo); |
|
featureInfo.Add(f); |
|
} |
|
} |
|
} |
|
foreach (FeatureInfo item in featureInfo) |
|
{ |
|
List<IGeometry> newFeatureList = new List<IGeometry>(); |
|
double area = 0; |
|
if (item.GeometryList == null) continue; |
|
foreach (IGeometry geo in item.GeometryList) |
|
{ |
|
//获取相交部分图形 |
|
IGeometry geo2 = FeatureAPI.InterSect(geo, pGeo); |
|
ITopologicalOperator2 topo2 = geo2 as ITopologicalOperator2; |
|
if (topo2 != null) |
|
{ |
|
topo2.Simplify(); |
|
} |
|
//feature.Shape = geo2; |
|
//将面积最大的插入到集合索引开始位置，方便后面继承属性取值 |
|
if ((geo2 as IArea) != null && (geo2 as IArea).Area > area) |
|
{ |
|
area = (geo2 as IArea).Area; |
|
newFeatureList.Insert(0, geo2); |
|
} |
|
else |
|
{ |
|
newFeatureList.Add(geo2); |
|
} |
|
} |
|
if (newFeatureList.Count == 0) |
|
{ |
|
continue; |
|
} |
|
//同坐落及权属的图斑合并 |
|
IGeometry MergeFeatuer = FeatureAPI.MergeGeometry(newFeatureList); |
|
if (MergeFeatuer != null && !MergeFeatuer.IsEmpty) |
|
{ |
|
result.Add(MergeFeatuer); |
|
} |
|
} |
|
#endregion |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
#endregion |
|
|
|
/// <summary> |
|
/// 线转面 |
|
/// </summary> |
|
/// <param name="pPolyline">线对象</param> |
|
/// <returns>IGeometry 面对象</returns> |
|
public static IGeometry ConstructPolygonFromPolyline(IPolyline pPolyline) |
|
{ |
|
IGeometry newGeometry = null; |
|
try |
|
{ |
|
IGeometryCollection pPolygonGeoCol = new PolygonClass(); |
|
if (pPolyline == null || pPolyline.IsEmpty) |
|
{ |
|
return pPolygonGeoCol as IGeometry; |
|
} |
|
IGeometryCollection pPolylineGeoCol = pPolyline as IGeometryCollection; |
|
ISegmentCollection pSegCol = new RingClass(); |
|
ISegment pSegment = null; |
|
object missing = Type.Missing; |
|
for (int i = 0; i < pPolylineGeoCol.GeometryCount; i++) |
|
{ |
|
ISegmentCollection pPolylineSegCol = pPolylineGeoCol.get_Geometry(i) as ISegmentCollection; |
|
for (int j = 0; j < pPolylineSegCol.SegmentCount; j++) |
|
{ |
|
pSegment = pPolylineSegCol.get_Segment(j); |
|
pSegCol.AddSegment(pSegment, ref missing, ref missing); |
|
} |
|
pPolygonGeoCol.AddGeometry(pSegCol as IGeometry, ref missing, ref missing); |
|
} |
|
newGeometry = pPolygonGeoCol as IGeometry; |
|
if (newGeometry != null && !newGeometry.IsEmpty) |
|
{ |
|
ITopologicalOperator topologicalOperator = newGeometry as ITopologicalOperator; |
|
if (!topologicalOperator.IsKnownSimple) |
|
{ |
|
topologicalOperator.Simplify(); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return newGeometry; |
|
} |
|
|
|
/// <summary> |
|
/// 拆分多部件要素 |
|
/// </summary> |
|
/// <param name="SelectedFeature">选中要素集合</param> |
|
public static void SplitMultipartFeature(List<IFeature> SelectedFeature) |
|
{ |
|
try |
|
{ |
|
foreach (IFeature item in SelectedFeature) |
|
{ |
|
IGeometry geo = item.ShapeCopy; |
|
ITopologicalOperator topologicalOperator = geo as ITopologicalOperator; |
|
if (topologicalOperator == null) continue; |
|
topologicalOperator.Simplify(); |
|
if (item.ShapeCopy.GeometryType == esriGeometryType.esriGeometryPolygon) |
|
{ |
|
#region |
|
//外环图形 |
|
GeometryBag ExterGeometryBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).ExteriorRingBag as GeometryBag; |
|
if (ExterGeometryBag == null) continue; |
|
//IGeometry firstGeo = null; |
|
IGeometryCollection ExterRingGeometryCollection = ExterGeometryBag as IGeometryCollection; |
|
for (int i = 0; i < ExterRingGeometryCollection.GeometryCount; i++) |
|
{ |
|
IGeometryCollection geometry = new ESRI.ArcGIS.Geometry.PolygonClass() as IGeometryCollection; |
|
IGeometry ExterGeometry = ExterRingGeometryCollection.get_Geometry(i); |
|
if (ExterGeometry != null && !ExterGeometry.IsEmpty) |
|
{ |
|
geometry.AddGeometry(ExterGeometry); |
|
} |
|
else |
|
{ |
|
continue; |
|
} |
|
//内环图形 |
|
IGeometryBag InteriorBag = (topologicalOperator as ESRI.ArcGIS.Geometry.IPolygon4).get_InteriorRingBag(ExterGeometry as IRing); |
|
if (InteriorBag != null) |
|
{ |
|
IGeometryCollection InteriorRingGeometryCollection = InteriorBag as IGeometryCollection; |
|
if (InteriorRingGeometryCollection == null) continue; |
|
for (int IG = 0; IG < InteriorRingGeometryCollection.GeometryCount; IG++) |
|
{ |
|
IGeometry interiorGeo = InteriorRingGeometryCollection.get_Geometry(IG); |
|
if (interiorGeo != null && !interiorGeo.IsEmpty) |
|
{ |
|
geometry.AddGeometry(interiorGeo); |
|
} |
|
} |
|
} |
|
if ((geometry as IGeometry) == null || (geometry as IGeometry).IsEmpty) |
|
{ |
|
continue; |
|
} |
|
if (i == 0) |
|
{ |
|
//firstGeo = geometry as IGeometry; |
|
item.Shape = geometry as IGeometry; |
|
item.Store(); |
|
} |
|
else |
|
{ |
|
IFeature newFeaturte = (item.Class as IFeatureClass).CreateFeature(); |
|
IFeatureEdit pFeatureEdit = item as IFeatureEdit; |
|
pFeatureEdit.SplitAttributes(newFeaturte); |
|
(geometry as IGeometry).SpatialReference = item.ShapeCopy.SpatialReference; |
|
newFeaturte.Shape = geometry as IGeometry; |
|
newFeaturte.Store(); |
|
} |
|
} |
|
//if (firstGeo != null) |
|
//{ |
|
// firstGeo.SpatialReference = item.ShapeCopy.SpatialReference; |
|
// item.Shape = firstGeo; |
|
// item.Store(); |
|
//} |
|
#endregion |
|
} |
|
else if (item.ShapeCopy.GeometryType == esriGeometryType.esriGeometryPolyline) |
|
{ |
|
#region |
|
IGeometryCollection pGeocoll = geo as IGeometryCollection; |
|
int geomcount = pGeocoll.GeometryCount; |
|
if (geomcount > 1) |
|
{ |
|
for (int k = 1; k < geomcount; k++) |
|
{ |
|
IFeature newFeaturte = (item.Class as IFeatureClass).CreateFeature(); |
|
IFeatureEdit pFeatureEdit = item as IFeatureEdit; |
|
pFeatureEdit.SplitAttributes(newFeaturte); |
|
IGeometry newGeom = pGeocoll.get_Geometry(k); |
|
IPointCollection points = newGeom as IPointCollection; |
|
IPointCollection line = new PolylineClass(); |
|
for (int i = 0; i < points.PointCount; i++) |
|
{ |
|
line.AddPoint(points.get_Point(i)); |
|
} |
|
newGeom = line as IGeometry; |
|
newGeom.SpatialReference = item.ShapeCopy.SpatialReference; |
|
newFeaturte.Shape = newGeom; |
|
newFeaturte.Store(); |
|
} |
|
IGeometry newGeom2 = pGeocoll.get_Geometry(0); |
|
IPointCollection points2 = newGeom2 as IPointCollection; |
|
IPointCollection line2 = new PolylineClass(); |
|
for (int i = 0; i < points2.PointCount; i++) |
|
{ |
|
line2.AddPoint(points2.get_Point(i)); |
|
} |
|
newGeom2 = line2 as IGeometry; |
|
newGeom2.SpatialReference = item.ShapeCopy.SpatialReference; |
|
if (newGeom2 != null && !newGeom2.IsEmpty) |
|
item.Shape = newGeom2; |
|
item.Store(); |
|
} |
|
#endregion |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 弧形（弧线和弧面）形折线化：按70米对弧线增加内差点（等分点） |
|
/// </summary> |
|
/// <param name="newGeometry">需要折线化的图形</param> |
|
/// <returns>返回当前图形是否包含弧线:true:表示包含弧线 false:表示不包含弧线</returns> |
|
public static bool ArcToPolyline(ref IGeometry newGeometry) |
|
{ |
|
bool ContainsArcs = false; |
|
try |
|
{ |
|
if (newGeometry == null || newGeometry.IsEmpty) |
|
{ |
|
return false; |
|
} |
|
ESRI.ArcGIS.Geometry.ISegmentCollection segmentCollection = newGeometry as ESRI.ArcGIS.Geometry.ISegmentCollection; |
|
if (segmentCollection == null || segmentCollection.SegmentCount <= 0) |
|
{ |
|
return false; |
|
} |
|
for (int i = 0; i < segmentCollection.SegmentCount; i++) |
|
{ |
|
ISegment segment = segmentCollection.Segment[i]; |
|
//圆弧，椭圆弧，贝塞尔弧 |
|
if (segment.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryCircularArc || segment.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryEllipticArc || segment.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryBezier3Curve) |
|
{ |
|
ContainsArcs = true; |
|
if (segmentCollection.Segment[i].Length > 70) |
|
{ |
|
int cutCount = (int)(Math.Ceiling(segment.Length / 70)); |
|
ICurve curve = segment as ICurve; |
|
IPointCollection polyline = new Polyline() as IPointCollection; |
|
IConstructMultipoint constructMultipoint = new Multipoint() as IConstructMultipoint; |
|
constructMultipoint.ConstructDivideEqual(curve, cutCount); |
|
polyline.SetPointCollection((constructMultipoint as IPointCollection)); |
|
segmentCollection.ReplaceSegmentCollection(i, 1, (polyline as ISegmentCollection)); |
|
//SegmentCollection.RemoveSegments(i, 1, false); |
|
//SegmentCollection.InsertSegmentCollection(1, (polyline as ISegmentCollection)); |
|
//pFeature.Shape = SegmentCollection as IGeometry; |
|
} |
|
else |
|
{ |
|
IPolyline polyline = new PolylineClass() { FromPoint = segment.FromPoint, ToPoint = segment.ToPoint, SpatialReference = newGeometry.SpatialReference }; |
|
segmentCollection.ReplaceSegmentCollection(i, 1, (polyline as ISegmentCollection)); |
|
//segmentCollection.RemoveSegments(i, 1, false); |
|
//segmentCollection.in(1, (polyline as ISegmentCollection)); |
|
} |
|
} |
|
else |
|
{ |
|
continue; |
|
} |
|
} |
|
if (ContainsArcs) |
|
{ |
|
newGeometry = (segmentCollection as IGeometry); |
|
ITopologicalOperator topological = newGeometry as ITopologicalOperator; |
|
if (!topological.IsKnownSimple) |
|
{ |
|
topological.Simplify(); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return ContainsArcs; |
|
} |
|
|
|
/// <summary> |
|
/// 给弧形(弧线和弧面)附近相交的图形折线化加点 |
|
/// </summary> |
|
/// <param name="feature">当前弧形要素</param> |
|
/// <param name="featureLayer">弧形所在的图层：此方法是针对的面图层</param> |
|
public static void AddFeaturePoint(IFeature feature, IFeatureLayer featureLayer) |
|
{ |
|
try |
|
{ |
|
if (featureLayer == null || featureLayer.FeatureClass == null) |
|
{ |
|
throw new Exception("图层不能为空！"); |
|
} |
|
if (featureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolygon || feature.Shape.GeometryType != esriGeometryType.esriGeometryPolygon) |
|
{ |
|
throw new Exception("图层或图形不是面图层！"); |
|
} |
|
bool isSplit; |
|
int splitIndex, segIndex; |
|
IIdentify identify = featureLayer as IIdentify; |
|
IArray iarray = identify.Identify(feature.ShapeCopy); |
|
IGeometry currentGeometry = feature.ShapeCopy; |
|
for (int i = 0; i < iarray.Count; i++) |
|
{ |
|
IFeatureIdentifyObj pFeatIdObj = iarray.get_Element(i) as IFeatureIdentifyObj; |
|
IRowIdentifyObject pRowObj = pFeatIdObj as IRowIdentifyObject; |
|
IFeature newFeature = pRowObj.Row as IFeature; |
|
if (newFeature.OID == feature.OID || newFeature == null || newFeature.Shape.IsEmpty) |
|
{ |
|
continue; |
|
} |
|
newFeature.Shape.SpatialReference = currentGeometry.SpatialReference; |
|
ITopologicalOperator topological = newFeature.ShapeCopy as ITopologicalOperator; |
|
IPolyline pPolyline = topological.Boundary as IPolyline; |
|
//判断图形是否相交 |
|
if (!FeatureAPI.IsInterSect(currentGeometry, newFeature.ShapeCopy)) |
|
{ |
|
IRelationalOperator relationalOperator = currentGeometry as IRelationalOperator; |
|
//判断图形是否有共边 |
|
if (!relationalOperator.Touches(newFeature.ShapeCopy)) |
|
{ |
|
continue; |
|
} |
|
} |
|
//newGeometry = KGIS.Framework.AE.FeatureAPI.Difference(newGeometry, newFeature.ShapeCopy); |
|
IPointCollection pointCollection = currentGeometry as IPointCollection; |
|
for (int j = 0; j < pointCollection.PointCount; j++) |
|
{ |
|
IGeometry geo = InterSect(newFeature.ShapeCopy as IGeometry, pointCollection.get_Point(j) as IGeometry); |
|
if (geo != null && !geo.IsEmpty) |
|
{ |
|
pPolyline.SplitAtPoint(pointCollection.get_Point(j), false, false, out isSplit, out splitIndex, out segIndex); |
|
} |
|
//else |
|
//{ |
|
// IRelationalOperator relationalOperator = pointCollection.get_Point(j) as IRelationalOperator; |
|
// string relationDescription = "RELATE(G1, G2, 'T********')"; |
|
// bool isIntersects = relationalOperator.Relation(pPolyline, relationDescription); |
|
// if (!isIntersects) |
|
// { |
|
// continue; |
|
// } |
|
// //判断图形是否有共边 |
|
// //if (!relationalOperator.Overlaps(pointCollection.get_Point(j))&& !relationalOperator.Contains(pointCollection.get_Point(j))) |
|
// //{ |
|
// // continue; |
|
// //} |
|
// pPolyline.SplitAtPoint(pointCollection.get_Point(j), false, false, out isSplit, out splitIndex, out segIndex); |
|
//} |
|
} |
|
IGeometry geometry = pPolyline; |
|
FeatureAPI.ArcToPolyline(ref geometry); |
|
newFeature.Shape = ConstructPolygonFromPolyline(geometry as IPolyline); |
|
newFeature.Store(); |
|
} |
|
} |
|
catch (Exception) |
|
{ |
|
throw; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 判断两个图形是否一样 |
|
/// </summary> |
|
/// <param name="pGeo1"></param> |
|
/// <param name="pGeo2"></param> |
|
/// <returns></returns> |
|
public static bool GetEqual(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
ITopologicalOperator topological = pGeo1 as ITopologicalOperator; |
|
if (topological != null && !topological.IsKnownSimple) |
|
{ |
|
topological.Simplify(); |
|
} |
|
ITopologicalOperator topological2 = pGeo2 as ITopologicalOperator; |
|
if (topological2 != null && !topological2.IsKnownSimple) |
|
{ |
|
topological2.Simplify(); |
|
} |
|
IRelationalOperator relational = pGeo1 as IRelationalOperator; |
|
if (relational != null) |
|
{ |
|
return relational.Contains(pGeo2); |
|
} |
|
return false; |
|
} |
|
|
|
/// <summary> |
|
/// 求目标图形与指定图形不相交部分 |
|
/// </summary> |
|
/// <param name="pGeo1">目标多边形</param> |
|
/// <param name="pGeo2">指定的图形</param> |
|
/// <returns></returns> |
|
public static IGeometry Union(IGeometry pGeo1, IGeometry pGeo2) |
|
{ |
|
try |
|
{ |
|
IGeometry result = null; |
|
if (pGeo1 == null || pGeo2 == null) |
|
return null; |
|
ITopologicalOperator topo = pGeo1 as ITopologicalOperator; |
|
if (topo != null) |
|
{ |
|
topo.Simplify(); |
|
result = topo.Union(pGeo2); |
|
ITopologicalOperator resTopo = result as ITopologicalOperator; |
|
resTopo.Simplify(); |
|
return result; |
|
} |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
} |
|
|
|
partial class FeatureInfo |
|
{ |
|
/// <summary> |
|
/// 坐落单位代码 |
|
/// </summary> |
|
public string ZLDWDM { get; set; } |
|
/// <summary> |
|
/// 权属单位代码 |
|
/// </summary> |
|
public string QSDWDM { get; set; } |
|
/// <summary> |
|
/// 要素集合 |
|
/// </summary> |
|
public List<IFeature> FeatureList { get; set; } |
|
/// <summary> |
|
/// 图形集合 |
|
/// </summary> |
|
public List<IGeometry> GeometryList { get; set; } |
|
} |
|
}
|
|
|