private static float[,] generateGraphMatrix(RoadNetwork roadNetwork)
{
float[,] result = new float[roadNetwork.crossroads.Count, roadNetwork.crossroads.Count];
for (int i = 0; i < roadNetwork.crossroads.Count; i++)
{
for (int j = 0; j < roadNetwork.crossroads.Count; j++)
{
result[i, j] = float.MaxValue;
}
}
for (int i = 0; i < roadNetwork.crossroads.Count; i++)
{
Crossroad cr = roadNetwork.crossroads[i];
foreach (RoadSegment segment in cr.adjacentSegemnts)
{
Crossroad otherCrossroad = segment.getEnd() == cr?segment.getStart() : segment.getEnd();
int j = roadNetwork.crossroads.IndexOf(otherCrossroad);
result[i, j] = segment.getLength();
result[j, i] = segment.getLength();
}
result[i, i] = 0;
}
return(result);
}
public static IFeatureSet RoadNetworkToShapefile(RoadNetwork rn, string writefilename)
{
FeatureSet fs = new FeatureSet(FeatureType.Line);
string filename = Path.GetFileNameWithoutExtension(writefilename);
fs.Name = filename;
fs.DataTable.Columns.Add("RoadID", typeof(long));
fs.DataTable.Columns.Add("RoadName", typeof(string));
fs.DataTable.Columns.Add("RoadFunction", typeof(byte));
fs.DataTable.Columns.Add("RoadLength", typeof(double));
fs.DataTable.Columns.Add("RoadAttribute", typeof(string));
for (int i = 0; i < rn.RoadCount; i++)
{
Road r = rn.GetRoadByIndex(i);
var fe = fs.AddFeature(r);
fe.DataRow.BeginEdit();
fe.DataRow["RoadID"] = r.RoadID;
fe.DataRow["RoadName"] = r.RoadName;
fe.DataRow["RoadFunction"] = r.RoadFunction;
fe.DataRow["RoadLength"] = r.RoadLength;
string attr = string.Empty;
for (int j = 0; j < r.RoadAttribute.Count; j++)
{
attr += r.RoadAttribute[j].RoadFunction.ToString() + r.RoadAttribute[j].RoadAtrribute.ToString();
if (j != r.RoadAttribute.Count - 1)
{
attr += "|";
}
}
fe.DataRow["RoadAttribute"] = attr;
fe.DataRow.EndEdit();
}
fs.SaveAs(writefilename, true);
return(fs);
}
public static RoadSegment getRelatedRoadSegment(RoadNetwork roadNetwork, float x1, float y1, float x2, float y2)
{
if (x1 > x2)
{
float tmp = x2;
x2 = x1;
x1 = tmp;
}
if (y1 > y2)
{
float tmp = y2;
y2 = y1;
y1 = tmp;
}
foreach (RoadSegment segment in roadNetwork.roadSegments)
{
if (segment.getStart().x == segment.getEnd().x&& x1 == x2 && x1 == segment.getStart().x) // Road segment and tested segment are horizontal
{
if (segment.getStart().y <= y1 && segment.getEnd().y >= y2 ||
segment.getStart().y >= y1 && segment.getEnd().y <= y2)
{
return(segment);
}
}
else if (segment.getStart().y == segment.getEnd().y&& y1 == y2 && y1 == segment.getStart().y) // Road segment and tested segment are vertical
{
if (segment.getStart().x <= x1 && segment.getEnd().x >= x2 ||
segment.getStart().x >= x1 && segment.getEnd().x <= x2)
{
return(segment);
}
}
}
return(null);
}
public override void OnInspectorGUI()
{
RoadNetwork roadNetwork = (RoadNetwork)target;
if (GUILayout.Button("Build Random Road Network"))
{
roadNetwork.BuildRandom();
}
jsonOutputPath = GUILayout.TextField(jsonOutputPath, 100);
if (GUILayout.Button("Save to json file"))
{
string jsonOutput = roadNetwork.ToJson(true);
File.WriteAllText(jsonOutputPath, jsonOutput);
}
if (GUILayout.Button("Load from json file"))
{
roadNetwork.FromJsonOverwrite(roadNetwork.inputJsonFile.text);
}
if (GUILayout.Button("Build Road Mesh"))
{
ProBuilderMesh roadMesh = Mesher.MeshRoadNetwork(roadNetwork);
roadMesh.GetComponent <MeshRenderer>().sharedMaterial = roadNetwork.roadMaterial;
roadMesh.transform.position = roadNetwork.transform.position;
roadMesh.transform.rotation = roadNetwork.transform.rotation;
}
DrawDefaultInspector();
}
private void OnEnable()
{
network = (RoadNetwork)target;
// If this is the first time selecting a road, the global settings will not have been set yet so call ResetGlobals
if (!areGlobalsSet)
{
ResetGlobals();
}
if (network.roads == null || network.roads.Count == 0)
{
network.InitialiseRoadNetwork(defaultMaterial);
}
selectedRoad = network.ActiveRoad;
// Disables the default transform/rotation/other handle when first selecting the road network
previousTool = Tools.current;
Tools.current = Tool.None;
// Ensures the mesh is regenerated when the developer undos or redos
Undo.undoRedoPerformed += GenerateMesh;
network.OnRoadSelected += SelectRoad;
}
public HashSet <RoadSegment> getRelatedRoadSegments(RoadNetwork roadNetwork)
{
if (relatedRoadSegments == null)
{
relatedRoadSegments = new HashSet <RoadSegment>();
foreach (DistrictCell cell in this.cells)
{
if (cell.edgeBottom)
{
relatedRoadSegments.Add(RoadHelper.getRelatedRoadSegment(roadNetwork, cell.x, cell.y + 1, cell.x + 1, cell.y + 1));
}
if (cell.edgeLeft)
{
relatedRoadSegments.Add(RoadHelper.getRelatedRoadSegment(roadNetwork, cell.x, cell.y, cell.x, cell.y + 1));
}
if (cell.edgeUp)
{
relatedRoadSegments.Add(RoadHelper.getRelatedRoadSegment(roadNetwork, cell.x, cell.y, cell.x + 1, cell.y));
}
if (cell.edgeRight)
{
relatedRoadSegments.Add(RoadHelper.getRelatedRoadSegment(roadNetwork, cell.x + 1, cell.y, cell.x + 1, cell.y + 1));
}
}
}
return(relatedRoadSegments);
}
protected static District detectDistrict(RoadNetwork roadNetwork, float dimension, int startX, int startY, bool[,] visited)
{
District result = new District();
Queue <Vector2> bfsQueue = new Queue <Vector2>();
bfsQueue.Enqueue(new Vector2(startX, startY));
while (bfsQueue.Count > 0)
{
Vector2 position = bfsQueue.Dequeue();
int px = (int)position.x, py = (int)position.y;
if (px < 0 || px >= dimension || py < 0 || py >= dimension || visited[px, py])
{
continue;
}
result.cells.Add(new DistrictCell(position));
visited[px, py] = true;
if (RoadHelper.hasRoadAt(roadNetwork, position.x, position.y, position.x, position.y + 1)) // Left
{
result.cells[result.cells.Count - 1].edgeLeft = true; // Update attribute for last added element
}
if (RoadHelper.hasRoadAt(roadNetwork, position.x, position.y, position.x + 1, position.y)) // Up
{
result.cells[result.cells.Count - 1].edgeUp = true; // Update attribute for last added element
}
if (RoadHelper.hasRoadAt(roadNetwork, position.x + 1, position.y, position.x + 1, position.y + 1)) // Right
{
result.cells[result.cells.Count - 1].edgeRight = true; // Update attribute for last added element
}
if (RoadHelper.hasRoadAt(roadNetwork, position.x, position.y + 1, position.x + 1, position.y + 1)) // Down
{
result.cells[result.cells.Count - 1].edgeBottom = true; // Update attribute for last added
}
if (px > 0 && !visited[px - 1, py] &&
!RoadHelper.hasRoadAt(roadNetwork, position.x, position.y, position.x, position.y + 1)) // Left
{
bfsQueue.Enqueue(new Vector2(position.x - 1, position.y));
}
if (py > 0 && !visited[px, py - 1] &&
!RoadHelper.hasRoadAt(roadNetwork, position.x, position.y, position.x + 1, position.y)) // Up
{
bfsQueue.Enqueue(new Vector2(position.x, position.y - 1));
}
if ((px + 1) < dimension && !visited[px + 1, py] &&
!RoadHelper.hasRoadAt(roadNetwork, position.x + 1, position.y, position.x + 1, position.y + 1)) // Right
{
bfsQueue.Enqueue(new Vector2(position.x + 1, position.y));
}
if ((py + 1) < dimension && !visited[px, py + 1] &&
!RoadHelper.hasRoadAt(roadNetwork, position.x, position.y + 1, position.x + 1, position.y + 1)) // Down
{
bfsQueue.Enqueue(new Vector2(position.x, position.y + 1));
}
}
return(result);
}
public override void agentAction()
{
RoadNetwork network = generator.roadNetwork;
Crossroad cr0 = network.crossroads[Random.Range(0, network.crossroads.Count)];
Crossroad cr1 = network.crossroads[Random.Range(0, network.crossroads.Count)];
bool cr0_founded = false, cr1_founded = false;
for (int i = 0; i < network.crossroads.Count; i++)
{
if (cr0.adjacentSegemnts.Count < 3)
{
cr0_founded = true;
break;
}
cr0 = network.crossroads[Random.Range(0, network.crossroads.Count)];
}
for (int i = 0; i < network.crossroads.Count; i++)
{ // Not guarantee checking all possible crossrods
if (cr1.adjacentSegemnts.Count < 3 && cr1 != cr0 && !hasIntersections(network, cr0, cr1))
{
cr1_founded = true;
break;
}
cr1 = network.crossroads[Random.Range(0, network.crossroads.Count)];
}
if (!cr0_founded || !cr1_founded)
{
return;
}
RoadSegment segment = new RoadSegment(cr0, cr1);
network.roadSegments.Add(segment);
Debug.Log("Roads connected");
}
//初始化道路智能体，获取每个道路智能体的车辆数以及ID、起点、终点、道路等级的信息
public void InitializeRoadAgent()
{
//设置道路智能体属性
IFeatureLayer pFeatureLayer = CDataImport.ImportFeatureLayerFromControltext(@"C:\Users\Administrator\Desktop\突发环境事件应急资源调度系统\data\road.shp");
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IFeatureCursor pFeatureCursor = pFeatureClass.Search(null, false);
IFeature pFeature = pFeatureCursor.NextFeature();
while (pFeature != null)
{
RoadNetwork pRoadNetwork = new RoadNetwork();
pRoadNetwork.ID = Convert.ToInt32(pFeature.get_Value(pFeature.Fields.FindField("OBJECTID")));
pRoadNetwork.StartNodeID = Convert.ToString(pFeature.get_Value(pFeature.Fields.FindField("StartNodeI")));
pRoadNetwork.EndNodeID = Convert.ToString(pFeature.get_Value(pFeature.Fields.FindField("EndNodeID")));
pRoadNetwork.Rank = Convert.ToString(pFeature.get_Value(pFeature.Fields.FindField("Rank")));
pRoadNetwork.Length = Convert.ToDouble((pFeature.Shape as IPolyline).Length);
pRoadAgent.Add(pRoadNetwork);
pFeature = pFeatureCursor.NextFeature();
}
//初始化道路智能体行驶的车辆数
for (int i = 0; i < pOrdinaryVehicleAgent.Count; i++)
{
pRoadAgent[pOrdinaryVehicleAgent[i].Origination].VehicleNumber++;
}
}
internal RoadCollection(RoadTopology topology, AssetLoadContext loadContext, HeightMap heightMap)
: this()
{
// The map stores road segments with no connectivity:
// - a segment is from point A to point B
// - with a road type name
// - and start and end curve types (angled, tight curve, broad curve).
// The goal is to create road networks of connected road segments,
// where a network has only a single road type.
// A road network is composed of 2 or more nodes.
// A network is a (potentially) cyclic graph.
// A road node has > 1 and <= 4 edges connected to it.
// A node can be part of multiple networks.
// An edge can only exist in one network.
// TODO: If a node stored in the map has > 4 edges, the extra edges
// are put into a separate network.
var networks = RoadNetwork.BuildNetworks(topology);
foreach (var network in networks)
{
_roads.Add(AddDisposable(new Road(
loadContext,
heightMap,
network)));
}
}
public TripsLoader(RoadNetwork rn)
{
TripFolders = Directory.GetDirectories(Parameters.TripsFolder);
TripFiles = new List <string>();
AllTripNodes = new ConcurrentStack <List <Node> >();
RN = rn;
}
private void Awake()
{
instance = this;
roadNetwork = new RoadNetwork(100f, this); //Create a New road Network
ClearRoads();
}
public static float getDistance(RoadNetwork roadNetwork, RoadSegment rs0, RoadSegment rs1)
{
if (rs0 == rs1)
{
return(rs0.getLength() / 2.0f);
}
float result = float.MaxValue;
float distance = getDistance(roadNetwork, rs0.getStart(), rs1.getStart());
if (distance < result)
{
result = distance;
}
distance = getDistance(roadNetwork, rs0.getStart(), rs1.getEnd());
if (distance < result)
{
result = distance;
}
distance = getDistance(roadNetwork, rs0.getEnd(), rs1.getStart());
if (distance < result)
{
result = distance;
}
distance = getDistance(roadNetwork, rs0.getEnd(), rs1.getEnd());
if (distance < result)
{
result = distance;
}
return(result + (rs0.getLength() / 2.0f) + (rs1.getLength() / 2.0f));
}
public float getDistanceTo(District another, RoadNetwork roadNetwork)
{
if (!distancesCache.ContainsKey(another))
{
float result = float.MaxValue;
HashSet <RoadSegment> roadSegments = this.getRelatedRoadSegments(roadNetwork);
HashSet <RoadSegment> anotherRoadSegments = another.getRelatedRoadSegments(roadNetwork);
foreach (RoadSegment segment in roadSegments)
{
if (segment == null)
{
continue;
}
foreach (RoadSegment anotherSegment in anotherRoadSegments)
{
if (anotherSegment == null)
{
continue;
}
float distance = RoadHelper.getDistance(roadNetwork, segment, anotherSegment);
if (distance < result)
{
result = distance;
}
}
}
distancesCache[another] = result;
}
return(distancesCache[another]);
}
//public enum PlacementMode
//{
// RoadStart,
// RoadEnd,
// BuildingPlop
//}
void Start()
{
mouseCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
mouseCube.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
placementPreview = false;
roadNetwork = GameObject.Find("RoadNetwork").GetComponent<RoadNetwork>();
}
internal PathSolver(int width, int height, List <Region> regions, List <TerrainType> terrainTypes)
{
nodes = new NodeList(width, height);
areas = getPathAreas(regions, ref nodes, terrainTypes);
ValidateNodes(nodes);
roadNetwork = new RoadNetwork();
}
//public enum PlacementMode
//{
// RoadStart,
// RoadEnd,
// BuildingPlop
//}
void Start()
{
mouseCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
mouseCube.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
placementPreview = false;
roadNetwork = GameObject.Find("RoadNetwork").GetComponent <RoadNetwork>();
}
public static ProBuilderMesh MeshRoadNetwork(RoadNetwork roadNet)
{
var(vertices, faces) = CalcVerticesAndFaces(roadNet);
ProBuilderMesh roadMesh = ProBuilderMesh.Create(vertices, faces);
roadMesh.GetComponent <Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
return(roadMesh);
}
public void Clear()
{
roadNetwork = new RoadNetwork(100f, this); //Clears any list that has been made
ClearBuildings();
ClearRoads();
manualPoints.Clear();
roads.Clear();
intersections.Clear();
}
void ConstructRoadAndData()
{
myRoadNetwork = RoadNetworkReader.ReadRoadDataFromFile(@"Data\link_hefei.txt", @"Data\connectivity_hefei.txt", @"Data\ref_points_hefei.txt");
myRoadNetwork.BuildRoadRtree();
toolStripProgressBar1.ProgressBar.Invoke(new Action(() => { toolStripStatusLabel1.Text = "路网以及R树构建完成"; }));
AddGPSFile(@"Data/newTrajectoriespart.txt");
toolStripProgressBar1.ProgressBar.Invoke(new Action(() => { toolStripStatusLabel1.Text = "GPS轨迹装载完成"; webBrowser1.Document.InvokeScript("LoadingDone"); }));
//通知浏览器数据加载完成
}
public static void ConstructGraph(string roadFilename, string roadNetworkFilename, string poiFilename, string meterologyDirectory, string mobilityDirectory, string aqiDirectory, string outputGraphFilename, int numDays, int knn, int timeSlot, double s)
{
RoadNetwork roadNetwork = IO.ReadRoadNetwork(roadFilename);
Grid grid = new Grid(roadNetwork.MinPoint, roadNetwork.MaxPoint, 0.015);
CoupledDL.GraphInput graphInput = new CoupledDL.GraphInput(timeSlot, numDays, 4, roadNetworkFilename, poiFilename, meterologyDirectory, mobilityDirectory, aqiDirectory, grid);
CoupledDL.Graph.HyperGraph graph = graphInput.ReadGraphFromFiles(1);
double[] sigma = new double[] { 10, 2, 4, 4 };
graphInput.BuildEdgesOfGraph(graph, knn, 9, sigma, 0, outputGraphFilename);
}
private static (List <Vector3>, List <Face>) CalcVerticesAndFaces(RoadNetwork roadNet)
{
var vertices = new List <Vector3>();
var faces = new List <Face>();
RoadSegmentMeshInfo[] segmentMeshInfos = new RoadSegmentMeshInfo[roadNet.SegmentCount];
for (int i = 0; i < roadNet.VertCount; ++i)
{
// Construct incoming road edge descriptors
RoadVertexView roadVert = roadNet.GetVertex(i);
List <int> connSegIndices = roadVert.Data.ConnectedSegmentIndices; // Assumed connected segments in clockwise order
var incRoadEdges = new RoadSegmentEdges[connSegIndices.Count];
var roadMeshEndInfos = new RoadSegmentMeshEndInfo[connSegIndices.Count];
for (int j = 0; j < connSegIndices.Count; ++j)
{
// Extract road segment mesh end info to fill out
// This is used to assign the vertices we create in this loop to the correct road segment, at the correct end.
int curSegmentIndex = connSegIndices[j];
ref RoadSegmentMeshInfo curSegmentMeshInfo = ref segmentMeshInfos[curSegmentIndex];
if (curSegmentMeshInfo == null)
{
curSegmentMeshInfo = new RoadSegmentMeshInfo();
}
RoadSegmentView curSegment = roadNet.GetSegment(curSegmentIndex);
ref RoadSegmentMeshEndInfo curSegMeshEndInfo = ref ((curSegment.StartVertex.Index != i) ? ref curSegmentMeshInfo.startVertIndices : ref curSegmentMeshInfo.endVertIndices);
curSegMeshEndInfo = new RoadSegmentMeshEndInfo();
roadMeshEndInfos[j] = curSegMeshEndInfo;
// Get adjacent vertex on this road segment
int adjVertIdx = curSegment.StartVertex.Index != i ? curSegment.StartVertex.Index : curSegment.EndVertex.Index;
RoadVertexView adjRoadVert = roadNet.GetVertex(adjVertIdx);
// Construct the incoming left and right road edge descriptors
Vector2 incDir = (roadVert.Position - adjRoadVert.Position).normalized;
Vector2 rot90Dir = new Vector2(-incDir.y, incDir.x); // Rotated 90 degrees counter clockwise
Vector2 leftOffset = rot90Dir * curSegment.HalfWidth;
Vector2 rightOffset = -rot90Dir * curSegment.HalfWidth;
RoadSegmentEdges roadSegmentEdges = new RoadSegmentEdges()
{
left = new Line()
{
start = adjRoadVert.Position + leftOffset,
end = roadVert.Position + leftOffset
},
right = new Line()
{
start = adjRoadVert.Position + rightOffset,
end = roadVert.Position + rightOffset
}
};
// Add incoming edges to array
incRoadEdges[j] = roadSegmentEdges;
}
protected bool hasIntersections(RoadNetwork network, Crossroad cr0, Crossroad cr1)
{
for (int i = 0; i < network.roadSegments.Count; i++)
{
if (RoadHelper.areRoadsIntersects(new RoadSegment(cr0, cr1), network.roadSegments[i]))
{
return(true);
}
}
return(false);
}
static void Main(string[] args)
{
ShapeFileFeatureSource sourceData = new ShapeFileFeatureSource(@"..\..\Data\Roads.shp");
StreamSource source = new StreamSource();
Stopwatch watch = Stopwatch.StartNew();
RoadNetwork netWork = source.CreateNetwork(sourceData);
watch.Stop();
Console.WriteLine(String.Format("The total cost:{0} Minutes, Nodes' count is {1}", watch.ElapsedMilliseconds / 1000 / 60, netWork.Nodes.Count));
Console.Read();
}
/// <summary>
/// Tries to get cycles, starting from the given vertex.
/// </summary>
/// <param name="roadNetwork">The road network to search in.</param>
/// <param name="startVertex">The vertex to start searching from.</param>
/// <param name="cycles">The found cycles in the road network.</param>
/// <returns>true if any were found, false if not.</returns>
private static bool TryGetCycles(
RoadNetwork roadNetwork,
Vector3 startVertex,
out IReadOnlyCollection <IReadOnlyCollection <Vector3> > cycles)
{
cycles = GetCycles(
roadNetwork,
startVertex,
startVertex,
new HashSet <(Vector3 Start, Vector3 End)>());
return(cycles.Any());
}
private void Populate1()
{
RoadNetwork network = new RoadNetwork();
Vertex start = network.AddVertex(100, 10);
Vertex a = network.AddVertex(50, 10);
Vertex b = network.AddVertex(150, 10);
Vertex c = network.AddVertex(50, 75);
Vertex d = network.AddVertex(100, 75);
Vertex e = network.AddVertex(150, 75);
Vertex f = network.AddVertex(50, 150);
Vertex g = network.AddVertex(100, 150);
Vertex h = network.AddVertex(150, 150);
Vertex i = network.AddVertex(50, 210);
Vertex j = network.AddVertex(150, 210);
Vertex end = network.AddVertex(100, 210);
network.AddEdge(start, a);
network.AddEdge(start, b);
network.AddEdge(a, c);
network.AddEdge(b, e);
network.AddEdge(c, d);
network.AddEdge(e, d);
network.AddEdge(c, f);
network.AddEdge(d, g);
network.AddEdge(e, h);
network.AddEdge(f, g);
network.AddEdge(h, g);
network.AddEdge(f, i);
network.AddEdge(h, j);
network.AddEdge(i, end);
network.AddEdge(j, end);
parent1.Network = network;
ConjugationOperator op = new ConjugationOperator();
RoadNetwork cut = new RoadNetwork(network);
op.Cut(cut);
cut1.Network = cut;
}
public void ReDraw()
{
roadNetwork = new RoadNetwork(100f, this);
ClearBuildings();
ClearRoads();
roads.Clear();
intersections.Clear();
TryDraw();
Subdivide();
}
public float getDistanceTo(District another, RoadNetwork roadNetwork)
{
if (!distancesCache.ContainsKey(another))
{
float result = float.MaxValue;
HashSet <RoadSegment> roadSegments = this.getRelatedRoadSegments(roadNetwork);
HashSet <RoadSegment> anotherRoadSegments = another.getRelatedRoadSegments(roadNetwork);
foreach (RoadSegment segment in roadSegments)
{
if (segment == null)
{
continue;
}
foreach (RoadSegment anotherSegment in anotherRoadSegments)
{
if (anotherSegment == null)
{
continue;
}
float distance = RoadHelper.getDistance(roadNetwork, segment, anotherSegment);
if (distance < result)
{
result = distance;
}
}
}
distancesCache[another] = result;
}
return(distancesCache[another]);
//Vector2 thisPosition = new Vector2();
//foreach (DistrictCell cell in cells)
//{
// thisPosition.x += cell.x;
// thisPosition.y += cell.y;
//}
//thisPosition.x /= cells.Count;
//thisPosition.y /= cells.Count;
//Vector2 anotherPosition = new Vector2();
//foreach (DistrictCell cell in another.cells)
//{
// anotherPosition.x += cell.x;
// anotherPosition.y += cell.y;
//}
//anotherPosition.x /= cells.Count;
//anotherPosition.y /= cells.Count;
//return Vector2.Distance(thisPosition, anotherPosition);
}
// Start is called before the first frame update
void Start()
{
var roadNetwork = new RoadNetwork();
roadNetwork.AddVertex(new RoadVertex(0, 0));
roadNetwork.AddVertex(new RoadVertex(50, 0));
roadNetwork.AddVertex(new RoadVertex(100, 0));
roadNetwork.AddSegment(new RoadSegment(0, 1));
roadNetwork.AddSegment(new RoadSegment(1, 2));
Debug.Log(roadNetwork.ToJson(true));
}
public Experiments()
{
RN = new RoadNetwork();
RN.BuildNetwork();
// try loading trips
TLoader = new TripsLoader(RN);
TLoader.LoadTrips();
Options = new ProgressBarOptions
{
DisplayTimeInRealTime = false
};
}
public override void agentAction()
{
RoadNetwork network = generator.roadNetwork;
Crossroad cr0 = new Crossroad();
do
{
cr0.x = Random.value * generator.meshDimension;
cr0.y = Random.value * generator.meshDimension;
} while (RoadHelper.isUnderWaterline(cr0, generator));
cr0.x = (int)cr0.x;
cr0.y = (int)cr0.y;
network.crossroads.Add(cr0);
}
/// <summary>
/// Gets all cycles in the road network.
/// </summary>
/// <param name="roadNetwork">The road network.</param>
/// <returns>All cycles in the road network.</returns>
private IEnumerable <IReadOnlyCollection <Vector3> > GetAllCycles(RoadNetwork roadNetwork)
{
// Concurrent search for cycles from each vertex
return(TaskUtils.RunActionInTasks(
roadNetwork.RoadVertices,
vertex => TryGetCycles(roadNetwork, vertex, out var vertexCycles)
? vertexCycles
: new List <IReadOnlyCollection <Vector3> >(),
CancelToken)
// Put all found cycles in one collection
?.SelectMany(cycle => cycle)
// Filter out any cycles that do not have any vertices
.Where(c => c.Any()));
}
private void Populate2()
{
RoadNetwork network = new RoadNetwork();
Vertex start = network.AddVertex(100, 10);
Vertex a = network.AddVertex(50, 50);
Vertex b = network.AddVertex(150, 50);
Vertex c = network.AddVertex(25, 75);
Vertex d = network.AddVertex(100, 75);
Vertex e = network.AddVertex(175, 75);
Vertex f = network.AddVertex(100, 150);
Vertex g = network.AddVertex(50, 190);
Vertex h = network.AddVertex(150, 190);
Vertex end = network.AddVertex(100, 210);
network.AddEdge(start, a);
network.AddEdge(start, b);
network.AddEdge(a, c);
network.AddEdge(a, d);
network.AddEdge(b, d);
network.AddEdge(b, e);
network.AddEdge(c, f);
network.AddEdge(e, f);
network.AddEdge(f, g);
network.AddEdge(f, h);
network.AddEdge(g, end);
network.AddEdge(h, end);
parent2.Network = network;
ConjugationOperator op = new ConjugationOperator();
RoadNetwork cut = new RoadNetwork(network);
op.Cut(cut);
cut2.Network = cut;
}
