/// <summary>
/// 简化几何形状
/// 对传入的几何形状直接进行简化
/// 主要在编辑时使用
/// </summary>
/// <param name="geometry">需要被简化的几何形状</param>
public static void Simplify(IGeometry geometry)
{
if (geometry != null)
{
if (geometry is ITopologicalOperator2)
{
ITopologicalOperator2 topoOp = geometry as ITopologicalOperator2;
topoOp.IsKnownSimple_2 = false;
switch (geometry.GeometryType)
{
case esriGeometryType.esriGeometryPolygon:
{
IPolygon poly = (IPolygon)geometry;
poly.SimplifyPreserveFromTo();
break;
}
case esriGeometryType.esriGeometryPolyline:
{
IPolyline polyLineGeom = (IPolyline)geometry;
polyLineGeom.SimplifyNetwork();
break;
}
default:
{
topoOp.Simplify();
break;
}
}
}
}
}
/// <summary>
/// 求面的并
/// </summary>
/// <param name="taskLayout"></param>
/// <param name="satelliteResault"></param>
/// <returns></returns>
public static IPolygon UnionPolygon(IPolygon polygonOne, IPolygon polygonTwo)
{
try
{
if (polygonOne == null && polygonTwo != null)
{
return(polygonTwo);
}
else if (polygonOne != null && polygonTwo == null)
{
return(polygonOne);
}
else
{
ITopologicalOperator2 pTopologicalOperator = polygonOne as ITopologicalOperator2;
IGeometry pGeometry =
pTopologicalOperator.Union(polygonTwo) as IGeometry;
if (!pGeometry.IsEmpty)
{
IPolygon unionPolygon = pGeometry as IPolygon;
return(unionPolygon);
}
else
{
return(null);
}
}
}
catch (System.Exception ex)
{
return(null);
}
}
//获取矿界
private IPolygon GetPolygon()
{
IPolygon polygon2 = null;
ILayer pLayer = DataEditCommon.GetLayerByName(DataEditCommon.g_pMap, LayerNames.LAYER_ALIAS_MINE_BOUNDARY);
IFeatureLayer polygonLayer = (IFeatureLayer)pLayer;
IQueryFilter filter = new QueryFilterClass();
filter.WhereClause = "layer = '预警矿界'";
IFeatureLayer featureLayer = polygonLayer as IFeatureLayer;
IFeatureCursor featureCursor = featureLayer.Search(filter, false);
ITopologicalOperator2 topologicalOperator = null;
// 获得矿界组合成面
if (featureCursor != null)
{
ISegmentCollection polygon = new PolygonClass();
IFeature feature = featureCursor.NextFeature();
while (feature != null)
{
polygon.AddSegmentCollection((ISegmentCollection)feature.Shape);
feature = featureCursor.NextFeature();
}
topologicalOperator = (ITopologicalOperator2)polygon;
topologicalOperator.IsKnownSimple_2 = true;
topologicalOperator.Simplify();
polygon2 = (IPolygon)topologicalOperator;
}
return(polygon2);
}
/// <summary>
/// 验证是否自相交
/// </summary>
/// <param name="polyline">The polyline.</param>
/// <returns>如果自相交，则为true，反之为false</returns>
public static bool IsSelfCross(this IPolyline polyline)
{
var isSelfCross = false;
if (polyline == null)
{
return(isSelfCross);
}
ITopologicalOperator2 topological = polyline as ITopologicalOperator2;
topological.IsKnownSimple_2 = false;
bool bol = topological.IsSimple;
// 注意,下面的两次取值,不重复,若删除,则判断将会产生错误
bol = topological.IsSimple;
if (bol == false)
{
isSelfCross = true;
}
else
{
isSelfCross = false;
}
return(isSelfCross);
}
/// 合并列表中所有多边形
/// </summary>
/// <param name="orifeature">保留源对象</param>
/// <param name="geolist">图形列表</param>
/// <returns></returns>
public void CreatePolygonFromExistingGeometries(IFeatureLayer lyr, IFeature orifeature, List <IGeometry> geolist)
{
int i = 0;
IGeometry geometry = null;
IFeatureClass Featureclass = lyr.FeatureClass;
IWorkspaceEdit workspace = (IWorkspaceEdit)(Featureclass as IDataset).Workspace;
workspace.StartEditing(false);
workspace.StartEditOperation();
//合并图形
ITopologicalOperator2 topologicalOperator2 = orifeature.ShapeCopy as ITopologicalOperator2;
for (i = 0; i < geolist.Count; i++)
{
IGeometry geo = geolist[i];
if (geometry != null)
{
topologicalOperator2 = geometry as ITopologicalOperator2;
}
ITopologicalOperator opertor = geo as ITopologicalOperator;
opertor.Simplify();
topologicalOperator2.IsKnownSimple_2 = false;
topologicalOperator2.Simplify();
geometry = topologicalOperator2.Union(geo);
}
//更新图形对象
IGeometry geoCombined = (IGeometry)geometry;
orifeature.Shape = geoCombined as IGeometry;
orifeature.Store();
workspace.StopEditOperation();
workspace.StopEditing(true);
}
//<CSCM>
//********************************************************************************
//** 函 数 名: CutFeatByGeometry
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 根据传入的图形,剪切需要被剪切的要素
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 2006-10-13
//** 参数列表: pOriGeometry (IGeometry)'需要被剪切的要素
// pRefGeometry (IGeometry)'参照要素
// EnumGeometryDimension (esriGeometryDimension)'返回的图形的维数
// 线:esriGeometry1Dimension 用于面剪切线;
// 面:esriGeometry2Dimension 用于面剪切面
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IGeometry CutFeatByGeometry(ref IGeometry pOriGeometry, ref IGeometry pRefGeometry, ref esriGeometryDimension EnumGeometryDimension)
{
IGeometry functionReturnValue = default(IGeometry);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
ITopologicalOperator2 pTopoOperator2 = default(ITopologicalOperator2);
//原要素和参照要素相交的部分
IGeometry pGeometry = default(IGeometry);
// ERROR: Not supported in C#: OnErrorStatement
try
{
pTopoOperator = (ITopologicalOperator2)pRefGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
pTopoOperator2 = (ITopologicalOperator2)pOriGeometry;
pTopoOperator2.IsKnownSimple_2 = false;
pTopoOperator2.Simplify();
//根据不同的需要返回点,线,面等相交的部分
pGeometry = pTopoOperator2.Intersect((IGeometry)pTopoOperator, EnumGeometryDimension);
pTopoOperator = (ITopologicalOperator2)pGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
functionReturnValue = (IGeometry)pTopoOperator;
return(functionReturnValue);
}
catch (Exception)
{
functionReturnValue = null;
return(functionReturnValue);
}
}
//<CSCM>
//********************************************************************************
//** 函 数 名: IntersectTwoGeometry
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 二个图形求差
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 20070818
//** 参数列表: pOriGeometry (IGeometry)
// pDesGeometry (IGeometry)
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IGeometry IntersectTwoGeometry(IGeometry pOriGeometry, IGeometry pDesGeometry)
{
IGeometry functionReturnValue = default(IGeometry);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
ITopologicalOperator2 pTopoOperator2 = default(ITopologicalOperator2);
IGeometry pGeometry = default(IGeometry);
// ERROR: Not supported in C#: OnErrorStatement
try
{
pTopoOperator = (ITopologicalOperator2)pOriGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
pTopoOperator2 = (ITopologicalOperator2)pDesGeometry;
pTopoOperator2.IsKnownSimple_2 = false;
pTopoOperator2.Simplify();
pGeometry = pTopoOperator.Intersect((IGeometry)pTopoOperator2, esriGeometryDimension.esriGeometry2Dimension);
pTopoOperator = (ITopologicalOperator2)pGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
functionReturnValue = (IGeometry)pTopoOperator;
return(functionReturnValue);
}
catch (Exception)
{
functionReturnValue = null;
return(functionReturnValue);
}
}
public void OnMouseDown(int button, int shift, int x, int y)
{
try
{
IPoint point = this._hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
IFeatureClass featureClass = Editor.UniqueInstance.TargetLayer.FeatureClass;
ISpatialFilter queryFilter = new SpatialFilterClass {
Geometry = point,
GeometryField = featureClass.ShapeFieldName,
SubFields = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelWithin
};
IFeatureCursor o = Editor.UniqueInstance.TargetLayer.Search(queryFilter, false);
IFeature feature = o.NextFeature();
Marshal.ReleaseComObject(o);
o = null;
if ((feature != null) && (feature.OID != this._feature.OID))
{
feature = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(feature.OID);
ITopologicalOperator2 shape = this._feature.Shape as ITopologicalOperator2;
shape.IsKnownSimple_2 = false;
shape.Simplify();
shape = feature.Shape as ITopologicalOperator2;
shape.IsKnownSimple_2 = false;
shape.Simplify();
shape = shape.Union(this._feature.Shape) as ITopologicalOperator2;
shape.IsKnownSimple_2 = false;
shape.Simplify();
Editor.UniqueInstance.StartEditOperation();
Editor.UniqueInstance.AddAttribute = false;
List <IFeature> pFeatureList = new List <IFeature> {
this._feature,
feature
};
IFeature resultFeature = Editor.UniqueInstance.TargetLayer.FeatureClass.CreateFeature();
resultFeature.Shape = shape as IGeometry;
if (AttributeManager.AttributeCombineHandleClass.AttributeCombine(pFeatureList, ref resultFeature) == DialogResult.OK)
{
resultFeature.Store();
foreach (IFeature feature3 in pFeatureList)
{
feature3.Delete();
}
IFeatureSelection targetLayer = Editor.UniqueInstance.TargetLayer as IFeatureSelection;
targetLayer.Clear();
targetLayer.Add(resultFeature);
this._hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, Editor.UniqueInstance.TargetLayer, resultFeature.Extent);
}
Editor.UniqueInstance.StopEditOperation("combineex");
}
}
catch (Exception exception)
{
Editor.UniqueInstance.AbortEditOperation();
this._mErrOpt.ErrorOperate(this._mSubSysName, "ShapeEdit.CombineEx", "OnMouseDown", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
}
}
//<CSCM>
//********************************************************************************
//** 函 数 名: GetCursorByFieldAndValue
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 给出查询信息后,返回一个满足范围的光标
//
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 20070817
//** 参数列表: sValue (String)
// sFieldName (String)
// pFeatCls (IFeatureClass)
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IFeatureCursor GetFeatCursor(IFeatureClass pFeatCls, string sSQLExpress, esriSpatialRelEnum EnumSpatialRel,
ref IGeometry pDomainGeometry, bool bGetFeatCount, ref long lFeatCount)
{
//sSQLExpress = "";
//EnumSpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//pDomainGeometry = null;
//bGetFeatCount = false;
//lFeatCount = 0;
IFeatureCursor functionReturnValue = default(IFeatureCursor);
ISpatialFilter pSpatialfilter = default(ISpatialFilter);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
IFeatureCursor pFeatCursor = default(IFeatureCursor);
// ERROR: Not supported in C#: OnErrorStatement
try
{
if (pFeatCls == null)
{
functionReturnValue = null;
return(functionReturnValue);
}
pSpatialfilter = new SpatialFilter();
pSpatialfilter.WhereClause = sSQLExpress;
//范围一起查询,提高查询效率
if (pDomainGeometry != null)
{
pTopoOperator = (ITopologicalOperator2)pDomainGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
pSpatialfilter.Geometry = (IGeometry)pTopoOperator;
pSpatialfilter.SpatialRel = EnumSpatialRel;
}
//获得一个新的选择集
pFeatCursor = pFeatCls.Search(pSpatialfilter, false);
//如果需要获得要满足条件的个数，则获得
if (bGetFeatCount)
{
lFeatCount = pFeatCls.FeatureCount(pSpatialfilter);
}
functionReturnValue = pFeatCursor;
return(functionReturnValue);
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode == -2147216117)
{
MessageBoxEx.Show("失去了与SDE服务器的连接,提取失败！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
}
functionReturnValue = null;
return(functionReturnValue);
}
}
private void TrimPolyline(IFeature trimFeature, IFeature targetFeature, IPoint secondPoint)
{
IGeometry preservedGeom = null;
IGeometry leftGeom = null;
IGeometry rightGeom = null;
double distanceOnCurve = 0;
double nearestDistance = 0;
bool isRightSide = false;
IPoint outPoint = new PointClass();
IFeatureClass featureClass = trimFeature.Class as IFeatureClass;
IDataset dataset = featureClass as IDataset;
IWorkspaceEdit workspaceEdit = dataset.Workspace as IWorkspaceEdit;
if (!(workspaceEdit.IsBeingEdited()))
{
return;
}
try
{ IGeometry targetGeometry = targetFeature.ShapeCopy;
IGeometry trimGeometry = trimFeature.ShapeCopy;
ITopologicalOperator2 topo = trimGeometry as ITopologicalOperator2;
topo.IsKnownSimple_2 = false;
topo.Simplify();
ITopologicalOperator2 topo2 = targetGeometry as ITopologicalOperator2;
topo2.IsKnownSimple_2 = false;
topo2.Simplify();
topo.Cut(targetGeometry as IPolyline, out leftGeom, out rightGeom);
ICurve curve = targetGeometry as ICurve;
curve.QueryPointAndDistance(esriSegmentExtension.esriNoExtension, secondPoint, false, outPoint, ref distanceOnCurve, ref nearestDistance, ref isRightSide);
if (isRightSide)
{
preservedGeom = leftGeom;
}
else
{
preservedGeom = rightGeom;
}
workspaceEdit.StartEditOperation();
trimFeature.Shape = preservedGeom;
trimFeature.Store();
workspaceEdit.StopEditOperation();
FlashGeometry(trimGeometry as IGeometry, 3, 10); }
catch (Exception ex)
{
workspaceEdit.AbortEditOperation();
MessageBox.Show("线要素延伸失败！！" + ex.Message, "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
private double[][] EdgeCorrection(int intNFeatureCount, int intNDistBnd, IFeature pFeature, double[,] arrXYPts, double dblDistInc, double dblBeginDist)
{
double[][] dblWeightCnt = new double[intNFeatureCount][];
ITopologicalOperator2 pTopoOpt = (ITopologicalOperator2)pFeature.ShapeCopy;
for (int i = 0; i < intNFeatureCount; i++)
{
IPoint pFromPts = new PointClass();
pFromPts.X = arrXYPts[i, 0];
pFromPts.Y = arrXYPts[i, 1];
dblWeightCnt[i] = new double[intNDistBnd];
ITopologicalOperator pTopoBuffer = pFromPts as ITopologicalOperator;
for (int l = intNDistBnd; l > 0; l--)
{
if (l == intNDistBnd)
{
double dblWeight = 0;
double dblRefDist = l * dblDistInc + dblBeginDist;
IPolygon polygon = pTopoBuffer.Buffer(dblRefDist) as IPolygon;
IArea pPolyArea = polygon as IArea;
IArea pIntersectedArea = (IArea)pTopoOpt.Intersect(polygon, esriGeometryDimension.esriGeometry2Dimension);
dblWeight = pIntersectedArea.Area / pPolyArea.Area;
dblWeightCnt[i][l - 1] = dblWeight;
}
else
{
if (dblWeightCnt[i][l] != 1)
{
double dblWeight = 0;
double dblRefDist = l * dblDistInc + dblBeginDist;
IPolygon polygon = pTopoBuffer.Buffer(dblRefDist) as IPolygon;
IArea pPolyArea = polygon as IArea;
IArea pIntersectedArea = (IArea)pTopoOpt.Intersect(polygon, esriGeometryDimension.esriGeometry2Dimension);
dblWeight = pIntersectedArea.Area / pPolyArea.Area;
dblWeightCnt[i][l - 1] = dblWeight;
}
else
{
dblWeightCnt[i][l - 1] = 1;
}
}
}
}
//if (dblWeightCnt[l - 1] < 0.5)
// MessageBox.Show("11");
return(dblWeightCnt);
}
//<CSCM>
//********************************************************************************
//** 函 数 名: getFeatSelection
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 由非标准的sSQL表达式获得选择集,如果SQL为空的话,默认选择要素类内的所有要素
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 20070813
//** 参数列表: pFeatSelection (IFeatureSelection)传入的选择集,
// sSQLExpress (String)
// pDomainGeometry 如果有范围的时和范围一起进行查寻,提高效率
// EnumSelectMethod 选择方式:添加,新建等
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IFeatureSelection GetFeatSelection(ref IFeatureLayer pFeatLayer, string sSQLExpress, esriSelectionResultEnum EnumSelectMethod, esriSpatialRelEnum EnumSpatialRel, ref IGeometry pDomainGeometry)
{
//sSQLExpress = "";
//EnumSelectMethod = esriSelectionResultEnum.esriSelectionResultNew;
//EnumSpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//pDomainGeometry = null;
IFeatureSelection functionReturnValue = default(IFeatureSelection);
ISpatialFilter pSpatialfilter = default(ISpatialFilter);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
IFeatureSelection pFeatSelection = default(IFeatureSelection);
// ERROR: Not supported in C#: OnErrorStatement
try
{
if (pFeatLayer == null)
{
functionReturnValue = null;
return(functionReturnValue);
}
pFeatSelection = (IFeatureSelection)pFeatLayer;
pSpatialfilter = new SpatialFilter();
pSpatialfilter.WhereClause = sSQLExpress;
//范围一起查询,提高查询效率
if (pDomainGeometry != null)
{
pTopoOperator = (ITopologicalOperator2)pDomainGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
pSpatialfilter.Geometry = (IGeometry)pTopoOperator;
pSpatialfilter.SpatialRel = EnumSpatialRel;
}
//获得一个新的选择集
pFeatSelection.SelectFeatures(pSpatialfilter, EnumSelectMethod, false);
functionReturnValue = pFeatSelection;
return(functionReturnValue);
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode == -2147216117)
{
MessageBoxEx.Show("失去了与SDE服务器的连接,提取失败！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
}
functionReturnValue = null;
return(functionReturnValue);
}
}
//public List<ErrorEntity> CheckOverLap(string idname,IFeatureLayer pLayer)
//{
// ArrayList arraylist = new ArrayList();
// IQueryFilter filter = new QueryFilterClass();
// filter.SubFields = pLayer.FeatureClass.OIDFieldName + "," + pLayer.FeatureClass.ShapeFieldName;
// IFeatureCursor cursor = pLayer.FeatureClass.Search(filter, true);
// List<ErrorEntity> listErrorEntity = new List<ErrorEntity>();
// IFeature pFeature = null;
// IFeature feature;
// while ((pFeature = cursor.NextFeature()) != null)
// {
// ITopologicalOperator2 @operator = (ITopologicalOperator2)pFeature.ShapeCopy;
// @operator.IsKnownSimple_2 = false;
// @operator.Simplify();
// IIdentify pIdentify = pLayer as IIdentify;
// IArray pIDs = pIdentify.Identify((IGeometry)pFeature.ShapeCopy);
// if (pIDs != null && pIDs.Count > 1)
// {
// //取第一个实体
// for (int i = 0; i < pIDs.Count; i++)
// {
// feature = (pIDs.get_Element(i) as IRowIdentifyObject).Row as IFeature;
// if (feature != null && pFeature.OID != feature.OID && (!arraylist.Contains(pFeature.OID + "" + feature.OID) && !arraylist.Contains(feature.OID + "" + pFeature.OID)))
// {
// arraylist.Add(pFeature.OID + "" + feature.OID);
// IGeometry item = feature.ShapeCopy;
// IGeometry geometry3 = @operator.Intersect(item, esriGeometryDimension.esriGeometry2Dimension);
// if (!geometry3.IsEmpty)
// {
// Console.WriteLine(pFeature.OID + "-" + feature.OID);
// listErrorEntity.Add(new ErrorEntity(idname, pFeature.OID.ToString(), "自重叠", feature.OID.ToString(), ErrType.OverLap, geometry3));
// }
// }
// }
// }
// }
// return listErrorEntity;
//}
public List <ErrorEntity> CheckOverLap(string idname, IFeatureLayer pLayer)
{
List <ErrorEntity> listErrorEntity = new List <ErrorEntity>();
IFeatureClass IN_FeatureClass = pLayer.FeatureClass;
IList <IGeometry> list = new List <IGeometry>();
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.GeometryField = IN_FeatureClass.ShapeFieldName;
spatialFilter.SubFields = IN_FeatureClass.OIDFieldName + "," + IN_FeatureClass.ShapeFieldName;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelOverlaps;
IFeatureCursor pFeatureCursor = IN_FeatureClass.Search(null, false);
IFeature pFeature = pFeatureCursor.NextFeature();
while (pFeature != null)
{//记录集循环
spatialFilter.Geometry = pFeature.ShapeCopy;
IFeatureCursor featureCursor = IN_FeatureClass.Search(spatialFilter, true);
IFeature tFeature = featureCursor.NextFeature();//遍历查询结果
if (tFeature != null)
{
IGeometry pGeometry = new PolygonClass();
pGeometry = tFeature.ShapeCopy;
while (tFeature != null)
{
ITopologicalOperator2 iUnionTopo = pGeometry as ITopologicalOperator2;
pGeometry = iUnionTopo.Union(tFeature.Shape);
tFeature = featureCursor.NextFeature();//移动到下一条记录
}
ITopologicalOperator2 pRo = (ITopologicalOperator2)pFeature.ShapeCopy;
IGeometry pIntersectGeo = new PolygonClass();
pIntersectGeo = pRo.Intersect(pGeometry, esriGeometryDimension.esriGeometry2Dimension) as IPolygon;
if (pIntersectGeo != null && !pIntersectGeo.IsEmpty)
{
listErrorEntity.Add(new ErrorEntity(idname, pFeature.OID.ToString(), "自重叠", "", ErrType.OverLap, pIntersectGeo));
}
}
Marshal.ReleaseComObject(featureCursor);
pFeature = pFeatureCursor.NextFeature();//移动到下一条记录
}
Marshal.ReleaseComObject(pFeature);
Marshal.ReleaseComObject(spatialFilter);
return(listErrorEntity);
}
private void InitOtherLayer(IGeometry pGeo)
{
if (this._linkLayers != null)
{
ISpatialFilter filter = new SpatialFilterClass {
Geometry = pGeo
};
foreach (IFeatureLayer layer in this._linkLayers)
{
if (layer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
filter.SubFields = layer.FeatureClass.ShapeFieldName;
filter.GeometryField = layer.FeatureClass.ShapeFieldName;
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
IFeatureCursor o = layer.FeatureClass.Search(filter, false);
IFeature pFeature = o.NextFeature();
IFeature feature2 = o.NextFeature();
IFeature feature3 = o.NextFeature();
Marshal.ReleaseComObject(o);
o = null;
if (((pFeature != null) && (feature2 != null)) && (feature3 == null))
{
ITopologicalOperator2 shapeCopy = pFeature.ShapeCopy as ITopologicalOperator2;
shapeCopy.IsKnownSimple_2 = false;
shapeCopy.Simplify();
shapeCopy = feature2.ShapeCopy as ITopologicalOperator2;
shapeCopy.IsKnownSimple_2 = false;
shapeCopy.Simplify();
if (!shapeCopy.Intersect(pFeature.ShapeCopy, esriGeometryDimension.esriGeometry1Dimension).IsEmpty)
{
IRelationalOperator operator2 = shapeCopy.Union(pFeature.ShapeCopy) as IRelationalOperator;
if (operator2.Contains(this._editBound))
{
this._las.Add(new LinkArgs(pFeature));
this._las.Add(new LinkArgs(feature2));
Marshal.ReleaseComObject(o);
o = null;
}
}
}
}
}
}
}
/// <summary>
/// 简化几何形状
/// 不直接对传入的几何形状进行简化，而是克隆传入参数再进行简化出结果
/// 主要在编辑时使用
/// </summary>
/// <param name="geometry">需要被简化的几何形状</param>
/// <returns>简化后的几何形状</returns>
public static IGeometry QuerySimplify(IGeometry geometry)
{
if (geometry == null)
{
return(null);
}
else
{
IGeometry geom = (geometry as IClone).Clone() as IGeometry;
if (geom is ITopologicalOperator2)
{
ITopologicalOperator2 topoOp = geom as ITopologicalOperator2;
topoOp.IsKnownSimple_2 = false;
switch (geom.GeometryType)
{
case esriGeometryType.esriGeometryPolygon:
{
IPolygon poly = (IPolygon)geom;
poly.SimplifyPreserveFromTo();
return(poly);
}
case esriGeometryType.esriGeometryPolyline:
{
IPolyline polyLineGeom = (IPolyline)geom;
polyLineGeom.SimplifyNetwork();
return(polyLineGeom);
}
default:
{
topoOp.Simplify();
return((IGeometry)topoOp);
}
}
}
else
{
return(geometry);
}
}
}
/// <summary>
/// 对地类图斑进行拓扑纠正
/// </summary>
public void SimplifyDLTB()
{
IFeatureCursor dltbCursor = pDLTBFeatureLayer.FeatureClass.Search(null, true);
IFeature feature = dltbCursor.NextFeature();
while (feature != null)
{
ITopologicalOperator2 pTopo = (ITopologicalOperator2)feature.ShapeCopy;
//if (pTopo.IsSimple)
//{
// feature = dltbCursor.NextFeature();
// continue;
//}
pTopo.IsKnownSimple_2 = false;
pTopo.Simplify();
feature.Shape = pTopo as IGeometry;
feature.Store();
feature = dltbCursor.NextFeature();
}
Marshal.ReleaseComObject(dltbCursor);
}
public override void OnMouseDown(int Button, int Shift, int X, int Y)
{
if (Button != 1)
{
return;
}
IMapControl2 pMapCtl = m_hookHelper.Hook as IMapControl2;
ESRI.ArcGIS.Geometry.IGeometry pGeometry = null;
pGeometry = pMapCtl.TrackLine();//控件画线
if (pGeometry == null)
{
return;
}
//简化拓扑
ITopologicalOperator2 topoOperator = pGeometry as ITopologicalOperator2;
topoOperator.IsKnownSimple_2 = false;
topoOperator.Simplify();
splitFeature(pGeometry);
}
/// <summary>
/// 获得当前视图上的选择要素
/// </summary>
/// <param name="pMap"></param>
/// <returns></returns>
private IGeometry ConstructUnion(IMap pMap)
{
ISelection pSelection = pMap.FeatureSelection;
//
IEnumFeature pEnumFeature = pSelection as IEnumFeature;
IFeature pFeature = pEnumFeature.Next();
//考虑到有点 线 面的情况 所以只选第一个要素
if (pFeature == null)
{
return(null);
}
IGeometry pGeometry = pFeature.ShapeCopy;
ITopologicalOperator2 pTopo2 = pGeometry as ITopologicalOperator2;
pTopo2.IsKnownSimple_2 = false;
pTopo2.Simplify();
return(pTopo2 as IGeometry);
}
public void OnMouseUp(int button, int shift, int x, int y)
{
if (button != 2)
{
IPoint pPoint = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
IEnvelope searchEnvelope = FeatureFuncs.GetSearchEnvelope(this.m_hookHelper.ActiveView, pPoint);
IFeature feature = FeatureFuncs.SearchFeatures(Editor.UniqueInstance.TargetLayer, searchEnvelope, esriSpatialRelEnum.esriSpatialRelIntersects).NextFeature();
if (feature != null)
{
ITopologicalOperator2 shape = feature.Shape as ITopologicalOperator2;
Editor.UniqueInstance.StartEditOperation();
shape.IsKnownSimple_2 = false;
shape.Simplify();
Editor.UniqueInstance.StopEditOperation("simplify");
IActiveView activeView = this.m_hookHelper.ActiveView;
IFeatureSelection targetLayer = Editor.UniqueInstance.TargetLayer as IFeatureSelection;
targetLayer.Clear();
targetLayer.Add(feature);
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, null, null);
}
}
}
internal static List <IGeometry> spatialIntersect(IGeometry pGeometry, List <IGeometry> inputGeometryList)
{
List <IGeometry> resultGeoList = new List <IGeometry>();
if (pGeometry.GeometryType == esriGeometryType.esriGeometryPoint || pGeometry.GeometryType == esriGeometryType.esriGeometryMultipoint)
{
resultGeoList.Add(pGeometry);
return(resultGeoList);
}
foreach (IGeometry geo in inputGeometryList)
{
ITopologicalOperator2 topoOper = pGeometry as ITopologicalOperator2;
IGeometry resultGeo = topoOper.Intersect(geo, esriGeometryDimension.esriGeometry2Dimension);
if (resultGeo != null)
{
resultGeoList.Add(resultGeo);
}
}
return(resultGeoList);
}
/// <summary>
/// Simplifies the geometry.
/// </summary>
/// <param name="inputGeometry">The input geometry.</param>
/// <returns></returns>
public static IGeometry SimplifyGeometry(IGeometry inputGeometry)
{
// Validate the arguments
if (inputGeometry == null)
{
throw new ArgumentNullException("inputGeometry", "Failed to simplify geometry. Input geometry has not been set.");
}
ITopologicalOperator2 topologicalOperator = inputGeometry as ITopologicalOperator2;
if (topologicalOperator == null)
{
throw new ArgumentException("Failed to simplify geometry. Input geometry must be a polyline, polygon, multipoint or multipatch.");
}
// Simplify the geometry
topologicalOperator.IsKnownSimple_2 = false;
topologicalOperator.Simplify();
// Return simple geometry
return(inputGeometry);
}
public void OnDblClick()
{
try
{
IEngineEditor engineEditor = Editor.UniqueInstance.EngineEditor;
IEngineEditSketch sketch = Editor.UniqueInstance.EngineEditor as IEngineEditSketch;
IGeometry other = sketch.Geometry;
if (this.m_Feature == null)
{
MessageBox.Show("当前无要素可进行挖空！", "提示");
Editor.UniqueInstance.CancleSketch();
}
else
{
if (other.SpatialReference != this.m_Feature.Shape.SpatialReference)
{
other.Project(this.m_Feature.Shape.SpatialReference);
other.SpatialReference = this.m_Feature.Shape.SpatialReference;
}
ITopologicalOperator2 @operator = other as ITopologicalOperator2;
@operator.IsKnownSimple_2 = false;
@operator.Simplify();
ITopologicalOperator2 shapeCopy = this.m_Feature.ShapeCopy as ITopologicalOperator2;
shapeCopy.IsKnownSimple_2 = false;
shapeCopy.Simplify();
IGeometry geometry2 = shapeCopy.Difference(other);
Editor.UniqueInstance.StartEditOperation();
this.m_Feature.Shape = geometry2;
this.m_Feature.Store();
Editor.UniqueInstance.StopEditOperation("erase");
Editor.UniqueInstance.CancleSketch();
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, null, null);
}
}
catch
{
Editor.UniqueInstance.CancleSketch();
}
}
/// <summary>
/// 求面的交
/// </summary>
/// <param name="taskLayout"></param>
/// <param name="satelliteResault"></param>
/// <returns></returns>
public static IPolygon IntersectPolygon(IPolygon polygonOne, IPolygon polygonTwo)
{
try
{
ITopologicalOperator2 pTopologicalOperator = polygonOne as ITopologicalOperator2;
IGeometry pGeometry =
pTopologicalOperator.Intersect(polygonTwo, esriGeometryDimension.esriGeometry2Dimension) as
IGeometry;
if (!pGeometry.IsEmpty)
{
IPolygon intersectPolygon = pGeometry as IPolygon;
return(intersectPolygon);
}
else
{
return(null);
}
}
catch (System.Exception ex)
{
return(null);
}
}
public virtual IGeometry IntersectsMuliDim(IGeometry byGeo, IGeometry pGeo)
{
IGeometry retGeo = null;
IGeometry TopGeometry1 = byGeo;
IGeometry TopGeometry2 = pGeo;
if (TopGeometry1 == null || TopGeometry2 == null || TopGeometry1.IsEmpty == true || TopGeometry2.IsEmpty == true)
{
retGeo = null;
MessageBox.Show("空间叠加有一对象为空", "空间分析错误");
return(retGeo);
}
if (!(TopGeometry1 is ITopologicalOperator2) && !(TopGeometry2 is ITopologicalOperator2))
{
retGeo = null;
MessageBox.Show("空间叠加有一对象不是高级对象(Polygon,Polyline,MuliPoint)", "空间分析错误");
return(retGeo);
}
try
{
Topoperator2 = (ITopologicalOperator2)TopGeometry2;
Topoperator2.Simplify();
Topoperator2 = (ITopologicalOperator2)TopGeometry1;
Topoperator2.Simplify();
retGeo = Topoperator2.IntersectMultidimension(TopGeometry2);
}
catch (Exception ee)
{
retGeo = null;
System.Diagnostics.Debug.WriteLine(ee.ToString());
//ZH.Error.Write.Line("ZHFeature.IntersectsMuliDim():<Topoperator2.IntersectMultidimension>出错:<" + this.Tag.ToString() + ">", ee.Message);
}
return(retGeo);
}
private IList <IGeometry> GetGeometrys(IGeometry pGeo)
{
IList <IGeometry> list = new List <IGeometry>();
try
{
if (pGeo.GeometryType == esriGeometryType.esriGeometryPolyline)
{
IGeometryCollection geometrys = pGeo as IGeometryCollection;
int geometryCount = geometrys.GeometryCount;
for (int i = 0; i < geometryCount; i++)
{
IGeometry inGeometry = geometrys.get_Geometry(i);
if (!inGeometry.IsEmpty)
{
IGeometryCollection geometrys2 = new PolylineClass();
object missing = System.Type.Missing;
geometrys2.AddGeometry(inGeometry, ref missing, ref missing);
IGeometry item = geometrys2 as IGeometry;
item.SpatialReference = pGeo.SpatialReference;
list.Add(item);
}
}
return(list);
}
if (pGeo.GeometryType == esriGeometryType.esriGeometryPolygon)
{
IPolygon4 polygon = pGeo as IPolygon4;
if (polygon.ExteriorRingCount < 2)
{
list.Add(pGeo);
return(list);
}
IEnumGeometry exteriorRingBag = polygon.ExteriorRingBag as IEnumGeometry;
exteriorRingBag.Reset();
for (IRing ring = exteriorRingBag.Next() as IRing; ring != null; ring = exteriorRingBag.Next() as IRing)
{
IGeometryBag bag2 = polygon.get_InteriorRingBag(ring);
object before = System.Type.Missing;
IGeometryCollection geometrys3 = null;
geometrys3 = new PolygonClass();
geometrys3.AddGeometry(ring, ref before, ref before);
IPolygon polygon2 = geometrys3 as IPolygon;
polygon2.SpatialReference = pGeo.SpatialReference;
ITopologicalOperator2 @operator = (ITopologicalOperator2)polygon2;
@operator.IsKnownSimple_2 = false;
@operator.Simplify();
if (!bag2.IsEmpty)
{
IGeometryCollection geometrys4 = new PolygonClass();
IEnumGeometry geometry4 = bag2 as IEnumGeometry;
geometry4.Reset();
for (IRing ring2 = geometry4.Next() as IRing; ring2 != null; ring2 = geometry4.Next() as IRing)
{
geometrys4.AddGeometry(ring2, ref before, ref before);
}
IPolygon other = geometrys4 as IPolygon;
other.SpatialReference = pGeo.SpatialReference;
ITopologicalOperator2 operator2 = (ITopologicalOperator2)other;
operator2.IsKnownSimple_2 = false;
operator2.Simplify();
IGeometry geometry5 = @operator.Difference(other);
list.Add(geometry5);
}
else
{
list.Add(polygon2);
}
}
}
return(list);
}
catch
{
return(null);
}
return(list);
}
//<CSCM>
//********************************************************************************
//** 函 数 名: UnionTwoGeometry
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 合并二个图形成一个图形
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 20070818
//** 参数列表: pOriGeometry (IGeometry)需要合并的二个图形
// pDesOrigeometry (IGeometry)
// bHasErr合并过程中是否产生了错误
// sErrDes 错误描述
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IGeometry UnionTwoGeometry(IGeometry pOriGeometry, IGeometry pDesGeometry, ref bool bHasErr, ref string sErrDes)
{
//bHasErr = false;
//sErrDes = "";
IGeometry functionReturnValue = default(IGeometry);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
IGeometry pGeometry = default(IGeometry);
//如果图形为空,则置为nothing
bHasErr = false;
sErrDes = "";
if (pOriGeometry != null && pDesGeometry != null)
{
if (pOriGeometry.SpatialReference == null & pDesGeometry.SpatialReference != null)
{
if (pOriGeometry.SpatialReference.FactoryCode != pDesGeometry.SpatialReference.FactoryCode)
{
bHasErr = true;
sErrDes = "二个图形的投影坐标系不相同,不能进行求交。";
return(null);
}
}
}
if (pOriGeometry != null)
{
if (pOriGeometry.IsEmpty == true)
{
pOriGeometry = null;
}
}
if (pDesGeometry != null)
{
if (pDesGeometry.IsEmpty == true)
{
pDesGeometry = null;
}
}
try
{
if (pOriGeometry != null && pDesGeometry != null)
{
pTopoOperator = (ITopologicalOperator2)pOriGeometry;
pGeometry = pTopoOperator.Union(pDesGeometry);
pTopoOperator = (ITopologicalOperator2)pGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
functionReturnValue = (IGeometry)pTopoOperator;
return(functionReturnValue);
}
else if (pOriGeometry != null)
{
return(pOriGeometry);
}
else if (pDesGeometry != null)
{
return(pDesGeometry);
}
else
{
return(null);
}
}
catch
{
functionReturnValue = null;
}
return(functionReturnValue);
}
public bool Snap(IGeometry igeometry_0, IPoint ipoint_0, double double_0)
{
bool flag;
int i;
IHitTest shape;
IGeometry geometry;
if (!EditorLicenseProviderCheck.Check())
{
flag = false;
}
else if (this.ifeatureCache_0.Count != 0)
{
bool flag1 = false;
double num = 0;
int num1 = 0;
int num2 = 0;
bool flag2 = true;
IPoint pointClass = new ESRI.ArcGIS.Geometry.Point();
object value = Missing.Value;
IArray arrayClass = new Array();
for (i = 0; i < this.ifeatureCache_0.Count; i++)
{
shape = (IHitTest)this.ifeatureCache_0.Feature[i].Shape;
if ((shape is IPolyline ? true : shape is IPolygon) &&
shape.HitTest(ipoint_0, double_0, esriGeometryHitPartType.esriGeometryPartBoundary, pointClass,
ref num, ref num1, ref num2, ref flag2))
{
arrayClass.Add(shape);
}
}
IPointCollection multipointClass = new Multipoint();
IArray arrayClass1 = new Array() as IArray;
for (i = 0; i < arrayClass.Count; i++)
{
ITopologicalOperator2 element = (ITopologicalOperator2)arrayClass.Element[i];
for (int j = 0; j < arrayClass.Count; j++)
{
if (i != j)
{
if (((IGeometry)arrayClass.Element[i]).GeometryType !=
((IGeometry)arrayClass.Element[j]).GeometryType)
{
geometry = element.IntersectMultidimension((IGeometry)arrayClass.Element[j]);
if (geometry != null)
{
IGeometryCollection geometryCollection = geometry as IGeometryCollection;
if (geometryCollection != null)
{
for (int k = 0; k < geometryCollection.GeometryCount; k++)
{
geometry = geometryCollection.Geometry[k];
if (geometry is IPointCollection)
{
multipointClass.AddPointCollection((IPointCollection)geometry);
}
else if (geometry is IPointCollection)
{
multipointClass.AddPoint((IPoint)geometry, ref value, ref value);
}
}
}
}
}
else
{
geometry = element.Intersect((IGeometry)arrayClass.Element[j],
esriGeometryDimension.esriGeometry0Dimension);
if (geometry != null)
{
if (geometry is IPointCollection)
{
multipointClass.AddPointCollection((IPointCollection)geometry);
}
else if (geometry is IPointCollection)
{
multipointClass.AddPoint((IPoint)geometry, ref value, ref value);
}
}
}
}
}
}
shape = (IHitTest)multipointClass;
if (shape.HitTest(ipoint_0, double_0, esriGeometryHitPartType.esriGeometryPartVertex, pointClass,
ref num, ref num1, ref num2, ref flag2))
{
ipoint_0.PutCoords(pointClass.X, pointClass.Y);
flag1 = true;
}
flag = flag1;
}
else
{
flag = false;
}
return(flag);
}
public void OnMouseDown(int button, int shift, int x, int y)
{
if (button != 2)
{
try
{
IFeatureLayer targetLayer = Editor.UniqueInstance.TargetLayer;
if (targetLayer != null)
{
IFeatureClass featureClass = targetLayer.FeatureClass;
if (featureClass != null)
{
IPoint pGeometry = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
ISpatialFilter queryFilter = new SpatialFilterClass {
Geometry = pGeometry,
GeometryField = featureClass.ShapeFieldName,
SubFields = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelWithin
};
IFeatureCursor o = targetLayer.Search(queryFilter, false);
IFeature feature = o.NextFeature();
IFeature feature2 = o.NextFeature();
Marshal.ReleaseComObject(o);
o = null;
if ((feature != null) && (feature2 != null))
{
feature = featureClass.GetFeature(feature.OID);
feature2 = featureClass.GetFeature(feature2.OID);
ITopologicalOperator2 shape = feature.Shape as ITopologicalOperator2;
IGeometry geometry1 = feature2.Shape;
IGeometry other = shape.Intersect(feature2.Shape, esriGeometryDimension.esriGeometry2Dimension);
if (!other.IsEmpty)
{
pGeometry = GISFunFactory.UnitFun.ConvertPoject(pGeometry, other.SpatialReference) as IPoint;
IGeometryCollection geometrys = other as IGeometryCollection;
if (geometrys.GeometryCount > 1)
{
for (int i = 0; i < geometrys.GeometryCount; i++)
{
IGeometry inGeometry = geometrys.get_Geometry(i);
if (!inGeometry.IsEmpty)
{
if (inGeometry.GeometryType == esriGeometryType.esriGeometryRing)
{
object missing = System.Type.Missing;
IGeometryCollection geometrys2 = new PolygonClass();
geometrys2.AddGeometry(inGeometry, ref missing, ref missing);
IPolygon polygon = geometrys2 as IPolygon;
inGeometry = polygon;
}
IRelationalOperator operator2 = inGeometry as IRelationalOperator;
if ((operator2 != null) && operator2.Contains(pGeometry))
{
other = inGeometry;
break;
}
}
}
}
else
{
IRelationalOperator operator3 = other as IRelationalOperator;
if (!operator3.Contains(pGeometry))
{
return;
}
}
if (other != null)
{
feature = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(feature.OID);
feature2 = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(feature2.OID);
IList <IFeature> pList = new List <IFeature> {
feature,
feature2
};
OverlapSublot sublot = new OverlapSublot(this.m_hookHelper.Hook, pList)
{
Text = "合并",
Tip = "请选择要保留重叠部分的小班ID"
};
if (sublot.ShowDialog() == DialogResult.OK)
{
int selectedIndex = sublot.SelectedIndex;
IFeature feature3 = null;
if (selectedIndex == 0)
{
feature3 = feature2;
}
else
{
feature3 = feature;
}
if (other.GeometryType != esriGeometryType.esriGeometryPolygon)
{
IPolygon polygon2 = new PolygonClass {
SpatialReference = other.SpatialReference
};
IPointCollection newPoints = other as IPointCollection;
(polygon2 as IPointCollection).AddPointCollection(newPoints);
other = polygon2;
}
IGeometry geometry3 = (feature3.Shape as ITopologicalOperator2).Difference(other);
if (geometry3.IsEmpty)
{
Editor.UniqueInstance.StartEditOperation();
feature3.Delete();
Editor.UniqueInstance.StopEditOperation();
}
else
{
Editor.UniqueInstance.StartEditOperation();
feature3.Shape = geometry3;
feature3.Store();
Editor.UniqueInstance.StopEditOperation();
IFeatureSelection selection = Editor.UniqueInstance.TargetLayer as IFeatureSelection;
selection.Add(feature);
selection.Add(feature2);
}
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, null, this.m_hookHelper.ActiveView.Extent);
}
sublot = null;
MessageBox.Show("修改完成！", "提示");
}
}
}
}
}
}
catch (Exception exception)
{
Editor.UniqueInstance.AbortEditOperation();
this.mErrOpt.ErrorOperate(this.mSubSysName, "ShapeEdit.OverlapCombine", "OnMouseDown", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
MessageBox.Show("修改出错！", "提示");
}
}
}
public override void OnMouseUp(int Button, int Shift, int X, int Y)
{
IPoint point = this.m_hookHelper.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(X, Y);
try
{
IFeatureLayer targetLayer = Editor.UniqueInstance.TargetLayer;
IFeatureClass featureClass = targetLayer.FeatureClass;
ISpatialFilter queryFilter = null;
queryFilter = new SpatialFilterClass {
Geometry = point,
GeometryField = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelWithin
};
IFeature feature = null;
IFeatureCursor cursor = targetLayer.Search(queryFilter, false);
IFeature item = cursor.NextFeature();
int num = 0;
IList <IFeature> pList = new List <IFeature>();
while (item != null)
{
if ((this.m_Feature1 != null) && (item.OID == this.m_Feature1.OID))
{
item = cursor.NextFeature();
}
else
{
feature = item;
num++;
pList.Add(item);
item = cursor.NextFeature();
}
}
if (num < 1)
{
MessageBox.Show("当前无要素可进行裁切！", "提示");
}
else
{
if (num > 1)
{
OverlapSublot sublot = new OverlapSublot(this.m_hookHelper.Hook, pList)
{
Text = "裁切",
Tip = "超过一个要素被选中，请选择需要的小班ID"
};
if (sublot.ShowDialog() == DialogResult.OK)
{
int selectedIndex = sublot.SelectedIndex;
feature = pList[selectedIndex];
}
else
{
MessageBox.Show("超过一个要素被选中，无法进行裁切！", "提示");
return;
}
}
IFeatureSelection selection = Editor.UniqueInstance.TargetLayer as IFeatureSelection;
if (this.m_Feature1 == null)
{
this.m_Feature1 = feature;
selection.Add(this.m_Feature1);
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
this._cursor = ToolCursor.Erase22;
}
else
{
this.m_Feature2 = feature;
selection.Add(this.m_Feature2);
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
IGeometry shapeCopy = this.m_Feature1.ShapeCopy;
IGeometry other = this.m_Feature2.ShapeCopy;
ITopologicalOperator2 @operator = shapeCopy as ITopologicalOperator2;
@operator.IsKnownSimple_2 = false;
@operator.Simplify();
IGeometry geometry3 = @operator.Intersect(other, esriGeometryDimension.esriGeometry2Dimension);
if (geometry3.IsEmpty)
{
MessageBox.Show("选中两个要素无相交部分，无法进行裁切！", "提示");
this.m_Feature1 = null;
this.m_Feature2 = null;
this._cursor = ToolCursor.Erase2;
}
else
{
ITopologicalOperator2 operator2 = geometry3 as ITopologicalOperator2;
operator2.IsKnownSimple_2 = false;
operator2.Simplify();
IGeometry geometry4 = (other as ITopologicalOperator2).Difference(geometry3);
if (geometry4.IsEmpty)
{
MessageBox.Show("选中两个要素完全重合，无法进行裁切！", "提示");
this.m_Feature1 = null;
this.m_Feature2 = null;
this._cursor = ToolCursor.Erase2;
}
else
{
Editor.UniqueInstance.CheckOverlap = false;
Editor.UniqueInstance.StartEditOperation();
this.m_Feature2.Shape = geometry4;
this.m_Feature2.Store();
Editor.UniqueInstance.StopEditOperation();
Editor.UniqueInstance.CheckOverlap = true;
this.m_Feature1 = null;
this.m_Feature2 = null;
this._cursor = ToolCursor.Erase2;
(Editor.UniqueInstance.TargetLayer as IFeatureSelection).Clear();
this.m_hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, null, null);
}
}
}
}
}
catch (Exception exception)
{
Editor.UniqueInstance.AbortEditOperation();
this.m_Feature1 = null;
this.m_Feature2 = null;
this._cursor = ToolCursor.Erase2;
this.mErrOpt.ErrorOperate(this.mSubSysName, "ShapeEdit.Erase2", "OnMouseUp", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
}
}
public void OnFinishSketch()
{
if (m_editSketch == null)
{
return;
}
bool hasCutPolygons = false;
//Change the cursor to be hourglass shape.
System.Windows.Forms.Cursor.Current = Cursors.WaitCursor;
try
{
//Get the geometry that performs the cut from the edit sketch.
IGeometry cutGeometry = m_editSketch.Geometry;
//The sketch geometry is simplified to deal with a multi-part sketch as well
//as the case where the sketch loops back over itself.
ITopologicalOperator2 topoOperator = cutGeometry as ITopologicalOperator2;
topoOperator.IsKnownSimple_2 = false;
topoOperator.Simplify();
//Create the spatial filter to search for features in the target feature class.
//The spatial relationship we care about is whether the interior of the line
//intersects the interior of the polygon.
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = m_editSketch.Geometry;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//Find the polygon features that cross the sketch.
IFeatureClass featureClass = m_editLayer.TargetLayer.FeatureClass;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
//Only do work if there are features that intersect the edit sketch.
IFeature origFeature = featureCursor.NextFeature();
if (origFeature != null)
{
//Check the first feature to see if it is ZAware and if it needs to make the
//cut geometry ZAware.
IZAware zAware = origFeature.Shape as IZAware;
if (zAware.ZAware)
{
zAware = cutGeometry as IZAware;
zAware.ZAware = true;
}
ArrayList comErrors = new ArrayList();
//Start an edit operation so we can have undo/redo.
m_engineEditor.StartOperation();
//Cycle through the features, cutting with the sketch.
while (origFeature != null)
{
try
{
//Split the feature. Use the IFeatureEdit::Split method which ensures
//the attributes are correctly dealt with.
IFeatureEdit featureEdit = origFeature as IFeatureEdit;
//Set to hold the new features that are created by the Split.
ISet newFeaturesSet = featureEdit.Split(cutGeometry);
//New features have been created.
if (newFeaturesSet != null)
{
newFeaturesSet.Reset();
hasCutPolygons = true;
}
}
catch (COMException comExc)
{
comErrors.Add(String.Format("OID: {0}, Error: {1} , {2}", origFeature.OID.ToString(), comExc.ErrorCode, comExc.Message));
}
finally
{
//Continue to work on the next feature if it fails to split the current one.
origFeature = featureCursor.NextFeature();
}
}
//If any polygons were cut, refresh the display and stop the edit operation.
if (hasCutPolygons)
{
//Clear the map's selection.
m_engineEditor.Map.ClearSelection();
//Refresh the display including modified layer and any previously selected component.
IActiveView activeView = m_engineEditor.Map as IActiveView;
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography | esriViewDrawPhase.esriViewGeoSelection, null, activeView.Extent);
//Complete the edit operation.
m_engineEditor.StopOperation("Cut Polygons Without Selection");
}
else
{
m_engineEditor.AbortOperation();
}
//report any errors that have arisen while splitting features
if (comErrors.Count > 0)
{
StringBuilder stringBuilder = new StringBuilder("The following features could not be split: \n", 200);
foreach (string comError in comErrors)
{
stringBuilder.AppendLine(comError);
}
MessageBox.Show(stringBuilder.ToString(), "Cut Errors");
}
}
}
catch (Exception e)
{
MessageBox.Show("Unable to perform the cut task.\n" + e.Message);
m_engineEditor.AbortOperation();
}
finally
{
//Change the cursor shape to default.
System.Windows.Forms.Cursor.Current = Cursors.Default;
}
}
