/// <summary>
/// 通过缓冲区二分查找获取点到线要素图层中的最短距离
/// 基于二分查找和贪心算法
/// </summary>
/// <param name="featureLayer">要素图层</param>
/// <param name="point">被查询点</param>
/// <param name="thefeature">缓冲区中最近要素</param>
/// <param name="distance">最短距离</param>
/// <param name="disNum">在线段上的位置集合,1在右方,2在左方，0在线上</param>
/// <param name="minSpan">最小间距</param>
/// <returns>离点最近的单线</returns>
public static IPoint GetNearestLineInFeatureLayerByBufferBinary(IFeatureLayer featureLayer, IPoint point, ref IFeature thefeature, ref double distance, ref int disNum, double minSpan)
{
#region 初始化操作
IQueryFilter pQueryFilter = new QueryFilter();
pQueryFilter.WhereClause = "";
//要素个数为0则直接返回null
int count = featureLayer.FeatureClass.FeatureCount(pQueryFilter);
if (count == 0)
{
return(null);
}
//个数为1则直接计算
else if (count == 1)
{
return(GetNearestLineInFeatureLayer(featureLayer, point, ref thefeature, ref distance, ref disNum));
}
#endregion
double low = 0;
double high = GetPointToTheEnvelopMax(featureLayer, point);
IArray pArray = null;
////求最大缓冲区内的要素个数
ITopologicalOperator pTopOperator = point as ITopologicalOperator;
IGeometry pGeometry = pTopOperator.Buffer(high);
ILayer layer = featureLayer as ILayer;
IIdentify pIdentity = layer as IIdentify;
pArray = pIdentity.Identify(pGeometry);
// 如果为0或者计算错误直接返回null
if (pArray.Count == 0 || pArray == null)
{
return(null);
}
//如果只有一个要素 则直接计算返回
else if (pArray.Count == 1)
{
return(GetPointToIArrayMin(point, ref thefeature, ref distance, ref disNum, pArray));
}
///////////////////////////////////////////////
while ((high - low) < minSpan)
{
double buffer_distance = (low + high) / 2;
pGeometry = pTopOperator.Buffer(buffer_distance);
pArray = pIdentity.Identify(pGeometry);
if (pArray.Count == 0)
{
low = buffer_distance;
}
else
{
high = buffer_distance;
}
}
////此时high可以认为是最低缓冲区距离 直接求解最短距离
pGeometry = pTopOperator.Buffer(high);
pArray = pIdentity.Identify(pGeometry);
return(GetPointToIArrayMin(point, ref thefeature, ref distance, ref disNum, pArray));
}
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);
}
/// <summary>
/// 跳转
/// </summary>
/// <params name="pGeo"></params>
public static void Jump(IGeometry pGeo)
{
if (pGeo == null)
{
return;
}
if (pGeo.GeometryType == esriGeometryType.esriGeometryPoint)
{
ITopologicalOperator pTopo = (ITopologicalOperator)pGeo;
pGeo = pTopo.Buffer(10);
}
else
{
double ct = 10;
if (pGeo.Envelope.Height > pGeo.Envelope.Width)
{
ct = pGeo.Envelope.Height / 4;
}
else
{
ct = pGeo.Envelope.Width / 4;
}
ITopologicalOperator pTopo = (ITopologicalOperator)pGeo;
pGeo = pTopo.Buffer(ct);
}
GIS.Common.DataEditCommon.g_pAxMapControl.Extent = pGeo.Envelope;
GIS.Common.DataEditCommon.g_pMyMapCtrl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, GIS.Common.DataEditCommon.g_pAxMapControl.Extent);
}
public static IArray Identity(IFeatureClass featureclass, IGeometry geometry, string whereClause)
{
if (geometry == null)
{
return(null);
}
if (geometry.GeometryType == esriGeometryType.esriGeometryPoint)
{
ITopologicalOperator topop = geometry as ITopologicalOperator;
double buffer = 0.0;
if (double.TryParse(System.Configuration.ConfigurationManager.AppSettings["BUFFER"], out buffer))
{
geometry = topop.Buffer(buffer);
}
}
IFeatureLayer featureLayer = new FeatureLayerClass();
featureLayer.FeatureClass = featureclass;
IFeatureLayerDefinition featureLayerDefinition = featureLayer as IFeatureLayerDefinition;
featureLayerDefinition.DefinitionExpression = whereClause;
IFeatureLayer newfeatureLayer = featureLayerDefinition.CreateSelectionLayer(featureclass.AliasName, false, null, whereClause);
IIdentify identify = featureLayer as IIdentify;
IArray identifyObjs = identify.Identify(geometry);
return(identifyObjs);
}
/// <summary>
/// 执行空间查询
/// </summary>
private void SelectFeaturesBySpatial()
{
IActiveView pActView = mMap as IActiveView;
IPoint pt = pActView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
ITopologicalOperator pTopo = pt as ITopologicalOperator;
IGeometry pGeo = pTopo.Buffer((double)NumericDistance.Value);
//定义和创建用于查询的ISpatialFilter接口对象
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
//对选择的目标图层进行遍历，并对每一个图层进行空间查询，查询结果将放在选择集中
IFeatureLayer featureLayer;
//对所有选择的目标图层进行遍历
for (int i = 0; i < checkListLayer.CheckedItems.Count; i++)
{
//根据选择的目标图层名称获得对应的矢量图层
featureLayer = GetFeatureLayerByName(mMap, (string)checkListLayer.CheckedItems[i]);
//进行接口转换,使用IFeatureSelection接口选择要素
IFeatureSelection featureSelection = featureLayer as IFeatureSelection;
//使用IFeatureSelection接口的SelectFeature方法，根据空间查询过滤器选择要素，将其放在新的选择集中
featureSelection.SelectFeatures((IQueryFilter)spatialFilter, esriSelectionResultEnum.esriSelectionResultAdd, false);
}
//进行接口转换，使用IActiveView接口进行视图操作
IActiveView activeView = mMap as IActiveView;
//进行部分刷新操作，只刷新选择集的内容
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, activeView.Extent);
}
public IFeature GetNearToFeature()
{
if (Polyline == null || PointFeatureLayer == null)
{
return(null);
}
ITopologicalOperator pTopologicalOperator = Polyline.ToPoint as ITopologicalOperator;
if (pTopologicalOperator == null)
{
return(null);
}
ISpatialFilter pSpatialFilter = new SpatialFilterClass();
pSpatialFilter.Geometry = pTopologicalOperator.Buffer(Tolerance);
pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
pSpatialFilter.GeometryField = PointFeatureLayer.FeatureClass.ShapeFieldName;
IFeatureCursor pFeatureCursor = PointFeatureLayer.Search(pSpatialFilter, false);
IFeature pFeature = pFeatureCursor.NextFeature();
Marshal.ReleaseComObject(pFeatureCursor);
return(pFeature);
}
/// <summary>生成缓冲区多边形</summary>
/// <param name="dblVerySmall">一个极小值</param>
/// <param name="dblBuffer">缓冲区半径</param>
public void CreateBufferAndSmallBuffer(double dblBuffer, double dblVerySmall)
{
//正常缓冲区
this.CreateBuffer(dblBuffer);
//CreateBufferWithoutEnds(_pBufferGeo, dblBuffer);
//this .cut
//考虑到数据存储的问题，建立小缓冲区，用于判断线段是否相交等
ITopologicalOperator pTop = this.pPolyline as ITopologicalOperator;
IGeometry pSmallGeo = pTop.Buffer(dblVerySmall);
_pSmallBufferGeo = pSmallGeo;
//考虑到数据存储的问题，建立ToPoint的小缓冲区，用于判断线段是否相交等
ITopologicalOperator pTopTo = this.pPolyline.ToPoint as ITopologicalOperator;
IGeometry pToPointSmallGeo = pTopTo.Buffer(dblVerySmall);
_pToptSmallBufferGeo = pToPointSmallGeo;
//考虑到数据存储的问题，建立ToPoint的小缓冲区，用于判断线段是否相交等
ITopologicalOperator pTopFr = this.pPolyline.FromPoint as ITopologicalOperator;
IGeometry pFrPointSmallGeo = pTopFr.Buffer(dblVerySmall);
_pFrptSmallBufferGeo = pFrPointSmallGeo;
}
private void 给出可测区域ToolStripMenuItem_Click(object sender, EventArgs e)
{
IGeometry buffer;
ISelection pSeletion = axMapControl1.Map.FeatureSelection;
IEnumFeature pEnumFeature = (IEnumFeature)pSeletion;
IGraphicsContainer graphicsContainer = axMapControl1.ActiveView.GraphicsContainer;
graphicsContainer.DeleteAllElements();
IFeature pFeature = pEnumFeature.Next();
double bufferDistance = GlobalData.dist;
if (bufferDistance <= 0.0)
{
MessageBox.Show("距离设置错误");
return;
}
while (pFeature != null)
{
ITopologicalOperator topoOperator = pFeature.Shape as ITopologicalOperator;
buffer = topoOperator.Buffer(bufferDistance);
IElement element = new PolygonElementClass();
element.Geometry = buffer;
graphicsContainer.AddElement(element, 0);
pFeature = pEnumFeature.Next();
}
axMapControl1.Refresh();
}
public override void OnMouseUp(int Button, int Shift, int X, int Y)
{
int iPiexl = 3;
double iMapTolerance = ConvertPixelsToMapUnits(m_MapControl.ActiveView, iPiexl);
IGeometry pGeometry = null;
ITopologicalOperator pTopo = (ITopologicalOperator)m_pPoint;
if (pTopo != null)
{
pGeometry = pTopo.Buffer(iMapTolerance);
}
if (m_frmQuery == null)
{
m_frmQuery = new frmQueryForest(m_MapControl);
m_frmQuery.Owner = m_mainFrm;
m_frmQuery.FormClosed += new FormClosedEventHandler(frmQuery_FormClosed);
}
//ygc 2012-8-28 将查询结果数据在主窗体下方显示
// _QuerBar.m_pMapControl = m_MapControl;
// _QuerBar.EmergeQueryData(m_MapControl.ActiveView.FocusMap, pGeometry, esriSpatialRelEnum.esriSpatialRelIntersects);
m_frmQuery.Show();
///ZQ 20111119 modify
m_frmQuery.FillData(m_MapControl.ActiveView.FocusMap, pGeometry, esriSpatialRelEnum.esriSpatialRelIntersects);
}
public Tower GetNearestTower(IPoint pPoint, int buffer)
{
ITopologicalOperator pTopo = (ITopologicalOperator)pPoint;
IGeometry pBufferedPoint = pTopo.Buffer(buffer);
ISpatialFilter pSFilter = new SpatialFilter();
pSFilter.Geometry = pBufferedPoint;
pSFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//query the geodatabase..
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)_workspace;
IFeatureClass fcTower = pFeatureWorkspace.OpenFeatureClass("Towers");
IFeatureCursor pFCursor = fcTower.Search(pSFilter, true);
IFeature pTowerFeature = pFCursor.NextFeature();
if (pTowerFeature == null)
{
return(null);
}
return(GetTower(pTowerFeature));
}
public bool Buffer(string layerName, string sWhere, int iSize, IMap imap)
{
IFeatureClass pFcl;
IFeature pF;
IGeometry pGt;
DataOperator pDo = new DataOperator(imap, null);
IFeatureLayer pFl = (IFeatureLayer)pDo.GetLayerbyName(layerName);
pFcl = pFl.FeatureClass;
IQueryFilter pQf = new QueryFilterClass();
pQf.WhereClause = sWhere;
IFeatureCursor pFc;
pFc = (IFeatureCursor)pFcl.Search(pQf, false);
int count = pFcl.FeatureCount(pQf);
pF = pFc.NextFeature();
pGt = pF.Shape;
ITopologicalOperator pTo = (ITopologicalOperator)pGt;
IGeometry pGtBuffer = pTo.Buffer(iSize);
ISpatialFilter pSf = new SpatialFilter();
pSf.Geometry = pGtBuffer;
pSf.SpatialRel = esriSpatialRelEnum.esriSpatialRelIndexIntersects;
IFeatureSelection pFs = (IFeatureSelection)pFl;
pFs.SelectFeatures(pSf, esriSelectionResultEnum.esriSelectionResultNew, false);
return(true);
}
/// <summary>
/// 点选查询
/// </summary>
/// <param name="pPoint">空间点</param>
/// <param name="pFeatureLayer">操作图层</param>
/// <param name="pRadius">缓冲区半径</param>
/// <returns>返回查找结果</returns>
public IFeature GetPointSelect(IPoint pPoint, IFeatureLayer pFeatureLayer, double pRadius)
{
if (pPoint != null && pFeatureLayer != null)
{
ITopologicalOperator pTopologicalOperator = pPoint as ITopologicalOperator;
IGeometry pGeometry = pTopologicalOperator.Buffer(pRadius);//建立缓冲区
ISpatialFilter pSpatialFilter = new SpatialFilterClass();
pSpatialFilter.Geometry = pGeometry;
pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects; //求交
IFeatureCursor pFeatureCursor = pFeatureLayer.FeatureClass.Search(pSpatialFilter, false); //空间查询
IFeature pFeature = pFeatureCursor.NextFeature();
if (pFeature != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor); //释放缓存
System.Runtime.InteropServices.Marshal.ReleaseComObject(pSpatialFilter); //释放缓存
pGeometry = pFeature.Shape;
return(pFeature);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
private void GlacisUpDown_ValueChanged(object sender, EventArgs e)
{
if (this.bGeo.Checked && this.m_OriginGeo != null)
{
if (this.GlacisUpDown.Value > 0m)
{
try
{
ITopologicalOperator topologicalOperator = (ITopologicalOperator)this.m_OriginGeo;
IGeometry geometry = topologicalOperator.Buffer((double)this.GlacisUpDown.Value);
if (geometry != null)
{
this.m_ipGeo = geometry;
}
else
{
MessageBox.Show(@"复杂多边形,创建缓冲区失败!");
this.m_ipGeo = this.m_OriginGeo;
}
goto IL_CF;
}
catch (Exception)
{
MessageBox.Show(@"复杂多边形,创建缓冲区失败!");
this.GlacisUpDown.Value = 0m;
this.m_ipGeo = this.m_OriginGeo;
goto IL_CF;
}
}
this.m_ipGeo = this.m_OriginGeo;
IL_CF:
IActiveView activeView = m_context.ActiveView;
activeView.Refresh();
}
}
/// <summary>
/// 缩放到Feature
/// </summary>
/// <param name="pMapControl"></param>
/// <param name="pFeature"></param>
private void ZoomToFeature(IMapControlDefault pMapControl, IFeature pFeature)
{
if (pFeature == null)
{
return;
}
if (pFeature.Shape == null)
{
return;
}
IEnvelope pEnvelope = null;
if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
ITopologicalOperator pTop = pFeature.Shape as ITopologicalOperator;
IGeometry pGeometry = pTop.Buffer(50);
pEnvelope = pGeometry.Envelope;
}
else
{
pEnvelope = pFeature.Extent;
}
if (pEnvelope == null)
{
return;
}
pEnvelope.Expand(1.5, 1.5, true);
IActiveView pActiveView = pMapControl.Map as IActiveView;
pActiveView.Extent = pEnvelope;
pActiveView.Refresh();
}
public bool Buffer(string layerName, string sWhere, int iSize, IMap iMap)
{
IFeatureClass featureClass;
IFeature feature;
IGeometry geometry;
DataOperator dataOperator = new DataOperator(iMap);
IFeatureLayer featureLayer = (IFeatureLayer)dataOperator.GetLayerByName(layerName);
featureClass = featureLayer.FeatureClass;
IQueryFilter queryFilter = new QueryFilter();
queryFilter.WhereClause = sWhere;
IFeatureCursor featureCursor;
featureCursor = (IFeatureCursor)featureClass.Search(queryFilter, false);
int count = featureClass.FeatureCount(queryFilter);
feature = featureCursor.NextFeature();
geometry = feature.Shape;
ITopologicalOperator ipTO = (ITopologicalOperator)geometry;
IGeometry iGeomBuffer = ipTO.Buffer(iSize);
ISpatialFilter spatialFilter = new SpatialFilter();
spatialFilter.Geometry = iGeomBuffer;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIndexIntersects;
IFeatureSelection featureSelection = (IFeatureSelection)featureLayer;
featureSelection.SelectFeatures(spatialFilter, esriSelectionResultEnum.esriSelectionResultNew, false);
return(true);
}
public void createPointBuffer()
{
// ITopologicalOperator ===> IGeometry as ITopologicalOperator
IGeometry geometry = axMapControl1.TrackLine(); // IRubberBand ---- 橡皮筋
ITopologicalOperator topoOper = geometry as ITopologicalOperator;
IPolygon geoPolygon = topoOper.Buffer(1) as IPolygon;
// IElement
// 创建符号
ISimpleLineSymbol pSimpleLineSymbol = new SimpleLineSymbol();
pSimpleLineSymbol.Width = 2;
pSimpleLineSymbol.Style = esriSimpleLineStyle.esriSLSSolid;
//pSimpleLineSymbol.Color = GetRGBColor(46, 24, 63);// Common.GetRGBColor(46, 24, 63);
ISimpleFillSymbol pSimpleFillSymbol = new SimpleFillSymbol();
//pSimpleFillSymbol.Color = GetRGBColor(11, 200, 145);
pSimpleFillSymbol.Outline = pSimpleLineSymbol;
// 创建Element并赋值图形和符号
IFillShapeElement pPolygonElement = new PolygonElement() as IFillShapeElement;
IElement pElement = (IElement)pPolygonElement;
pElement.Geometry = geoPolygon;
pPolygonElement.Symbol = pSimpleFillSymbol;
// 添加到IGraphicsContainer容器
IGraphicsContainer pGraphicsContainer = (IGraphicsContainer)axMapControl1.Map;
pGraphicsContainer.AddElement((IElement)pPolygonElement, 0);
axMapControl1.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null);
}
public static IFeatureCursor GetAllFeaturesFromPointSearchInGeoFeatureLayer(Double searchTolerance, IPoint point, IFeatureClass featureClass, IActiveView activeView)
{
if (searchTolerance < 0 || point == null || featureClass == null || activeView == null)
{
return(null);
}
IMap map = activeView.FocusMap;
// Expand the points envelope to give better search results
//IEnvelope envelope = point.Envelope;
//envelope.Expand(searchTolerance, searchTolerance, false);
ITopologicalOperator pTopologicalOperator = point as ITopologicalOperator;
String shapeFieldName = featureClass.ShapeFieldName;
// Create a new spatial filter and use the new envelope as the geometry
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = pTopologicalOperator.Buffer(searchTolerance);
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
spatialFilter.set_OutputSpatialReference(shapeFieldName, map.SpatialReference);
spatialFilter.GeometryField = shapeFieldName;
// Do the search
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
return(featureCursor);
}
public bool Buffer(string layerName, string sWhere, int iSize, IMap iMap)
{
IFeatureClass featClass;
IFeature feature;
IGeometry iGeom;
DataOperator dataOperator = new DataOperator(iMap);
IFeatureLayer featLayer = (IFeatureLayer)dataOperator.GetLayerByName(layerName);
IGraphicsContainer graphicsContainer = (IGraphicsContainer)iMap;
graphicsContainer.DeleteAllElements();
featClass = featLayer.FeatureClass;
IQueryFilter queryFilter = new QueryFilter();
queryFilter.WhereClause = sWhere;
IFeatureCursor featCursor;
featCursor = (IFeatureCursor)featClass.Search(queryFilter, false);
int count = featClass.FeatureCount(queryFilter);
feature = featCursor.NextFeature();
iGeom = feature.Shape;
IElement element = new PolygonElementClass();
ITopologicalOperator ipTO = (ITopologicalOperator)iGeom;
element.Geometry = ipTO.Buffer(iSize);
graphicsContainer.AddElement(element, 0);
return(true);
}
public static List <IFeature> GetAllFeaturesFromPolygonInGeoFeatureLayer(IPolygon polygon, IFeatureLayer featureLayer, IMap map, double distance = 0)
{
List <IFeature> list = new List <IFeature>();
if (polygon == null || featureLayer == null || map == null)
{
return(list);
}
ITopologicalOperator pTopologicalOperator = polygon as ITopologicalOperator;
if (pTopologicalOperator == null)
{
return(list);
}
ISpatialFilter pSpatialFilter = new SpatialFilterClass();
pSpatialFilter.Geometry = pTopologicalOperator.Buffer(distance);
pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
pSpatialFilter.OutputSpatialReference[featureLayer.FeatureClass.ShapeFieldName] = map.SpatialReference;
pSpatialFilter.GeometryField = featureLayer.FeatureClass.ShapeFieldName;
IFeatureCursor pFeatureCursor = featureLayer.Search(pSpatialFilter, false);
IFeature pFeature;
while ((pFeature = pFeatureCursor.NextFeature()) != null)
{
list.Add(pFeature);
}
Marshal.ReleaseComObject(pFeatureCursor);
return(list);
}
/// <summary>
/// 创建指定图形的缓冲区
/// </summary>
/// <param name="shape">要缓冲区的图形</param>
/// <param name="tolerance">缓冲间隔</param>
/// <returns>生成的缓冲区图形</returns>
public static IGeometry GetBuffer(this IGeometry shape, double tolerance)
{
ITopologicalOperator topo = shape as ITopologicalOperator;
if (topo == null || (tolerance < 0 && shape.GeometryType != esriGeometryType.esriGeometryPolygon))
{
return(null);
}
if (!topo.IsSimple)//若是不是简单图形，进行简化处理
{
topo.Simplify();
}
int iTry = 0;//测验测验10次
IGeometry buffer = null;
while (buffer == null && iTry <= 10)
{
try
{
//若是调用不成功，将缓冲间隔加0.01倍再试（若是第10次成功，则缓冲间隔比本来大了0.09倍）
//若是对缓冲间隔请求更严格，可以削减增量的倍数
//按照测试经验，一般最多测验测验三次就可以成功
buffer = topo.Buffer(tolerance * (1.0 + 0.01 * iTry));
}
catch
{
buffer = null;
iTry = iTry + 1;
}
}
return(buffer);
}
private void button2_Click(object sender, EventArgs e)
{
IActiveView pIActiveView = pmapcontrol.Map as IActiveView;
IGraphicsContainer pIGraphicsContainer = pIActiveView.GraphicsContainer;
pIGraphicsContainer.DeleteAllElements();
IFeatureLayer pIFeatureLayer = pmapcontrol.get_Layer(0) as IFeatureLayer;
IFeatureCursor pIFeatureCursor = pIFeatureLayer.FeatureClass.Search(null, false);
IFeature pfeature = pIFeatureCursor.NextFeature();
while (pfeature != null)
{
ITopologicalOperator pITopologicalOperator = pfeature.Shape as ITopologicalOperator;
IPolygon pPolygon = pITopologicalOperator.Buffer(double.Parse(textBox1.Text)) as IPolygon;
IElement pIElement = new PolygonElement();
pIElement.Geometry = pPolygon;
pIGraphicsContainer.AddElement(pIElement, 0);
pfeature = pIFeatureCursor.NextFeature();
}
pmapcontrol.Refresh();
this.Close();
}
public string CheckLine(string pipelineName, IPolyline polyline, IFeatureClass featureClass)
{
string message = "";
ITopologicalOperator topologicalOperator = polyline as ITopologicalOperator;
IPolygon polygon = topologicalOperator.Buffer(_dataCheck.DataCheckConfig.LineMinimumSpacing) as IPolygon;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = polygon;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
spatialFilter.GeometryField = featureClass.ShapeFieldName;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
IFeature feature;
while ((feature = featureCursor.NextFeature()) != null)
{
IPolyline tempPolyline = feature.Shape as IPolyline;
if (tempPolyline == null || tempPolyline.IsEmpty)
{
continue;
}
IProximityOperator proximityOperator = polyline as IProximityOperator;
double d = proximityOperator.ReturnDistance(tempPolyline);
if (d < _dataCheck.DataCheckConfig.LineMinimumSpacing)
{
message += $"{pipelineName}:与 {feature.OID} 的距离为 {d}；";
}
}
Marshal.ReleaseComObject(featureCursor);
return(message);
}
private IFeature SelctFeatureBasedMousePoint(IPoint pPoint)
{
//对点对象做缓冲区运算
ITopologicalOperator pTopo = pPoint as ITopologicalOperator;
IGeometry pBuffer = pTopo.Buffer(0.5);
IGeometry pGeometry = pBuffer.Envelope;
SetAllPolylinePolygonLayersSelectable();
ISelectionEnvironment selEnvironment = new SelectionEnvironmentClass();
selEnvironment.CombinationMethod = esriSelectionResultEnum.esriSelectionResultNew;
m_map.SelectByShape(pGeometry, selEnvironment, true);
IEnumFeature SelectedFeatures = m_map.FeatureSelection as IEnumFeature;
SelectedFeatures.Reset();
IFeature extendFeature = SelectedFeatures.Next();
SetAllLayersSelectable();
m_activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, m_activeView.Extent);
if (extendFeature != null && extendFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
return(extendFeature);
}
return(null);
}
/// <summary>
/// 计算每个数据点相邻的数据点，找出核心点
/// </summary>
private void FindNeighborPoints()
{
for (int i = 0; i < m_DBSCANPnts.Count; i++)
{
List <DBSCANPoint> neighborPnts = new List <DBSCANPoint>();
IPoint point = m_DBSCANPnts[i].GetPoint();
ITopologicalOperator topologicalOperator = point as ITopologicalOperator;
IGeometry pointBuffer = topologicalOperator.Buffer(m_dEps);//缓冲距离
topologicalOperator.Simplify();
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = pointBuffer;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
IFeatureLayer featurelayer = m_dataInfo.GetInputLayer() as IFeatureLayer;
IFeatureCursor featureCursor = featurelayer.FeatureClass.Search(spatialFilter, false);
IFeature feature = featureCursor.NextFeature();
while (feature != null)
{
neighborPnts.Add(GetDBSCANPointByOID(feature.OID));
feature = featureCursor.NextFeature();
}
m_DBSCANPnts[i].SetNeighborPoints(neighborPnts);
//标记核心点
if (m_DBSCANPnts[i].GetNeighborPoints().Count >= m_nMinPts)
{
m_DBSCANPnts[i].SetPointType(1);
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureCursor);
}
}
/// <summary>
/// Buffers the input geometry.
/// </summary>
/// <param name="inputGeometry">The input geometry.</param>
/// <param name="bufferDistance">The buffer distance.</param>
public static void BufferGeometry(ref IGeometry inputGeometry, double bufferDistance)
{
if (inputGeometry == null)
{
return;
}
if (inputGeometry.IsEmpty)
{
return;
}
IGeometry bufferGeometry = null;
//// DEBUG - Check area before
//if (inputGeometry is IPolygon)
//{
// IArea areaBefore = inputGeometry as IArea;
// System.Diagnostics.Debug.WriteLine(areaBefore.Area);
//}
// Get the ITopologicalOperator
ITopologicalOperator topoOp = (ITopologicalOperator)inputGeometry;
// Perform buffer
bufferGeometry = topoOp.Buffer(bufferDistance);
//// DEBUG - Check area after
//if (bufferGeometry is IPolygon)
//{
// IArea areaAfter = bufferGeometry as IArea;
// System.Diagnostics.Debug.WriteLine("After Buffer: " + areaAfter.Area);
//}
inputGeometry = bufferGeometry;
}
/// <summary>
/// 把geometry合并起来,组成一个新的geometry,在缓冲buffer个单位
/// </summary>
/// <param name="lstGeo">Geo列表</param>
/// <param name="buffer">缓冲单位</param>
/// <returns></returns>
public static IGeometry GetUnionGeometry(IList <IGeometry> lstGeo, double buffer)
{
if (lstGeo.Count == 0)
{
return(null);
}
IGeometryBag pGeometryBag = new GeometryBagClass();
pGeometryBag.SpatialReference = lstGeo[0].SpatialReference;
IGeometryCollection pGeometryCollection = pGeometryBag as IGeometryCollection;
object obj = Type.Missing;
foreach (IGeometry geo in lstGeo)
{
pGeometryCollection.AddGeometry(geo, ref obj, ref obj);
}
ITopologicalOperator UnionPolygon = new PolygonClass();
UnionPolygon.ConstructUnion(pGeometryCollection as ESRI.ArcGIS.Geometry.IEnumGeometry);
IGeometry geoResult = UnionPolygon as IGeometry;
ITopologicalOperator operatorTopo = geoResult as ITopologicalOperator;
return(operatorTopo.Buffer(buffer));
}
public void GetFeatureOnMouseDown(int x, int y)
{
MyselectedFeature.Clear();
try
{
if (MyselectedLayer == null)
{
return;
}
IFeatureLayer featureLayer = MyselectedLayer as IFeatureLayer;
if (featureLayer == null)
{
return;
}
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass == null)
{
return;
}
IPoint point = MyMapControl.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
IGeometry geometry = point as IGeometry;
double length = ConvertPixelsToMapUnits(4);
ITopologicalOperator pTopo = geometry as ITopologicalOperator;
IGeometry buffer = pTopo.Buffer(length);
geometry = buffer.Envelope as IGeometry;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = geometry;
switch (featureClass.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
break;
case esriGeometryType.esriGeometryPolygon:
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
case esriGeometryType.esriGeometryPolyline:
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelCrosses;
break;
}
spatialFilter.GeometryField = featureClass.ShapeFieldName;
IQueryFilter filter = spatialFilter as IQueryFilter;
IFeatureCursor cursor = featureClass.Search(filter, false);
IFeature pfeature = cursor.NextFeature();
while (pfeature != null)
{
MyselectedFeature.Add(pfeature);
pfeature = cursor.NextFeature();
}
}
catch
{
return;
}
}
public override void OnDblClick()
{
if (this._lineFeedback != null)
{
this._Point = null;
IPolyline polyline = this._lineFeedback.Stop();
this._lineFeedback = null;
if (!polyline.IsEmpty)
{
frmInputText frm = new frmInputText();
frm.Title = "输入缓冲距离";
frm.Label = "缓冲距离";
frm.txtText.EditValue = 50;
if (frm.ShowDialog() != DialogResult.OK)
{
return;
}
double bufferDist = 50;
try
{
bufferDist = Convert.ToDouble(frm.txtText.EditValue);
}
catch (Exception)
{
MessageService.Current.Warn("缓冲距离必须为数字!");
return;
}
ITopologicalOperator topo = polyline as ITopologicalOperator;
IGeometry buffer = topo.Buffer(bufferDist);
_plugin.FireFenceAdded(new FenceAddedArgs((IGeometry)buffer));
IActiveView activeView = this._context.FocusMap as IActiveView;
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, buffer.Envelope);
}
}
}
protected override void OnDoubleClick()
{
base.OnDoubleClick();
try
{
if (LineFeedBack != null)
{
trackgeom = LineFeedBack.Stop();
LineFeedBack = null;
if (GetDriveCenterlineIntersection(trackgeom))
{
if (CalculateHouseNumber())
{
SetAttributes();
}
}
mMap.ClearSelection();
ITopologicalOperator to = SelectedPoint.Shape as ITopologicalOperator;
IGeometry g = to.Buffer(10);
mMap.SelectByShape(g, ArcMap.ThisApplication.SelectionEnvironment, true);
IFeatureSelection fsel = Globals.AddressPointLayer as IFeatureSelection;
ArcMap.Document.FocusMap.ClearSelection();
ArcMap.Document.ActiveView.Refresh();
ArcMap.Document.FocusMap.ClearSelection();
}
}
catch { }
}
/// <summary>
/// 根据要素的缓冲距离查找要素
/// </summary>
/// <param name="desFeaCls"></param>
/// <param name="pointFeature"></param>
/// <param name="dis"></param>
/// <returns></returns>
private List <IFeature> GetFeatureByDis(IFeatureClass desFeaCls, IFeature pointFeature, esriSpatialRelEnum spatialRelEnum, double dis)
{
List <IFeature> LstFeature = new List <IFeature>();
//根据源要素的缓冲半径得到缓冲范围
ITopologicalOperator pTopoOper = pointFeature.Shape as ITopologicalOperator;
IGeometry pGeo = pTopoOper.Buffer(dis);
//查找缓冲范围内的要素
ISpatialFilter pFilter = new SpatialFilterClass();
pFilter.GeometryField = "SHAPE";
pFilter.Geometry = pGeo;
pFilter.SpatialRel = spatialRelEnum;// esriSpatialRelEnum.esriSpatialRelIntersects;//.esriSpatialRelWithin;
IFeatureCursor pCursor = desFeaCls.Search(pFilter, false);
if (pCursor == null)
{
return(null);
}
IFeature pFeature = pCursor.NextFeature();
while (pFeature != null)
{
LstFeature.Add(pFeature);
pFeature = pCursor.NextFeature();
}
//释放cursor
System.Runtime.InteropServices.Marshal.ReleaseComObject(pCursor);
return(LstFeature);
}
