async public static Task AppendNodeFlags(INetworkFeatureClass network, GraphTable gt, List <int> nodeIds, NetworkTracerOutputCollection output /*, IProgressReporterEvent reportEvent, ProgressReport report*/)
{
try
{
Dictionary <int, string> fcNames = new Dictionary <int, string>();
//int counter = 0;
//if (report != null)
//{
// report.Message = "Add Nodes...";
// report.featurePos = 0;
// report.featureMax = nodeIds.Count;
// reportEvent.reportProgress(report);
//}
foreach (int nodeId in nodeIds)
{
int fcId = gt.GetNodeFcid(nodeId);
if (fcId >= 0)
{
IFeature nodeFeature = await network.GetNodeFeature(nodeId);
if (nodeFeature != null && nodeFeature.Shape is IPoint)
{
if (!fcNames.ContainsKey(fcId))
{
fcNames.Add(fcId, await network.NetworkClassName(fcId));
}
string fcName = fcNames[fcId];
output.Add(new NetworkFlagOutput(nodeFeature.Shape as IPoint,
new NetworkFlagOutput.NodeFeatureData(nodeId, fcId, Convert.ToInt32(nodeFeature["OID"]), fcName)));
}
}
//counter++;
//if (report != null && counter % 1000 == 0)
//{
// report.featurePos = counter;
// reportEvent.reportProgress(report);
//}
}
}
catch { }
}
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);
}
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 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>();
List <int> nodeIds = new List <int>();
foreach (Dijkstra.Node dijkstraNode in dijkstraNodes)
{
if (gt.GetNodeType(dijkstraNode.Id) == TargetNodeType)
{
nodeIds.Add(dijkstraNode.Id);
}
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);
}
#region Collection Nodes
counter = 0;
foreach (int nodeId in nodeIds)
{
int fcId = gt.GetNodeFcid(nodeId);
IFeature nodeFeature = network.GetNodeFeature(nodeId);
if (nodeFeature != null && nodeFeature.Shape is IPoint)
{
//outputCollection.Add(new NetworkNodeFlagOuput(endNode.Id, nodeFeature.Shape as IPoint));
output.Add(new NetworkFlagOutput(nodeFeature.Shape as IPoint,
new NetworkFlagOutput.NodeFeatureData(nodeId, fcId, Convert.ToInt32(nodeFeature["OID"]), TargetNodeType.ToString())));
}
counter++;
if (report != null && counter % 1000 == 0)
{
report.featurePos = counter;
ReportProgress(report);
}
}
#endregion
#region Collection Edges
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)
{
Helper.AppendNodeFlags(network, gt, Helper.NodeIds(dijkstraNodes), output);
}
#endregion
return(output);
}