/// <summary> Creates, loads, and returns a <see cref="NeuralNetwork"/> using the given <paramref name="networkLoader"/>. </summary>
/// <param name="networkLoader"> The <see cref="INetworkLoader"/> used to load the network. </param>
/// <returns> The loaded <see cref="NeuralNetwork"/>. </returns>
public static NeuralNetwork Load(INetworkLoader networkLoader)
{
// Get the number of neuron layers in the file.
int neuronLayerCount = networkLoader.GetNetworkNeuronLayerCount();
// Create an empty neural network.
NeuralNetwork neuralNetwork = new NeuralNetwork(networkLoader.GetNetworkLearningRate(), neuronLayerCount);
// Create the neuron layers for the neural network.
for (uint i = 0; i < neuronLayerCount; i++)
{
neuralNetwork.neuronLayers[i] = NeuronLayer.Load(neuralNetwork, networkLoader, i);
}
// Create the weight layers for the neural network.
for (uint i = 0; i < neuronLayerCount - 1; i++)
{
neuralNetwork.weightLayers[i] = WeightLayer.Load(neuralNetwork, networkLoader, i, neuralNetwork.neuronLayers[i], neuralNetwork.neuronLayers[i + 1]);
}
// Set the highest neuron count.
neuralNetwork.HighestNeuronCount = calculateHighestNeuronCount(neuralNetwork);
// Return the neural network.
return(neuralNetwork);
}
/// <summary> Creates, loads, links up, and returns a <see cref="WeightLayer"/> from the given <paramref name="networkLoader"/>. </summary>
/// <param name="neuralNetwork"> The neural network for which this layer is created. </param>
/// <param name="networkLoader"> The <see cref="INetworkLoader"/> used to load this <see cref="WeightLayer"/>. </param>
/// <param name="index"> The index of this new <see cref="WeightLayer"/>. </param>
/// <param name="previousNeuronLayer"> The previous <see cref="NeuronLayer"/> that this <see cref="WeightLayer"/> is linked to. </param>
/// <param name="nextNeuronLayer"> The next <see cref="NeuronLayer"/> that this <see cref="WeightLayer"/> is linked to. </param>
/// <returns> A new <see cref="WeightLayer"/> loaded from the given parameters. </returns>
public static WeightLayer Load(IReadOnlyNeuralNetwork neuralNetwork, INetworkLoader networkLoader, uint index, ILinkableNeuronLayer previousNeuronLayer, ILinkableNeuronLayer nextNeuronLayer)
{
// Create the weight layer to return.
WeightLayer weightLayer = new WeightLayer(neuralNetwork, index, previousNeuronLayer, nextNeuronLayer);
// Get all defined connections from the file.
Tuple <uint, float, uint>[] connections = networkLoader.GetAllWeightConnections(index);
// Link the layers together based on the given connections.
for (int i = 0; i < connections.Length; i++)
{
weightLayer.LinkNeurons(previousNeuronLayer[connections[i].Item1], nextNeuronLayer[connections[i].Item3], connections[i].Item2);
}
// Return the weight layer.
return(weightLayer);
}
/// <summary> Creates and loads a new <see cref="NeuronLayer"/> from the given <see cref="INetworkLoader"/>. </summary>
/// <param name="neuralNetwork"> The <see cref="IReadOnlyNeuralNetwork"/> that this <see cref="NeuronLayer"/> is for. </param>
/// <param name="networkLoader"> The <see cref="INetworkLoader"/> used to load the network. </param>
/// <param name="index"> The index of the <see cref="NeuronLayer"/> within the <see cref="NeuralNetwork"/>. </param>
/// <returns> The created and loaded <see cref="NeuronLayer"/>. </returns>
public static NeuronLayer Load(IReadOnlyNeuralNetwork neuralNetwork, INetworkLoader networkLoader, uint index)
{
// The amount of neurons in the layer.
int neuronCount = networkLoader.GetLayerNeuronCount(index);
// Create a new empty layer.
NeuronLayer neuronLayer = new NeuronLayer(neuralNetwork, index, neuronCount);
// Set the neurons of the layer to the loaded neurons from the loader.
Neuron[] newNeurons = networkLoader.LoadNeuronsFromLayerIndex(neuronLayer, index);
for (int i = 0; i < neuronCount; i++)
{
neuronLayer.neurons[i] = newNeurons[i];
}
// Return the filled neuron layer.
return(neuronLayer);
}
private void MainForm_Load(object sender, System.EventArgs e)
{
// 初始化RenderControl控件
IPropertySet ps = new PropertySet();
ps.SetProperty("RenderSystem", gviRenderSystem.gviRenderOpenGL);
this.axRenderControl1.Initialize(true, ps);
rootId = this.axRenderControl1.ObjectManager.GetProjectTree().RootID;
// 设置天空盒
if (System.IO.Directory.Exists(strMediaPath))
{
string tmpSkyboxPath = strMediaPath + @"\skybox";
ISkyBox skybox = this.axRenderControl1.ObjectManager.GetSkyBox(0);
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageBack, tmpSkyboxPath + "\\1_BK.jpg");
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageBottom, tmpSkyboxPath + "\\1_DN.jpg");
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageFront, tmpSkyboxPath + "\\1_FR.jpg");
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageLeft, tmpSkyboxPath + "\\1_LF.jpg");
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageRight, tmpSkyboxPath + "\\1_RT.jpg");
skybox.SetImagePath(gviSkyboxImageIndex.gviSkyboxImageTop, tmpSkyboxPath + "\\1_UP.jpg");
}
else
{
MessageBox.Show("请不要随意更改SDK目录名");
return;
}
this.axRenderControl1.Camera.FlyTime = 0;
this.cbOrderPolicy.SelectedIndex = 0;
if (geoFac == null)
{
geoFac = new GeometryFactory();
}
#region 加载road FDB
try
{
IConnectionInfo ci = new ConnectionInfo();
ci.ConnectionType = gviConnectionType.gviConnectionFireBird2x;
string tmpFDBPath = (strMediaPath + @"\Network.FDB");
ci.Database = tmpFDBPath;
IDataSourceFactory dsFactory = new DataSourceFactory();
IDataSource ds = dsFactory.OpenDataSource(ci);
string[] setnames = (string[])ds.GetFeatureDatasetNames();
if (setnames.Length == 0)
{
return;
}
dataset_Road = ds.OpenFeatureDataset(setnames[0]);
string[] fcnames = (string[])dataset_Road.GetNamesByType(gviDataSetType.gviDataSetFeatureClassTable);
if (fcnames.Length == 0)
{
return;
}
fcMap_Road = new Hashtable(fcnames.Length);
foreach (string name in fcnames)
{
IFeatureClass fc = dataset_Road.OpenFeatureClass(name);
// 找到空间列字段
List <string> geoNames = new List <string>();
IFieldInfoCollection fieldinfos = fc.GetFields();
for (int i = 0; i < fieldinfos.Count; i++)
{
IFieldInfo fieldinfo = fieldinfos.Get(i);
if (null == fieldinfo)
{
continue;
}
IGeometryDef geometryDef = fieldinfo.GeometryDef;
if (null == geometryDef)
{
continue;
}
geoNames.Add(fieldinfo.Name);
}
fcMap_Road.Add(fc, geoNames);
}
}
catch (COMException ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
return;
}
// CreateFeautureLayer
bool hasfly = false;
foreach (IFeatureClass fc in fcMap_Road.Keys)
{
List <string> geoNames = (List <string>)fcMap_Road[fc];
foreach (string geoName in geoNames)
{
if (!geoName.Equals("Geometry"))
{
continue;
}
IFeatureLayer featureLayer = this.axRenderControl1.ObjectManager.CreateFeatureLayer(
fc, geoName, null, null, rootId);
if (!hasfly)
{
IFieldInfoCollection fieldinfos = fc.GetFields();
IFieldInfo fieldinfo = fieldinfos.Get(fieldinfos.IndexOf(geoName));
IGeometryDef geometryDef = fieldinfo.GeometryDef;
IEnvelope env = geometryDef.Envelope;
if (env == null || (env.MaxX == 0.0 && env.MaxY == 0.0 && env.MaxZ == 0.0 &&
env.MinX == 0.0 && env.MinY == 0.0 && env.MinZ == 0.0))
{
continue;
}
IEulerAngle angle = new EulerAngle();
angle.Set(0, -20, 0);
this.axRenderControl1.Camera.LookAt(env.Center, 1000, angle);
}
hasfly = true;
}
}
Thread.Sleep(2000);
// 加载网络
try
{
dsManager = dataset_Road.GetNetworkManager();
string[] networkDatasetNames = dsManager.GetNetworkNames();
bool hasNetworkDataset = false;
for (int i = 0; i < networkDatasetNames.Length; i++)
{
if (networkDatasetNames[i] == "newNetworkDataset")
{
hasNetworkDataset = true;
}
}
if (!hasNetworkDataset)
{
dsLoader = dsManager.CreateNetworkLoader();
dsLoader.Name = "newNetworkDataset";
dsLoader.XYTolerance = double.Parse(txtLoaderTolerance.Text);
edgeNS = new EdgeNetworkSource();
edgeNS.SourceName = "road";
edgeNS.ConnectivityPolicy = gviNetworkEdgeConnectivityPolicy.gviEndVertex;
edgeNS.GeoColumnName = "Geometry";
edgeNS.ClassConnectivityGroup = 1;
dsLoader.AddSource(edgeNS);
INetworkAttribute attr = new NetworkAttribute();
attr.FieldType = gviFieldType.gviFieldDouble;
attr.Name = "Length";
attr.UsageType = gviNetworkAttributeUsageType.gviUseAsCost;
INetworkFieldEvaluator fieldEvaluator = new NetworkFieldEvaluator();
fieldEvaluator.FieldName = "Geometry";
attr.SetEvaluator(edgeNS, gviEdgeDirection.gviAlongDigitized, fieldEvaluator);
attr.SetEvaluator(edgeNS, gviEdgeDirection.gviAgainstDigitized, fieldEvaluator);
dsLoader.AddNetworkAttribute(attr);
dsLoader.LoadNetwork();
}
network = dsManager.GetNetwork("newNetworkDataset");
routeSolver = network.CreateRouteSolver();
routeSolver.ImpedanceAttributeName = "Length";
routeSolver.LocationSearchTolerance = double.Parse(txtSearchTolerance.Text);
////Marshal.ReleaseComObject(dsManager);
////Marshal.ReleaseComObject(dsLoader);
////Marshal.ReleaseComObject(attr);
////Marshal.ReleaseComObject(edgeNS);
////Marshal.ReleaseComObject(fieldEvaluator);
}
catch (COMException ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
#endregion
#region 加载POI FDB
try
{
IConnectionInfo ci = new ConnectionInfo();
ci.ConnectionType = gviConnectionType.gviConnectionFireBird2x;
string tmpFDBPath = (strMediaPath + @"\POI-1.FDB");
ci.Database = tmpFDBPath;
IDataSourceFactory dsFactory = new DataSourceFactory();
IDataSource ds = dsFactory.OpenDataSource(ci);
string[] setnames = (string[])ds.GetFeatureDatasetNames();
if (setnames.Length == 0)
{
return;
}
IFeatureDataSet dataset = ds.OpenFeatureDataset(setnames[0]);
string[] fcnames = (string[])dataset.GetNamesByType(gviDataSetType.gviDataSetFeatureClassTable);
if (fcnames.Length == 0)
{
return;
}
fcMap_POI = new Hashtable(fcnames.Length);
foreach (string name in fcnames)
{
IFeatureClass fc = dataset.OpenFeatureClass(name);
// 找到空间列字段
List <string> geoNames = new List <string>();
IFieldInfoCollection fieldinfos = fc.GetFields();
for (int i = 0; i < fieldinfos.Count; i++)
{
IFieldInfo fieldinfo = fieldinfos.Get(i);
if (null == fieldinfo)
{
continue;
}
IGeometryDef geometryDef = fieldinfo.GeometryDef;
if (null == geometryDef)
{
continue;
}
geoNames.Add(fieldinfo.Name);
}
fcMap_POI.Add(fc, geoNames);
}
}
catch (COMException ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
return;
}
//解析配置文件
string featurelayerName = "";
IValueMapGeometryRender render_JingDian = new ValueMapGeometryRender();
IValueMapGeometryRender render_MeiShi = new ValueMapGeometryRender();
IValueMapGeometryRender render_ZhuSu = new ValueMapGeometryRender();
IValueMapGeometryRender render_HuoDong = new ValueMapGeometryRender();
IValueMapGeometryRender render_GouWu = new ValueMapGeometryRender();
IValueMapGeometryRender render_ATM = new ValueMapGeometryRender();
IValueMapGeometryRender render_WC = new ValueMapGeometryRender();
string[] fn = Directory.GetFiles((strMediaPath + @"\xml\xml"));
foreach (string str in fn)
{
IValueMapGeometryRender render = new ValueMapGeometryRender();
try
{
XmlDocument docReader = new XmlDocument();
docReader.Load(str);
if (docReader.SelectSingleNode("FeatureLayer") != null)
{
featurelayerName = docReader.SelectSingleNode("FeatureLayer").Attributes["Name"].Value;
XmlNode GeometryRenderNode = docReader.SelectSingleNode("FeatureLayer").ChildNodes[0];
switch (GeometryRenderNode.Attributes["HeightStyle"].Value)
{
case "gviHeightAbsolute":
render.HeightStyle = gviHeightStyle.gviHeightAbsolute;
break;
case "gviHeightOnTerrain":
render.HeightStyle = gviHeightStyle.gviHeightOnTerrain;
break;
case "gviHeightRelative":
render.HeightStyle = gviHeightStyle.gviHeightRelative;
break;
}
render.RenderGroupField = GeometryRenderNode.Attributes["GroupField"].Value;
XmlNodeList xnl = docReader.SelectSingleNode("FeatureLayer").ChildNodes[0].ChildNodes[0].ChildNodes;
if (xnl.Count > 0)
{
foreach (XmlNode RenderSchemeNode in xnl)
{
IGeometryRenderScheme renderScheme = new GeometryRenderScheme();
IUniqueValuesRenderRule uniqueRenderRule = new UniqueValuesRenderRule();
IImagePointSymbol imagePointSym = new ImagePointSymbol();
XmlNodeList renderSchemeChilds = RenderSchemeNode.ChildNodes;
if (renderSchemeChilds.Count > 0)
{
XmlNode renderRuleNode = renderSchemeChilds.Item(0);
uniqueRenderRule.LookUpField = renderRuleNode.Attributes["LookUpField"].Value;
uniqueRenderRule.AddValue(renderRuleNode.Attributes["UniqueValue"].Value);
XmlNode geometrySymbolNode = renderSchemeChilds.Item(1);
imagePointSym.ImageName = geometrySymbolNode.Attributes["ImageName"].Value;
//imagePointSym.Size = int.Parse(geometrySymbolNode.Attributes["Size"].Value);
imagePointSym.Size = 60;
imagePointSym.Alignment = gviPivotAlignment.gviPivotAlignBottomCenter;
}
renderScheme.AddRule(uniqueRenderRule);
renderScheme.Symbol = imagePointSym;
render.AddScheme(renderScheme);
}
}
switch (featurelayerName)
{
case "景点347":
render_JingDian = render;
break;
case "ATM611":
render_ATM = render;
break;
case "购物67":
render_GouWu = render;
break;
case "活动927":
render_HuoDong = render;
break;
case "WC968":
render_WC = render;
break;
case "美食563":
render_MeiShi = render;
break;
case "住宿513":
render_ZhuSu = render;
break;
}
}
}
catch (System.Exception ex)
{
MessageBox.Show(str + " 解析失败");
return;
}
}
ISimpleTextRender textRender = new SimpleTextRender();
textRender.Expression = "$(Name)";
textRender.DynamicPlacement = true;
textRender.MinimizeOverlap = true;
ITextSymbol textSymbol = new TextSymbol();
TextAttribute textAttribute = new TextAttribute();
textAttribute.TextColor = System.Drawing.Color.Blue;
textAttribute.Font = "微软雅黑";
textSymbol.TextAttribute = textAttribute;
textSymbol.PivotAlignment = gviPivotAlignment.gviPivotAlignBottomCenter;
textSymbol.VerticalOffset = 10;
textRender.Symbol = textSymbol;
// CreateFeautureLayer
foreach (IFeatureClass fc in fcMap_POI.Keys)
{
List <string> geoNames = (List <string>)fcMap_POI[fc];
foreach (string geoName in geoNames)
{
if (!geoName.Equals("Geometry"))
{
continue;
}
switch (fc.Name)
{
case "景点347":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_JingDian, rootId);
break;
case "ATM611":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_ATM, rootId);
break;
case "购物67":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_GouWu, rootId);
break;
case "活动927":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_HuoDong, rootId);
break;
case "WC968":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_WC, rootId);
break;
case "美食563":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_MeiShi, rootId);
break;
case "住宿513":
this.axRenderControl1.ObjectManager.CreateFeatureLayer(fc, geoName, textRender, render_ZhuSu, rootId);
break;
}
}
}
#endregion
{
this.helpProvider1.SetShowHelp(this.axRenderControl1, true);
this.helpProvider1.SetHelpString(this.axRenderControl1, "");
this.helpProvider1.HelpNamespace = "Network.html";
}
}
public IGeometricNetwork CreateGeometricNetwork(IFeatureDataset ifeatureDataset_1)
{
int i;
IGeometricNetwork geometricNetworkByName;
try
{
INetworkCollection ifeatureDataset1 = ifeatureDataset_1 as INetworkCollection;
INetworkLoader networkLoader = this.NetworkLoader;
INetworkLoader2 preserveEnabledValues = networkLoader as INetworkLoader2;
INetworkLoaderProps networkLoaderProp = networkLoader as INetworkLoaderProps;
networkLoader.FeatureDatasetName = ifeatureDataset_1.FullName as IFeatureDatasetName as IDatasetName;
networkLoader.NetworkName = this.Name;
UID uIDClass = new UIDClass();
UID gUIDSIMPLEEDGECLSID = new UIDClass();
UID gUIDSIMPLEJUNCTIONCLSID = new UIDClass();
uIDClass.Value = this.GUID_COMPLEXEDGE_CLSID;
gUIDSIMPLEEDGECLSID.Value = this.GUID_SIMPLEEDGE_CLSID;
gUIDSIMPLEJUNCTIONCLSID.Value = this.GUID_SIMPLEJUNCTION_CLSID;
if (!this.IsSnap)
{
networkLoader.SnapTolerance = preserveEnabledValues.MinSnapTolerance;
}
else
{
networkLoader.SnapTolerance = this.SnapTolerance;
}
for (i = 0; i < this.Weights.Count; i++)
{
BulidGeometryNetworkHelper.Weight item = this.Weights[i] as BulidGeometryNetworkHelper.Weight;
networkLoader.AddWeight(item.networkWeightName, item.weightType, item.bitGateSize);
}
bool flag = true;
bool flag1 = false;
for (i = 0; i < this.FeatureClassWraps.Count; i++)
{
BulidGeometryNetworkHelper.FeatureClassWrap featureClassWrap =
this.FeatureClassWraps[i] as BulidGeometryNetworkHelper.FeatureClassWrap;
if (featureClassWrap.IsUse)
{
flag = true;
IDataset featureClass = featureClassWrap.FeatureClass as IDataset;
esriNetworkLoaderFeatureClassCheck _esriNetworkLoaderFeatureClassCheck =
preserveEnabledValues.CanUseFeatureClass(featureClass.Name);
esriNetworkLoaderFeatureClassCheck _esriNetworkLoaderFeatureClassCheck1 =
_esriNetworkLoaderFeatureClassCheck;
if (_esriNetworkLoaderFeatureClassCheck1 ==
esriNetworkLoaderFeatureClassCheck.esriNLFCCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name, " 未知错误"));
flag = false;
}
else
{
switch (_esriNetworkLoaderFeatureClassCheck1)
{
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInTerrain:
{
MessageBox.Show(string.Concat(featureClass.Name, "已用在三角网中"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCIsCompressedReadOnly:
{
MessageBox.Show(string.Concat(featureClass.Name, "是压缩只读要素类"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInTopology:
{
MessageBox.Show(string.Concat(featureClass.Name, "已用在拓扑中"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCRegisteredAsVersioned:
{
MessageBox.Show(string.Concat(featureClass.Name, "已注册版本"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInvalidShapeType:
{
MessageBox.Show(string.Concat(featureClass.Name, "不是点或线几何要素"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInvalidFeatureType:
{
MessageBox.Show(string.Concat(featureClass.Name, "是无效要素类型"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCInAnotherNetwork:
{
MessageBox.Show(string.Concat(featureClass.Name, "已在其它网络中使用"));
flag = false;
break;
}
case esriNetworkLoaderFeatureClassCheck.esriNLFCCCannotOpen:
{
MessageBox.Show(string.Concat("无法打开", featureClass.Name));
flag = false;
break;
}
}
}
if (flag &&
_esriNetworkLoaderFeatureClassCheck == esriNetworkLoaderFeatureClassCheck.esriNLFCCValid)
{
preserveEnabledValues.PreserveEnabledValues = this.PreserveEnabledValues;
esriNetworkLoaderFieldCheck _esriNetworkLoaderFieldCheck =
preserveEnabledValues.CheckEnabledDisabledField(featureClass.Name,
networkLoaderProp.DefaultEnabledField);
if (_esriNetworkLoaderFieldCheck == esriNetworkLoaderFieldCheck.esriNLFCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name, ": (ENABLED 字段)- 产生未知错误."));
flag = false;
}
else
{
switch (_esriNetworkLoaderFieldCheck)
{
case esriNetworkLoaderFieldCheck.esriNLFCInvalidDomain:
{
MessageBox.Show(string.Concat(featureClass.Name, ": ENABLED字段有无效域值."));
flag = false;
break;
}
case esriNetworkLoaderFieldCheck.esriNLFCInvalidType:
{
MessageBox.Show(string.Concat(featureClass.Name, ": ENABLED字段有无效类型"));
flag = false;
break;
}
case esriNetworkLoaderFieldCheck.esriNLFCNotFound:
{
try
{
networkLoader.PutEnabledDisabledFieldName(featureClass.Name,
networkLoaderProp.DefaultEnabledField);
break;
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
break;
}
break;
}
}
}
if (flag)
{
esriNetworkClassAncillaryRole _esriNetworkClassAncillaryRole =
esriNetworkClassAncillaryRole.esriNCARNone;
if (featureClassWrap.GeometryType == esriGeometryType.esriGeometryPoint &&
featureClassWrap.IsUse)
{
_esriNetworkClassAncillaryRole = esriNetworkClassAncillaryRole.esriNCARSourceSink;
}
esriFeatureType featureType = featureClassWrap.FeatureType;
if (featureType == esriFeatureType.esriFTSimpleJunction)
{
switch (_esriNetworkClassAncillaryRole)
{
case esriNetworkClassAncillaryRole.esriNCARNone:
{
break;
}
case esriNetworkClassAncillaryRole.esriNCARSourceSink:
{
_esriNetworkLoaderFieldCheck =
preserveEnabledValues.CheckAncillaryRoleField(featureClass.Name,
networkLoaderProp.DefaultAncillaryRoleField);
if (_esriNetworkLoaderFieldCheck ==
esriNetworkLoaderFieldCheck.esriNLFCUnknownError)
{
MessageBox.Show(string.Concat(featureClass.Name,
": (ROLE Field)- An unknown error was encountered."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
else
{
switch (_esriNetworkLoaderFieldCheck)
{
case esriNetworkLoaderFieldCheck.esriNLFCInvalidDomain:
{
MessageBox.Show(string.Concat(featureClass.Name,
": ROLE字段有无效域值."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
case esriNetworkLoaderFieldCheck.esriNLFCInvalidType:
{
MessageBox.Show(string.Concat(featureClass.Name,
": ROLE字段有无效类型."));
geometricNetworkByName = null;
return(geometricNetworkByName);
}
case esriNetworkLoaderFieldCheck.esriNLFCNotFound:
{
try
{
networkLoader.PutAncillaryRole(featureClass.Name,
esriNetworkClassAncillaryRole.esriNCARSourceSink,
networkLoaderProp.DefaultAncillaryRoleField);
break;
}
catch
{
break;
}
break;
}
default:
{
break;
}
}
}
break;
}
default:
{
goto case esriNetworkClassAncillaryRole.esriNCARNone;
}
}
}
try
{
switch (featureType)
{
case esriFeatureType.esriFTSimpleJunction:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTSimpleJunction, gUIDSIMPLEJUNCTIONCLSID,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
case esriFeatureType.esriFTSimpleEdge:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTSimpleEdge, gUIDSIMPLEEDGECLSID,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
case esriFeatureType.esriFTComplexJunction:
{
flag1 = true;
break;
}
case esriFeatureType.esriFTComplexEdge:
{
networkLoader.AddFeatureClass(featureClass.Name,
esriFeatureType.esriFTComplexEdge, uIDClass,
(this.IsSnap ? featureClassWrap.canChangeGeometry : false));
goto case esriFeatureType.esriFTComplexJunction;
}
default:
{
goto case esriFeatureType.esriFTComplexJunction;
}
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
if (cOMException.ErrorCode != -2147220462)
{
MessageBox.Show(cOMException.Message);
}
else
{
MessageBox.Show(string.Concat("要素类[", featureClass.Name, "]无法添加到几何网络中!"));
}
}
catch (Exception exception1)
{
MessageBox.Show(exception1.Message);
}
}
}
}
}
if (flag1)
{
for (i = 0; i < this.WeightAssociations.Count; i++)
{
BulidGeometryNetworkHelper.WeightAssociation weightAssociation =
this.WeightAssociations[i] as BulidGeometryNetworkHelper.WeightAssociation;
preserveEnabledValues.AddWeightAssociation(weightAssociation.networkWeightName,
weightAssociation.featureClassName, weightAssociation.fieldName);
}
preserveEnabledValues.ConfigurationKeyword = this.ConfigurationKeyword;
preserveEnabledValues.PreserveEnabledValues = this.PreserveEnabledValues;
networkLoader.LoadNetwork();
geometricNetworkByName = ifeatureDataset1.GeometricNetworkByName[this.Name];
}
else
{
geometricNetworkByName = null;
}
}
catch (Exception exception2)
{
MessageBox.Show(exception2.Message);
geometricNetworkByName = null;
return(geometricNetworkByName);
}
return(geometricNetworkByName);
}
