//规则添加工具
private void PRV_AddRuleTool(ITopologyRule IN_TopologyRule)
{
ITopologyRuleContainer Temp_TopologyRuleContainer = (ITopologyRuleContainer)Topology;//构建容器
try
{
Temp_TopologyRuleContainer.get_CanAddRule(IN_TopologyRule);//不能添加的话直接报错
try
{
Temp_TopologyRuleContainer.DeleteRule(IN_TopologyRule); //删除已存在的规则后再添加
Temp_TopologyRuleContainer.AddRule(IN_TopologyRule); //规则存在的话直接报错
}
catch
{
Temp_TopologyRuleContainer.AddRule(IN_TopologyRule);
}
}
catch
{
MessageBox.Show("不支持添加");
}
PRV_ValidateTopologyWithGP(); //添加完成后自动检验
PUB_GetTopoLayer(); //存储创建的拓扑图层
PRV_GetError(IN_TopologyRule); //输出错误
}
//获取错误信息
private void PRV_GetError(ITopologyRule IN_TopologyRule)
{
if (Topology != null)
{
IEnvelope Temp_Envolope = (this.Topology as IGeoDataset).Extent;
IErrorFeatureContainer Temp_ErrorContainer = Topology as IErrorFeatureContainer;
//获取所有信息
IEnumTopologyErrorFeature Temp_EnumErrorFeature = Temp_ErrorContainer.get_ErrorFeatures(((IGeoDataset)FeatureDataset_Main).SpatialReference, IN_TopologyRule, Temp_Envolope, true, true);
ITopologyErrorFeature Temp_ErrorFeature = Temp_EnumErrorFeature.Next();
while (Temp_ErrorFeature != null)
{
IFeature Temp_Feature = Temp_ErrorFeature as IFeature;
string Temp_ErrorInfo;
if (Temp_ErrorFeature.DestinationClassID != 0)//检测是否是双要素规则
{
Temp_ErrorInfo = Temp_ErrorFeature.OriginOID + "," + Temp_ErrorFeature.DestinationOID;
}
else
{
Temp_ErrorInfo = Temp_ErrorFeature.OriginOID.ToString();
}
LI_AllErrorInfo.Add((PRV_RecorverTopologyRuleType((int)(Temp_ErrorFeature.TopologyRuleType))) + " " + Temp_ErrorInfo);//将错误信息加入List
//MessageBox.Show("错误：" + PRV_RecorverTopologyRuleType((int)(Temp_ErrorFeature.TopologyRuleType)) + "\r\n错误ID：" + Temp_ErrorInfo);
Temp_ErrorFeature = Temp_EnumErrorFeature.Next();
}
}
else
{
MessageBox.Show("请先构建拓扑");
}
}
//规则添加工具
private void PRV_AddRuleTool(ITopologyRule IN_TopologyRule, string idname)
{
ITopologyRuleContainer Temp_TopologyRuleContainer = (ITopologyRuleContainer)Topology;//构建容器
try
{
Temp_TopologyRuleContainer.get_CanAddRule(IN_TopologyRule);//不能添加的话直接报错
try
{
Temp_TopologyRuleContainer.DeleteRule(IN_TopologyRule); //删除已存在的规则后再添加
IN_TopologyRule.OriginSubtype = int.Parse(idname);
Temp_TopologyRuleContainer.AddRule(IN_TopologyRule); //规则存在的话直接报错
}
catch
{
Temp_TopologyRuleContainer.AddRule(IN_TopologyRule);
}
}
catch
{
MessageBox.Show("不支持添加");
}
// PRV_ValidateTopologyWithGP();//添加完成后自动检验
//PUB_GetTopoLayer();//存储创建的拓扑图层
//PRV_GetError(IN_TopologyRule);//输出错误
}
/// <summary>
/// 导出拓扑错误图形， 在指定要素数据集(IFeatureDataset)或工作空间(IWorkspace)新建要素类以保存拓扑错误图形
/// </summary>
/// <param name="topologyRule">拓扑规则</param>
/// <param name="topology">拓扑</param>
/// <param name="resultObject">指定的要素数据集(IFeatureDataset)或工作空间(IWorkspace)，用于创建新要素类，保存拓扑错误图形</param>
public static IFeatureClass TopoErrorToNewFeatureClass(this ITopologyRule topologyRule, ITopology topology, object resultObject, string resultClassName = null)
{
//获得指定拓扑规则类型的拓扑错误要素
var errorFeatures = GetTopoErrorFeatures(topologyRule, topology);
if (errorFeatures.Count < 1)
{
return(null);
}
//创建保存拓扑错误的要素类
var feature = errorFeatures[0] as IFeature;
var geoType = feature.Shape.GeometryType;
if (string.IsNullOrEmpty(resultClassName))
{
resultClassName = topologyRule.TopologyRuleType.ToString();
}
IFeature tmpFeature = errorFeatures[0] as IFeature;
var resultFeatureClass = FeatureClassEx.Create(resultObject, resultClassName,
tmpFeature.Shape.SpatialReference, geoType, new FieldsClass());
//将拓扑错误要素存入要素类中
TopoErrorInsertToFeatureClass(errorFeatures, resultFeatureClass);
return(resultFeatureClass);
}
private void btnClearRule_Click(object sender, EventArgs e)
{
for (int i = 0; i < this.listRule.SelectedItems.Count; i++)
{
ITopologyRule tag = (ITopologyRule)this.listRule.SelectedItems[i].Tag;
this.listRule.Items.Remove(this.listRule.SelectedItems[i]);
}
this.listRule.SelectedItems.Clear();
}
/// <summary>
/// 获取指定类型的拓扑错误要素枚举
/// </summary>
/// <param name="topologyRule">拓扑规则</param>
/// <param name="topology">拓扑</param>
/// <returns></returns>
public static IEnumTopologyErrorFeature GetEnumTopoErrorFeature(this ITopologyRule topologyRule, ITopology topology)
{
IEnvelope envelope = (topology as IGeoDataset).Extent;
IErrorFeatureContainer errorContainer = topology as IErrorFeatureContainer;
IEnumTopologyErrorFeature enumErrorFeature = errorContainer.get_ErrorFeatures(
((IGeoDataset)topology.FeatureDataset).SpatialReference, topologyRule, envelope, true, true);
return(enumErrorFeature);
}
private void btnAddRule_Click(object sender, EventArgs e)
{
frmRule rule = new frmRule
{
OriginClassArray = TopologyEditHelper.m_pList
};
if (rule.ShowDialog() == DialogResult.OK)
{
try
{
if (!rule.bVaildRule)
{
MessageBox.Show("无效规则！");
}
else
{
ITopologyRule topologyRule = rule.TopologyRule;
if (!this.method_2(topologyRule))
{
string[] items = new string[3];
items[0] =
(this.itopology_0 as IFeatureClassContainer).get_ClassByID(topologyRule.OriginClassID)
.AliasName;
items[1] = this.method_0(topologyRule.TopologyRuleType);
if ((topologyRule.OriginClassID != topologyRule.DestinationClassID) &&
(topologyRule.DestinationClassID > 0))
{
items[2] =
(this.itopology_0 as IFeatureClassContainer).get_ClassByID(
topologyRule.DestinationClassID).AliasName;
}
ListViewItem item = new ListViewItem(items)
{
Tag = new Class2(topologyRule, true)
};
this.listView1.Items.Add(item);
this.bool_0 = true;
if (this.OnValueChange != null)
{
this.OnValueChange();
}
}
else
{
MessageBox.Show("该规则已应用到该要素类！");
}
}
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
}
}
private void btnAddRule1_Click(object sender, EventArgs e)
{
frmAddRuleByClass class2 = new frmAddRuleByClass
{
OriginClassArray = this.iarray_1
};
if (class2.ShowDialog() == DialogResult.OK)
{
ITopologyRule[] topologyRules = class2.TopologyRules;
if (topologyRules != null)
{
for (int i = 0; i < topologyRules.Length; i++)
{
IFeatureClass class3;
ITopologyRule rule = topologyRules[i];
if (this.method_2(rule))
{
continue;
}
int index = 0;
while (index < this.iarray_0.Count)
{
class3 = (IFeatureClass)this.iarray_0.get_Element(index);
if (class3.ObjectClassID == rule.OriginClassID)
{
goto Label_0093;
}
index++;
}
goto Label_0106;
Label_0093:
this.listRule.Items.Add(class3.AliasName);
this.listRule.Items[this.listRule.Items.Count - 1].SubItems.Add(rule.Name);
this.listRule.Items[this.listRule.Items.Count - 1].Tag = rule;
Label_0106:
if (rule.OriginClassID != rule.DestinationClassID)
{
for (index = 0; index < this.iarray_0.Count; index++)
{
class3 = (IFeatureClass)this.iarray_0.get_Element(index);
if (class3.ObjectClassID == rule.DestinationClassID)
{
goto Label_015C;
}
}
}
continue;
Label_015C:
this.listRule.Items[this.listRule.Items.Count - 1].SubItems.Add(class3.AliasName);
}
}
}
}
/// <summary>
/// 获取指定类型的拓扑错误要素
/// </summary>
/// <param name="topologyRule">拓扑规则</param>
/// <param name="topology">拓扑</param>
/// <returns></returns>
public static List <ITopologyErrorFeature> GetTopoErrorFeatures(this ITopologyRule topologyRule, ITopology topology)
{
List <ITopologyErrorFeature> result = new List <ITopologyErrorFeature>();
ITopologyErrorFeature errorFeature;
var enumErrorFeature = GetEnumTopoErrorFeature(topologyRule, topology);
while ((errorFeature = enumErrorFeature.Next()) != null)
{
result.Add(errorFeature);
}
return(result);
}
private bool method_2(ITopologyRule itopologyRule_0)
{
for (int i = 0; i < this.listRule.Items.Count; i++)
{
ITopologyRule tag = (ITopologyRule)this.listRule.Items[i].Tag;
if (((tag.Name == itopologyRule_0.Name) && (tag.OriginClassID == itopologyRule_0.OriginClassID)) &&
(tag.DestinationClassID == itopologyRule_0.DestinationClassID))
{
return(true);
}
}
return(false);
}
private bool method_1(ITopologyRule itopologyRule_0, IArray iarray_3)
{
for (int i = 0; i < iarray_3.Count; i++)
{
ITopologyRule rule = (ITopologyRule)iarray_3.get_Element(i);
if (((rule.Name == itopologyRule_0.Name) && (rule.OriginClassID == itopologyRule_0.OriginClassID)) &&
(rule.DestinationClassID == itopologyRule_0.DestinationClassID))
{
return(true);
}
}
return(false);
}
private void btnAddRule_Click(object sender, EventArgs e)
{
frmRule rule = new frmRule
{
OriginClassArray = this.iarray_1
};
if (rule.ShowDialog() == DialogResult.OK)
{
if (!rule.bVaildRule)
{
MessageBox.Show("无效规则！");
}
else
{
ITopologyRule topologyRule = rule.TopologyRule;
if (this.method_2(topologyRule))
{
MessageBox.Show("该规则已应用到该要素类！");
}
else
{
int num;
IFeatureClass class2;
for (num = 0; num < this.iarray_0.Count; num++)
{
class2 = (IFeatureClass)this.iarray_0.get_Element(num);
if (class2.ObjectClassID == topologyRule.OriginClassID)
{
this.listRule.Items.Add(class2.AliasName);
this.listRule.Items[this.listRule.Items.Count - 1].SubItems.Add(topologyRule.Name);
this.listRule.Items[this.listRule.Items.Count - 1].Tag = topologyRule;
break;
}
}
if (topologyRule.OriginClassID != topologyRule.DestinationClassID)
{
for (num = 0; num < this.iarray_0.Count; num++)
{
class2 = (IFeatureClass)this.iarray_0.get_Element(num);
if (class2.ObjectClassID == topologyRule.DestinationClassID)
{
this.listRule.Items[this.listRule.Items.Count - 1].SubItems.Add(class2.AliasName);
break;
}
}
}
}
}
}
}
private bool method_2(ITopologyRule itopologyRule_0)
{
for (int i = 0; i < this.listView1.Items.Count; i++)
{
ITopologyRule topoRule = (this.listView1.Items[i].Tag as Class2).TopoRule;
if (((topoRule.Name == itopologyRule_0.Name) &&
(topoRule.OriginClassID == itopologyRule_0.OriginClassID)) &&
(topoRule.DestinationClassID == itopologyRule_0.DestinationClassID))
{
return(true);
}
}
return(false);
}
private void btnAddRule1_Click(object sender, EventArgs e)
{
frmAddRuleByClass class2 = new frmAddRuleByClass
{
OriginClassArray = TopologyEditHelper.m_pList
};
if (class2.ShowDialog() == DialogResult.OK)
{
ITopologyRule[] topologyRules = class2.TopologyRules;
if (topologyRules != null)
{
for (int i = 0; i < topologyRules.Length; i++)
{
ITopologyRule rule = topologyRules[i];
if (!this.method_2(rule))
{
string[] items = new string[3];
items[0] =
(this.itopology_0 as IFeatureClassContainer).get_ClassByID(rule.OriginClassID).AliasName;
items[1] = this.method_0(rule.TopologyRuleType);
if ((rule.OriginClassID != rule.DestinationClassID) && (rule.DestinationClassID > 0))
{
items[2] =
(this.itopology_0 as IFeatureClassContainer).get_ClassByID(rule.DestinationClassID)
.AliasName;
}
ListViewItem item = new ListViewItem(items)
{
Tag = new Class2(rule, true)
};
this.listView1.Items.Add(item);
this.bool_0 = true;
if (this.OnValueChange != null)
{
this.OnValueChange();
}
}
}
}
}
}
/// <summary>
/// 添加拓扑规则
/// </summary>
/// <param name="topology"></param>
/// <param name="topologyRule"></param>
public static void AddRuleToTopology(this ITopology topology, ITopologyRule topologyRule)
{
ITopologyRuleContainer topologyRuleContainer = (ITopologyRuleContainer)topology;//构建容器
try
{
topologyRuleContainer.get_CanAddRule(topologyRule);//不能添加的话直接报错
try
{
topologyRuleContainer.DeleteRule(topologyRule); //删除已存在的规则后再添加
topologyRuleContainer.AddRule(topologyRule); //规则存在的话直接报错
}
catch
{
topologyRuleContainer.AddRule(topologyRule);
}
}
catch (Exception ex)
{
throw new Exception("不支持添加拓扑规则：" + ex.Message);
}
}
private IList method_4(ITopology itopology_0)
{
IList list = new ArrayList();
ITopologyRuleContainer container = itopology_0 as ITopologyRuleContainer;
IEnumRule rules = container.Rules;
rules.Reset();
for (ITopologyRule rule2 = rules.Next() as ITopologyRule;
rule2 != null;
rule2 = rules.Next() as ITopologyRule)
{
bool flag;
bool flag2;
bool flag3;
rule2.ErrorShapeTypes(out flag, out flag2, out flag3);
if (flag3)
{
list.Add(rule2);
}
}
return(list);
}
public TopologyRuleWrap(ITopologyRule itopologyRule_1, bool bool_1)
{
this.itopologyRule_0 = itopologyRule_1;
this.bool_0 = bool_1;
}
public Class2(ITopologyRule itopologyRule_1, bool bool_1)
{
this.itopologyRule_0 = itopologyRule_1;
this.bool_0 = bool_1;
}
/// <summary>
/// 面重叠检查错误列表 同层面检查 chenyafei 添加20101208
/// </summary>
/// <param name="pFeaDatset">数据集</param>
/// <param name="pTopo">拓扑</param>
/// <param name="pTopoRuleType">拓扑规则</param>
/// <param name="pOrgFeaClsNameDic">源图层名</param>
/// <param name="pEnvelop">拓扑验证范围</param>
/// <param name="pDataGrid">检查结果列表显示</param>
/// <param name="outError"></param>
public void GetAreaNoOverlopErrorList(IFeatureDataset pFeaDatset, ITopology pTopo, IEnvelope pEnvelop, DataGridViewX pDataGrid, out Exception outError)
{
outError = null;
try
{
IFeatureClass oriFeaCls = null; //源要素类
IFeatureClass desFeaCls = null; //目标要素类
//依照拓扑规则获取错误要素
IErrorFeatureContainer pErrorFeaCon = pTopo as IErrorFeatureContainer;
ITopologyRuleContainer pTopoRuleCon = pTopo as ITopologyRuleContainer;
IEnumRule pEnumRule = pTopoRuleCon.Rules;
pEnumRule.Reset();
ITopologyRule pTopoRule = pEnumRule.Next() as ITopologyRule;
//遍历拓扑规则
while (pTopoRule != null)
{
//if (pTopoRule.TopologyRuleType != pTopoRuleType)
//{
// pTopoRule = pEnumRule.Next() as ITopologyRule;
// continue;
//}
IEnumTopologyErrorFeature pEnumErrorFea = null;
try
{
pEnumErrorFea = pErrorFeaCon.get_ErrorFeatures(
(pFeaDatset as IGeoDataset).SpatialReference, pTopoRule, pEnvelop, true, false);
}
catch (Exception ex)
{
////*********************************************
////guozheng 2010-12-24 平安夜 added 系统异常日志
//if (ModData.SysLog == null) ModData.SysLog = new clsWriteSystemFunctionLog();
//ModData.SysLog.Write(ex);
////**********************************************
RemoveTopo(pFeaDatset, pFeaDatset.Name, out outError);
outError = ex;
return;
}
if (pEnumErrorFea == null)
{
pTopoRule = pEnumRule.Next() as ITopologyRule;
continue;
}
//进度条初始值
//ModData.m_ProgressBarDetail.Minimum = 0;
//ModData.m_ProgressBarDetail.Value = 0;
//ModData.m_ProgressBarDetail.Maximum = ModOperator.GetErrCount(pEnumErrorFea);
int pValue = 0;
//Application.DoEvents();
pEnumErrorFea = pErrorFeaCon.get_ErrorFeatures(
(pFeaDatset as IGeoDataset).SpatialReference, pTopoRule, pEnvelop, true, false);
ITopologyErrorFeature pErrorFea = pEnumErrorFea.Next();
//遍历错误要素，进行错误输出
while (pErrorFea != null)
{
double pMapx = 0; //错误定位点x
double pMapy = 0; //错误定位点y
string errFeaGeoStr = ""; //错误几何信息
string errCoorStr = "";
string pFeaClsName = ""; //要素类名称
int desID = pErrorFea.DestinationOID; //目标要素ID
int oriID = pErrorFea.OriginOID; //源要素类ID
IFeature oriFeature = null; //源要素
IFeature desFeature = null; //目标要素
int oriFeaClsID = pErrorFea.OriginClassID; //源要素类ID
int desFeaClsID = pErrorFea.DestinationClassID; //目标要素类ID
string errDes = ""; //错误描述
try
{
//若要素类为空，则说明是对数据集中的所有的同层面进行重叠检查
oriFeaCls = (pTopo as IFeatureClassContainer).get_ClassByID(oriFeaClsID);
desFeaCls = oriFeaCls;
}
catch
{ }
if (oriFeaCls != null && oriID > 0)
{
oriFeature = oriFeaCls.GetFeature(oriID);
}
else
{
//源要素OID
oriID = -1;
}
if (desFeaCls != null && desID > 0)
{
desFeature = desFeaCls.GetFeature(desID);
}
else
{
//目标要素OID
desID = -1;
}
double pMinArea = 0; //面积最小值
double pMaxArea = 0; //重叠面积最大值
pFeaClsName = (oriFeaCls as IDataset).Name;
if (pFeaClsName.Contains("."))
{
pFeaClsName = pFeaClsName.Substring(pFeaClsName.IndexOf('.') + 1);
}
//获得错误几何信息
GetZoomErrFea(pErrorFea as IFeature, out pMapx, out pMapy, out errFeaGeoStr, out errCoorStr);
//目标数据库对应到元数据库中的OID
int dicDesOID = -1;
if (desFeature != null)
{
int index = desFeature.Fields.FindField(desFeaCls.OIDFieldName);
if (index != -1)
{
if (desFeature.get_Value(index).ToString().Trim() != "")
{
dicDesOID = Convert.ToInt32(desFeature.get_Value(index).ToString().Trim());
}
}
}
string errType = "";
if (pTopoRule.TopologyRuleType == esriTopologyRuleType.esriTRTAreaNoOverlap)
{
errDes = "OID为" + oriID + "的小班与OID为" + dicDesOID + "的小班之间有重叠";
errType = "面重叠检查";
}
else if (pTopoRule.TopologyRuleType == esriTopologyRuleType.esriTRTAreaNoGaps)
{
errDes = "小班之间有缝隙";
errType = "面缝隙检查";
}
//处理错误结果
ProcErrorList(errType, pFeaDatset, pFeaClsName, oriID, pFeaClsName, dicDesOID, pMapx, pMapy, errFeaGeoStr, pDataGrid, errDes, errCoorStr);
//ProcErrorList(pFeaDatset, pFeaClsName, oriFeature, pFeaClsName, desID, pDataGrid, EnumCheckType.面重叠检查, pErrType, errDes);
//错误数加1
//ModData.m_ErrCount++;
//m_ErrCount++;
//m_LabelRes.Text = "同层面重叠检查错误:" + m_ErrCount + "个";
//进度条
pValue++;
//ModData.m_ProgressBarDetail.Value = pValue;
//Application.DoEvents(); //实时处理windows消息
pErrorFea = pEnumErrorFea.Next();
}
pTopoRule = pEnumRule.Next() as ITopologyRule;
}
}
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="_AppHk"></param>
private void ExcutePolygonOverlapTreat()
{
Plugin.Application.IAppFormRef pAppFrm = _AppHk as Plugin.Application.IAppFormRef;
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "正在获取所有面层..." });
//获取所有面层
List <ILayer> listLayers = GetCheckLayers(_AppHk.MapControl.Map, "更新修编数据");
if (listLayers == null)
{
return;
}
List <ILayer> listCheckLays = new List <ILayer>();
//遍历更新库体里的所有层
foreach (ILayer pTempLay in listLayers)
{
IFeatureLayer pFeatLay = pTempLay as IFeatureLayer;
if (pFeatLay == null)
{
continue;
}
if (pFeatLay.FeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
continue;
}
//接边针对的是线和面，所以我们操作时只需对线和面层进行即可
if (pFeatLay.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolygon)
{
continue;
}
listCheckLays.Add(pTempLay);
}
if (listCheckLays.Count == 0)
{
return;
}
//遍历各个面层并与其它面层建立拓扑规则以获取所有存在重叠的最小面
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "正在建立拓扑规则..." });
Dictionary <ITopologyRule, IFeatureClass> dicTemp = new Dictionary <ITopologyRule, IFeatureClass>();
ITopologyRuleContainer pTopologyRuleContainer = SetCheckState.pT as ITopologyRuleContainer;//使用建立好的拓扑
//遍历我们得出的所有面层并操作
foreach (ILayer pLay in listCheckLays)
{
IFeatureLayer pFeatLay = pLay as IFeatureLayer;
if (pFeatLay == null)
{
continue;
}
ITopologyRule topologyRule = new TopologyRuleClass(); //实例一个拓扑规则类
topologyRule.TopologyRuleType = esriTopologyRuleType.esriTRTAreaNoOverlap; //使用规则的类型(面不相交)
topologyRule.OriginClassID = pFeatLay.FeatureClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
topologyRule.Name = pFeatLay.FeatureClass.AliasName;
if (pTopologyRuleContainer.get_CanAddRule(topologyRule) == true)//提示拓扑规则是否可以被添加
{
pTopologyRuleContainer.AddRule(topologyRule);
dicTemp.Add(topologyRule, pFeatLay.FeatureClass);
}
foreach (ILayer pOtherLay in listCheckLays)
{
if (pOtherLay == pLay)
{
continue;
}
IFeatureLayer pOtherFeatLay = pOtherLay as IFeatureLayer;
if (pOtherFeatLay == null)
{
continue;
}
topologyRule = new TopologyRuleClass();
topologyRule.TopologyRuleType = esriTopologyRuleType.esriTRTAreaNoOverlapArea;
topologyRule.OriginClassID = pFeatLay.FeatureClass.FeatureClassID;
topologyRule.AllOriginSubtypes = true;
topologyRule.DestinationClassID = pOtherFeatLay.FeatureClass.FeatureClassID;
topologyRule.AllDestinationSubtypes = true;
topologyRule.Name = pFeatLay.FeatureClass.AliasName + " AreaNoOverlapArea with " + pOtherFeatLay.FeatureClass.AliasName;
if (pTopologyRuleContainer.get_CanAddRule(topologyRule) == true)
{
pTopologyRuleContainer.AddRule(topologyRule);
dicTemp.Add(topologyRule, pFeatLay.FeatureClass);
}
}
}
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "正在验证拓扑..." });
ISegmentCollection pLocation = new PolygonClass(); //使用多边形接口
pLocation.SetRectangle(SetCheckState.Geodatabase.Extent); //将我们用来操作验证的要素类利用SETRECTANGLE来构造一个完整的几何形体
IPolygon pPoly = SetCheckState.pT.get_DirtyArea(pLocation as IPolygon);
IEnvelope pAreaValidated = SetCheckState.pT.ValidateTopology(pPoly.Envelope); //验证拓扑
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "正在分析获取要处理的要素..." });
pAppFrm.MainForm.Invoke(new ShowProgress(ShowProgressBar), new object[] { pAppFrm, true });
pAppFrm.MainForm.Invoke(new ChangeProgress(ChangeProgressBar), new object[] { pAppFrm.ProgressBar, 0, dicTemp.Count, 0 });
//获取所有存在重叠的最小面
Dictionary <IFeature, IFeatureClass> dicCheckFeats = new Dictionary <IFeature, IFeatureClass>();
IErrorFeatureContainer pErrFeatCon = SetCheckState.pT as IErrorFeatureContainer;
IEnumRule pEnumRule = pTopologyRuleContainer.Rules;
pEnumRule.Reset();
ITopologyRule pTempTopologyRule = pEnumRule.Next() as ITopologyRule;
int intcnt = 0;
while (pTempTopologyRule != null)
{
intcnt++;
pAppFrm.MainForm.Invoke(new ChangeProgress(ChangeProgressBar), new object[] { pAppFrm.ProgressBar, -1, -1, intcnt });
if (!(pTempTopologyRule.TopologyRuleType == esriTopologyRuleType.esriTRTAreaNoOverlap || pTempTopologyRule.TopologyRuleType == esriTopologyRuleType.esriTRTAreaNoOverlapArea))
{
continue;
}
IEnumTopologyErrorFeature pEnumTopoErrFeat = pErrFeatCon.get_ErrorFeatures(SetCheckState.Geodatabase.SpatialReference, pTempTopologyRule, SetCheckState.Geodatabase.Extent, true, false);
ITopologyErrorFeature pTopoErrFeat = pEnumTopoErrFeat.Next();
IFeatureClass pOrgFeatCls = null;
if (dicTemp.ContainsKey(pTempTopologyRule))
{
pOrgFeatCls = dicTemp[pTempTopologyRule];
}
if (pOrgFeatCls == null)
{
break;
}
IDataset pDatasetTemp = pOrgFeatCls as IDataset;
while (pTopoErrFeat != null)
{
IFeature orgFeat = pOrgFeatCls.GetFeature(pTopoErrFeat.OriginOID);
bool bHasFeat = false;
foreach (ILayer pLay in listCheckLays)
{
IFeatureLayer pFeatLay = pLay as IFeatureLayer;
if (pFeatLay == null)
{
continue;
}
IDataset pDataset = pFeatLay.FeatureClass as IDataset;
string strCon = "";
//排除指定要素
if (pDataset.Name == pDatasetTemp.Name)
{
strCon = "OBJECTID<>" + orgFeat.OID.ToString();
}
//判断面orgFeat内是否包含有面
if (HasFeatureWithInGeometry(pFeatLay.FeatureClass, orgFeat.Shape, strCon) == true)
{
bHasFeat = true;
break;
}
}
if (bHasFeat == false)
{
dicCheckFeats.Add(orgFeat, pOrgFeatCls);
}
pTopoErrFeat = pEnumTopoErrFeat.Next();
}
pTempTopologyRule = pEnumRule.Next() as ITopologyRule;
}
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "处理数据中..." });
pAppFrm.MainForm.Invoke(new ChangeProgress(ChangeProgressBar), new object[] { pAppFrm.ProgressBar, 0, dicCheckFeats.Count, 0 });
Exception err = null;
//开启编辑 wjj 20090921
IDataset pFeatDataset = SetCheckState.Geodatabase as IDataset;
IWorkspaceEdit pWorkspaceEdit = pFeatDataset.Workspace as IWorkspaceEdit;
if (pWorkspaceEdit.IsBeingEdited() == false)
{
pWorkspaceEdit.StartEditing(false);
}
//遍历上步所获得到的重叠最小面，分析获取包含该面的所有面并根据面积排序
intcnt = 0;
foreach (KeyValuePair <IFeature, IFeatureClass> keyvlue in dicCheckFeats)
{
intcnt++;
pAppFrm.MainForm.Invoke(new ChangeProgress(ChangeProgressBar), new object[] { pAppFrm.ProgressBar, -1, -1, intcnt });
IFeature pFeat = keyvlue.Key;
Dictionary <IFeature, IFeatureClass> dicFeats = GetFeaturesByGeometry(pFeat, listCheckLays);
bool bDel = false;
if (dicFeats.Count > 0)
{
//从外到内做处理,处理原则分类代码相同则利用小面套空大面并删除小面,不同则小面套空大面
IFeature[] pFeatArray = new IFeature[dicFeats.Count];
dicFeats.Keys.CopyTo(pFeatArray, 0);
for (int i = 0; i < dicFeats.Count - 1; i++)
{
if (bDel == false)
{
IFeature pBigFeat = pFeatArray[i];
IFeature pLowFeat = pFeatArray[i + 1];
//小面掏空大面
UpdateFeatureByOverlapArea(dicFeats[pBigFeat], "OBJECTID=" + pBigFeat.OID.ToString(), pLowFeat.Shape, out err);
if (pBigFeat.get_Value(pBigFeat.Fields.FindField("CODE")).ToString() == pLowFeat.get_Value(pLowFeat.Fields.FindField("CODE")).ToString())
{
SysCommon.Gis.ModGisPub.DelFeature(dicFeats[pLowFeat], "OBJECTID=" + pLowFeat.OID.ToString(), out err);
bDel = true;
}
else
{
bDel = false;
}
}
else
{
bDel = false;
}
}
IFeature pLastFeat = pFeatArray[dicFeats.Count - 1];
//小面掏空大面
UpdateFeatureByOverlapArea(dicFeats[pLastFeat], "OBJECTID=" + pLastFeat.OID.ToString(), pFeat.Shape, out err);
if (pLastFeat.get_Value(pLastFeat.Fields.FindField("CODE")).ToString() == pFeat.get_Value(pFeat.Fields.FindField("CODE")).ToString())
{
SysCommon.Gis.ModGisPub.DelFeature(dicCheckFeats[pFeat], "OBJECTID=" + pFeat.OID.ToString(), out err);
bDel = true;
}
else
{
bDel = false;
}
}
}
pEnumRule.Reset();
pTempTopologyRule = pEnumRule.Next() as ITopologyRule;
while (pTempTopologyRule != null)
{
pTopologyRuleContainer.DeleteRule(pTempTopologyRule);
pTempTopologyRule = pEnumRule.Next() as ITopologyRule;
}
//结束编辑 wjj 20090921
if (pWorkspaceEdit.IsBeingEdited() == true)
{
pWorkspaceEdit.StopEditing(true);
}
_AppHk.CurrentThread = null;
pAppFrm.MainForm.Invoke(new ShowTips(ShowStatusTips), new object[] { pAppFrm, "" });
pAppFrm.MainForm.Invoke(new ShowProgress(ShowProgressBar), new object[] { pAppFrm, false });
pAppFrm.MainForm.Invoke(new ShowForm(ShowErrForm), new object[] { "提示", "处理完毕!" });
}
public override bool Pretreat()
{
try
{
//SendMessage(enumMessageType.RuleError, "����������");
IFeatureWorkspace fws = m_TopoWorkspace as IFeatureWorkspace;
IWorkspace2 ws2 = m_TopoWorkspace as IWorkspace2;
IFeatureClassContainer fClassContainer = this.m_Topology as IFeatureClassContainer;
IEnumFeatureClass enFeatureClass = fClassContainer.Classes;
IFeatureClass fClass = enFeatureClass.Next();
IFeatureClass fClassRefer = null;
bool isAdded = false;
while (fClass != null)
{
IDataset ds = fClass as IDataset;
if (ds.Name == m_LayerName)
{
isAdded = true;
break;
}
fClass = enFeatureClass.Next();
}
if (!isAdded)
{
if (!ws2.get_NameExists(esriDatasetType.esriDTFeatureClass, m_LayerName))
{
SendMessage(enumMessageType.RuleError, string.Format("ͼ��{0}�������˿�ʧ�ܣ������", this.m_psRuleParas.arraySeledLayers[0]));
return false;
}
fClass = fws.OpenFeatureClass(m_LayerName);
this.m_Topology.AddClass(fClass as IClass, 1, m_psRuleParas.arrayRanks[0], 1, false);
}
if (this.m_psRuleParas.arraySeledLayers.Count > 1)
{
enFeatureClass.Reset();
fClassRefer = enFeatureClass.Next();
isAdded = false;
while (fClass != null)
{
IDataset ds = fClassRefer as IDataset;
if (ds.Name == m_ReferLayerName)
{
isAdded = true;
break;
}
fClassRefer = enFeatureClass.Next();
}
if (!isAdded)
{
if (!ws2.get_NameExists(esriDatasetType.esriDTFeatureClass, m_ReferLayerName))
{
SendMessage(enumMessageType.RuleError, string.Format("ͼ��{0}�����ڣ������", this.m_psRuleParas.arraySeledLayers[1]));
return false;
}
fClassRefer = fws.OpenFeatureClass(m_ReferLayerName);
this.m_Topology.AddClass(fClass as IClass, 1, m_psRuleParas.arrayRanks[1], 1, false);
}
}
m_TopologylRule = new TopologyRuleClass();
m_TopologylRule.Name = m_psRuleParas.arrayRules[0].strRuleAliasName;
m_TopologylRule.OriginClassID = fClass.ObjectClassID;
if (fClassRefer != null)
m_TopologylRule.DestinationClassID = fClassRefer.ObjectClassID;
m_TopologylRule.AllOriginSubtypes = true;
m_TopologylRule.AllDestinationSubtypes = true;
m_TopologylRule.TopologyRuleType = GetTopologyTypeByName(m_psRuleParas.arrayRules[0].strTopoRuleName);
(this.m_Topology as ITopologyRuleContainer).AddRule(m_TopologylRule);
return true;
}
catch (Exception exp)
{
SendMessage(enumMessageType.PretreatmentError, "���뵽����ʱ�������Ϣ��"+exp.Message);
SendMessage(enumMessageType.Exception, exp.ToString());
return false;
}
}
