/// <summary>
/// 根据范围查找数据填充窗体
/// </summary>
/// <param name="pMap">被查询的地图对象</param>
/// <param name="pGeometry">查询范围</param>
public void FillData(IMap pMap, IGeometry pGeometry, esriSpatialRelEnum pesriSpatialRelEnum)
{
string strNodeKey = SysCommon.ModSysSetting.GetLinBanLayerNodeKey(Plugin.ModuleCommon.TmpWorkSpace);
ILayer pLayer = SysCommon.ModuleMap.GetLayerByNodeKey(null, pMap, strNodeKey, null, true);
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
if (pFeatureLayer != null)
{
ISpatialFilter pSpatialFilter = new SpatialFilterClass();
pSpatialFilter.Geometry = pGeometry;
pSpatialFilter.SpatialRel = pesriSpatialRelEnum;
IFeatureCursor pFeatureCursor = pFeatureLayer.Search(pSpatialFilter, false);
Application.DoEvents();
IFeature pFeat = pFeatureCursor.NextFeature();
if (pFeat != null)
{
m_pFeature = pFeat;
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
pFeatureCursor = null;
string strName = "";
try
{
strName = dataGridCategory.SelectedCells[0].Value.ToString();
}
catch
{ }
InitValueGrid(strName);
}
}
private void cbx_SelectRelationShip_SelectedIndexChanged(object sender, EventArgs e)
{
int pSelectedItem = cbx_SelectRelationShip.SelectedIndex;
switch (pSelectedItem)
{
case 0:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
}
case 1:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
break;
}
case 2:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelIndexIntersects;
break;
}
case 3:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelTouches;
break;
}
case 4:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelOverlaps;
break;
}
case 5:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelCrosses;
break;
}
case 6:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelWithin;
break;
}
case 7:
{
m_SpatoalRel = esriSpatialRelEnum.esriSpatialRelContains;
break;
}
default:
{
break;
}
}
}
public esriSpatialRelEnum GetSpatialRelation()
{
esriSpatialRelEnum pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelContains;
if (cbMethod.Text == "Contains")
{
pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelContains;
}
else if (cbMethod.Text == "Intersects")
{
pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelIntersects;
}
else if (cbMethod.Text == "Envelope Intersects")
{
pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
}
else if (cbMethod.Text == "Index Intersects")
{
pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelIndexIntersects;
}
else if (cbMethod.Text == "Are within a distance of")
{
pesriSpatialRelationEnum = esriSpatialRelEnum.esriSpatialRelIndexIntersects;
}
return(pesriSpatialRelationEnum);
}
//空间选择方式转化
private esriSpatialRelEnum SpatialRelConvert(string Spatial)
{
esriSpatialRelEnum Spatial_lable = esriSpatialRelEnum.esriSpatialRelContains;
switch (Spatial)
{
case "esriSpatialRelUndefined": Spatial_lable = esriSpatialRelEnum.esriSpatialRelUndefined; break;
case "esriSpatialRelIntersects": Spatial_lable = esriSpatialRelEnum.esriSpatialRelIndexIntersects; break;
case "esriSpatialRelEnvelopeIntersects": Spatial_lable = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects; break;
case "esriSpatialRelIndexIntersects": Spatial_lable = esriSpatialRelEnum.esriSpatialRelIntersects; break;
case "esriSpatialRelTouches": Spatial_lable = esriSpatialRelEnum.esriSpatialRelTouches; break;
case "esriSpatialRelOverlaps": Spatial_lable = esriSpatialRelEnum.esriSpatialRelOverlaps; break;
case "esriSpatialRelCrosses": Spatial_lable = esriSpatialRelEnum.esriSpatialRelCrosses; break;
case "esriSpatialRelWithin": Spatial_lable = esriSpatialRelEnum.esriSpatialRelWithin; break;
case "esriSpatialRelContains": Spatial_lable = esriSpatialRelEnum.esriSpatialRelContains; break;
case "esriSpatialRelRelation": Spatial_lable = esriSpatialRelEnum.esriSpatialRelRelation; break;
default:
break;
}
return(Spatial_lable);
}
protected IEnumerable <IRow> Search(
int involvedTableIndex,
[NotNull] IGeometry geometry,
esriSpatialRelEnum spatialRelation = esriSpatialRelEnum.esriSpatialRelIntersects,
[CanBeNull] string where = null)
{
EnsureDefaultFilters();
ITable table = InvolvedTables[involvedTableIndex];
ISpatialFilter filter = _defaultFilters[involvedTableIndex];
QueryFilterHelper defaultHelper = _defaultFilterHelpers[involvedTableIndex];
QueryFilterHelper whereHelper = (string.IsNullOrWhiteSpace(where))
? new QueryFilterHelper(
table, where, GetSqlCaseSensitivity(table))
: null;
filter.Geometry = geometry;
filter.SpatialRel = spatialRelation;
foreach (var row in Search(table, filter, defaultHelper))
{
if (whereHelper == null || whereHelper.MatchesConstraint(row))
{
yield return(row);
}
}
}
private static bool IsKnownSymmetric(esriSpatialRelEnum relation)
{
switch (relation)
{
case esriSpatialRelEnum.esriSpatialRelIntersects:
case esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects:
case esriSpatialRelEnum.esriSpatialRelTouches:
case esriSpatialRelEnum.esriSpatialRelOverlaps: // TODO revise
case esriSpatialRelEnum.esriSpatialRelCrosses:
return(true);
case esriSpatialRelEnum.esriSpatialRelWithin:
case esriSpatialRelEnum.esriSpatialRelContains:
case esriSpatialRelEnum.esriSpatialRelRelation: // can be asymmetric
return(false);
case esriSpatialRelEnum.esriSpatialRelIndexIntersects:
case esriSpatialRelEnum.esriSpatialRelUndefined:
throw new ArgumentOutOfRangeException(string.Format("Unsupported relation: {0}",
relation));
default:
throw new ArgumentOutOfRangeException(string.Format("Unknown relation: {0}",
relation));
}
}
private IFeature FeatureMerge(IFeatureClass pSearchFC, IGeometry pEnv, esriSpatialRelEnum spatialRel, string strGeoObjNum)
{
IFeature feature = null;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = pEnv;
spatialFilter.SpatialRel = spatialRel;
spatialFilter.WhereClause = "SMSSYMBOL = '" + strGeoObjNum + "'";
IFeatureCursor featureCursor = pSearchFC.Update(spatialFilter, false);
if (featureCursor != null)
{
IFeature feature2 = featureCursor.NextFeature();
feature = feature2;
while (feature2 != null)
{
if (feature2.OID != feature.OID)
{
feature.Shape = CommonFunction.UnionGeometry(feature.Shape, feature2.Shape);
feature2.Delete();
feature.Store();
}
feature2 = featureCursor.NextFeature();
}
Marshal.ReleaseComObject(featureCursor);
}
return(feature);
}
public static IEnumFeature SelectByPolygon(IMap pMap, IPolygon pPolygon, esriSpatialRelEnum pSpatialRelEnum)
{
ISelectionEnvironment selectionEnvironmentClass = new SelectionEnvironmentClass()
{
AreaSelectionMethod = pSpatialRelEnum,
LinearSelectionMethod = pSpatialRelEnum,
PointSelectionMethod = pSpatialRelEnum,
CombinationMethod = esriSelectionResultEnum.esriSelectionResultNew
};
try
{
pMap.SelectByShape(pPolygon, selectionEnvironmentClass, false);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
if (cOMException.ErrorCode != -2147467259)
{
//Logger.Current.Error("",cOMException, "");
}
else
{
MessageBox.Show("执行查询时产生错误。空间索引不存在", "选择");
}
}
catch (Exception exception)
{
//Logger.Current.Error("",exception, "");
}
return((IEnumFeature)pMap.FeatureSelection);
}
public virtual ZhFeature[] GetFeatures(ZhFeature[] zhFeatures, esriSpatialRelEnum pesriSpatialRelEnum)
{
List <ZhFeature> pMuliFeatures = new List <ZhFeature>();
ZhFeature[] pFeatures = null;
try
{
pMuliFeatures.Clear();
for (int i = 0; i < zhFeatures.Length; i++)
{
pFeatures = this.GetFeatures(zhFeatures[i].GetBufferedGeometry(), pesriSpatialRelEnum);
for (int j = 0; j < pFeatures.Length; j++)
{
if (pMuliFeatures.Contains(pFeatures[j]) == false)
{
pMuliFeatures.Add(pFeatures[j]);
}
}
}
}
catch
{
pMuliFeatures.Clear();
}
pFeatures = null;
return(pMuliFeatures.ToArray());
}
protected QaSpatialRelationOtherBase(
[NotNull] IList <IFeatureClass> featureClasses,
[NotNull] IList <IFeatureClass> relatedClasses,
esriSpatialRelEnum relation)
: base(Union(featureClasses, relatedClasses), relation)
{
_fromClassCount = featureClasses.Count;
}
private void button1_Click(object sender, EventArgs e)
{
//获取目标图层；
IFeatureLayer[] player = new IFeatureLayer[5];
int counter = 0;
for (int i = 0; i < checkedListBox1.CheckedItems.Count; i++)
{
for (int j = 0; j < pmapcontrol.LayerCount; j++)
{
if (checkedListBox1.CheckedItems[i].ToString() == pmapcontrol.get_Layer(j).Name)
{
player[counter++] = pmapcontrol.get_Layer(j) as IFeatureLayer;
}
}
}
// 获取源图层；
IFeatureLayer pyuanLyaer = null;
for (int k = 0; k < pmapcontrol.LayerCount; k++)
{
if (comboBox1.GetItemText(comboBox1.SelectedItem) == pmapcontrol.get_Layer(k).Name)
{
pyuanLyaer = pmapcontrol.get_Layer(k) as IFeatureLayer;
}
}
//空间参考
esriSpatialRelEnum pesriSpatialRelEnum = SpatialRelConvert(comboBox2.GetItemText(comboBox2.SelectedItem));
//空间位置判断
if (pyuanLyaer != null && player.Length >= 1)
{
ISpatialFilter pISpatialFilter = new SpatialFilterClass();
for (int i = 0; i < player.Length && player[i] != null; i++)
{
IFeatureCursor pFeatureCursor = pyuanLyaer.FeatureClass.Search(null, true);
IFeature pfeature = pFeatureCursor.NextFeature();
IFeatureSelection pIFeatureSelection = player[i] as IFeatureSelection;
while (pfeature != null)
{
pISpatialFilter.Geometry = pfeature.ShapeCopy;
pISpatialFilter.SpatialRel = pesriSpatialRelEnum;
pIFeatureSelection.SelectFeatures(pISpatialFilter as IQueryFilter, esriSelectionResultEnum.esriSelectionResultAdd, true);
pfeature = pFeatureCursor.NextFeature();
}
}
pmapcontrol.Refresh();
this.Close();
}
else
{
MessageBox.Show("请至少选择一个目标图层，原图层和空间关系方式！");
}
}
private void StartQuery(IEnvelope ienvelope_0)
{
ISpatialReference spatialReference = _context.FocusMap.SpatialReference;
ienvelope_0.SpatialReference = spatialReference;
IMap focusMap = _context.FocusMap;
IActiveView activeView = focusMap as IActiveView;
ISelectionEnvironment selectionEnvironment = _context.Config.SelectionEnvironment;
selectionEnvironment.CombinationMethod = esriSelectionResultEnum.esriSelectionResultAdd;
esriSpatialRelEnum linearSelectionMethod = selectionEnvironment.LinearSelectionMethod;
esriSpatialRelEnum areaSelectionMethod = selectionEnvironment.AreaSelectionMethod;
if (ienvelope_0 is IEnvelope)
{
if (this.double_0 != -1.0)
{
if (this.double_0 > this.double_1)
{
selectionEnvironment.LinearSelectionMethod = esriSpatialRelEnum.esriSpatialRelContains;
selectionEnvironment.AreaSelectionMethod = esriSpatialRelEnum.esriSpatialRelContains;
this.double_1 = -1.0;
}
else
{
selectionEnvironment.LinearSelectionMethod = esriSpatialRelEnum.esriSpatialRelIntersects;
selectionEnvironment.AreaSelectionMethod = esriSpatialRelEnum.esriSpatialRelIntersects;
}
}
else
{
this.double_0 = -1.0;
}
}
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
try
{
focusMap.SelectByShape(ienvelope_0, selectionEnvironment, false);
}
catch (COMException ex)
{
if (ex.ErrorCode == -2147467259)
{
System.Windows.Forms.MessageBox.Show("执行查询时产生错误。空间索引不存在", "选择");
}
else
{
//CErrorLog.writeErrorLog(this, ex, "");
}
}
catch (Exception exception_)
{
//CErrorLog.writeErrorLog(this, exception_, "");
}
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
selectionEnvironment.LinearSelectionMethod = linearSelectionMethod;
selectionEnvironment.AreaSelectionMethod = areaSelectionMethod;
}
protected QaSpatialRelationBase([NotNull] IList <IFeatureClass> featureClasses,
esriSpatialRelEnum relation)
: base(CastToTables((IEnumerable <IFeatureClass>)featureClasses))
{
TotalClassCount = featureClasses.Count;
Relation = relation;
UsesSymmetricRelation = IsKnownSymmetric(relation);
}
private void method_2(IEnvelope ienvelope_0)
{
IGeometry ienvelope0 = ienvelope_0;
ienvelope0.SpatialReference = this._appContext.MapControl.Map.SpatialReference;
IMap focusMap = this._appContext.MapControl.Map;
IActiveView activeView = focusMap as IActiveView;
ISelectionEnvironment selectionEnvironment = this._appContext.Config.SelectionEnvironment;
selectionEnvironment.CombinationMethod = esriSelectionResultEnum.esriSelectionResultAdd;
esriSpatialRelEnum linearSelectionMethod = selectionEnvironment.LinearSelectionMethod;
esriSpatialRelEnum areaSelectionMethod = selectionEnvironment.AreaSelectionMethod;
if (ienvelope0 is IEnvelope)
{
if (this.double_0 == -1)
{
this.double_0 = -1;
}
else if (this.double_0 <= this.double_1)
{
selectionEnvironment.LinearSelectionMethod = esriSpatialRelEnum.esriSpatialRelIntersects;
selectionEnvironment.AreaSelectionMethod = esriSpatialRelEnum.esriSpatialRelIntersects;
}
else
{
selectionEnvironment.LinearSelectionMethod = esriSpatialRelEnum.esriSpatialRelContains;
selectionEnvironment.AreaSelectionMethod = esriSpatialRelEnum.esriSpatialRelContains;
this.double_1 = -1;
}
}
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
try
{
focusMap.SelectByShape(ienvelope0, selectionEnvironment, false);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
if (cOMException.ErrorCode != -2147467259)
{
Logger.Current.Error("", cOMException, "");
}
else
{
MessageBox.Show("执行查询时产生错误。空间索引不存在", "选择");
}
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
selectionEnvironment.LinearSelectionMethod = linearSelectionMethod;
selectionEnvironment.AreaSelectionMethod = areaSelectionMethod;
}
/// <summary>
/// 获取topo下的geometry union的数据
/// </summary>
/// <param name="featureClass">源要素类</param>
/// <param name="queryClause">查询条件</param>
/// <param name="queryGeometry">指定范围下</param>
/// <param name="spatialRelType">空间参考类型</param>
/// <param name="topoUnionGeometry">输出topo union后的geometry</param>
/// <param name="oidList">输出OID集合</param>
/// <param name="geometryField">geometry字段名称，默认为Shape</param>
public static void GetTopounionGeometryByQuery(IFeatureClass featureClass, String queryClause,
IGeometry queryGeometry, esriSpatialRelEnum spatialRelType,
out IGeometry topoUnionGeometry, out IList <string> oidList, string geometryField = "Shape")
{
List <IFeature> featureList = new List <IFeature>();
topoUnionGeometry = null;
oidList = new List <string>();
try
{
ISpatialFilter spatialFilter = new SpatialFilter();
if (!string.IsNullOrEmpty(queryClause))
{
spatialFilter.WhereClause = queryClause;
}
if (!string.IsNullOrEmpty(geometryField))
{
spatialFilter.GeometryField = geometryField;
}
if (queryGeometry != null)
{
spatialFilter.Geometry = queryGeometry;
spatialFilter.SpatialRel = spatialRelType;
}
ITopologicalOperator topologicalOperator = null;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
IFeature feature = featureCursor.NextFeature();
IGeometry geometryTemp;
while (feature != null)
{
geometryTemp = feature.Shape; // feature.ShapeCopy;
if (topologicalOperator == null)
{
topologicalOperator = geometryTemp as ITopologicalOperator;
}
else
{
topologicalOperator = topologicalOperator.Union(geometryTemp) as ITopologicalOperator;
}
oidList.Add(feature.OID.ToString());
featureList.Add(feature);
feature = featureCursor.NextFeature();
}
topoUnionGeometry = topologicalOperator as IGeometry;
WorkspaceUtil.ReleaseComObject(featureCursor);
}
catch (Exception e)
{
LOG.Error(e, $"{nameof(GetTopounionGeometryByQuery)}抛异常");
}
}
public IFeatureCursor Search(IMap pMap, string lyrName, string whereClause, IGeometry pGeometry,
esriSpatialRelEnum pSpatialRelEnum)
{
IFeatureCursor featureCursor;
IFeatureLayer featureLayer = MapHelper.FindLayer(pMap as IBasicMap, lyrName) as IFeatureLayer;
if (featureLayer == null)
{
featureCursor = null;
}
else
{
featureCursor = this.SearchShape(pGeometry, featureLayer.FeatureClass, whereClause, pSpatialRelEnum);
}
return(featureCursor);
}
public IFeatureCursor SearchShape(IGeometry pGeometry, IFeatureClass pFeatureClass, string whereClause,
esriSpatialRelEnum pSpatialRelEnum)
{
ISpatialFilter spatialFilterClass = new SpatialFilter()
{
GeometryField = pFeatureClass.ShapeFieldName,
Geometry = pGeometry
};
if (whereClause.Length > 0)
{
spatialFilterClass.WhereClause = whereClause;
}
spatialFilterClass.SpatialRel = pSpatialRelEnum;
return(pFeatureClass.Search(spatialFilterClass, false));
}
public bool EvaluateRelation(ISpatialFilter spatialFilter)
{
Assert.ArgumentNotNull(spatialFilter, nameof(spatialFilter));
Assert.NotNull(_sourceGeometry, nameof(_sourceGeometry));
Assert.NotNull(_targetGeometry, nameof(_targetGeometry));
esriSpatialRelEnum relation = spatialFilter.SpatialRel;
switch (relation)
{
case esriSpatialRelEnum.esriSpatialRelIntersects:
return(EvaluateIntersects(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelTouches:
return(EvaluateTouches(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelOverlaps:
return(EvaluateOverlaps(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelCrosses:
return(EvaluateCrosses(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelWithin:
return(EvaluateWithin(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelContains:
return(EvaluateContains(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelRelation:
return(EvaluateRelation(_sourceGeometry, _targetGeometry,
spatialFilter.SpatialRelDescription));
case esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects:
return(EvaluateEnvelopeIntersects(_sourceGeometry, _targetGeometry));
case esriSpatialRelEnum.esriSpatialRelUndefined:
case esriSpatialRelEnum.esriSpatialRelIndexIntersects:
throw new ArgumentException(
string.Format("Filter uses unsupported spatial relation: {0}", relation),
nameof(spatialFilter));
default:
throw new ArgumentException(
string.Format("Filter uses unknown spatial relation: {0}", relation),
nameof(spatialFilter));
}
}
private void comboBoxSpatialRel_SelectedIndexChanged(object sender, EventArgs e)
{
switch (comboBoxSpatialRel.SelectedIndex)
{
case 0: pSpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
labelDescription.Text = "从待选的图层中选择出与＂条件图层＂（或已被选中的元素）相交的那些元素"; break;
case 1: pSpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
labelDescription.Text = "从待选的图层中选择出那些被＂条件图层＂（或已被选中的元素）所包含的元素"; break;
case 2: pSpatialRel = esriSpatialRelEnum.esriSpatialRelWithin;
labelDescription.Text = "从待选图层中选择出那些完全包含＂条件图层＂（或已被选中的元素）的元素"; break;
case 3: pSpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
labelDescription.Text = "适用于由边界接触的情况"; break;
}
}
/// <summary>
/// ZQ 20111119 add
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cmbSpatialRel_SelectedIndexChanged(object sender, EventArgs e)
{
switch (cmbSpatialRel.SelectedItem.ToString())
{
case "相交":
m_esriSpatialRelEnum = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
case "相接":
m_esriSpatialRelEnum = esriSpatialRelEnum.esriSpatialRelTouches;
break;
case "穿越":
m_esriSpatialRelEnum = esriSpatialRelEnum.esriSpatialRelCrosses;
break;
case "包含":
m_esriSpatialRelEnum = esriSpatialRelEnum.esriSpatialRelContains;
break;
}
}
public virtual ZhFeature[] GetFeaturesNoExtend(IGeometry pGeometry, esriSpatialRelEnum pesriSpatialRelEnum)
{
//List<ZHFeature> pFeatures = new List<ZHFeature>();
//try
//{
// pFeatures.Clear();
if (pGeometry is ITopologicalOperator)
{
(pGeometry as ITopologicalOperator).Simplify();
}
ISpatialFilter psf = new SpatialFilterClass();
psf.Geometry = pGeometry;
psf.GeometryField = this.featureClass.ShapeFieldName;
psf.SpatialRel = pesriSpatialRelEnum;
//属性先搜索，再空间搜索
psf.SearchOrder = esriSearchOrder.esriSearchOrderAttribute;
IFeatureCursor pFeatCur = this.featureClass.Search(psf, false);
return(GetFeatures(pFeatCur));
// IFeature feat = pFeatCur.NextFeature();
// while (feat != null)
// {
// pFeatures.Add(this.CreateZHFeature(feat));
// feat = pFeatCur.NextFeature();
// }
// feat = null;
// pFeatCur = null;
// psf = null;
//}
//catch
//{
// pFeatures.Clear();
//}
//return pFeatures.ToArray();
}
protected QaSpatialRelationBase([NotNull] IFeatureClass featureClass,
esriSpatialRelEnum relation)
: this(new[] { featureClass }, relation)
{
}
/// <summary>
/// 空间属性查询
/// </summary>
/// <params name="geom">查询对象</params>
/// <params name="sql">sql语句</params>
/// <params name="featurelyr">图层</params>
/// <returns>返回查询结果集合</returns>
public IFeatureCursor SpatialSearch(IGeometry geom, string sql, IFeatureLayer featurelyr, esriSpatialRelEnum rel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects)
{
IFeatureClass featureclass = featurelyr.FeatureClass;
IFeatureCursor feacursor = null;
if (featureclass != null)
{
ISpatialFilter filter = new SpatialFilter();
filter.Geometry = geom;
filter.WhereClause = sql;
filter.SpatialRel = rel;
feacursor = featureclass.Search(filter, false);
}
return feacursor;
}
private void comboBoxSpatialRel_SelectedIndexChanged(object sender, EventArgs e)
{
switch (comboBoxSpatialRel.SelectedIndex)
{
case 0: pSpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
labelDescription.Text = "�Ӵ�ѡ��ͼ����ѡ����룢����ͼ�㣢�����ѱ�ѡ�е�Ԫ�أ��ཻ����ЩԪ��"; break;
case 1: pSpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
labelDescription.Text = "�Ӵ�ѡ��ͼ����ѡ�����Щ��������ͼ�㣢�����ѱ�ѡ�е�Ԫ�أ���������Ԫ��"; break;
case 2: pSpatialRel = esriSpatialRelEnum.esriSpatialRelWithin;
labelDescription.Text = "�Ӵ�ѡͼ����ѡ�����Щ��ȫ����������ͼ�㣢�����ѱ�ѡ�е�Ԫ�أ���Ԫ��"; break;
case 3: pSpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
labelDescription.Text = "�������ɱ߽�Ӵ������"; break;
}
}
/// <summary>
/// check if a shape has the specified relationship with any features in the specified feature class
/// </summary>
public static bool HasRelationshipWithFC(IGeometry GeomToCheck, esriSpatialRelEnum SpatRel,
IFeatureClass FeatureClassToSearchIn, string WhereClause)
{
ISpatialFilter ThisSpatialFilter;
IFeatureCursor ThisFeatureCursor;
IFeature CheckFeature;
bool DoesRelate = false;
ThisSpatialFilter = new SpatialFilterClass();
ThisSpatialFilter.set_GeometryEx(GeomToCheck, false);
ThisSpatialFilter.GeometryField = FeatureClassToSearchIn.ShapeFieldName;
ThisSpatialFilter.SpatialRel = SpatRel;
ThisSpatialFilter.WhereClause = WhereClause;
try
{
ThisFeatureCursor = FeatureClassToSearchIn.Search(ThisSpatialFilter, false);
CheckFeature = ThisFeatureCursor.NextFeature();
DoesRelate = CheckFeature == null ? false : true;
}
catch
{
}
ThisFeatureCursor = null;
CheckFeature = null;
return DoesRelate;
}
public void Apply()
{
if (this.cboSourceLayer.SelectedIndex != -1)
{
IFeatureLayer layer = null;
layer = (this.cboSourceLayer.SelectedItem as LayerObject).Layer as IFeatureLayer;
ICursor cursor = null;
if (this.chkUseSelectFeature.Checked)
{
(layer as IFeatureSelection).SelectionSet.Search(null, false, out cursor);
}
else
{
cursor = layer.Search(null, false) as ICursor;
}
esriSpatialRelEnum esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelIntersects;
string text = this.cboSpatialRelation.Text;
switch (text)
{
case null:
break;
case "相交":
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
case "包围矩形相交":
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
break;
case "相接":
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelTouches;
break;
case "重叠":
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelOverlaps;
break;
default:
if (!(text == "被包含"))
{
if (text == "包含")
{
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelContains;
}
}
else
{
esriSpatialRelIntersects = esriSpatialRelEnum.esriSpatialRelWithin;
}
break;
}
esriSelectionResultEnum esriSelectionResultNew = esriSelectionResultEnum.esriSelectionResultNew;
switch (this.cboOperationType.SelectedIndex)
{
case 0:
esriSelectionResultNew = esriSelectionResultEnum.esriSelectionResultNew;
break;
case 1:
esriSelectionResultNew = esriSelectionResultEnum.esriSelectionResultAdd;
break;
case 2:
esriSelectionResultNew = esriSelectionResultEnum.esriSelectionResultSubtract;
break;
case 3:
esriSelectionResultNew = esriSelectionResultEnum.esriSelectionResultAnd;
break;
}
IFeatureLayer layer2 = null;
for (int i = 0; i < this.checkedListBoxLayer.CheckedItems.Count; i++)
{
layer2 = (this.checkedListBoxLayer.CheckedItems[i] as LayerObject).Layer as IFeatureLayer;
this.method_6(layer2, cursor as IFeatureCursor, esriSpatialRelIntersects, esriSelectionResultNew);
}
(this.imap_0 as IActiveView).Refresh();
ComReleaser.ReleaseCOMObject(cursor);
}
}
/// <summary>
/// 筛选要素类中，与指定图形满足一定空间关系的要素
/// (参考：http://blog.csdn.net/lanpy88/article/details/7173063)
/// </summary>
/// <param name="featureLayer">从中筛选要素的图层</param>
/// <param name="geometry">过滤条件图形</param>
/// <param name="spatialRefEnum">空间关系类型（举例：esriSpatialRelContains表示A包含B）</param>
/// <param name="whereClause">查询条件</param>
/// <returns></returns>
public static List <IFeature> FilterFeatures(this IFeatureLayer featureLayer, IGeometry geometry, esriSpatialRelEnum spatialRefEnum, string whereClause = "")
{
return(FilterFeatures(featureLayer.FeatureClass, geometry, spatialRefEnum, whereClause));
}
private IFeatureCursor FindFeatures(IGeometry geometry, IFeatureClass featureClass, esriSpatialRelEnum spatialRelationship, IMap map)
{
//1 = esriSpatialRelIntersects
//7 = esriSpatialWithin
//8 = esriSpatialRelContains
ISpatialFilter spatialFilter = new SpatialFilter();
spatialFilter.Geometry = geometry;
spatialFilter.set_OutputSpatialReference(featureClass.ShapeFieldName, map.SpatialReference);
spatialFilter.GeometryField = featureClass.ShapeFieldName;
spatialFilter.SpatialRel = spatialRelationship;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
return featureCursor;
}
/// <summary>
/// 空间属性查询
/// </summary>
/// <param name="geom">查询对象</param>
/// <param name="sql">sql语句</param>
/// <param name="featurelyr">图层</param>
/// <returns>返回查询结果集合</returns>
public IFeatureCursor SpatialSearch(IGeometry geom, string sql, IFeatureLayer featurelyr, esriSpatialRelEnum rel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects)
{
IFeatureClass featureclass = featurelyr.FeatureClass;
IFeatureCursor feacursor = null;
if (featureclass != null)
{
ISpatialFilter filter = new SpatialFilter();
filter.Geometry = geom;
filter.WhereClause = sql;
filter.SpatialRel = rel;
feacursor = featureclass.Search(filter, false);
}
return(feacursor);
}
/// <summary>
/// Realiza uma busca espacial retornando um cursor apenas
/// no layer específico. A relação é "Está contido"
/// </summary>
/// <param name="polyBuffer">Geometria do buffer que circunda a pesquisa</param>
/// <param name="flayer">Feature Class que se deseja selecionar</param>
/// <param name="spatialEnum">Relação espacial de consulta</param>
/// <param name="whereClause">Condition beyond the spatial filter</param>
/// <returns>Cursor com o resultado da busca espacial</returns>
public static IFeatureCursor BuscaEspacial(IGeometry polyBuffer,
IFeatureClass fClass,
esriSpatialRelEnum spatialEnum)
{
ISpatialFilter sf = new SpatialFilter();
sf.Geometry = polyBuffer;
sf.GeometryField = "Shape";
sf.SpatialRel = spatialEnum;
IFeatureCursor fc = null;
try
{
fc = fClass.Search(sf, false);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return fc;
}
/// <summary>
/// Realiza uma busca espacial retornando um cursor apenas
/// no layer específico. A relação é "Está contido"
/// </summary>
/// <param name="polyBuffer">Geometria do buffer que circunda a pesquisa</param>
/// <param name="flayer">Feature Class que se deseja selecionar</param>
/// <param name="spatialEnum">Relação espacial de consulta</param>
/// <param name="whereClause">Condition beyond the spatial filter</param>
/// <returns>Cursor com o resultado da busca espacial</returns>
public static IFeatureCursor BuscaEspacial(IGeometry polyBuffer,
IFeatureLayer flayer,
esriSpatialRelEnum spatialEnum)
{
ISpatialFilter sf = new SpatialFilter();
sf.Geometry = polyBuffer;
sf.GeometryField = "Shape";
sf.SpatialRel = spatialEnum;
IFeatureCursor fc = null;
//sf.WhereClause = (flayer as IFeatureLayerDefinition).DefinitionExpression;
try
{
fc = flayer.FeatureClass.Search(sf, false);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return fc;
}
//<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);
}
}
//<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);
}
}
/// <summary>
/// 筛选要素类中，与指定图形满足一定空间关系的要素
/// (参考：http://blog.csdn.net/lanpy88/article/details/7173063)
/// </summary>
/// <param name="featureClass">从中筛选要素的要素类(A)</param>
/// <param name="geometry">过滤条件图形(B)</param>
/// <param name="spatialRefEnum">空间关系类型（举例：esriSpatialRelContains表示A包含B）</param>
/// <param name="whereClause">查询条件</param>
/// <returns></returns>
public static List <IFeature> FilterFeatures(this IFeatureClass featureClass, IGeometry geometry, esriSpatialRelEnum spatialRefEnum, string whereClause = "")
{
List <IFeature> result = new List <IFeature>();
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = geometry;
spatialFilter.SpatialRel = spatialRefEnum;
spatialFilter.WhereClause = whereClause;
IFeatureCursor cursor = featureClass.Search(spatialFilter, false);
IFeature touchFeature = cursor.NextFeature();
while (touchFeature != null)
{
result.Add(touchFeature);
touchFeature = cursor.NextFeature();
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(cursor);
return(result);
}
private void method_6(IFeatureLayer ifeatureLayer_0, IFeatureCursor ifeatureCursor_0,
esriSpatialRelEnum esriSpatialRelEnum_0, esriSelectionResultEnum esriSelectionResultEnum_0)
{
IFeature feature = ifeatureCursor_0.NextFeature();
IFeatureSelection selection = ifeatureLayer_0 as IFeatureSelection;
double bufferDistance = selection.BufferDistance;
if (this.chkUseBuffer.Checked)
{
try
{
selection.BufferDistance = double.Parse(this.txtRadius.Text);
}
catch
{
}
}
bool flag = true;
while (feature != null)
{
if (feature.Shape == null)
{
feature = ifeatureCursor_0.NextFeature();
}
else if (feature.Shape.IsEmpty)
{
feature = ifeatureCursor_0.NextFeature();
}
else
{
try
{
ISpatialFilter filter = new SpatialFilter
{
SpatialRel = esriSpatialRelEnum_0
};
if (selection.BufferDistance > 0.0)
{
filter.Geometry = (feature.Shape as ITopologicalOperator).Buffer(selection.BufferDistance);
}
else
{
IGeometry shape = feature.Shape;
filter.Geometry = shape;
}
if (flag)
{
selection.SelectFeatures(filter, esriSelectionResultEnum_0, false);
flag = false;
}
else
{
selection.SelectFeatures(filter, esriSelectionResultEnum.esriSelectionResultAdd, false);
}
}
catch
{
}
feature = ifeatureCursor_0.NextFeature();
}
}
selection.BufferDistance = bufferDistance;
}
/// <summary>
/// 筛选要素类中，与指定图形满足一定空间关系的要素（空间筛选时添加空间索引）
/// (参考：http://blog.csdn.net/lanpy88/article/details/7173063)
/// </summary>
/// <param name="featureClass">从中筛选要素的要素类(A)</param>
/// <param name="geometry">过滤条件图形(B)</param>
/// <param name="spatialRefEnum">空间关系类型（举例：esriSpatialRelContains表示A包含B）</param>
/// <param name="whereClause">查询条件</param>
/// <returns></returns>
public static List <IFeature> FilterFeaturesEx(this IFeatureClass featureClass, IGeometry geometry, esriSpatialRelEnum spatialRefEnum, string whereClause = "")
{
IGeometryBag geometryBag = new GeometryBagClass();
IGeometryCollection geometryCollection = (IGeometryCollection)geometryBag;
geometryBag.SpatialReference = ((IGeoDataset)featureClass).SpatialReference; //一定要给GeometryBag赋空间参考
geometryCollection.AddGeometry(geometry);
//为GeometryBag生成空间索引，以提高效率
ISpatialIndex spatialIndex = (ISpatialIndex)geometryBag;
spatialIndex.AllowIndexing = true;
spatialIndex.Invalidate();
return(FilterFeatures(featureClass, geometry, spatialRefEnum, whereClause));
}
