/// <summary>
/// 直接添加所有层--通过IFeatureClassContainer
/// </summary>
/// <param name="mapControlDefault">地图控件</param>
/// <param name="pFeatureWorkspace">要素工作空间</param>
/// <param name="strFileName">文件名，包括后缀</param>
public static void GetALLCADbyWorkspace(IMapControlDefault mapControlDefault, IWorkspace pCADWorkspace, string strFileName)
{
IFeatureWorkspace pFeatureWorkspace = pCADWorkspace as IFeatureWorkspace;
IFeatureDataset pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset(strFileName);
IFeatureClassContainer pFeatureClassContainer = pFeatureDataset as IFeatureClassContainer;
for (int i = 0; i < pFeatureClassContainer.ClassCount; i++)
{
IFeatureClass pFeatureClass = pFeatureClassContainer.get_Class(i);
IFeatureLayer pFeatureLayer = null;
if (pFeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
pFeatureLayer = new CadAnnotationLayerClass();
}
else
{
pFeatureLayer = new CadFeatureLayerClass();
}
if (pFeatureLayer != null)
{
pFeatureLayer.Name = pFeatureClass.AliasName;
pFeatureLayer.FeatureClass = pFeatureClass;
mapControlDefault.AddLayer(pFeatureLayer as ILayer, 0);
}
}
}
public ITopology Create_Topology(IFeatureWorkspace featureWorkspace, string featuredatasetName, string featureClassName, string topologyName)
{
try
{
//1.---打开拓朴所在的要素数据集，并创建拓朴
IFeatureDataset featureDataset = featureWorkspace.OpenFeatureDataset(featuredatasetName);
if (featureDataset != null)
{
ITopologyContainer topologyContainer = (ITopologyContainer)featureDataset;
ITopology topology = topologyContainer.CreateTopology("topo", topologyContainer.DefaultClusterTolerance, -1, ""); //在这个地方报错
//2.---给拓朴加入要素集
IFeatureClassContainer featureclassContainer = (IFeatureClassContainer)featureDataset;
IFeatureClass featureClass = featureclassContainer.get_ClassByName(featureClassName);
topology.AddClass(featureClass, 5, 1, 1, false); // Parameters: AddClass(IClass, double weight, int xyrank, int zrank, Boolean EventNotificationOnValidate).
//3.---返回拓朴
return(topology);
}
}
catch (Exception ex)
{
//System.Diagnostics.Debug.WriteLine(ex.ToString());
MessageBox.Show(ex.ToString());
}
return(null);
}
/// <summary>
/// Provides a feature class from the feature dataset by the feature class name
/// </summary>
/// <param name="featureDataset">Feature dataset object </param>
/// <param name="featureClassName">Feature class name</param>
/// <returns>A feature class <see cref="IFeatureClass"/></returns>
private IFeatureClass GetFeatureClass(IFeatureDataset featureDataset, string featureClassName)
{
IFeatureClassContainer featureclassContainer = (IFeatureClassContainer)featureDataset;
IFeatureClass featureClass = featureclassContainer.ClassByName[featureClassName];
return(featureClass);
}
/// <summary>
/// 以迭代形式返回工作空间下的所有要素类，包括数据集中的要素类
/// </summary>
/// <param name="workspace">工作空间</param>
/// <returns>要素类枚举数（要素类集合）</returns>
private static IEnumerable GetDataset(this IWorkspace workspace)
{
//工作空间下的要素类
IEnumDataset enumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureClass];
IFeatureClass featureClass = enumDataset.Next() as IFeatureClass;
while (featureClass != null)
{
yield return(featureClass);
featureClass = enumDataset.Next() as IFeatureClass;
}
//工作空间下的要素集
IEnumDataset dsEnumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureDataset];
IDataset dataset = dsEnumDataset.Next();
while (dataset != null)//遍历要数集
{
IFeatureDataset featureDataset = (IFeatureDataset)dataset;
IFeatureClassContainer featureclassContainer = (IFeatureClassContainer)featureDataset;
IEnumFeatureClass enumFeatureClass = featureclassContainer.Classes;
IFeatureClass dsFeatureClass = enumFeatureClass.Next();
while (dsFeatureClass != null)//在每一个数据集中遍历数据层IFeatureClass
{
yield return(dsFeatureClass);
dsFeatureClass = enumFeatureClass.Next();
}
dataset = dsEnumDataset.Next();
}
}
//加载文件数据库操作（gdb）
private void OpenGDB_Click(object sender, EventArgs e)
{
PWSp = first.get_FWorkSp();
textBoxGdbPath.Text = first.File_Name;
IFeatureClassContainer myFCContainer = first.get_FCName(PWSp);
myFCName = first.get_FCName2(PWSp);
TopoCheckForm.pass_FCName(myFCName);
if (myFCName != null)
{
int j = 0;
if (myFCContainer.ClassCount != 0 && myFCName != null)
{
while (j < myFCContainer.ClassCount)
{//在IFeatureClass中有AliaName（别名）属性
//现在采用这个方法能够获得FC的原名，代码如下：
//myFCContainer.Class[j].AliaName
checkedListBoxFeatures.Items.Add(myFCName[j]);
j++;
}
}
else
{
MessageBox.Show("There is no FeatureClass in your DataSet!");
return;
}
}
}
/// <summary>
/// 获取IFeatureDataset所有的要素类，返回IDataset列表
/// </summary>
/// <param name="ipDataset"></param>
/// <param name="arrayDs"></param>
public static void GetFcNameInDs(IFeatureDataset ipDataset, ref Hashtable arrayDs)
{
try
{
if (ipDataset == null)
{
return;
}
IFeatureClassContainer ipFcContain = (IFeatureClassContainer)ipDataset;
IEnumFeatureClass ipFcEnum = ipFcContain.Classes;
IFeatureClass ipFtClass = ipFcEnum.Next();
while (ipFtClass != null)
{
arrayDs.Add(((IDataset)ipFtClass).Name, (IDataset)ipFtClass);
ipFtClass = ipFcEnum.Next();
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
public static StandardItem Import(IFeatureDataset fds)
{
if (fds == null)
{
return(null);
}
StandardItem sItem = new StandardItem();
sItem.Type = enumItemType.FeatureDataset;
sItem.Name = fds.Name;
sItem.SpatialReference = (fds as IGeoDataset).SpatialReference;
sItem.ID = Guid.NewGuid().ToString("N");
IList <StandardItem> subList = new List <StandardItem>();
sItem.SubItems = subList;
IFeatureClassContainer fcContianer = fds as IFeatureClassContainer;
for (int i = 0; i < fcContianer.ClassCount; i++)
{
StandardItem sItemClass = Import(fcContianer.get_Class(i));
sItemClass.Parent = sItem;
subList.Add(sItemClass);
}
return(sItem);
}
/// <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;
}
}
//添加cad文件
public void addcadfile(string filePath, string filename, AxMapControl mapControl)
{
if (filename + filePath == "")
{
return;
}
IWorkspaceFactory pWorkspaceFactory = new CadWorkspaceFactoryClass(); //打开CAD数据集
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWorkspaceFactory.OpenFromFile(filePath, 0); //打开一个要素集
IFeatureLayer pFeatureLayer;
IFeatureDataset pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset(filename);
//IFeaturClassContainer可以管理IFeatureDataset中的每个要素类
IFeatureClassContainer pFeatClassContainer = (IFeatureClassContainer)pFeatureDataset;
//对CAD文件中的要素进行遍历处理
for (int i = 0; i < pFeatClassContainer.ClassCount - 1; i++)
{
IFeatureClass pFeatClass = pFeatClassContainer.get_Class(i);
if (pFeatClass.FeatureType == esriFeatureType.esriFTCoverageAnnotation)
{
//如果是注记，则添加注记层
pFeatureLayer = new CadAnnotationLayerClass();
}
else
{
//如果是点、线、面，则添加要素层
pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.Name = pFeatClass.AliasName;
pFeatureLayer.FeatureClass = pFeatClass;
mapControl.Map.AddLayer(pFeatureLayer);
mapControl.ActiveView.Refresh();
}
}
}
/// <summary>
/// Determines whether the specified network element corresponds to the required generic junction feature class.
/// </summary>
/// <param name="junctionEID">The junction EID.</param>
/// <returns>
/// <c>true</c> if the specified network element corresponds to the required generic junction feature class; otherwise,
/// <c>false</c>.
/// </returns>
protected bool IsGenericJunction(int junctionEID)
{
if (_JunctionsClassID < 0)
{
// Determine the generic junction class ID.
IFeatureClassContainer container = (IFeatureClassContainer)this.GeometricNetwork;
IEnumFeatureClass enumClasses = container.Classes;
enumClasses.Reset();
// Iterate through all of the classes that participate in the network.
IFeatureClass networkClass;
while ((networkClass = enumClasses.Next()) != null)
{
if (this.IsGenericJunction(networkClass))
{
_JunctionsClassID = networkClass.ObjectClassID;
break;
}
}
}
// Determine the class identifier for the element.
IEIDInfo eidInfo = this.GetEIDInfo(junctionEID, esriElementType.esriETJunction);
// When the class ID equals the generic junction.
return(eidInfo.Feature.Class.ObjectClassID == _JunctionsClassID);
}
//注册要素类
/// <summary>
/// 返回true说明FeatureClass存在，返回false说明不存在，重新创建
/// </summary>
/// <param name="IN_ShapePath"></param>
/// <returns></returns>
private bool PRV_AddFeatureClass(string IN_ShapePath)
{
string Temp_Direction = System.IO.Path.GetDirectoryName(IN_ShapePath); //该Shp文件的目录
string Temp_Name = System.IO.Path.GetFileNameWithoutExtension(IN_ShapePath); //该Shp文件的名称
IWorkspaceFactory Temp_ShapeWorkFactory = new ShapefileWorkspaceFactory();
IFeatureWorkspace Temp_ShapeWorkspace = Temp_ShapeWorkFactory.OpenFromFile(Temp_Direction, 0) as IFeatureWorkspace;
IWorkspaceFactory Temp_AccessWorkFactory = new AccessWorkspaceFactory();
IFeatureWorkspace Temp_Workspace = Temp_AccessWorkFactory.OpenFromFile(S_MDBFile, 0) as IFeatureWorkspace;
IFeatureClassContainer tem_FeatureClassContainer = (IFeatureClassContainer)FDS_Featuredataset;
IEnumFeatureClass pEnumFeatureClass = (IEnumFeatureClass)tem_FeatureClassContainer.Classes;
IFeatureClass tem_FeatureClass = pEnumFeatureClass.Next();
while (null != tem_FeatureClass)
{
if (Temp_Name == tem_FeatureClass.AliasName)
{// return true;
}
tem_FeatureClass = pEnumFeatureClass.Next();
}
IFeatureClass Temp_FeatureClass = Temp_ShapeWorkspace.OpenFeatureClass(Temp_Name);
FeatureClassToFeatureClass Temp_FCToFC = new FeatureClassToFeatureClass(IN_ShapePath, S_MDBFile + "\\" + FDS_Featuredataset.Name, Temp_Name);//将Shp文件导入要素数据集
GP_Progress = GP_Tool.ExecuteAsync(Temp_FCToFC);
TH_TimeSpan = new Thread(PRV_GetStatus);//开辟线程计时
TH_TimeSpan.Start();
TH_TimeSpan.Join();
return(false);
// IFeatureClassContainer ss = (FDS_Featuredataset.Workspace as IFeatureWorkspace).OpenFeatureDataset(FDS_Featuredataset.Name) as IFeatureClassContainer;
// Console.WriteLine("完成");
}
//topology code
public ITopology create_topology(IWorkspace myWSp, string[] FCIndex, string TopologyName)
{
IEnumDataset myEDS = myWSp.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IDataset myDS = myEDS.Next();
if (myDS != null)
{
DS_Name = myDS.Name;
IFeatureDataset myFDS = myDS as IFeatureDataset;
//IWorkspace myWSp = DS as IWorkspace;
IFeatureClassContainer myFCContainer = myFDS as IFeatureClassContainer;
//要素类容器
ITopologyContainer myTopologyContainer = myFDS as ITopologyContainer;
ITopology myTopology = myTopologyContainer.CreateTopology(TopologyName, myTopologyContainer.DefaultClusterTolerance, -1, "");
int count = 0;
while (count < FCIndex.Length)
{
myTopology.AddClass(myFCContainer.get_Class(int.Parse(FCIndex[count])), 5, 1, 1, false);
count++;
}
return(myTopology);
}
else
{
MessageBox.Show("Error,your Dataset is not a standar DataSet which can be uesed to created topology!");
return(null);
}
}
//通过IWokspace和图层名称获取图层
public static List <IFeatureClass> GetFeatureClass(IWorkspace pWorkspace, string DatasetName)
{
List <IFeatureClass> newlist = new List <IFeatureClass>();
if (pWorkspace == null || DatasetName == "")
{
return(newlist);
}
IEnumDataset pEnumDataset = pWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
pEnumDataset.Reset();
IFeatureDataset pFeaDataset = pEnumDataset.Next() as IFeatureDataset;
while (pFeaDataset != null)
{
if (pFeaDataset.Name == DatasetName)
{
IFeatureClassContainer pFeatureClassContainer = pFeaDataset as IFeatureClassContainer;
IEnumFeatureClass pEnumFeatureClass = pFeatureClassContainer.Classes;
IFeatureClass pFeatureClass = pEnumFeatureClass.Next();
while (pFeatureClass != null)
{
newlist.Add(pFeatureClass);
pFeatureClass = pEnumFeatureClass.Next();
}
}
pFeaDataset = pEnumDataset.Next() as IFeatureDataset;
}
return(newlist);
}
private void method_0(IGeometricNetwork igeometricNetwork_1)
{
try
{
IFeatureClassContainer featureDataset = (IFeatureClassContainer)igeometricNetwork_1.FeatureDataset;
IEnumRule rules = igeometricNetwork_1.Rules;
rules.Reset();
for (IRule rule2 = rules.Next(); rule2 != null; rule2 = rules.Next())
{
if (rule2 is IConnectivityRule)
{
IConnectivityRule rule3 = (IConnectivityRule)rule2;
if (rule3.Category == -1)
{
IJunctionConnectivityRule2 rule4 = (IJunctionConnectivityRule2)rule3;
featureDataset.get_ClassByID(rule4.EdgeClassID);
featureDataset.get_ClassByID(rule4.JunctionClassID);
}
else if (rule3.Type == esriRuleType.esriRTEdgeConnectivity)
{
IEdgeConnectivityRule rule5 = (IEdgeConnectivityRule)rule3;
featureDataset.get_ClassByID(rule5.FromEdgeClassID);
featureDataset.get_ClassByID(rule5.ToEdgeClassID);
featureDataset.get_ClassByID(rule5.DefaultJunctionClassID);
for (int i = 0; i < rule5.JunctionCount; i++)
{
}
}
}
}
}
catch
{
}
}
//通过IWorkspace获取图层
public static IFeatureClass GetFeatureClass(IWorkspace pWorkspace, string LayerName, string DatasetName)
{
if (pWorkspace == null)
{
return(null);
}
IEnumDataset pEnumDataset = pWorkspace.get_Datasets(esriDatasetType.esriDTFeatureClass);
pEnumDataset.Reset();
IDataset pDataset = pEnumDataset.Next();
while (pDataset != null)
{
if (pDataset.Name == LayerName)
{
return(pDataset as IFeatureClass);
}
pDataset = pEnumDataset.Next();
}
pEnumDataset = pWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
pDataset = pEnumDataset.Next();
// IFeatureDataset pFeaDataset = pEnumDataset.Next() as IFeatureDataset;
while (pDataset != null)
{
if (DatasetName == "")
{
IFeatureClassContainer pFeatureClassContainer = pDataset as IFeatureClassContainer;
IEnumFeatureClass pEnumFeatureClass = pFeatureClassContainer.Classes;
IFeatureClass pFeatureClass = pEnumFeatureClass.Next();
while (pFeatureClass != null)
{
if (pFeatureClass.AliasName.Contains(LayerName))
{
return(pFeatureClass);
}
pFeatureClass = pEnumFeatureClass.Next();
}
}
else
{
if (pDataset.Name == DatasetName)
{
IFeatureClassContainer pFeatureClassContainer = pDataset as IFeatureClassContainer;
IEnumFeatureClass pEnumFeatureClass = pFeatureClassContainer.Classes;
IFeatureClass pFeatureClass = pEnumFeatureClass.Next();
while (pFeatureClass != null)
{
if (pFeatureClass.AliasName.Contains(LayerName))
{
return(pFeatureClass);
}
pFeatureClass = pEnumFeatureClass.Next();
}
}
}
pDataset = pEnumDataset.Next() as IFeatureDataset;
}
return(null);
}
public DataTable GetFeaturesStatDt()
{
DataTable result = GenerateDataTable();
IFeatureDataset pDataset = null;
IFeatureClassContainer pFeatClsContainer = null;
IFeatureClass pFeatureCls = null;
try
{
//List<StandardLayer> layers = LayerReader.GetLayersByStandard(m_StandardID);
//获取标准的图层列表
if (m_Workspace == null)
{
return(result);
}
IEnumDataset enumDataset = m_Workspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
enumDataset.Reset();
IFeatureDataset subDataset = enumDataset.Next() as IFeatureDataset;
while (subDataset != null)
{
pFeatClsContainer = subDataset as IFeatureClassContainer;
int iCount = 0;
DataRow dr = null;
for (int i = 0; i < pFeatClsContainer.ClassCount; i++)
{
pFeatureCls = pFeatClsContainer.get_Class(i);
string featClsName = (pFeatureCls as IDataset).Name;
iCount = pFeatureCls.FeatureCount(null);
dr = result.NewRow();
dr[0] = featClsName;
dr[1] = pFeatureCls.AliasName;
dr[2] = iCount;
result.Rows.Add(dr);
Marshal.ReleaseComObject(pFeatureCls);
}
subDataset = enumDataset.Next() as IFeatureDataset;
}
}
catch (Exception ex)
{
//MessageBox.Show("获取要素个数失败！原因：" + ex.Message, "警告");
return(result);
}
finally
{
if (pFeatureCls != null)
{
Marshal.ReleaseComObject(pFeatureCls);
}
if (pDataset != null)
{
Marshal.ReleaseComObject(pDataset);
}
}
return(result);
}
private void OpenMDB_Click(object sender, EventArgs e)
{
#region 用IFeatureClassContainer来读取Name属性失败~
//openGDB first = new openGDB();
//PWSp = first.get_PWorkSp();
//textBox1.Text = first.File_Name;
//IFeatureClassContainer myFCContainer = first.get_FCName(PWSp);
//if (myFCContainer != null)
//{
// int j = 0;
// if (myFCContainer.ClassCount != 0)
// {
// while (j < myFCContainer.ClassCount)
// {
// checkedListBox1.Items.Add(myFCContainer.Class[j].AliasName);
// j++;
// }
// }
// else
// {
// MessageBox.Show("There is no FeatureClass in your DataSet!");
// return;
// }
//}
//else
//{
// MessageBox.Show("There is no DataSet in your DataBase!");
// return;
//}
#endregion
FWSp = first.get_FWorkSp();
textBoxGdbPath.Text = first.File_Name;
IFeatureClassContainer myFCContainer = first.get_FCName(FWSp);
string[] myFCName;
myFCName = first.get_FCName2(FWSp);
TopoCheckForm.pass_FCName(myFCName);
if (myFCContainer.ClassCount != 0 && myFCName != null)
{
int j = 0;
if (myFCContainer.ClassCount != 0)
{
while (j < myFCContainer.ClassCount)
{//在IFeatureClass中有AliaName（别名）属性
//现在采用这个方法能够获得FC的原名，代码如下：
//myFCContainer.Class[j].AliaName
checkedListBoxFeatures.Items.Add(myFCName[j]);
j++;
}
}
else
{
MessageBox.Show("There is no FeatureClass in your DataSet!");
return;
}
}
}
/// <summary>
/// 获取要素数据集中指定名称或别名的要素类
/// </summary>
/// <param name="featureDataset">要素数据集</param>
/// <returns></returns>
public static IFeatureClass GetFirstFeatureClass(this IFeatureDataset featureDataset)
{
IFeatureClassContainer featureClassContainer = (IFeatureClassContainer)featureDataset;
IEnumFeatureClass enumFeatureClass = featureClassContainer.Classes;
Marshal.ReleaseComObject(enumFeatureClass);
Marshal.ReleaseComObject(featureClassContainer);
return(enumFeatureClass.Next());
}
/// <summary>
/// Creates an <see cref="IEnumerable{T}" /> from an <see cref="IFeatureClassContainer" />
/// </summary>
/// <param name="source">An <see cref="IFeatureClassContainer" /> to create an <see cref="IEnumerable{T}" /> from.</param>
/// <returns>An <see cref="IEnumerable{T}" /> that contains the feature class from the input source.</returns>
public static IEnumerable <IFeatureClass> AsEnumerable(this IFeatureClassContainer source)
{
if (source != null)
{
for (int i = 0; i < source.ClassCount; i++)
{
yield return(source.Class[i]);
}
}
}
private void btnCollectCAD_Click(object sender, EventArgs e)
{
if (this.textboxCAD.Text == "")
{
return;
}
try
{
//获取文件名和文件路径
int pIndex = this.textboxCAD.Text.LastIndexOf("\\");
string pFilePath = this.textboxCAD.Text.Substring(0, pIndex);
string pFileName = this.textboxCAD.Text.Substring(pIndex + 1);
//打开CAD数据集
IWorkspaceFactory pWorkspaceFactory;
IFeatureWorkspace pFeatureWorkspace;
IFeatureLayer pFeatureLayer;
IFeatureDataset pFeatureDataset;
pWorkspaceFactory = new CadWorkspaceFactoryClass(); //using ESRI.ArcGIS.DataSourcesFile;
pFeatureWorkspace = (IFeatureWorkspace)pWorkspaceFactory.OpenFromFile(pFilePath, 0);
//打开一个要素集
pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset(pFileName);
//IFeatureClassContainer可以管理IFeatureDataset中的每个要素类
IFeatureClassContainer pFeatClassContainer = (IFeatureClassContainer)pFeatureDataset;
IGroupLayer pGroupLayer = new GroupLayerClass();
pGroupLayer.Name = pFileName;
//对CAD文件中的要素进行遍历处理
for (int i = 0; i < pFeatClassContainer.ClassCount; i++)
{
IFeatureClass pFeatClass = pFeatClassContainer.get_Class(i);
//如果是注记，则添加注记层
if (pFeatClass.FeatureType == esriFeatureType.esriFTCoverageAnnotation)
{
pFeatureLayer = new CadAnnotationLayerClass();
pFeatureLayer.Name = pFeatClass.AliasName;
pFeatureLayer.FeatureClass = pFeatClass;
pGroupLayer.Add(pFeatureLayer);
//this.pMapControl.Map.AddLayer(pFeatureLayer);
}
else //如果是点、线、面则添加要素层
{
pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.Name = pFeatClass.AliasName;
pFeatureLayer.FeatureClass = pFeatClass;
pGroupLayer.Add(pFeatureLayer);
//this.pMapControl.Map.AddLayer(pFeatureLayer);
}
}
this.pMapControl.Map.AddLayer(pGroupLayer);
this.pMapControl.ActiveView.Refresh();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void ExportDatasetToXML(string datasetFeatureClassName)
{
IFeatureDataset featureDataset = featureWorkspace.OpenFeatureDataset(datasetFeatureClassName);
IFeatureClassContainer featureClassContainer = featureDataset as IFeatureClassContainer;
for (int i = 0; i < featureClassContainer.ClassCount; i++)
{
IFeatureClass featureClass = featureClassContainer.get_Class(i);
ExportFeatureClassToReportData(featureClass);
}
}
private void InitBrokePoint()
{
int userClassID;
int userID;
int userSubID;
IFeatureClassContainer featureDataset =
(IFeatureClassContainer)this._nearestEdgeInfo.GeometricNetwork.FeatureDataset;
IFeatureClass pointClass = null;
IFeatureClass lineClass = null;
int num3 = 0;
pointClass = _pipeLayer.GetLayers(enumPipelineDataType.Point)[0].FeatureClass;
lineClass = _pipeLayer.GetLayers(enumPipelineDataType.Line)[0].FeatureClass;
this._networkInfo.LayerLine =
MapHelper.FindFeatureLayerByFCName(m_iApp.FocusMap as IBasicMap, ((IDataset)lineClass).Name, false) as
IFeatureLayer;
this._networkInfo.LayerPoint =
MapHelper.FindFeatureLayerByFCName(m_iApp.FocusMap as IBasicMap, ((IDataset)pointClass).Name, false) as
IFeatureLayer;
INetElements network = (INetElements)this._nearestEdgeInfo.GeometricNetwork.Network;
network.QueryIDs(this._nearestEdgeInfo.EdgeID, esriElementType.esriETEdge, out userClassID, out userID,
out userSubID);
this._networkInfo.LineFeature = lineClass.GetFeature(userID);
Label label = this.lblPickPipeInfo;
string[] name = new string[]
{ this._networkInfo.LayerLine.Name, ",", lineClass.OIDFieldName, "=", userID.ToString() };
label.Text = string.Concat(name);
string.Format("\r\n爆管点位置({0:f2},{1:f2},{2:f2})", this._nearestEdgeInfo.Location.X,
this._nearestEdgeInfo.Location.Y, this._nearestEdgeInfo.Location.Z);
//初始化下拉菜单
cmbDomainValues.Items.Clear();
IBasicLayerInfo pLayerInfo = _pipeLayer.GetLayers(enumPipelineDataType.Point)[0];
IYTField pField = pLayerInfo.GetField(PipeConfigWordHelper.PointWords.FSW);
this.label1.Text = pField.Name;
if (!string.IsNullOrEmpty(pField.DomainValues))
{
string[] domianValues = pField.DomainValues.Split('/');
foreach (var onePair in domianValues)
{
cmbDomainValues.Items.Add(onePair);
}
}
if (this.listFieldValues.Items.Count == 0)
{
this.listFieldValues.Items.Add("阀门");
this.listFieldValues.Items.Add("阀门井");
}
}
//! 通过点击获取需要分析的管线
public bool PickBrokePipe(IPoint _pMousePoint)
{
this.InitClick();
this.ipoint_0 = _pMousePoint;
bool flag = false;
double num = 2147483647.0;
ArrayList arrayList = new ArrayList();
GetMapVisibleILayers(m_iApp.FocusMap, null, arrayList);
for (int i = 0; i < arrayList.Count; i++)
{
IFeatureLayer featureLayer = arrayList[i] as IFeatureLayer;
if (featureLayer != null && featureLayer.FeatureClass != null && featureLayer.Visible &&
m_Config.IsPipelineLayer(featureLayer.FeatureClass.AliasName, enumPipelineDataType.Line))
{
IPipelineLayer pipeLayer = m_Config.GetPipelineLayer(featureLayer.FeatureClass.AliasName,
enumPipelineDataType.Line);
IFeatureDataset featureDataset = featureLayer.FeatureClass.FeatureDataset;
IFeatureClassContainer featureClassContainer = featureDataset as IFeatureClassContainer;
List <IBasicLayerInfo> basicInfos = pipeLayer.GetLayers(enumPipelineDataType.Junction);
IFeatureClass featureClass = basicInfos.Count > 0 ? basicInfos[0].FeatureClass : null;
if (featureClass != null && featureClass is INetworkClass)
{
IGeometricNetwork geometricNetwork = ((INetworkClass)featureClass).GeometricNetwork;
IPointToEID pointToEIDClass = new PointToEID();
pointToEIDClass.SourceMap = (m_iApp.FocusMap);
pointToEIDClass.GeometricNetwork = (geometricNetwork);
pointToEIDClass.SnapTolerance = (m_iApp.ActiveView.Extent.Width / 200.0);
int edgeID = 0;
IPoint location = null;
double percent = 0;
pointToEIDClass.GetNearestEdge(this.ipoint_0, out edgeID, out location, out percent);
if (location != null && num > percent)
{
num = percent;
_pipeLayer = pipeLayer;
this._nearestEdgeInfo.GeometricNetwork = geometricNetwork;
this._nearestEdgeInfo.Percent = percent;
this._nearestEdgeInfo.EdgeID = edgeID;
this._nearestEdgeInfo.Location = location;
flag = true;
break;
}
}
}
}
arrayList.Clear();
if (flag)
{
this.DrawBrokeEdge();
}
return(flag);
}
private bool InitializeNetworkAndMap(IFeatureDataset FeatureDataset)
{
bool flag = false;
try
{
IFeatureLayer layer;
int num;
this.m_ipGeometricNetwork = ((INetworkCollection)FeatureDataset).get_GeometricNetwork(0);
INetwork network = this.m_ipGeometricNetwork.Network;
if (this.m_ipMap == null)
{
this.m_ipMap = new MapClass();
IFeatureClassContainer ipGeometricNetwork = (IFeatureClassContainer)this.m_ipGeometricNetwork;
for (num = 0; num < ipGeometricNetwork.ClassCount; num++)
{
IFeatureClass class2 = ipGeometricNetwork.get_Class(num);
layer = new FeatureLayerClass
{
FeatureClass = class2
};
this.m_ipMap.AddLayer(layer);
}
}
IEnvelope envelope = new EnvelopeClass();
for (num = 0; num < this.m_ipMap.LayerCount; num++)
{
layer = (IFeatureLayer)this.m_ipMap.get_Layer(num);
IGeoDataset dataset = (IGeoDataset)layer;
IEnvelope extent = dataset.Extent;
envelope.Union(extent);
}
this.m_ipPointToEID = new PointToEIDClass();
this.m_ipPointToEID.SourceMap = this.m_ipMap;
this.m_ipPointToEID.GeometricNetwork = this.m_ipGeometricNetwork;
double width = envelope.Width;
double height = envelope.Height;
if (width > height)
{
this.m_ipPointToEID.SnapTolerance = width / 100.0;
}
else
{
this.m_ipPointToEID.SnapTolerance = height / 100.0;
}
flag = true;
}
catch (Exception exception)
{
MessageBox.Show(exception.ToString());
}
return(flag);
}
/// <summary>
/// 初始化CADtoShape类（遍历属性表操作时）
/// </summary>
/// <param name="_CADPath"></param>
public CADtoShape(string _CADPath)
{
CADPath = _CADPath;
//建立存储点线面的文件夹
int index = CADPath.LastIndexOf("\\");
string name = CADPath.Substring(index + 1);
string path = CADPath.Substring(0, index);
pFeaWorkspace = pWorkspaceFactory.OpenFromFile(path, 0) as IFeatureWorkspace;
IFeatureDataset pFeaDataset = pFeaWorkspace.OpenFeatureDataset(name);
pFeaClassContainer = pFeaDataset as IFeatureClassContainer;
}
public static List <IFeatureClass> GetFeatureClasses(IDataset pDataset)
{
List <IFeatureClass> pList = new List <IFeatureClass>();
IFeatureClassContainer ipFcContain = (IFeatureClassContainer)pDataset;
IEnumFeatureClass ipFcEnum = ipFcContain.Classes;
IFeatureClass ipFtClass;
while ((ipFtClass = ipFcEnum.Next()) != null)
{
pList.Add(ipFtClass);
}
return(pList);
}
/// <summary>
/// Take a network element and return its corresponding source feature
/// <param name="element">The return source feature corresponds to this element</param>
/// </summary>
private IFeature GetSourceFeature(INetworkElement element)
{
// To draw the network element, we will need its corresponding source feature information
// Get the sourceID and OID from the element
int sourceID = element.SourceID;
int sourceOID = element.OID;
// Get the source feature from the network source
INetworkSource netSource = m_context.NetworkDataset.get_SourceByID(sourceID);
IFeatureClassContainer fClassContainer = m_context.NetworkDataset as IFeatureClassContainer;
IFeatureClass sourceFClass = fClassContainer.get_ClassByName(netSource.Name);
return(sourceFClass.GetFeature(sourceOID));
}
private void 查找ToolStripMenuItem_Click(object sender, EventArgs e)
{
if (!DBHelper.ifLogin)
{
MessageBox.Show("请登录");
return;
}
ArrayList test = DBHelper.queryAll("NAME LIKE '%52%'");
for (int i = 0; i < test.Count; i++)
{
MessageBox.Show(((NameAndType)test[i]).name + "");
}
object data = DBHelper.openByTypeAndName(((NameAndType)test[0]).name, ((NameAndType)test[0]).type);
//显示矢量图的方法
if (((NameAndType)test[0]).type.StartsWith("f"))
{
IFeatureDataset queryData = (IFeatureDataset)data;
IFeatureClassContainer datasetContainer = (IFeatureClassContainer)queryData;
IFeatureLayer m_FeatureLayer;
for (int i = 0; i < datasetContainer.ClassCount; i++)
{
IFeatureClass pFeatureClass = datasetContainer.get_Class(i);
if (pFeatureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
m_FeatureLayer = new CadAnnotationLayerClass();
MessageBox.Show("");
}
else
{
m_FeatureLayer = new FeatureLayerClass();
m_FeatureLayer.Name = pFeatureClass.AliasName;
m_FeatureLayer.FeatureClass = pFeatureClass;
m_mapControl.Map.AddLayer(m_FeatureLayer);
}
}
}
//显示栅格图的方法
if (((NameAndType)test[0]).type.StartsWith("r"))
{
IRasterDataset queryData = (IRasterDataset)data;
IRasterLayer pRasterLayer = new RasterLayerClass();
pRasterLayer.CreateFromDataset(queryData);
m_mapControl.Map.AddLayer(pRasterLayer as ILayer);
}
}
/// <summary>
/// CAD文件作为矢量图层加载
/// 整幅图加载
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnAddWhileCADToolStripMenuItem_Click(object sender, EventArgs e)
{
string filePath;
string fileName;
string filter = "CAD(*.dwg)|*.dwg";
string title = "打开CAD数据文件";
outFilePathAndFileName(title, filter, out filePath, out fileName);
if (fileName == null || filePath == null)
{
return;
}
// 打开一个CAD数据集
IWorkspaceFactory pWorkspaceFactory = new CadWorkspaceFactory();
IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(filePath, 0) as IFeatureWorkspace;
// 打开一个要素集
IFeatureDataset pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset(fileName);
// IFeatureClassContainer 可以管理IFeatureDataset中的每个要素类
IFeatureClassContainer pFeatureClassContainer = pFeatureDataset as IFeatureClassContainer;
// 新增删除数据
ClearAllData();
// 对CAD文件中的要素进行遍历处理
for (int i = 0; i < pFeatureClassContainer.ClassCount; i++)
{
IFeatureClass pFeatClass = pFeatureClassContainer.get_Class(i);
// 如果是注记，则添加注记层
if (pFeatClass.FeatureType == esriFeatureType.esriFTCoverageAnnotation)
{
IFeatureLayer pFeatureLayer = new CadAnnotationLayerClass();
pFeatureLayer.Name = pFeatClass.AliasName;
pFeatureLayer.FeatureClass = pFeatClass;
MainMapControl.AddLayer(pFeatureLayer);
}
// 如果是点线面则添加要素层
else
{
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.Name = pFeatClass.AliasName;
pFeatureLayer.FeatureClass = pFeatClass;
MainMapControl.AddLayer(pFeatureLayer);
}
MainMapControl.Refresh();
}
// 同步鹰眼
SynchronizeEagleEye();
}
// Join the data.
private static void JoinTheTableToFeatureClass(string dataToJoin)
{
string featureClassName = "";
string featureClassJoinFieldName = "";
string tableNameJoinFieldName = "";
// table name.
if (dataToJoin == "AddrPoints")
{
featureClassName = "AddrPnts" + "_SGID";
featureClassJoinFieldName = ".UTAddPtID";
tableNameJoinFieldName = ".ADDR_UID";
}
else if (dataToJoin == "Roads")
{
featureClassName = "Roads" + "_SGID";
featureClassJoinFieldName = ".UNIQUE_ID";
tableNameJoinFieldName = ".ROAD_UID";
}
string tableName = "tbl_" + countyName + "Report";
string queryDefTables = tableName + "," + featureClassName;
string queryDefWhereClause = tableName + tableNameJoinFieldName + " = " + featureClassName + featureClassJoinFieldName;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFGDB;
//create query definition
IQueryDef queryDef = featureWorkspace.CreateQueryDef();
//provide list of tables to join
//queryDef.Tables = "ROCKVILLE_Report, AddrPntsROCKVILLE_SGID";
queryDef.Tables = queryDefTables;
//retrieve the fields from all tables
//queryDef.SubFields = "sde.datesjoin.dt_field, sde.dudates.dt_field";
//set up join
//queryDef.WhereClause = "ROCKVILLE_Report.ADDR_UID = AddrPntsROCKVILLE_SGID.UTAddPtID";
queryDef.WhereClause = queryDefWhereClause;
//Create FeatureDataset. Note the use of .OpenFeatureQuery.
//The name "MyJoin" is the name of the restult of the query def and
//is used in place of a feature class name.
IFeatureDataset featureDataset = featureWorkspace.OpenFeatureQuery("MyJoin", queryDef);
//open layer to test against
IFeatureClassContainer featureClassContainer = (IFeatureClassContainer)featureDataset;
IFeatureClass featureClass = featureClassContainer.get_ClassByName("MyJoin");
// Export the joined feature class to the file geodatabase (at this point, it's just in memory)
ExportTheJoinedFeatureClass(featureClass, dataToJoin);
}
//加载拓扑图层
public static void AddTopoLayer(ref AxMapControl pMapCtrl, string strTopoLayerName, ITopologyWorkspace ipTopologyWS,IFeatureClassContainer ipFeatClassContainer, IFeatureDataset ipFeatDataset)
{
int nOriginClassID, nDestClassID;
ITopology ipTopology;
//打开数据集
//ITopologyContainer ipTopoContainer = (ITopologyContainer)ipFeatDataset;
IWorkspace2 pWorkspace = (IWorkspace2)ipFeatDataset.Workspace;
if (pWorkspace.get_NameExists(esriDatasetType.esriDTTopology, strTopoLayerName))
{
ipTopology = ipTopologyWS.OpenTopology(strTopoLayerName);
if (ipTopology == null)
{
return;
}
ITopologyLayer ipTopologyLayer = new TopologyLayerClass();
ipTopologyLayer.Topology = ipTopology;
ILegendInfo legendInfo = (ILegendInfo)ipTopologyLayer;
for (int i = 0; i < legendInfo.LegendGroupCount; i++)
{
ILegendGroup legendgroup = legendInfo.get_LegendGroup(i);
ILegendClass legendclass = legendgroup.get_Class(0);
switch (legendgroup.Heading)
{
case "Area Errors":
{
legendgroup.Heading = "";
legendclass.Label = "面状错误";
legendclass.Description = "面状错误";
break;
}
case "Line Errors":
{
legendgroup.Heading = "";
legendclass.Label = "线状错误";
legendclass.Description = "线状错误";
break;
}
case "Point Errors":
{
legendgroup.Heading = "";
legendclass.Label = "点状错误";
legendclass.Description = "点状错误";
break;
}
}
}
ILayer ipLayer = (ILayer)ipTopologyLayer;
ipLayer.Name = strTopoLayerName; //将拓扑检查合并后，将拓扑图层名指定为“拓扑错误”后，采用此方法命名 hehy20080724
/* 将拓扑检查合并后，将拓扑图层名指定为“拓扑错误”后，注销以下代码 hehy20080724
///////////////////////////////////////////////////
//得到拓扑层相对应的规则名称
CModelSchema pModelSchema = new CModelSchema();
string strRuleName = pModelSchema.GetRuleNameByTopoLayerName(m_pTask.pSchema, strTopoLayerName);
//////////////////////////////////////////////////
if (strRuleName.Length == 0)
{
ipLayer.Name = strTopoLayerName;
}
else
{
ipLayer.Name = strRuleName;
}
*/
//把拓扑图层加载到map控件中
//pMapCtrl.AddLayer(ipLayer, pMapCtrl.LayerCount);
pMapCtrl.Map.AddLayer(ipLayer);
//pMapCtrl.ActiveView.Extent = ipLayer.AreaOfInterest;
}
}
