/// <summary> /// Adds an edge. /// </summary> /// <param name="forward"></param> /// <param name="from"></param> /// <param name="to"></param> /// <param name="tags"></param> protected virtual bool AddRoadEdge(TagsCollectionBase tags, bool forward, uint from, uint to) { float latitude; float longitude; GeoCoordinate fromCoordinate = null; if (_dynamicGraph.GetVertex(from, out latitude, out longitude)) { // fromCoordinate = new GeoCoordinate(latitude, longitude); } GeoCoordinate toCoordinate = null; if (_dynamicGraph.GetVertex(to, out latitude, out longitude)) { // toCoordinate = new GeoCoordinate(latitude, longitude); } if (fromCoordinate != null && toCoordinate != null) { // calculate the edge data. TEdgeData edgeData = this.CalculateEdgeData(_interpreter.EdgeInterpreter, _tagsIndex, tags, forward, fromCoordinate, toCoordinate); _dynamicGraph.AddArc(from, to, edgeData, _edgeComparer); } return(false); }
/// <summary> /// Contracts the given vertex. /// </summary> /// <param name="vertex"></param> public void Contract(uint vertex) { if (_contracted.Length > vertex && _contracted[vertex]) { throw new Exception("Is already contracted!"); } // keep the neighbours. HashSet <KeyValuePair <uint, CHEdgeData> > neighbours = new HashSet <KeyValuePair <uint, CHEdgeData> >(); // get all information from the source. KeyValuePair <uint, CHEdgeData>[] edges = _target.GetArcs(vertex); // remove all informative edges. edges = edges.RemoveInformativeEdges(); // report the before contraction event. this.OnBeforeContraction(vertex, edges); // remove the edges from the neighbours to the target. foreach (KeyValuePair <uint, CHEdgeData> edge in edges) { // remove the edge. _target.DeleteArc(edge.Key, vertex); // keep the neighbour. if (_keepDirectNeighbours && !edge.Value.HasContractedVertex) { // edge does represent a neighbour relation. neighbours.Add( new KeyValuePair <uint, CHEdgeData>(edge.Key, edge.Value.ConvertToInformative())); } } // loop over each combination of edges just once. for (int x = 1; x < edges.Length; x++) { // loop over all elements first. KeyValuePair <uint, CHEdgeData> xEdge = edges[x]; if (xEdge.Value.IsInformative) { continue; } for (int y = 0; y < x; y++) { // loop over all elements. KeyValuePair <uint, CHEdgeData> yEdge = edges[y]; if (yEdge.Value.IsInformative) { continue; } // calculate the total weight. float weight = xEdge.Value.Weight + yEdge.Value.Weight; // add the combinations of these edges. if (((xEdge.Value.Backward && yEdge.Value.Forward) || (yEdge.Value.Backward && xEdge.Value.Forward)) && (xEdge.Key != yEdge.Key)) { // there is a connection from x to y and there is no witness path. bool witnessXToY = _witnessCalculator.Exists(_target, xEdge.Key, yEdge.Key, vertex, weight, 100); bool witnessYToX = _witnessCalculator.Exists(_target, yEdge.Key, xEdge.Key, vertex, weight, 100); // create x-to-y data and edge. CHEdgeData dataXToY = new CHEdgeData(); bool forward = (xEdge.Value.Backward && yEdge.Value.Forward) && !witnessXToY; bool backward = (yEdge.Value.Backward && xEdge.Value.Forward) && !witnessYToX; dataXToY.SetDirection(forward, backward, true); dataXToY.Weight = weight; dataXToY.ContractedVertexId = vertex; if ((dataXToY.Forward || dataXToY.Backward) || !_target.HasArc(xEdge.Key, yEdge.Key)) { // add the edge if there is usefull info or if there needs to be a neighbour relationship. _target.AddArc(xEdge.Key, yEdge.Key, dataXToY, _comparer); } // create y-to-x data and edge. CHEdgeData dataYToX = new CHEdgeData(); forward = (yEdge.Value.Backward && xEdge.Value.Forward) && !witnessYToX; backward = (xEdge.Value.Backward && yEdge.Value.Forward) && !witnessXToY; dataYToX.SetDirection(forward, backward, true); dataYToX.Weight = weight; dataYToX.ContractedVertexId = vertex; if ((dataYToX.Forward || dataYToX.Backward) || !_target.HasArc(yEdge.Key, xEdge.Key)) { // add the edge if there is usefull info or if there needs to be a neighbour relationship. _target.AddArc(yEdge.Key, xEdge.Key, dataYToX, _comparer); } } } } // mark the vertex as contracted. this.MarkContracted(vertex); // notify a contracted neighbour. _calculator.NotifyContracted(vertex); // add contracted neighbour edges again. if (_keepDirectNeighbours) { foreach (KeyValuePair <uint, CHEdgeData> neighbour in neighbours) { _target.AddArc(neighbour.Key, vertex, neighbour.Value, null); } } // report the after contraction event. this.OnAfterContraction(vertex, edges); }