public List <int> GetIntersectionNeighbors(int intersectionIndex)
{
List <int> outList = new List <int>();
foreach (int segmentIndex in this.intersectionToSegmentDict[intersectionIndex])
{
StreetSegment seg = this.Streets[segmentIndex];
int i0 = seg.EndpointIndices[0];
int i1 = seg.EndpointIndices[1];
int unselected = -1;
if (i0 == intersectionIndex)
{
unselected = i1;
}
else
{
unselected = i0;
}
if (!outList.Contains(unselected))
{
outList.Add(unselected);
}
}
return(outList);
}
public static List <StreetSegment> GetConnectingStreetSegments(List <StreetConnector> connectors)
{
StreetType t;
List <StreetSegment> s = new List <StreetSegment>();
foreach (StreetConnector sc1 in connectors)
{
foreach (StreetConnector sc2 in connectors)
{
if (sc1 != sc2 && sc1.FindNeighbours() != null && sc1.FindNeighbours().Contains(sc2))
{
if (sc1.EP1.FindNeighbours().Contains(sc2))
{
t = sc1.EP1.Self;
}
else
{
t = sc1.EP2.Self;
}
if (t is StreetSegment)
{
StreetSegment segment = (StreetSegment)t;
if (!s.Contains(segment))
{
s.Add(segment);
}
}
}
}
}
return(s);
}
public async Task <StreetSegmentResponse> PostStreetSegment(PostStreetSegmentRequest model)
{
StreetSegment insert = new StreetSegment
{
Name = model.Name,
Geom = model.Geom,
CreateDate = DateTime.UtcNow.AddHours(7).Date,
WardId = model.WardId,
StreetId = model.StreetId
};
try
{
_unitOfWork.Repository <StreetSegment>().Insert(insert);
await _unitOfWork.CommitAsync();
return(new StreetSegmentResponse
{
Name = insert.Name,
Geom = insert.Geom,
CreateDate = insert.CreateDate,
WardId = insert.WardId,
Id = insert.Id,
StreetId = insert.StreetId
});
}
catch (Exception e)
{
throw new CrudException(HttpStatusCode.BadRequest, "Insert Error!!!", e.InnerException?.Message);
}
}
void AddStreetRange(StreetSegment seg, float f0, float f1)
{
//Debug.Log(string.Format("Adding segment with values {0} {1}", f0, f1));
Vector2 v0 = seg.InterpolateEndpoints(f0);
Vector2 v1 = seg.InterpolateEndpoints(f1);
GridAddress a0 = new GridAddress(v0);
GridAddress a1 = new GridAddress(v1);
if (a0 == a1)
{
//Debug.Log(string.Format("Adding segment at location {0}", a0));
AddStreetAtPoint(seg, v0);
}
else
if ((Mathf.Abs(a0.x - a1.x) <= 1) &&
(Mathf.Abs(a0.y - a1.y) <= 1))
{
//Debug.Log(string.Format("Adding segment at locations {0} and {1}", a0, a1));
AddStreetAtPoint(seg, v0);
AddStreetAtPoint(seg, v1);
}
else
{
float fh = (f0 + f1) / 2.0f;
AddStreetRange(seg, f0, fh);
AddStreetRange(seg, fh, f1);
}
}
public void AddStreetAtPoint(StreetSegment seg, Vector2 pt)
{
GridAddress addr = new GridAddress(pt);
if (!addressToStreetSegmentIdListDict.ContainsKey(addr))
{
addressToStreetSegmentIdListDict[addr] = new List <int>();
}
int streetSegmentId = -1;
if (!StreetSegmentIdToStreetSegmentDict.ContainsValue(seg))
{
streetSegmentId = nextStreetSegmentId++;
StreetSegmentIdToStreetSegmentDict[streetSegmentId] = seg;
}
else
{
foreach (int segId in StreetSegmentIdToStreetSegmentDict.Keys)
{
if (seg == StreetSegmentIdToStreetSegmentDict[segId])
{
streetSegmentId = segId;
break;
}
}
}
if (!addressToStreetSegmentIdListDict[addr].Contains(streetSegmentId))
{
addressToStreetSegmentIdListDict[addr].Add(streetSegmentId);
}
}
public Vector2 GetRandomPointOnStreet()
{
int streetIndex = Random.Range(0, Streets.Count);
StreetSegment seg = Streets[streetIndex];
Vector2 randPos = seg.InterpolateEndpoints(Random.Range(0.0f, 1.0f));
return(randPos);
}
public static void SetSpeedlimit(StreetSegment segment, double speedlimit)
{
if (segment.SpeedLimit != speedlimit)
{
RoadInstruction ri = new RoadInstruction(segment.ID, speedlimit, true);
SendRoadInstruction(ri);
}
}
//adapts the speed limit of the chosen road
private static bool AdaptSpeedLimit(int roadId, double limit)
{
StreetSegment road = roads.Find(x => x.ID == roadId);
if (road != null)
{
road.SpeedLimit = limit;
return(true);
}
return(false);
}
//adapts the state of the chosen road
private static bool AdaptRoadState(int roadId, bool state)
{
StreetSegment road = roads.Find(x => x.ID == roadId);
if (road != null)
{
road.IsUsable = state;
return(true);
}
return(false);
}
//the DataLinker calls this method to forward a new road command from SS3
//it returns true if the command is valid
/// <summary>
/// This method gets called by the DataLinker and receives a new RoadCommand from SS3.
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
public static bool ReceiveRoadCommand(RoadInstruction command)
{
if (command != null)
{
StreetSegment road = roads.Find(x => x.ID == command.Id); //check, if there is a road with this id
if (road != null) //road should be valid
{
ExecuteRoadCommand(command);
return(true);
}
}
return(false);
}
bool WithinExistingAngles(int intersectionIndex, float candidateAngleRadians)
{
candidateAngleRadians = Wrap(candidateAngleRadians, 2 * Mathf.PI);
//Debug.Log("Trying angle " + candidateAngleRadians);
Vector2 myPos = intersections[intersectionIndex];
float minStreetAngleRadians = MIN_INTERSECTION_ANGLE_DEGREES * Mathf.PI / 180.0f;
if (!intersectionToSegmentDict.ContainsKey(intersectionIndex))
{
//Debug.Log("no segments for this intersection, no overlap");
return(false);
}
foreach (int segIndex in intersectionToSegmentDict[intersectionIndex])
{
int otherIntersectionIndex = -1;
StreetSegment seg = Streets[segIndex];
if (seg.EndpointIndices[0] == intersectionIndex)
{
otherIntersectionIndex = seg.EndpointIndices[1];
}
else
{
otherIntersectionIndex = seg.EndpointIndices[0];
}
Vector2 otherPos = intersections[otherIntersectionIndex];
Vector2 deltaPos = otherPos - myPos;
float angleToOther = Mathf.Atan2(deltaPos.y, deltaPos.x);
//Debug.Log("existing angle:" + angleToOther);
float deltaAngle = Wrap(angleToOther - candidateAngleRadians, 2 * Mathf.PI);
if (deltaAngle > Mathf.PI)
{
deltaAngle -= 2 * Mathf.PI;
}
//Debug.Log("delta angle:" + deltaAngle);
//Debug.Log("delta angle degrees: " + deltaAngle * 180 / Mathf.PI);
if (Mathf.Abs(deltaAngle) < minStreetAngleRadians)
{
//Debug.Log("deltaAngle too close, reporting overlap");
return(true);
}
}
//Debug.Log("no overlap");
return(false);
}
public void TestGetConnectingStreetSegmentWithStreetHub()
{
List <StreetConnector> sc1 = new List <StreetConnector>();
StreetConnector c1 = new StreetConnector(0, 0);
StreetConnector c2 = new StreetConnector(0, 50);
StreetConnector c3 = new StreetConnector(0, 120);
StreetConnector ch1 = new StreetConnector(0, 200);
StreetConnector ch2 = new StreetConnector(0, 210);
StreetConnector ch3 = new StreetConnector(5, 205);
StreetConnector c4 = new StreetConnector(0, 300);
StreetConnector c5 = new StreetConnector(50, 205);
sc1.Add(c1);
sc1.Add(c2);
sc1.Add(c3);
sc1.Add(ch1);
sc1.Add(ch2);
sc1.Add(ch3);
sc1.Add(c4);
sc1.Add(c5);
List <StreetConnector> h = new List <StreetConnector>();
h.Add(ch1);
h.Add(ch2);
h.Add(ch3);
List <StreetSegment> ss1 = new List <StreetSegment>();
StreetSegment s1 = new StreetSegment(c1, c2);
StreetSegment s2 = new StreetSegment(c2, c3);
StreetSegment s3 = new StreetSegment(c3, ch1);
StreetSegment s4 = new StreetSegment(ch2, c4);
StreetSegment s5 = new StreetSegment(ch3, c5);
ss1.Add(s1);
ss1.Add(s2);
ss1.Add(s3);
ss1.Add(s4);
ss1.Add(s5);
List <StreetSegment> sTest1 = ControlSystem.GetConnectingStreetSegments(sc1);
Assert.AreEqual(5, sTest1.Count());
Assert.AreEqual(true, sTest1.Contains(s1));
Assert.AreEqual(true, sTest1.Contains(s2));
Assert.AreEqual(true, sTest1.Contains(s3));
Assert.AreEqual(true, sTest1.Contains(s4));
Assert.AreEqual(true, sTest1.Contains(s5));
}
public List <StreetSegment> CreateStreetSegments(List <Way> OsmStreets, Dictionary <long?, OsmGeo> allNodes)
{
var boundLines = this.geometryService.CreateBoundingLines();
List <StreetSegment> streetSegments = new List <StreetSegment>();
foreach (var osmStreet in OsmStreets)
{
var points = new List <XYZ>();
foreach (var nodeId in osmStreet.Nodes)
{
var geometry = allNodes[nodeId];
if (geometry is Node node)
{
var coords = coordService.GetRevitCoords((double)node.Latitude, (double)node.Longitude);
points.Add(coords);
}
}
for (int i = 0; i < points.Count - 1; i++)
{
var start = points[i];
var end = points[i + 1];
if (!geometryService.IsInsideBounds(boundLines, start) &&
!geometryService.IsInsideBounds(boundLines, end))
{
continue;
}
var line = Line.CreateBound(points[i], points[i + 1]);
var segment = new StreetSegment();
segment.Id = (long)osmStreet.Id;
segment.SegmentId = osmStore.MoveNextId();
segment.Line = line;
segment.Width = osmStore.DefaultStreetWidth;
if (osmStreet.Tags.TryGetValue("name", out string name))
{
segment.Name = name;
}
streetSegments.Add(segment);
}
}
return(streetSegments);
}
public async void ShouldCreateGroup()
{
var now = DateTime.Now;
//Given
var segments = new StreetSegment[] {
Segments[0],
Segments[1]
};
//When
var group = await Repository.CreateGroup(segments);
//Then
Assert.NotNull(group);
Assert.Equal(1, group.Key);
Assert.Equal(2, group.Bridges.Count);
}
protected void FreeSpace(StreetType last)
{
if (last is StreetSegment)
{
StreetSegment segment = (StreetSegment)last;
int direction = segment.EP1.Connector == currentConnector ? 2 : 1;
segment.FreeSpace(direction, size);
}
else if (last is StreetHub)
{
StreetHub hub = (StreetHub)last;
hub.FreeSpace(size);
}
else
{
throw new StreetMapException("Unknown StreetType");
}
}
bool AreIntersectionsJoined(int i0, int i1)
{
if (!intersectionToSegmentDict.ContainsKey(i0))
{
return(false);
}
foreach (int segIndex in intersectionToSegmentDict[i0])
{
StreetSegment seg = Streets[segIndex];
if (((seg.EndpointIndices[0] == i0) &&
(seg.EndpointIndices[1] == i1)) ||
((seg.EndpointIndices[0] == i1) &&
(seg.EndpointIndices[1] == i0)))
{
return(true);
}
}
return(false);
}
public List <StreetSegment> CreateStreetSegments(List <Way> OsmStreets, Dictionary <long?, OsmGeo> allNodes)
{
var boundLines = this.geometryService.CreateBoundingLines();
List <StreetSegment> streetSegments = new List <StreetSegment>();
foreach (var osmStreet in OsmStreets)
{
var points = this.geometryService.GetPointsFromNodes(osmStreet.Nodes, allNodes);
if (points == null)
{
continue;
}
for (int i = 0; i < points.Count - 1; i++)
{
var start = points[i];
var end = points[i + 1];
if (!geometryService.IsInsideBounds(boundLines, start) &&
!geometryService.IsInsideBounds(boundLines, end))
{
continue;
}
var line = Line.CreateBound(points[i], points[i + 1]);
var segment = new StreetSegment();
segment.Id = (long)osmStreet.Id;
segment.SegmentId = osmStore.MoveNextId();
segment.Line = line;
segment.Width = osmStore.DefaultStreetWidth;
if (osmStreet.Tags.TryGetValue("name", out string name))
{
segment.Name = name;
}
streetSegments.Add(segment);
}
}
return(streetSegments);
}
void JoinIntersections(int index1, int index2, int[] branchesPerIntersection)
{
StreetSegment seg = new StreetSegment(intersections[index1], intersections[index2], Random.Range(MIN_STREET_WIDTH, MAX_STREET_WIDTH));
seg.SetEndpointIndices(index1, index2);
Streets.Add(seg);
branchesPerIntersection[index1]++;
branchesPerIntersection[index2]++;
int streetIndex = Streets.Count - 1;
if (!intersectionToSegmentDict.ContainsKey(index1))
{
intersectionToSegmentDict[index1] = new List <int>();
}
if (!intersectionToSegmentDict.ContainsKey(index2))
{
intersectionToSegmentDict[index2] = new List <int>();
}
intersectionToSegmentDict[index1].Add(streetIndex);
intersectionToSegmentDict[index2].Add(streetIndex);
}
public void TestShortestPath()
{
List <StreetConnector> sc = new List <StreetConnector>();
StreetConnector c1 = new StreetConnector(0, 0);
StreetConnector c2 = new StreetConnector(0, 50);
StreetConnector c3 = new StreetConnector(0, 120);
StreetConnector c4 = new StreetConnector(20, 0);
StreetConnector c5 = new StreetConnector(20, 40);
StreetConnector c6 = new StreetConnector(20, 100);
sc.Add(c1);
sc.Add(c2);
sc.Add(c3);
sc.Add(c4);
sc.Add(c5);
sc.Add(c6);
List <StreetSegment> ss = new List <StreetSegment>();
StreetSegment s1 = new StreetSegment(c1, c2);
StreetSegment s2 = new StreetSegment(c2, c3);
StreetSegment s3 = new StreetSegment(c1, c4);
StreetSegment s4 = new StreetSegment(c4, c5);
StreetSegment s5 = new StreetSegment(c5, c6);
StreetSegment s6 = new StreetSegment(c6, c3);
ss.Add(s1);
ss.Add(s2);
ss.Add(s3);
ss.Add(s4);
ss.Add(s5);
ss.Add(s6);
BaseRoute b = new ShortestBaseRoute(c1, c6);
Assert.AreEqual(2, b.Waypoints.Count);
Assert.AreEqual(true, b.Waypoints[0] == c4);
Assert.AreEqual(true, b.Waypoints[1] == c5);
}
public void TestGetConnectingStreetSegments()
{
List <StreetConnector> sc1 = new List <StreetConnector>();
StreetConnector c1 = new StreetConnector(0, 0);
StreetConnector c2 = new StreetConnector(0, 50);
StreetConnector c3 = new StreetConnector(0, 120);
sc1.Add(c1);
sc1.Add(c2);
sc1.Add(c3);
List <StreetSegment> ss1 = new List <StreetSegment>();
StreetSegment s1 = new StreetSegment(c1, c2);
StreetSegment s2 = new StreetSegment(c2, c3);
ss1.Add(s1);
ss1.Add(s2);
List <StreetSegment> sTest1 = ControlSystem.GetConnectingStreetSegments(sc1);
Assert.AreEqual(2, sTest1.Count());
Assert.AreEqual(true, sTest1.Contains(s1));
Assert.AreEqual(true, sTest1.Contains(s2));
}
/// <summary>
/// Adds a new StreetSegment to the list of roads.
/// </summary>
/// <param name="road">The StreetSegment which needs to be added.</param>
public static void AddRoadSegment(StreetSegment road)
{
roads.Add(road);
}
public void AddStreet(StreetSegment seg)
{
AddStreetRange(seg, 0.0f, 1.0f);
}
/// <summary>
/// Removes a StreetSegment from the list roads. Returns true in case of a success.
/// </summary>
/// <param name="road">The StreetSegment which needs to be removed.</param>
/// <returns></returns>
public static bool RemoveRoadSegment(StreetSegment road)
{
return(roads.Remove(road));
}
protected bool AdvanceRoute()
{
StreetType typeCur, typeLast;
TimeSpan requiredTime;
if (currentConnector.EP1.FindNeighbours().Contains(nextConnector))
{
typeCur = currentConnector.EP1.Self;
typeLast = currentConnector.EP2.Self;
}
else
{
typeCur = currentConnector.EP2.Self;
typeLast = currentConnector.EP1.Self;
}
if (typeCur is StreetSegment)
{
StreetSegment segment = (StreetSegment)typeCur;
if (!claimedSpace)
{
int direction = segment.EP1.Connector == currentConnector ? 1 : 2;
if (!segment.ClaimSpace(direction, size))
{
timeBonus = TimeSpan.Zero;
return(false);
}
if (isFirstClaim)
{
isFirstClaim = false;
}
else
{
FreeSpace(typeLast);
}
claimedSpace = true;
}
requiredTime = maxSpeed < segment.SpeedLimit ? TimeSpan.FromSeconds(segment.Length / maxSpeed) : segment.MinDriveTime;
if (requiredTime.CompareTo(timeBonus) > 0)
{
return(false);
}
timeBonus = timeBonus.Subtract(requiredTime);
lastConnector = currentConnector;
currentConnector = nextConnector;
nextConnector = null;
claimedSpace = false;
ReportManager.PrintDebug(this + " advanced to " + currentConnector + " over " + segment + ".");
return(true);
}
else if (typeCur is StreetHub)
{
StreetHub hub = (StreetHub)typeCur;
bool isGreen;
hub.IsGreenList.TryGetValue(currentConnector.ID, out isGreen);
if (!isGreen)
{
timeBonus = TimeSpan.Zero;
return(false);
}
if (!claimedSpace)
{
if (!hub.ClaimSpace(size))
{
timeBonus = TimeSpan.Zero;
return(false);
}
if (isFirstClaim)
{
isFirstClaim = false;
}
else
{
FreeSpace(typeLast);
}
claimedSpace = true;
}
double speed = maxSpeed < hub.SpeedLimit ? maxSpeed : hub.SpeedLimit;
requiredTime = TimeSpan.FromSeconds(Coordinate.GetDistance(currentConnector.Coordinate, nextConnector.Coordinate) / speed);
if (requiredTime.CompareTo(timeBonus) > 0)
{
return(false);
}
timeBonus = timeBonus.Subtract(requiredTime);
lastConnector = currentConnector;
currentConnector = nextConnector;
nextConnector = null;
claimedSpace = false;
ReportManager.PrintDebug(this + " advanced to " + currentConnector + " over " + hub + ".");
return(true);
}
else
{
throw new StreetMapException("Unknown StreetType");
}
}
