/// <summary>
/// 添加单要素拓扑规则
/// </summary>
/// <param name="topology">建立的拓扑</param>
/// <param name="FeatureClassName1">要素的名称</param>
/// <param name="TopoRule">拓扑规则中文描述</param>
private void AddTopoRules(ITopology topology, string FeatureClassName1, string TopoRule)
{
IFeatureClass pFeatureClass1 = getFeatureClassByName(FeatureClassName1, pFeatureClassList);
esriTopologyRuleType RuleType = getTopoRuleByDescription(TopoRule);
//创建拓扑规则
ITopologyRule pTopoRule = new TopologyRuleClass();
pTopoRule.OriginClassID = pFeatureClass1.FeatureClassID;
pTopoRule.TopologyRuleType = RuleType;
//这两个参数应该设置为true，否则生成的拓扑没有东西
pTopoRule.AllDestinationSubtypes = true;
pTopoRule.AllOriginSubtypes = true;
ITopologyRuleContainer pTopologyRuleContainer = topology as ITopologyRuleContainer;
if (pTopologyRuleContainer.CanAddRule[pTopoRule])
{
pTopologyRuleContainer.AddRule(pTopoRule);
}
else
{
throw new ArgumentException("无法添加" + pFeatureClass1.AliasName + "-" + pTopoRule.Name + "!");
}
}
public void AddRuleToTopology2(ITopology topology, esriTopologyRuleType ruleType, String ruleName, IFeatureClass originClass, int originSubtype, IFeatureClass destinationClass, int destinationSubtype)
{
// Create a topology rule.
ITopologyRule topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = ruleType;
topologyRule.Name = ruleName;
topologyRule.OriginClassID = originClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
//topologyRule.OriginSubtype = originSubtype;
topologyRule.DestinationClassID = destinationClass.FeatureClassID;
topologyRule.AllDestinationSubtypes = true;
//topologyRule.DestinationSubtype = destinationSubtype;
// Cast the topology to the ITopologyRuleContainer interface and add the rule.
ITopologyRuleContainer topologyRuleContainer = (ITopologyRuleContainer)topology;
if (topologyRuleContainer.get_CanAddRule(topologyRule))
{
topologyRuleContainer.AddRule(topologyRule);
}
else
{
throw new ArgumentException("Could not add specified rule to the topology.");
}
}
/// <summary>
/// 为要素类添加拓扑规则，针对针对特殊的要素类检查
/// </summary>
/// <param name="pTopo">拓扑</param>
/// <param name="pTopoRuleType">拓扑规则</param>
/// <param name="outError">异常</param>
public void AddRuletoTopology(ITopology pTopo, esriTopologyRuleType pTopoRuleType, out Exception outError)
{
outError = null;
try
{
ITopologyRuleContainer pRuleContainer = pTopo as ITopologyRuleContainer;
IFeatureClassContainer pFeaClsContainer = pTopo as IFeatureClassContainer;
IEnumFeatureClass pEnumFeaCls = pFeaClsContainer.Classes;
pEnumFeaCls.Reset();
IFeatureClass pFeaCls = pEnumFeaCls.Next();
//设置拓扑规则
while (pFeaCls != null)
{
ITopologyRule pTopoRule = new TopologyRuleClass();
pTopoRule.TopologyRuleType = pTopoRuleType;
pTopoRule.Name = (pFeaCls as IDataset).Name;
pTopoRule.OriginClassID = pFeaCls.FeatureClassID;
pTopoRule.AllOriginSubtypes = true;
pRuleContainer.AddRule(pTopoRule);
pFeaCls = pEnumFeaCls.Next();
}
}
catch (Exception ex)
{
////*********************************************
////guozheng 2010-12-24 平安夜 added 系统异常日志
//if (ModData.SysLog == null) ModData.SysLog = new clsWriteSystemFunctionLog();
//ModData.SysLog.Write(ex);
////**********************************************
outError = ex;
}
}
/// <summary>
/// 添加拓扑规则条件
/// </summary>
/// <param name="topology">拓扑对象</param>
/// <param name="ruleType">规则类型</param>
/// <param name="ruleName">规则名称</param>
/// <param name="featureClass">要素类</param>
private void AddRuleToTopology(ITopology topology, esriTopologyRuleType ruleType, String ruleName, IFeatureClass featureClass)
{
try
{
// Create a topology rule.
ITopologyRule topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = ruleType;
topologyRule.Name = ruleName;
topologyRule.OriginClassID = featureClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
// Cast the topology to the ITopologyRuleContainer interface and add the rule.
ITopologyRuleContainer topologyRuleContainer = (ITopologyRuleContainer)topology;
if (topologyRuleContainer.get_CanAddRule(topologyRule))
{
topologyRuleContainer.AddRule(topologyRule);
}
else
{
throw new ArgumentException("Could not add specified rule to the topology.");
}
}
catch (Exception)
{
}
}
/// <summary>
/// 添加拓扑规则
/// </summary>
/// <param name="topology"></param>
/// <param name="ruleType">要添加的双要素规则</param>
/// <param name="featureClassA">第一个要素类</param>
/// <param name="featureClassB">第二个要素类</param>
public static void AddRuleToTopology(this ITopology topology, esriTopologyRuleType ruleType, IFeatureClass featureClassA, IFeatureClass featureClassB = null)
{
if (topology == null)
{
throw new Exception("请先构建拓扑");
}
var topologyRule = CreateTopologyRule(ruleType, featureClassA, featureClassB);
AddRuleToTopology(topology, topologyRule);
}
public TopologyRule(SerializationInfo info, StreamingContext context) : base(info, context)
{
this._name = info.GetString("name");
this._guid = info.GetString("guid");
this._topologyRuleType = (esriTopologyRuleType)Enum.Parse(typeof(esriTopologyRuleType), info.GetString("topologyRuleType"), true);
this._originClassId = info.GetInt32("originClassId");
this._originSubtype = info.GetInt32("originSubtype");
this._destinationClassId = info.GetInt32("destinationClassId");
this._destinationSubtype = info.GetInt32("destinationSubtype");
this._triggerErrorEvents = info.GetBoolean("triggerErrorEvents");
this._allOriginSubtypes = info.GetBoolean("allOriginSubtypes");
this._allDestinationSubtypes = info.GetBoolean("allDestinationSubtypes");
}
public TopologyRule(TopologyRule prototype) : base(prototype)
{
this._name = prototype.Name;
this._guid = prototype.Guid;
this._topologyRuleType = prototype.TopologyRuleType;
this._originClassId = prototype.OriginClassId;
this._originSubtype = prototype.OriginSubtype;
this._destinationClassId = prototype.DestinationClassId;
this._destinationSubtype = prototype.DestinationSubtype;
this._triggerErrorEvents = prototype.TriggerErrorEvents;
this._allOriginSubtypes = prototype.AllOriginSubtypes;
this._allDestinationSubtypes = prototype.AllDestinationSubtypes;
}
/// <summary>
/// 创建拓扑规则
/// </summary>
/// <param name="ruleType">拓扑规则类型</param>
/// <param name="featureClassA">第一个要素类</param>
/// <param name="featureClassB">第二个要素类</param>
/// <returns></returns>
public static ITopologyRule CreateTopologyRule(this esriTopologyRuleType ruleType, IFeatureClass featureClassA, IFeatureClass featureClassB = null)
{
ITopologyRule topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = ruleType;
topologyRule.Name = ruleType.ToString();
topologyRule.OriginClassID = featureClassA.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
if (featureClassB != null)
{
topologyRule.DestinationClassID = featureClassB.FeatureClassID;
topologyRule.AllDestinationSubtypes = true;
}
return(topologyRule);
}
private void AddRuleToTopology(ITopology topology, esriTopologyRuleType ruleType, string ruleName, IFeatureClass featureClass)
{
ITopologyRule topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = ruleType;
topologyRule.Name = ruleName;
topologyRule.OriginClassID = featureClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
ITopologyRuleContainer topologyRuleConatiner = topology as ITopologyRuleContainer;
if (topologyRuleConatiner.get_CanAddRule(topologyRule))
{
topologyRuleConatiner.AddRule(topologyRule);
}
else
{
throw new ArgumentException("Counld not add specified rule to the topology");
}
}
public static bool DeleteError(ITopology pTopology, ITopologyErrorFeature pTopoErrorFeat)
{
IFeatureClass class2 = (pTopology as IFeatureClassContainer).get_ClassByID(pTopoErrorFeat.OriginClassID);
esriTopologyRuleType topologyRuleType = pTopoErrorFeat.TopologyRuleType;
if (topologyRuleType != esriTopologyRuleType.esriTRTPointProperlyInsideArea)
{
if (topologyRuleType != esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint)
{
return(false);
}
}
else
{
class2.GetFeature(pTopoErrorFeat.OriginOID).Delete();
return(true);
}
class2.GetFeature(pTopoErrorFeat.OriginOID).Delete();
return(true);
}
public static string GetDescription(esriTopologyRuleType rule) {
switch (rule) {
case esriTopologyRuleType.esriTRTAny:
return "Any Rule";
case esriTopologyRuleType.esriTRTFeatureLargerThanClusterTolerance:
return "The rule is a feature to be deleted is smaller than the cluster tolerance rule";
case esriTopologyRuleType.esriTRTAreaNoGaps:
return "Must not have gaps";
case esriTopologyRuleType.esriTRTAreaNoOverlap:
return "Must not overlap";
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass:
return "Must be covered by feature class of";
case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther:
return "Must cover each other";
case esriTopologyRuleType.esriTRTAreaCoveredByArea:
return "Must be covered by";
case esriTopologyRuleType.esriTRTAreaNoOverlapArea:
return "Must not overlap with";
case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary:
return "Must be covered by boundary of";
case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary:
return "Must be covered by boundary of";
case esriTopologyRuleType.esriTRTPointProperlyInsideArea:
return "Must be properly inside polygons";
case esriTopologyRuleType.esriTRTLineNoOverlap:
return "Must not overlap";
case esriTopologyRuleType.esriTRTLineNoIntersection:
return "Must not intersect";
case esriTopologyRuleType.esriTRTLineNoDangles:
return "Must not have dangles";
case esriTopologyRuleType.esriTRTLineNoPseudos:
return "Must not have pseudo-nodes";
case esriTopologyRuleType.esriTRTLineCoveredByLineClass:
return "Must be covered by feature class of";
case esriTopologyRuleType.esriTRTLineNoOverlapLine:
return "Must not overlap with";
case esriTopologyRuleType.esriTRTPointCoveredByLine:
return "Point must be covered by line";
case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint:
return "Must be covered by endpoint of";
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine:
return "Boundary must be covered by";
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary:
return "Area boundary must be covered by boundary of";
case esriTopologyRuleType.esriTRTLineNoSelfOverlap:
return "Must not self overlap";
case esriTopologyRuleType.esriTRTLineNoSelfIntersect:
return "Must not self intersect";
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch:
return "Must not intersect or touch interior";
case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint:
return "Endpoint must be covered by";
case esriTopologyRuleType.esriTRTAreaContainPoint:
return "Contains point";
case esriTopologyRuleType.esriTRTLineNoMultipart:
return "Must be single part";
default:
return "Unknown";
}
}
public TopologyRule(IXPathNavigable path) : base(path)
{
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <Name />
XPathNavigator navigatorName = navigator.SelectSingleNode("Name");
if (navigatorName != null)
{
this._name = navigatorName.Value;
}
// <GUID>C27042FF-A8D0-4A18-9C55-21EAD4495196</GUID>
XPathNavigator navigatorGUID = navigator.SelectSingleNode("GUID");
if (navigatorGUID != null)
{
this._guid = navigatorGUID.Value;
}
// <TopologyRuleType>esriTRTAreaNoOverlap</TopologyRuleType>
XPathNavigator navigatorTopologyRuleType = navigator.SelectSingleNode("TopologyRuleType");
if (navigatorTopologyRuleType != null)
{
this._topologyRuleType = (esriTopologyRuleType)Enum.Parse(typeof(esriTopologyRuleType), navigatorTopologyRuleType.Value, true);
}
// <OriginClassID>5</OriginClassID>
XPathNavigator navigatorOriginClassID = navigator.SelectSingleNode("OriginClassID");
if (navigatorOriginClassID != null)
{
this._originClassId = navigatorOriginClassID.ValueAsInt;
}
// <OriginSubtype>0</OriginSubtype>
XPathNavigator navigatorOriginSubtype = navigator.SelectSingleNode("OriginSubtype");
if (navigatorOriginSubtype != null)
{
this._originSubtype = navigatorOriginSubtype.ValueAsInt;
}
// <DestinationClassID>5</DestinationClassID>
XPathNavigator navigatorDestinationClassID = navigator.SelectSingleNode("DestinationClassID");
if (navigatorDestinationClassID != null)
{
this._destinationClassId = navigatorDestinationClassID.ValueAsInt;
}
// <DestinationSubtype>0</DestinationSubtype>
XPathNavigator navigatorDestinationSubtype = navigator.SelectSingleNode("DestinationSubtype");
if (navigatorDestinationSubtype != null)
{
this._destinationSubtype = navigatorDestinationSubtype.ValueAsInt;
}
// <TriggerErrorEvents>false</TriggerErrorEvents>
XPathNavigator navigatorTriggerErrorEvents = navigator.SelectSingleNode("TriggerErrorEvents");
if (navigatorTriggerErrorEvents != null)
{
this._triggerErrorEvents = navigatorTriggerErrorEvents.ValueAsBoolean;
}
// <AllOriginSubtypes>true</AllOriginSubtypes>
XPathNavigator navigatorAllOriginSubtypes = navigator.SelectSingleNode("AllOriginSubtypes");
if (navigatorName != null)
{
this._allOriginSubtypes = navigatorAllOriginSubtypes.ValueAsBoolean;
}
// <AllDestinationSubtypes>true</AllDestinationSubtypes>
XPathNavigator navigatorAllDestinationSubtypes = navigator.SelectSingleNode("AllDestinationSubtypes");
if (navigatorAllDestinationSubtypes != null)
{
this._allDestinationSubtypes = navigatorAllDestinationSubtypes.ValueAsBoolean;
}
}
public TopologyRule(SerializationInfo info, StreamingContext context) : base(info, context) {
this._name = info.GetString("name");
this._guid = info.GetString("guid");
this._topologyRuleType = (esriTopologyRuleType)Enum.Parse(typeof(esriTopologyRuleType), info.GetString("topologyRuleType"), true);
this._originClassId = info.GetInt32("originClassId");
this._originSubtype = info.GetInt32("originSubtype");
this._destinationClassId = info.GetInt32("destinationClassId");
this._destinationSubtype = info.GetInt32("destinationSubtype");
this._triggerErrorEvents = info.GetBoolean("triggerErrorEvents");
this._allOriginSubtypes = info.GetBoolean("allOriginSubtypes");
this._allDestinationSubtypes = info.GetBoolean("allDestinationSubtypes");
}
public TopologyRule(TopologyRule prototype) : base(prototype) {
this._name = prototype.Name;
this._guid = prototype.Guid;
this._topologyRuleType = prototype.TopologyRuleType;
this._originClassId = prototype.OriginClassId;
this._originSubtype = prototype.OriginSubtype;
this._destinationClassId = prototype.DestinationClassId;
this._destinationSubtype = prototype.DestinationSubtype;
this._triggerErrorEvents = prototype.TriggerErrorEvents;
this._allOriginSubtypes = prototype.AllOriginSubtypes;
this._allDestinationSubtypes = prototype.AllDestinationSubtypes;
}
/// <summary>
/// 面拓扑检查
/// </summary>
/// <param name="pDataCheckClass"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="topoRule"></param>
/// <param name="eError"></param>
public void AreaTopoCheck(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType topoRule, out Exception eError)
{
eError = null;
//设置进度条
ProgressChangeEvent eInfo = new ProgressChangeEvent();
eInfo.Max = pTable.Rows.Count;
int pValue = 0;
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if ((FeaClsName == "") || (!FeaClsName.Contains(";")))
{
eError = new Exception("图层名为空或配置不正确!");
return;
}
string[] feaNameArr = FeaClsName.Split(new char[] { ';' });
string oriFeaClsName = feaNameArr[0].Trim(); //源要素类名
string desFeaClsName = feaNameArr[1].Trim(); //目标要素名
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryTopoCheck(hook, pFeaDataset, oriFeaClsName, desFeaClsName, topoRule, out eError);
if (eError != null)
{
return;
}
}
}
private void method_0()
{
this.ipopuMenuWrap_0.Clear();
this.ipopuMenuWrap_0.AddItem("TopologyError_ZoomTo", false);
this.ipopuMenuWrap_0.AddItem("TopologyError_PanTo", false);
this.ipopuMenuWrap_0.AddItem("TopologyError_SelectFeature", false);
this.ipopuMenuWrap_0.AddItem("ShowTopoRuleDescript", true);
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count != 0)
{
ITopologyErrorFeature topologyErrorFeature = FixTopologyErrorTool.m_pTopoErroeSelection[0].TopologyErrorFeature;
esriTopologyRuleType topologyRuleType = topologyErrorFeature.TopologyRuleType;
bool flag = true;
int num = 1;
while (true)
{
if (num >= FixTopologyErrorTool.m_pTopoErroeSelection.Count)
{
break;
}
else if (FixTopologyErrorTool.m_pTopoErroeSelection[num].TopologyErrorFeature.TopologyRuleType != topologyRuleType)
{
flag = false;
break;
}
else
{
num++;
}
}
if (flag)
{
esriTopologyRuleType _esriTopologyRuleType = topologyRuleType;
switch (_esriTopologyRuleType)
{
case esriTopologyRuleType.esriTRTAreaNoGaps:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", true);
break;
}
case (esriTopologyRuleType)2:
case (esriTopologyRuleType)6:
case esriTopologyRuleType.esriTRTAreaNoGaps | esriTopologyRuleType.esriTRTAreaNoOverlapArea:
case esriTopologyRuleType.esriTRTLineInsideArea:
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass | esriTopologyRuleType.esriTRTAreaNoOverlapArea:
case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary:
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass | esriTopologyRuleType.esriTRTAreaNoOverlapArea | esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary:
case esriTopologyRuleType.esriTRTAreaContainOnePoint:
case esriTopologyRuleType.esriTRTAreaNoGaps | esriTopologyRuleType.esriTRTAreaContainOnePoint:
case (esriTopologyRuleType)18:
{
break;
}
case esriTopologyRuleType.esriTRTAreaNoOverlap:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count == 1)
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Merge", false);
}
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", false);
break;
}
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass:
case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", false);
break;
}
case esriTopologyRuleType.esriTRTAreaCoveredByArea:
{
Label1:
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", true);
break;
}
case esriTopologyRuleType.esriTRTAreaNoOverlapArea:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count != 1)
{
break;
}
this.ipopuMenuWrap_0.AddItem("TopologyError_Merge", false);
break;
}
case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
break;
}
case esriTopologyRuleType.esriTRTPointProperlyInsideArea:
{
Label0:
this.ipopuMenuWrap_0.AddItem("TopologyError_Delete", true);
break;
}
case esriTopologyRuleType.esriTRTLineNoOverlap:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
break;
}
case esriTopologyRuleType.esriTRTLineNoIntersection:
{
Label2:
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count <= 0)
{
break;
}
topologyErrorFeature = FixTopologyErrorTool.m_pTopoErroeSelection[0].TopologyErrorFeature;
esriGeometryType shapeType = topologyErrorFeature.ShapeType;
bool flag1 = true;
num = 1;
while (true)
{
if (num >= FixTopologyErrorTool.m_pTopoErroeSelection.Count)
{
break;
}
else if (FixTopologyErrorTool.m_pTopoErroeSelection[num].TopologyErrorFeature.ShapeType != shapeType)
{
flag1 = false;
break;
}
else
{
num++;
}
}
if (!flag1)
{
break;
}
if (shapeType != esriGeometryType.esriGeometryPolyline)
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Split", true);
break;
}
else
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
break;
}
}
case esriTopologyRuleType.esriTRTLineNoDangles:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Extend", true);
this.ipopuMenuWrap_0.AddItem("TopologyError_Trim", false);
break;
}
case esriTopologyRuleType.esriTRTLineNoPseudos:
{
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count != 1)
{
break;
}
this.ipopuMenuWrap_0.AddItem("TopologyError_Merge", true);
break;
}
default:
{
switch (_esriTopologyRuleType)
{
case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Delete", true);
break;
}
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine:
case esriTopologyRuleType.esriTRTAreaContainPoint:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", true);
break;
}
case esriTopologyRuleType.esriTRTLineNoSelfOverlap:
case esriTopologyRuleType.esriTRTLineNoSelfIntersect:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Simply", true);
break;
}
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch:
{
if (FixTopologyErrorTool.m_pTopoErroeSelection.Count <= 0)
{
break;
}
topologyErrorFeature = FixTopologyErrorTool.m_pTopoErroeSelection[0].TopologyErrorFeature;
esriGeometryType shapeType = topologyErrorFeature.ShapeType;
bool flag1 = true;
num = 1;
while (true)
{
if (num >= FixTopologyErrorTool.m_pTopoErroeSelection.Count)
{
break;
}
else if (FixTopologyErrorTool.m_pTopoErroeSelection[num].TopologyErrorFeature.ShapeType != shapeType)
{
flag1 = false;
break;
}
else
{
num++;
}
}
if (!flag1)
{
break;
}
if (shapeType != esriGeometryType.esriGeometryPolyline)
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Split", true);
break;
}
else
{
this.ipopuMenuWrap_0.AddItem("TopologyError_Subtract", true);
break;
}
}
case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint:
{
this.ipopuMenuWrap_0.AddItem("TopologyError_CreateFeature", true);
break;
}
}
break;
}
}
}
this.ipopuMenuWrap_0.AddItem("PromoteToRuleException", true);
this.ipopuMenuWrap_0.AddItem("DemoteFromRuleException", false);
}
}
/// <summary>
/// 同层线相交检查
/// </summary>
/// <param name="hook"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="eError"></param>
public void SpecialFeaClsTopoCheck2(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType pTopoRule, out Exception eError)
{
eError = null;
List <string> feaclsNameList = new List <string>();
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if (FeaClsName == "")
{
eError = new Exception("图层名为空!");
return;
}
if (!feaclsNameList.Contains(FeaClsName))
{
feaclsNameList.Add(FeaClsName);
}
}
if (feaclsNameList.Count == 0)
{
return;
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryTopoCheck(hook, pFeaDataset, feaclsNameList, pTopoRule, out eError);
if (eError != null)
{
return;
}
}
/// <summary>
/// 将中文拓扑规则翻译为esri拓扑规则
/// </summary>
/// <param name="_topoRules">中文拓扑规则描述</param>
/// <returns></returns>
public static esriTopologyRuleType TransferToESRITopoRule(TopoRules _topoRules)
{
esriTopologyRuleType pESRITopoType = esriTopologyRuleType.esriTRTAny;
switch (_topoRules)
{
case TopoRules.一个面图层里各要素之间不能有个缝隙:
pESRITopoType = esriTopologyRuleType.esriTRTAreaNoGaps;
break;
case TopoRules.一个面图层里各要素间不能有叠加:
pESRITopoType = esriTopologyRuleType.esriTRTAreaNoOverlap;
break;
case TopoRules.第二个图层面要素必须被第一个图层任一面要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTAreaCoveredByAreaClass;
break;
case TopoRules.面要素必须只包含一个点要素:
pESRITopoType = esriTopologyRuleType.esriTRTAreaContainOnePoint;
break;
case TopoRules.两图层面要素必须互相覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTAreaAreaCoverEachOther;
break;
case TopoRules.第一个图层面要素必须被另一个图层任一面要素包含:
pESRITopoType = esriTopologyRuleType.esriTRTAreaCoveredByArea;
break;
case TopoRules.图层间面要素不能相互覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTAreaNoOverlapArea;
break;
case TopoRules.线要素必须跟面图层边界的一部分或全部重叠:
pESRITopoType = esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary;
break;
case TopoRules.点要素必须落在面要素边界上:
pESRITopoType = esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary;
break;
case TopoRules.点要素必须落在面要素内:
pESRITopoType = esriTopologyRuleType.esriTRTPointProperlyInsideArea;
break;
case TopoRules.线要素间不能有相互重叠部分:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoOverlap;
break;
case TopoRules.线要素之间不能相交:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoIntersection;
break;
case TopoRules.线要素不允许有悬挂点:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoDangles;
break;
case TopoRules.线要素不允许有假节点:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoPseudos;
break;
case TopoRules.第一个图层线要素应被第二个线图层线要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTLineCoveredByLineClass;
break;
case TopoRules.第一个图层线要素不被第二个线图层线要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoOverlapLine;
break;
case TopoRules.点要素应被线要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTPointCoveredByLine;
break;
case TopoRules.点要素应在线要素的端点上:
pESRITopoType = esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint;
break;
case TopoRules.面要素边界必须被线要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine;
break;
case TopoRules.面要素的边界必须被另一面要素边界覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary;
break;
case TopoRules.线要素不能自重叠:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoSelfOverlap;
break;
case TopoRules.线要素不能自相交:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoSelfIntersect;
break;
case TopoRules.线要素间不能重叠和相交:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch;
break;
case TopoRules.线要素端点必须被点要素覆盖:
pESRITopoType = esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint;
break;
case TopoRules.面要素内必须包含至少一个点要素:
pESRITopoType = esriTopologyRuleType.esriTRTAreaContainPoint;
break;
case TopoRules.线不能是多段:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoMultipart;
break;
case TopoRules.点要素之间不相交:
pESRITopoType = esriTopologyRuleType.esriTRTPointDisjoint;
break;
case TopoRules.线要素必须不相交:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoIntersectLine;
break;
case TopoRules.线必须不相交或内部接触:
pESRITopoType = esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouchLine;
break;
default:
break;
}
return(pESRITopoType);
}
private string method_0(esriTopologyRuleType esriTopologyRuleType_0)
{
switch (esriTopologyRuleType_0)
{
case esriTopologyRuleType.esriTRTAny:
return("所有错误");
case esriTopologyRuleType.esriTRTFeatureLargerThanClusterTolerance:
return("必需大于集束容限值");
case esriTopologyRuleType.esriTRTAreaNoGaps:
return("面不能有缝隙");
case esriTopologyRuleType.esriTRTAreaNoOverlap:
return("面不能重叠");
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass:
return("面必须被面要素类覆盖");
case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther:
return("面必须和其它面要素层相互覆盖");
case esriTopologyRuleType.esriTRTAreaCoveredByArea:
return("面必须被面覆盖");
case esriTopologyRuleType.esriTRTAreaNoOverlapArea:
return("面不能与其他面层重叠");
case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary:
return("线必须被面要素边界线覆盖");
case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary:
return("点必须被面要素边界线覆盖");
case esriTopologyRuleType.esriTRTPointProperlyInsideArea:
return("点落在面要素内");
case esriTopologyRuleType.esriTRTLineNoOverlap:
return("线不能重叠");
case esriTopologyRuleType.esriTRTLineNoIntersection:
return("线不能相交");
case esriTopologyRuleType.esriTRTLineNoDangles:
return("线不能有悬挂点");
case esriTopologyRuleType.esriTRTLineNoPseudos:
return("线不能有伪节点");
case esriTopologyRuleType.esriTRTLineCoveredByLineClass:
return("线必须被线要素覆盖");
case esriTopologyRuleType.esriTRTLineNoOverlapLine:
return("线与线不能重叠");
case esriTopologyRuleType.esriTRTPointCoveredByLine:
return("点必须被线要素覆盖");
case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint:
return("点必须被线要素终点覆盖");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine:
return("面边界线必须被线要素覆盖");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary:
return("面边界线必须被其它面层边界线覆盖");
case esriTopologyRuleType.esriTRTLineNoSelfOverlap:
return("线不能自重叠");
case esriTopologyRuleType.esriTRTLineNoSelfIntersect:
return("线不能自相交");
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch:
return("线不能相交或内部相接");
case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint:
return("线终点必须被点要素覆盖");
case esriTopologyRuleType.esriTRTAreaContainPoint:
return("面包含点");
case esriTopologyRuleType.esriTRTLineNoMultipart:
return("线必须为单部分");
}
return("所有错误");
}
/// <summary>
/// 同层线重叠检查
/// </summary>
/// <param name="hook"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="eError"></param>
public void SpecialFeaClsTopoCheck(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType pTopoRule, out Exception eError)
{
eError = null;
//设置进度条
ProgressChangeEvent eInfo = new ProgressChangeEvent();
eInfo.Max = pTable.Rows.Count;
int pValue = 0;
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if (FeaClsName == "")
{
eError = new Exception("图层名为空!");
return;
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryTopoCheck(hook, pFeaDataset, FeaClsName, pTopoRule, out eError);
if (eError != null)
{
return;
}
//进度条加1
pValue++;
eInfo.Value = pValue;
GeoDataChecker.GeoDataChecker_ProgressShow((object)GeoDataChecker._ProgressBarInner, eInfo);
}
}
private IFeature GetFeature(DataRow rowError, string strLayerName)
{
IMap theMap = this.m_HookHelper.FocusMap;
MapLayersController mapController = new MapLayersController(theMap);
enumErrorType errType = (enumErrorType)Convert.ToInt32(rowError["ErrorType"]);
switch (errType)
{
case enumErrorType.Topology:
{
ITopologyLayer topoLayerTarget = mapController.GetLayer(strLayerName) as ITopologyLayer;
if (topoLayerTarget == null)
{
return(null);
}
ITopology topology = topoLayerTarget.Topology;
IErrorFeatureContainer errFeatureContainer = topology as IErrorFeatureContainer;
esriTopologyRuleType ruleType = (esriTopologyRuleType)Convert.ToInt32(rowError[Field_Name_TopologyRuleType]);
//string strGeoType = rowError[Field_Name_TopologyGeometryType] as string;
//esriGeometryType geoType = (strGeoType == "点" ? esriGeometryType.esriGeometryPoint : (strGeoType == "线" ? esriGeometryType.esriGeometryLine : esriGeometryType.esriGeometryPolygon));
esriGeometryType geoType = (esriGeometryType)Convert.ToInt32(rowError[Field_Name_TopologyGeometryType]);
int sourceClassID = (int)rowError["SourceLayerID"];
int sourceOID = (int)rowError["OID"];
int targetClassID = (int)rowError["TargetLayerID"];
int targetOID = Convert.ToInt32(rowError["OID2"]);
return(errFeatureContainer.get_ErrorFeature((topology as IGeoDataset).SpatialReference, ruleType, geoType, sourceClassID, sourceOID, targetClassID, targetOID) as IFeature);
}
break;
case enumErrorType.Normal:
{
IFeatureLayer flyrTarget = mapController.GetLayer(strLayerName) as IFeatureLayer;
if (flyrTarget == null)
{
return(null);
}
// 改为优先从OID查找定位
if (rowError.Table.Columns.Contains(Field_Name_TargetOID) && rowError[Field_Name_TargetOID] != DBNull.Value)
{
return(flyrTarget.FeatureClass.GetFeature((int)rowError[Field_Name_TargetOID]));
}
else if (rowError.Table.Columns.Contains(Field_Name_TargetBSM) && !string.IsNullOrEmpty(rowError[Field_Name_TargetBSM] as string))
{
IQueryFilter qFilter = new QueryFilterClass();
IFields fields = flyrTarget.FeatureClass.Fields;
int fieldIndex = fields.FindField("BSM");
if (fieldIndex < 0)
{
return(null);
}
IField bsmField = fields.get_Field(fieldIndex);
if (bsmField.Type == esriFieldType.esriFieldTypeInteger)
{
qFilter.WhereClause = string.Format("BSM={0}", rowError[Field_Name_TargetBSM]);
}
else
{
qFilter.WhereClause = string.Format("BSM='{0}'", rowError[Field_Name_TargetBSM]);
}
IFeatureCursor fCursor = flyrTarget.FeatureClass.Search(qFilter, false);
return(fCursor.NextFeature());
}
else
{
return(null);
}
}
default: return(null);
}
}
public static void DoSplit(ITopology pTopology, ITopologyErrorFeature pTopoErrorFeat)
{
IFeatureClass class2 = (pTopology as IFeatureClassContainer).get_ClassByID(pTopoErrorFeat.OriginClassID);
IFeatureClass class3 = null;
try
{
if (pTopoErrorFeat.DestinationClassID != 0)
{
class3 = (pTopology as IFeatureClassContainer).get_ClassByID(pTopoErrorFeat.DestinationClassID);
}
}
catch
{
}
esriTopologyRuleType topologyRuleType = pTopoErrorFeat.TopologyRuleType;
if (((topologyRuleType == esriTopologyRuleType.esriTRTLineNoIntersection) ||
(topologyRuleType == esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch)) &&
((pTopoErrorFeat as IFeature).Shape is IPoint))
{
int num;
IFeature feature2;
IFeature feature3;
IFeature feature = class2.GetFeature(pTopoErrorFeat.OriginOID);
IPolycurve shapeCopy = feature.ShapeCopy as IPolycurve;
IPoint shape = (pTopoErrorFeat as IFeature).Shape as IPoint;
IList list = PointSplitLine(shapeCopy, shape);
for (num = 0; num < list.Count; num++)
{
if (num == 0)
{
feature.Shape = list[num] as IGeometry;
feature.Store();
}
else
{
feature2 = RowOperator.CreatRowByRow(feature) as IFeature;
feature2.Shape = list[num] as IGeometry;
}
}
if (class3 == null)
{
feature3 = class2.GetFeature(pTopoErrorFeat.DestinationOID);
}
else
{
feature3 = class3.GetFeature(pTopoErrorFeat.DestinationOID);
}
shapeCopy = feature3.ShapeCopy as IPolycurve;
list = PointSplitLine(shapeCopy, shape);
for (num = 0; num < list.Count; num++)
{
if (num == 0)
{
feature3.Shape = list[num] as IGeometry;
feature3.Store();
}
else
{
feature2 = RowOperator.CreatRowByRow(feature3) as IFeature;
feature2.Shape = list[num] as IGeometry;
feature2.Store();
}
}
}
}
/// <summary>
/// 添加拓扑规则条件
/// </summary>
/// <param name="topology">拓扑对象</param>
/// <param name="ruleType">规则类型</param>
/// <param name="ruleName">规则名称</param>
/// <param name="featureClass">要素类</param>
private void AddRuleToTopology(ITopology topology, esriTopologyRuleType ruleType, String ruleName, IFeatureClass featureClass)
{
try
{
// Create a topology rule.
ITopologyRule topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = ruleType;
topologyRule.Name = ruleName;
topologyRule.OriginClassID = featureClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
// Cast the topology to the ITopologyRuleContainer interface and add the rule.
ITopologyRuleContainer topologyRuleContainer = (ITopologyRuleContainer)topology;
if (topologyRuleContainer.get_CanAddRule(topologyRule))
{
topologyRuleContainer.AddRule(topologyRule);
}
else
{
throw new ArgumentException("Could not add specified rule to the topology.");
}
}
catch (Exception)
{
}
}
public TopologyRule(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <Name />
XPathNavigator navigatorName = navigator.SelectSingleNode("Name");
if (navigatorName != null) {
this._name = navigatorName.Value;
}
// <GUID>C27042FF-A8D0-4A18-9C55-21EAD4495196</GUID>
XPathNavigator navigatorGUID = navigator.SelectSingleNode("GUID");
if (navigatorGUID != null) {
this._guid = navigatorGUID.Value;
}
// <TopologyRuleType>esriTRTAreaNoOverlap</TopologyRuleType>
XPathNavigator navigatorTopologyRuleType = navigator.SelectSingleNode("TopologyRuleType");
if (navigatorTopologyRuleType != null) {
this._topologyRuleType = (esriTopologyRuleType)Enum.Parse(typeof(esriTopologyRuleType), navigatorTopologyRuleType.Value, true);
}
// <OriginClassID>5</OriginClassID>
XPathNavigator navigatorOriginClassID = navigator.SelectSingleNode("OriginClassID");
if (navigatorOriginClassID != null) {
this._originClassId = navigatorOriginClassID.ValueAsInt;
}
// <OriginSubtype>0</OriginSubtype>
XPathNavigator navigatorOriginSubtype = navigator.SelectSingleNode("OriginSubtype");
if (navigatorOriginSubtype != null) {
this._originSubtype = navigatorOriginSubtype.ValueAsInt;
}
// <DestinationClassID>5</DestinationClassID>
XPathNavigator navigatorDestinationClassID = navigator.SelectSingleNode("DestinationClassID");
if (navigatorDestinationClassID != null) {
this._destinationClassId = navigatorDestinationClassID.ValueAsInt;
}
// <DestinationSubtype>0</DestinationSubtype>
XPathNavigator navigatorDestinationSubtype = navigator.SelectSingleNode("DestinationSubtype");
if (navigatorDestinationSubtype != null) {
this._destinationSubtype = navigatorDestinationSubtype.ValueAsInt;
}
// <TriggerErrorEvents>false</TriggerErrorEvents>
XPathNavigator navigatorTriggerErrorEvents = navigator.SelectSingleNode("TriggerErrorEvents");
if (navigatorTriggerErrorEvents != null) {
this._triggerErrorEvents = navigatorTriggerErrorEvents.ValueAsBoolean;
}
// <AllOriginSubtypes>true</AllOriginSubtypes>
XPathNavigator navigatorAllOriginSubtypes = navigator.SelectSingleNode("AllOriginSubtypes");
if (navigatorName != null) {
this._allOriginSubtypes = navigatorAllOriginSubtypes.ValueAsBoolean;
}
// <AllDestinationSubtypes>true</AllDestinationSubtypes>
XPathNavigator navigatorAllDestinationSubtypes = navigator.SelectSingleNode("AllDestinationSubtypes");
if (navigatorAllDestinationSubtypes != null) {
this._allDestinationSubtypes = navigatorAllDestinationSubtypes.ValueAsBoolean;
}
}
public static string JTEsriTopologyRuleTypeCHNDescription(this esriTopologyRuleType type)
{
switch (type)
{
case esriTopologyRuleType.esriTRTAny: return("Any");
case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther: return("面面必须覆盖");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary: return("面边界必须覆盖面边界");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine: return("面边界必须被线覆盖");
case esriTopologyRuleType.esriTRTAreaContainOnePoint: return("面必须包含一个点");
case esriTopologyRuleType.esriTRTAreaContainPoint: return("面包含点");
case esriTopologyRuleType.esriTRTAreaCoveredByArea: return("面必须被面覆盖");
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass: return("面必须被面要素类覆盖");
case esriTopologyRuleType.esriTRTAreaNoGaps: return("面没有缝隙");
case esriTopologyRuleType.esriTRTAreaNoOverlap: return("面不能重叠");
case esriTopologyRuleType.esriTRTAreaNoOverlapArea: return("面不能覆盖面");
case esriTopologyRuleType.esriTRTFeatureLargerThanClusterTolerance: return("小于容差");
case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary: return("线必须被面边界覆盖");
case esriTopologyRuleType.esriTRTLineCoveredByLineClass: return("线被线要素类覆盖");
case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint: return("线端点被点覆盖");
case esriTopologyRuleType.esriTRTLineInsideArea: return("线在面内部");
case esriTopologyRuleType.esriTRTLineNoDangles: return("线不能有悬挂点");
case esriTopologyRuleType.esriTRTLineNoIntersection: return("线不能相交");
case esriTopologyRuleType.esriTRTLineNoIntersectLine: return("线与线不能相交");
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch: return("线不能相交或内部接触");
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouchLine: return("线不能相交或内部接触线");
case esriTopologyRuleType.esriTRTLineNoMultipart: return("线必须是单一部分");
case esriTopologyRuleType.esriTRTLineNoOverlap: return("线不能重叠");
case esriTopologyRuleType.esriTRTLineNoOverlapLine: return("线不能与线重叠");
case esriTopologyRuleType.esriTRTLineNoPseudos: return("线不能有伪节点");
case esriTopologyRuleType.esriTRTLineNoSelfIntersect: return("线不能自相交");
case esriTopologyRuleType.esriTRTLineNoSelfOverlap: return("线不能自重叠");
case esriTopologyRuleType.esriTRTPointCoincidePoint: return("点必须重合");
case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary: return("点必须被面边界覆盖");
case esriTopologyRuleType.esriTRTPointCoveredByLine: return("点必须被线覆盖");
case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint: return("点必须被线端点覆盖");
case esriTopologyRuleType.esriTRTPointDisjoint: return("点不相交");
case esriTopologyRuleType.esriTRTPointProperlyInsideArea: return("点必须完全在面内部");
}
return(null);
}
/// <summary>
/// 将要素类添加到拓扑中，并为要素类添加拓扑规则，针对针对特殊的要素类检查
/// </summary>
/// <param name="pTopo">拓扑</param>
/// <param name="pFeatureDataset">数据集</param>
/// <param name="pFeaClsName">图层名</param>
/// <param name="pTopoRuleType">拓扑规则</param>
/// <param name="outError">异常</param>
public void AddRuleandClasstoTopology(ITopology pTopo, IFeatureDataset pFeatureDataset, string pFeaClsName, esriTopologyRuleType pTopoRuleType, out Exception outError)
{
outError = null;
AddClasstoTopology(pTopo, pFeatureDataset, pFeaClsName, out outError);
if (outError != null)
{
return;
}
AddRuletoTopology(pTopo, pTopoRuleType, out outError);
if (outError != null)
{
return;
}
}
public static string GetDescription(esriTopologyRuleType rule)
{
switch (rule)
{
case esriTopologyRuleType.esriTRTAny:
return("Any Rule");
case esriTopologyRuleType.esriTRTFeatureLargerThanClusterTolerance:
return("The rule is a feature to be deleted is smaller than the cluster tolerance rule");
case esriTopologyRuleType.esriTRTAreaNoGaps:
return("Must not have gaps");
case esriTopologyRuleType.esriTRTAreaNoOverlap:
return("Must not overlap");
case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass:
return("Must be covered by feature class of");
case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther:
return("Must cover each other");
case esriTopologyRuleType.esriTRTAreaCoveredByArea:
return("Must be covered by");
case esriTopologyRuleType.esriTRTAreaNoOverlapArea:
return("Must not overlap with");
case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary:
return("Must be covered by boundary of");
case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary:
return("Must be covered by boundary of");
case esriTopologyRuleType.esriTRTPointProperlyInsideArea:
return("Must be properly inside polygons");
case esriTopologyRuleType.esriTRTLineNoOverlap:
return("Must not overlap");
case esriTopologyRuleType.esriTRTLineNoIntersection:
return("Must not intersect");
case esriTopologyRuleType.esriTRTLineNoDangles:
return("Must not have dangles");
case esriTopologyRuleType.esriTRTLineNoPseudos:
return("Must not have pseudo-nodes");
case esriTopologyRuleType.esriTRTLineCoveredByLineClass:
return("Must be covered by feature class of");
case esriTopologyRuleType.esriTRTLineNoOverlapLine:
return("Must not overlap with");
case esriTopologyRuleType.esriTRTPointCoveredByLine:
return("Point must be covered by line");
case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint:
return("Must be covered by endpoint of");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine:
return("Boundary must be covered by");
case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary:
return("Area boundary must be covered by boundary of");
case esriTopologyRuleType.esriTRTLineNoSelfOverlap:
return("Must not self overlap");
case esriTopologyRuleType.esriTRTLineNoSelfIntersect:
return("Must not self intersect");
case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch:
return("Must not intersect or touch interior");
case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint:
return("Endpoint must be covered by");
case esriTopologyRuleType.esriTRTAreaContainPoint:
return("Contains point");
case esriTopologyRuleType.esriTRTLineNoMultipart:
return("Must be single part");
default:
return("Unknown");
}
}
private bool InsertTopoError(IFeatureClass destFClass)
{
try
{
string strSQL = @"SELECT
b.CheckType,
IIF(b.TargetFeatClass1 is Null,'',b.TargetFeatClass1) as YSTC,
IIF(a.SourceBSM is Null,'',a.SourceBSM) as SourceBSM,
IIF(a.MBTC is Null,'',a.MBTC) as MBTC,
IIF(a.TargetBSM is Null,'',a.TargetBSM) as BSM2,
a.TPTC as TopoLayerName,
a.Reason as Description,
a.IsException as IsException,
IIf(a.Remark is Null,'',a.Remark) as Remark,
b.GZBM ,
a.ArcGisRule as ArcGisRule,
a.JHLX as JHLX,
a.SourceLayerID,
a.TargetLayerID,
a.SourceOID as OID,
a.TargetOID as OID2
from LR_ResAutoTopo as a, LR_ResultEntryRule as b where a.RuleInstID=b.RuleInstID
";
DataTable dtError = Hy.Common.Utility.Data.AdoDbHelper.GetDataTable(this.ResultConnection, strSQL);
IFeatureCursor fCusorInsert = destFClass.Insert(false);
Dictionary <int, int> dictFieldIndex = new Dictionary <int, int>();
for (int i = 0; i < m_FieldCaptions.Count; i++)
{
dictFieldIndex.Add(i, destFClass.FindField(m_FieldCaptions[i]));
}
int xFieldIndex = destFClass.FindField("X坐标");
int yFieldIndex = destFClass.FindField("Y坐标");
IErrorFeatureContainer errFeatureContainer = this.Topology as IErrorFeatureContainer;
ISpatialReference spatialRef = (this.Topology as IGeoDataset).SpatialReference;
for (int i = 0; i < dtError.Rows.Count; i++)
{
DataRow rowError = dtError.Rows[i];
int fClassID = Convert.ToInt32(rowError["SourceLayerID"]);
int fClassID2 = Convert.ToInt32(rowError["TargetLayerID"]);
int oid = Convert.ToInt32(rowError["OID"]);
int oid2 = Convert.ToInt32(rowError["OID2"]);
esriGeometryType geoType = (esriGeometryType)Convert.ToInt32(rowError["JHLX"]);
esriTopologyRuleType ruleType = (esriTopologyRuleType)Convert.ToInt32(rowError["ArcGISRule"]);
IFeature srcFeature = errFeatureContainer.get_ErrorFeature(spatialRef, ruleType, geoType, fClassID, fClassID2, oid, oid2) as IFeature;
IFeatureBuffer fNew = destFClass.CreateFeatureBuffer();
for (int j = 0; j < m_FieldCaptions.Count; j++)
{
int fIndex = dictFieldIndex[j];
if (fIndex < 0)
{
continue;
}
fNew.set_Value(fIndex, rowError[j]);
}
fNew.Shape = GetErrorGeometry(srcFeature);
IPoint point = fNew.Shape as IPoint;
fNew.set_Value(xFieldIndex, point.X);
fNew.set_Value(yFieldIndex, point.Y);
fCusorInsert.InsertFeature(fNew);
if (i % 2000 == 0)
{
fCusorInsert.Flush();
}
}
fCusorInsert.Flush();
return(true);
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return(false);
}
}
/// <summary>
/// 面拓扑检查
/// </summary>
/// <param name="pDataCheckClass"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="topoRule"></param>
/// <param name="eError"></param>
public void AreaTopoCheck2(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType topoRule, out Exception eError)
{
eError = null;
List <string> FeaClsNameDic = new List <string>();
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if ((FeaClsName == "") || (!FeaClsName.Contains(";")))
{
eError = new Exception("图层名为空或配置不正确!");
return;
}
string[] feaNameArr = FeaClsName.Split(new char[] { ';' });
string oriFeaClsName = feaNameArr[0].Trim(); //源要素类名
string desFeaClsName = feaNameArr[1].Trim(); //目标要素名
if (!FeaClsNameDic.Contains(oriFeaClsName + ";" + desFeaClsName))
{
FeaClsNameDic.Add(oriFeaClsName + ";" + desFeaClsName);
}
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryDicTopoCheck(hook, pFeaDataset, FeaClsNameDic, topoRule, out eError);
if (eError != null)
{
return;
}
}
private void btnCheck_Click(object sender, EventArgs e)
{
if (_FeatureClass == null)
{
MessageBox.Show("请选择小班图层!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
IFeatureDataset pFeaDataSet = _FeatureClass.FeatureDataset;
string pFeaClsName = (_FeatureClass as IDataset).Name;
if (pFeaDataSet == null)
{
MessageBox.Show("检查数据必须在要素集中!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
this.progressStep.Visible = true;
progressStep.Minimum = 0;
progressStep.Maximum = 7;
progressStep.Step = 1;
Exception outError = null;
ClsTopoCheck pTopoCheck = new ClsTopoCheck();
_ClsTopoCheck = pTopoCheck;
//创建拓扑
progressStep.PerformStep();
this.lblTips.Text = "创建拓扑";
Application.DoEvents();
ITopology pTopo = pTopoCheck.CreateTopo(pFeaDataSet, pFeaDataSet.Name, 0, out outError);
if (outError != null)
{
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);
progressStep.Visible = false;
this.lblTips.Text = "创建拓扑失败";
return;
}
esriTopologyRuleType pRuleNoOverLap = esriTopologyRuleType.esriTRTAreaNoOverlap;
//将要素类添加到拓扑中并创建拓扑规则
progressStep.PerformStep();
pTopoCheck.AddRuleandClasstoTopology(pTopo, pFeaDataSet, pFeaClsName, pRuleNoOverLap, out outError);
if (outError != null)
{
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);
progressStep.Visible = false;
this.lblTips.Text = "添加拓扑规则失败";
return;
}
esriTopologyRuleType pRuleNoGap = esriTopologyRuleType.esriTRTAreaNoGaps;
//将要素类添加到拓扑中并创建拓扑规则
progressStep.PerformStep();
this.lblTips.Text = "创建拓扑";
pTopoCheck.AddRuleandClasstoTopology(pTopo, pFeaDataSet, pFeaClsName, pRuleNoGap, out outError);
if (outError != null)
{
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);
progressStep.Visible = false;
this.lblTips.Text = "添加拓扑规则失败";
return;
}
//拓扑验证范围
IEnvelope pEnvelop = null;
pEnvelop = (pFeaDataSet as IGeoDataset).Extent;
//文字提示
//验证拓扑
progressStep.PerformStep();
this.lblTips.Text = "验证拓扑";
pTopoCheck.ValidateTopology(pTopo, pEnvelop, out outError);
if (outError != null)
{
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);
progressStep.Visible = false;
this.lblTips.Text = "验证拓扑失败";
return;
}
//文字提示
DataTable pDataTable = InitDataTale();
pTopoCheck.DataTable = pDataTable;
//获得错误列表
FrmTopoCheckResult pFrm = new FrmTopoCheckResult(_MapControl);
DevComponents.DotNetBar.Controls.DataGridViewX pDataGridErrs = pFrm.ErrorDataGrid;
progressStep.PerformStep();
this.lblTips.Text = "获取错误列表";
pTopoCheck.GetAreaNoOverlopErrorList(pFeaDataSet, pTopo, pEnvelop, pDataGridErrs, out outError);
if (outError != null)
{
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);
progressStep.Visible = false;
this.lblTips.Text = "获取错误列表失败";
return;
}
pDataGridErrs.DataSource = pDataTable;
pFrm.ErrDataTable = pDataTable;
//移除拓扑
progressStep.PerformStep();
this.lblTips.Text = "移除拓扑";
pTopoCheck.RemoveTopo(pFeaDataSet, pFeaDataSet.Name, out outError);//因为移除完无法编辑暂时没找到好办法先不屏蔽 zhangqi 2012-08-10
progressStep.Visible = false;
if (outError != null)
{
return;
}
this.Close();
pFrm.Show();
}
