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>
//********************************************************************************
//** 函 数 名: 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 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;
}
}
}
}
}
}
}
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>
/// 求面的交
/// </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 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 OnDblClick()
{
if (this._isLineStarted)
{
this._snapPoint = null;
try
{
this._isLineStarted = false;
this._linePoints.RemoveAll();
IPolyline other = this._feedback.Stop();
IFeatureSelection targetLayer = Editor.UniqueInstance.TargetLayer as IFeatureSelection;
IEnumIDs iDs = targetLayer.SelectionSet.IDs;
iDs.Reset();
IFeature srcFeature = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(iDs.Next());
if (other.SpatialReference != srcFeature.Shape.SpatialReference)
{
other.Project(srcFeature.Shape.SpatialReference);
other.SpatialReference = srcFeature.Shape.SpatialReference;
}
ITopologicalOperator2 shape = srcFeature.Shape as ITopologicalOperator2;
if (shape != null)
{
shape.IsKnownSimple_2 = false;
shape.Simplify();
ITopologicalOperator2 operator2 = other as ITopologicalOperator2;
operator2.IsKnownSimple_2 = false;
operator2.Simplify();
IGeometry geometry = null;
if (srcFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
geometry = shape.Intersect(other, esriGeometryDimension.esriGeometry0Dimension);
}
else
{
geometry = shape.Intersect(other, esriGeometryDimension.esriGeometry1Dimension);
}
if (!geometry.IsEmpty)
{
IGeometry geometry2;
IGeometry geometry3;
shape.Cut(other, out geometry3, out geometry2);
if ((geometry3 != null) && (geometry2 != null))
{
(geometry3 as ITopologicalOperator).Simplify();
(geometry2 as ITopologicalOperator).Simplify();
IFeatureClass featureClass = Editor.UniqueInstance.TargetLayer.FeatureClass;
IFeature feature = featureClass.CreateFeature();
IFeature feature3 = featureClass.CreateFeature();
feature.Shape = geometry3;
feature3.Shape = geometry2;
IAttributeSplit attributeSplitHandleClass = AttributeManager.AttributeSplitHandleClass;
if (attributeSplitHandleClass != null)
{
try
{
Editor.UniqueInstance.StartEditOperation();
Editor.UniqueInstance.AddAttribute = false;
List <IFeature> pFeatureList = null;
pFeatureList = new List <IFeature> {
feature,
feature3
};
attributeSplitHandleClass.AttributeSplit(srcFeature, ref pFeatureList);
feature = pFeatureList[0];
feature3 = pFeatureList[1];
feature.Store();
feature3.Store();
srcFeature.Delete();
Editor.UniqueInstance.StopEditOperation("split");
targetLayer.Clear();
targetLayer.Add(feature);
this._hookHelper.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography, null, null);
}
catch (Exception exception)
{
Editor.UniqueInstance.AbortEditOperation();
this._mErrOpt.ErrorOperate(this._mSubSysName, "ShapeEdit.Split", "OnDblClick", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
}
}
}
}
}
}
catch (Exception exception2)
{
this._mErrOpt.ErrorOperate(this._mSubSysName, "ShapeEdit.Split", "OnDblClick", exception2.GetHashCode().ToString(), exception2.Source, exception2.Message, "", "", "");
}
}
}
private IPoint method_8(IPoint ipoint_0, IFeatureCache2 ifeatureCache2_0, double double_0)
{
int i;
IGeometry geometry;
double num = 0;
int num1 = 0;
int num2 = 0;
bool flag = true;
IPoint point = null;
List <IGeometry> geometries = new List <IGeometry>();
for (i = 0; i < ifeatureCache2_0.Count; i++)
{
IFeature feature = ifeatureCache2_0.Feature[i];
if ((feature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline
? true
: feature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon))
{
IPoint pointClass = new ESRI.ArcGIS.Geometry.Point();
IHitTest shape = (IHitTest)feature.Shape;
if (
shape.HitTest(ipoint_0, double_0, esriGeometryHitPartType.esriGeometryPartBoundary, pointClass,
ref num, ref num1, ref num2, ref flag) && num <= double_0)
{
IGeometryCollection geometryCollection = shape as IGeometryCollection;
if (geometryCollection != null)
{
ISegmentCollection segmentCollection =
geometryCollection.Geometry[num1] as ISegmentCollection;
if (segmentCollection != null)
{
//segmentCollection.Segment[num2] is ICircularArc;
}
}
}
}
}
IPointCollection multipointClass = new Multipoint();
for (i = 0; i < geometries.Count; i++)
{
ITopologicalOperator2 item = (ITopologicalOperator2)geometries[i];
for (int j = 0; j < geometries.Count; j++)
{
if (i != j)
{
if (geometries[i].GeometryType != geometries[j].GeometryType)
{
geometry = item.IntersectMultidimension(geometries[j]);
if (geometry != null)
{
IGeometryCollection geometryCollection1 = geometry as IGeometryCollection;
if (geometryCollection1 != null)
{
for (int k = 0; k < geometryCollection1.GeometryCount; k++)
{
geometry = geometryCollection1.Geometry[k];
if (geometry is IPointCollection)
{
multipointClass.AddPointCollection((IPointCollection)geometry);
}
else if (geometry is IPoint)
{
object value = Missing.Value;
object obj = Missing.Value;
multipointClass.AddPoint((IPoint)geometry, ref value, ref obj);
}
}
}
}
}
else
{
geometry = item.Intersect(geometries[j], esriGeometryDimension.esriGeometry0Dimension);
if (geometry != null)
{
if (geometry is IPointCollection)
{
multipointClass.AddPointCollection((IPointCollection)geometry);
}
else if (geometry is IPoint)
{
object value1 = Missing.Value;
object obj1 = Missing.Value;
multipointClass.AddPoint((IPoint)geometry, ref value1, ref obj1);
}
}
}
}
}
}
IHitTest hitTest = (IHitTest)multipointClass;
IPoint pointClass1 = new ESRI.ArcGIS.Geometry.Point();
if (
hitTest.HitTest(ipoint_0, double_0, esriGeometryHitPartType.esriGeometryPartVertex, pointClass1, ref num,
ref num1, ref num2, ref flag) && num < double_0)
{
point = pointClass1;
}
return(point);
}
public void InitLinkage(IPoint mousePoint, double buffer)
{
this._isVertexEditing = false;
this._editOrigShape = null;
this._editBound = null;
this._las.Clear();
IFeatureClass featureClass = Editor.UniqueInstance.TargetLayer.FeatureClass;
ISpatialFilter queryFilter = new SpatialFilterClass {
Geometry = (mousePoint as ITopologicalOperator).Buffer(buffer),
GeometryField = featureClass.ShapeFieldName,
SubFields = featureClass.ShapeFieldName,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
IFeatureCursor o = Editor.UniqueInstance.TargetLayer.Search(queryFilter, false);
IFeature pFeature = o.NextFeature();
if (pFeature == null)
{
Marshal.ReleaseComObject(o);
o = null;
this.ClearUp();
}
else
{
IFeature feature = o.NextFeature();
if (feature == null)
{
Marshal.ReleaseComObject(o);
o = null;
this.ClearUp();
}
else if (o.NextFeature() != null)
{
Marshal.ReleaseComObject(o);
o = null;
this.ClearUp();
}
else
{
pFeature = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(pFeature.OID);
feature = Editor.UniqueInstance.TargetLayer.FeatureClass.GetFeature(feature.OID);
IGeometry pGeometry = null;
IGeometry shapeCopy = pFeature.ShapeCopy;
IGeometry other = feature.ShapeCopy;
ITopologicalOperator2 @operator = shapeCopy as ITopologicalOperator2;
@operator.IsKnownSimple_2 = false;
@operator.Simplify();
ITopologicalOperator2 operator2 = other as ITopologicalOperator2;
operator2.IsKnownSimple_2 = false;
operator2.Simplify();
pGeometry = @operator.Intersect(other, esriGeometryDimension.esriGeometry1Dimension);
if (pGeometry.IsEmpty)
{
this.ClearUp();
}
else
{
if ((pGeometry as IGeometryCollection).GeometryCount > 1)
{
IHitTest test = pGeometry as IHitTest;
IPoint hitPoint = null;
double hitDistance = 0.0;
int hitPartIndex = -1;
int hitSegmentIndex = -1;
bool bRightSide = false;
if (!test.HitTest(mousePoint, buffer, esriGeometryHitPartType.esriGeometryPartBoundary, hitPoint, ref hitDistance, ref hitPartIndex, ref hitSegmentIndex, ref bRightSide))
{
return;
}
pGeometry = (pGeometry as IGeometryCollection).get_Geometry(hitPartIndex);
}
pGeometry = GISFunFactory.UnitFun.ConvertPoject(pGeometry, this._viewMap.FocusMap.SpatialReference);
IPolyline polyline = null;
if (pGeometry.GeometryType != esriGeometryType.esriGeometryPolyline)
{
IPath path = pGeometry as IPath;
if ((path != null) && path.IsClosed)
{
this.ClearUp();
return;
}
IPointCollection newPoints = pGeometry as IPointCollection;
polyline = new PolylineClass {
SpatialReference = pGeometry.SpatialReference
};
(polyline as IPointCollection).AddPointCollection(newPoints);
}
IGeometry geometry4 = @operator.Union(other);
this._editBound = GISFunFactory.UnitFun.ConvertPoject(geometry4, this._viewMap.FocusMap.SpatialReference);
this._las.Add(new LinkArgs(pFeature));
this._las.Add(new LinkArgs(feature));
this.InitOtherLayer(pGeometry);
if (polyline != null)
{
this._editOrigShape = (polyline as IClone).Clone() as IGeometry;
Editor.UniqueInstance.LinageShape = polyline;
Editor.UniqueInstance.ReservedLinkShape = polyline;
}
else
{
this._editOrigShape = (pGeometry as IClone).Clone() as IGeometry;
Editor.UniqueInstance.LinageShape = pGeometry;
Editor.UniqueInstance.ReservedLinkShape = pGeometry;
}
this._isVertexEditing = true;
}
}
}
}