async public Task <NetworkTracerOutputCollection> Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput source = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
NetworkSinkInput sink = input.Collect(NetworkTracerInputType.SinkNode)[0] as NetworkSinkInput;
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
Dijkstra.ApplyInputIds(dijkstra, input);
// Kürzesten Weg berechenen
if (!dijkstra.Calculate(gt, source.NodeId, sink.NodeId))
{
return(null);
}
Dijkstra.Nodes initialNodes = dijkstra.DijkstraPathNodes(sink.NodeId);
dijkstra = new Dijkstra(initialNodes, cancelTraker);
dijkstra.ForbiddenTargetNodeIds = initialNodes.IdsToList();
for (int i = 1; i < initialNodes.Count - 1; i++)
{
dijkstra.Calculate(gt, initialNodes[i].Id);
}
NetworkTracerOutputCollection output = new NetworkTracerOutputCollection();
NetworkPathOutput pathOutput = new NetworkPathOutput();
Dijkstra.Nodes nodes = dijkstra.DijkstraNodes;
foreach (Dijkstra.Node node in nodes)
{
pathOutput.Add(new NetworkEdgeOutput(node.EId));
}
output.Add(pathOutput);
if (input.Collect(NetworkTracerInputType.AppendNodeFlags).Count > 0)
{
await Helper.AppendNodeFlags(network, gt, Helper.NodeIds(nodes), output);
}
return(output);
}
public NetworkTracerOutputCollection Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput sourceNode = null;
NetworkSourceEdgeInput sourceEdge = null;
if (input.Collect(NetworkTracerInputType.SourceNode).Count == 1)
{
sourceNode = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
}
else if (input.Collect(NetworkTracerInputType.SoruceEdge).Count == 1)
{
sourceEdge = input.Collect(NetworkTracerInputType.SoruceEdge)[0] as NetworkSourceEdgeInput;
}
else
{
return(null);
}
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
Dijkstra.ApplyInputIds(dijkstra, input);
if (sourceNode != null)
{
dijkstra.Calculate(gt, sourceNode.NodeId);
}
else if (sourceEdge != null)
{
IGraphEdge graphEdge = gt.QueryEdge(sourceEdge.EdgeId);
if (graphEdge == null)
{
return(null);
}
bool n1_2_n2 = gt.QueryN1ToN2(graphEdge.N1, graphEdge.N2) != null;
bool n2_2_n1 = gt.QueryN1ToN2(graphEdge.N2, graphEdge.N1) != null;
bool n1switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N1) : true;
bool n2switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N2) : true;
if (n1_2_n2 && n1switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N1);
}
else if (n2_2_n1 && n2switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N2);
}
else
{
return(null);
}
}
Dijkstra.Nodes dijkstraNodes = dijkstra.DijkstraNodesWithMaxDistance(double.MaxValue);
if (dijkstraNodes == null)
{
return(null);
}
ProgressReport report = (ReportProgress != null ? new ProgressReport() : null);
#region Collect EdgedIds
if (report != null)
{
report.Message = "Collected Edges...";
report.featurePos = 0;
report.featureMax = dijkstraNodes.Count;
ReportProgress(report);
}
NetworkInputForbiddenEdgeIds forbiddenEdgeIds = (input.Contains(NetworkTracerInputType.ForbiddenEdgeIds)) ? input.Collect(NetworkTracerInputType.ForbiddenEdgeIds)[0] as NetworkInputForbiddenEdgeIds : null;
NetworkInputForbiddenStartNodeEdgeIds forbiddenStartNodeEdgeIds = (input.Contains(NetworkTracerInputType.ForbiddenStartNodeEdgeIds)) ? input.Collect(NetworkTracerInputType.ForbiddenStartNodeEdgeIds)[0] as NetworkInputForbiddenStartNodeEdgeIds : null;
int counter = 0;
List <int> edgeIds = new List <int>();
foreach (Dijkstra.Node dijkstraNode in dijkstraNodes)
{
if (dijkstra.ApplySwitchState)
{
if (gt.SwitchState(dijkstraNode.Id) == false) // hier ist Schluss!!
{
continue;
}
}
GraphTableRows gtRows = gt.QueryN1(dijkstraNode.Id);
if (gtRows == null)
{
continue;
}
foreach (IGraphTableRow gtRow in gtRows)
{
int eid = gtRow.EID;
if (sourceNode != null &&
forbiddenStartNodeEdgeIds != null && dijkstraNode.Id == sourceNode.NodeId &&
forbiddenStartNodeEdgeIds.Ids.Contains(eid))
{
continue;
}
if (forbiddenEdgeIds != null && forbiddenEdgeIds.Ids.Contains(eid))
{
continue;
}
int index = edgeIds.BinarySearch(eid);
if (index < 0)
{
edgeIds.Insert(~index, eid);
}
}
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
#endregion
NetworkTracerOutputCollection output = new NetworkTracerOutputCollection();
if (report != null)
{
report.Message = "Add Edges...";
report.featurePos = 0;
report.featureMax = edgeIds.Count;
ReportProgress(report);
}
counter = 0;
NetworkPathOutput pathOutput = new NetworkPathOutput();
foreach (int edgeId in edgeIds)
{
pathOutput.Add(new NetworkEdgeOutput(edgeId));
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
//var x = network.GetEdgeFeatureAttributes(edgeId, null);
}
output.Add(pathOutput);
if (input.Collect(NetworkTracerInputType.AppendNodeFlags).Count > 0)
{
Helper.AppendNodeFlags(network, gt, Helper.NodeIds(dijkstraNodes), output);
}
return(output);
}
public NetworkTracerOutputCollection Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, gView.Framework.system.ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput source = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
NetworkSinkInput sink = input.Collect(NetworkTracerInputType.SinkNode)[0] as NetworkSinkInput;
NetworkWeighInput weight =
input.Contains(NetworkTracerInputType.Weight) ?
input.Collect(NetworkTracerInputType.Weight)[0] as NetworkWeighInput :
null;
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
if (weight != null)
{
dijkstra.GraphWeight = weight.Weight;
dijkstra.WeightApplying = weight.WeightApplying;
}
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
Dijkstra.ApplyInputIds(dijkstra, input);
dijkstra.Calculate(gt, source.NodeId, sink.NodeId);
Dijkstra.NetworkPath networkPath = dijkstra.DijkstraPath(sink.NodeId);
if (networkPath == null)
{
return(null);
}
NetworkTracerOutputCollection output = new NetworkTracerOutputCollection();
NetworkPathOutput pathOutput = new NetworkPathOutput();
foreach (Dijkstra.NetworkPathEdge pathEdge in networkPath)
{
pathOutput.Add(new NetworkEdgeOutput(pathEdge.EId));
}
output.Add(pathOutput);
if (input.Collect(NetworkTracerInputType.AppendNodeFlags).Count > 0)
{
Dijkstra.Nodes pathNodes = dijkstra.DijkstraPathNodes(sink.NodeId);
Helper.AppendNodeFlags(network, gt, Helper.NodeIds(pathNodes), output);
}
//if (pathNodes != null)
//{
// foreach (Dijkstra.Node node in pathNodes)
// {
// string label = node.Dist.ToString();
// if (weight != null)
// {
// label += "\n(" + (Math.Round(node.GeoDist, 2)).ToString() + ")";
// }
// output.Add(new NetworkNodeFlagOuput(node.Id));
// }
//}
return(output);
}
async public Task <NetworkTracerOutputCollection> Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, gView.Framework.system.ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput sourceNode = null;
NetworkSourceEdgeInput sourceEdge = null;
if (input.Collect(NetworkTracerInputType.SourceNode).Count == 1)
{
sourceNode = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
}
else if (input.Collect(NetworkTracerInputType.SoruceEdge).Count == 1)
{
sourceEdge = input.Collect(NetworkTracerInputType.SoruceEdge)[0] as NetworkSourceEdgeInput;
}
else
{
return(null);
}
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
Dijkstra.ApplyInputIds(dijkstra, input);
if (sourceNode != null)
{
dijkstra.Calculate(gt, sourceNode.NodeId);
}
else if (sourceEdge != null)
{
IGraphEdge graphEdge = gt.QueryEdge(sourceEdge.EdgeId);
if (graphEdge == null)
{
return(null);
}
bool n1_2_n2 = gt.QueryN1ToN2(graphEdge.N1, graphEdge.N2) != null;
bool n2_2_n1 = gt.QueryN1ToN2(graphEdge.N2, graphEdge.N1) != null;
bool n1switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N1) : true;
bool n2switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N2) : true;
if (n1_2_n2 && n1switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N1);
}
else if (n2_2_n1 && n2switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N2);
}
else
{
return(null);
}
}
Dijkstra.Nodes dijkstraNodes = dijkstra.DijkstraNodesWithMaxDistance(double.MaxValue);
if (dijkstraNodes == null)
{
return(null);
}
ProgressReport report = (ReportProgress != null ? new ProgressReport() : null);
int counter = 0;
#region Collect Disconnected Nodes
int maxNodeId = network.MaxNodeId;
if (report != null)
{
report.Message = "Collected Disconnected Nodes...";
report.featurePos = 0;
report.featureMax = maxNodeId;
ReportProgress(report);
}
List <int> connectedNodeIds = dijkstraNodes.IdsToList();
connectedNodeIds.Sort();
List <int> disconnectedNodeIds = new List <int>();
for (int id = 1; id <= maxNodeId; id++)
{
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
if (connectedNodeIds.BinarySearch(id) >= 0)
{
continue;
}
disconnectedNodeIds.Add(id);
}
#endregion
#region Collect EdgedIds
if (report != null)
{
report.Message = "Collected Edges...";
report.featurePos = 0;
report.featureMax = dijkstraNodes.Count;
ReportProgress(report);
}
List <int> edgeIds = new List <int>();
foreach (int id in disconnectedNodeIds)
{
GraphTableRows gtRows = gt.QueryN1(id);
if (gtRows == null)
{
continue;
}
foreach (IGraphTableRow gtRow in gtRows)
{
int index = edgeIds.BinarySearch(gtRow.EID);
if (index < 0)
{
edgeIds.Insert(~index, gtRow.EID);
}
}
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
#endregion
NetworkTracerOutputCollection output = new NetworkTracerOutputCollection();
if (report != null)
{
report.Message = "Add Edges...";
report.featurePos = 0;
report.featureMax = edgeIds.Count;
ReportProgress(report);
}
counter = 0;
NetworkPathOutput pathOutput = new NetworkPathOutput();
foreach (int edgeId in edgeIds)
{
pathOutput.Add(new NetworkEdgeOutput(edgeId));
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
output.Add(pathOutput);
if (input.Collect(NetworkTracerInputType.AppendNodeFlags).Count > 0)
{
await Helper.AppendNodeFlags(network, gt, disconnectedNodeIds, output);
}
return(output);
}
async public Task <NetworkTracerOutputCollection> Trace(INetworkFeatureClass network, NetworkTracerInputCollection input, ICancelTracker cancelTraker)
{
if (network == null || !CanTrace(input))
{
return(null);
}
GraphTable gt = new GraphTable(network.GraphTableAdapter());
NetworkSourceInput sourceNode = null;
NetworkSourceEdgeInput sourceEdge = null;
if (input.Collect(NetworkTracerInputType.SourceNode).Count == 1)
{
sourceNode = input.Collect(NetworkTracerInputType.SourceNode)[0] as NetworkSourceInput;
}
else if (input.Collect(NetworkTracerInputType.SoruceEdge).Count == 1)
{
sourceEdge = input.Collect(NetworkTracerInputType.SoruceEdge)[0] as NetworkSourceEdgeInput;
}
else
{
return(null);
}
input.Collect(NetworkTracerInputType.BarrierNodes);
NetworkTracerOutputCollection outputCollection = new NetworkTracerOutputCollection();
List <int> edgeIds = new List <int>();
NetworkPathOutput pathOutput = new NetworkPathOutput();
List <int> neighborNodeFcIds = new List <int>();
Dictionary <int, string> neighborFcs = new Dictionary <int, string>();
foreach (var networkClass in await network.NetworkClasses())
{
if (networkClass.GeometryType != geometryType.Point)
{
continue;
}
int fcid = await network.NetworkClassId(networkClass.Name);
neighborNodeFcIds.Add(fcid);
neighborFcs.Add(fcid, networkClass.Name);
}
Dijkstra dijkstra = new Dijkstra(cancelTraker);
dijkstra.reportProgress += this.ReportProgress;
dijkstra.ApplySwitchState = input.Contains(NetworkTracerInputType.IgnoreSwitches) == false &&
network.HasDisabledSwitches;
dijkstra.TargetNodeFcIds = neighborNodeFcIds;
dijkstra.TargetNodeType = TargetNodeType;
Dijkstra.ApplyInputIds(dijkstra, input);
Dijkstra.Nodes dijkstraEndNodes = null;
if (sourceNode != null)
{
dijkstra.Calculate(gt, sourceNode.NodeId);
dijkstraEndNodes = dijkstra.DijkstraEndNodes;
}
else if (sourceEdge != null)
{
IGraphEdge graphEdge = gt.QueryEdge(sourceEdge.EdgeId);
if (graphEdge == null)
{
return(null);
}
bool n1_2_n2 = gt.QueryN1ToN2(graphEdge.N1, graphEdge.N2) != null;
bool n2_2_n1 = gt.QueryN1ToN2(graphEdge.N2, graphEdge.N1) != null;
if (n1_2_n2 == false &&
n2_2_n1 == false)
{
return(null);
}
bool n1switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N1) : true;
bool n2switchState = dijkstra.ApplySwitchState ? gt.SwitchState(graphEdge.N2) : true;
bool n1isNeighbor = neighborNodeFcIds.Contains(gt.GetNodeFcid(graphEdge.N1));
bool n2isNeighbor = neighborNodeFcIds.Contains(gt.GetNodeFcid(graphEdge.N2));
if (n1isNeighbor && n2isNeighbor)
{
dijkstraEndNodes = new Dijkstra.Nodes();
dijkstraEndNodes.Add(new Dijkstra.Node(graphEdge.N1));
dijkstraEndNodes.Add(new Dijkstra.Node(graphEdge.N2));
dijkstraEndNodes[0].EId = graphEdge.Eid;
edgeIds.Add(graphEdge.Eid);
pathOutput.Add(new NetworkEdgeOutput(graphEdge.Eid));
}
else
{
if (!n1isNeighbor && n1switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N1);
dijkstraEndNodes = dijkstra.DijkstraEndNodes;
if (!n1_2_n2 && n2isNeighbor)
{
Dijkstra.Node n1Node = new Dijkstra.Node(graphEdge.N2);
n1Node.EId = graphEdge.Eid;
dijkstraEndNodes.Add(n1Node);
edgeIds.Add(graphEdge.Eid);
pathOutput.Add(new NetworkEdgeOutput(graphEdge.Eid));
}
}
else if (!n2isNeighbor && n2switchState == true)
{
dijkstra.Calculate(gt, graphEdge.N2);
dijkstraEndNodes = dijkstra.DijkstraEndNodes;
if (!n2_2_n1 && n1isNeighbor)
{
Dijkstra.Node n1Node = new Dijkstra.Node(graphEdge.N1);
n1Node.EId = graphEdge.Eid;
dijkstraEndNodes.Add(n1Node);
edgeIds.Add(graphEdge.Eid);
pathOutput.Add(new NetworkEdgeOutput(graphEdge.Eid));
}
}
}
}
#region Create Output
if (dijkstraEndNodes == null)
{
return(null);
}
ProgressReport report = (ReportProgress != null ? new ProgressReport() : null);
#region Collect End Nodes
if (report != null)
{
report.Message = "Collect End Nodes...";
report.featurePos = 0;
report.featureMax = dijkstraEndNodes.Count;
ReportProgress(report);
}
int counter = 0;
foreach (Dijkstra.Node endNode in dijkstraEndNodes)
{
int fcId = gt.GetNodeFcid(endNode.Id);
if (neighborNodeFcIds.Contains(fcId) && gt.GetNodeType(endNode.Id) == this.TargetNodeType)
{
IFeature nodeFeature = await network.GetNodeFeature(endNode.Id);
if (nodeFeature != null && nodeFeature.Shape is IPoint)
{
string fcName = neighborFcs.ContainsKey(fcId) ?
neighborFcs[fcId] : String.Empty;
//outputCollection.Add(new NetworkNodeFlagOuput(endNode.Id, nodeFeature.Shape as IPoint));
outputCollection.Add(new NetworkFlagOutput(nodeFeature.Shape as IPoint,
new NetworkFlagOutput.NodeFeatureData(endNode.Id, fcId, Convert.ToInt32(nodeFeature["OID"]), fcName)));
}
}
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
#endregion
#region Collect EdgedIds
if (report != null)
{
report.Message = "Collect Edges...";
report.featurePos = 0;
report.featureMax = dijkstra.DijkstraNodes.Count;
ReportProgress(report);
}
counter = 0;
foreach (Dijkstra.Node dijkstraEndNode in dijkstraEndNodes)
{
Dijkstra.NetworkPath networkPath = dijkstra.DijkstraPath(dijkstraEndNode.Id);
if (networkPath == null)
{
continue;
}
foreach (Dijkstra.NetworkPathEdge pathEdge in networkPath)
{
int index = edgeIds.BinarySearch(pathEdge.EId);
if (index >= 0)
{
continue;
}
edgeIds.Insert(~index, pathEdge.EId);
pathOutput.Add(new NetworkEdgeOutput(pathEdge.EId));
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
}
if (pathOutput.Count > 0)
{
outputCollection.Add(pathOutput);
}
#endregion
#endregion
return(outputCollection);
}