public static IntersectionData LineIntersectionPoint(Vector2 ps1, Vector2 pe1, Vector2 ps2,
Vector2 pe2)
{
var result = new IntersectionData();
float A1 = pe1.y - ps1.y;
float B1 = ps1.x - pe1.x;
float C1 = A1 * ps1.x + B1 * ps1.y;
float A2 = pe2.y - ps2.y;
float B2 = ps2.x - pe2.x;
float C2 = A2 * ps2.x + B2 * ps2.y;
float delta = A1 * B2 - A2 * B1;
if (delta == 0)
result.parallel = true;
else
{
result.point = new Vector2(
(B2 * C1 - B1 * C2) / delta,
(A1 * C2 - A2 * C1) / delta
);
result.parallel = false;
}
return result;
}
void IntersectionsAToB(IntersectionData intersection)
{
for (int i = 0; i < intersection.target.triangles.Count; i++)
{
intersection.targetTriangle = i;
RaycastIntersection(0, 1, intersection);
RaycastIntersection(0, 2, intersection);
RaycastIntersection(1, 2, intersection);
}
}
public void Execute()
{
for (var i = 0; i < IntersectionEntities.Length; i++)
{
IntersectionDataComponents[IntersectionEntities[i]] = new IntersectionData
{
Point = UniqueIntersectionPoints[i]
};
}
}
public void TheHitShouldOffsetThePointTest()
{
var r = Helper.Ray(Helper.CreatePoint(0, 0, -5), Helper.CreateVector(0, 0, 1));
var shape = Helper.Sphere();
shape.Transform = Helper.Translation(0, 0, 1);
var intersection = new Intersection(5, shape);
var comps = new IntersectionData(intersection, r);
Check.That(comps.OverPoint.Z).Not.IsStrictlyGreaterThan(Helper.Epsilon / 2).And.Not.IsStrictlyGreaterThan(comps.Point.Z);
}
public void TheUnderPointIsOffsetBelowTheSurfaceTest()
{
var r = Helper.Ray(Helper.CreatePoint(0, 0, -5), Helper.CreateVector(0, 0, 1));
var shape = Helper.CreateGlassSphere();
shape.Transform = Helper.Translation(0, 0, 1);
var intersection = new Intersection(5, shape);
var intersections = new Intersections(new[] { intersection });
var comps = new IntersectionData(intersection, r, intersections);
Check.That(comps.UnderPoint.Z).IsStrictlyGreaterThan(Helper.Epsilon / 2).And.IsStrictlyGreaterThan(comps.Point.Z);
}
void Start()
{
if (IntersectionDataManager.intersectionDatas == null)
{
IntersectionDataManager.intersectionDatas = new List <IntersectionData>();
}
if (intersectionData == null)
{
intersectionData = new IntersectionData();
IntersectionDataManager.intersectionDatas.Add(intersectionData);
}
}
public static LaneGroupData GetLaneGroupFromNemaMovementNumber(IntersectionData analysisIntersection, NemaMovementNumbers Movement)
{
foreach (ApproachData Approach in analysisIntersection.Approaches)
{
foreach (LaneGroupData LaneGroup in Approach.LaneGroups)
{
if ((int)LaneGroup.NemaMvmtID == (int)Movement)
{
return(LaneGroup);
}
}
}
return(null);
}
void SetupTargetVerticesType(IntersectionData intersection)
{
// Get which vertices from A are in B.
for (int i = 0; i < intersection.target.vertices.Count; i++)
{
if (IsIn(intersection.cutterCollider, intersection.target.vertices[i].pos))
{
intersection.target.vertices[i].type = Vertex.VertexType.In;
}
else
{
intersection.target.vertices[i].type = Vertex.VertexType.OutOrLocal;
}
}
}
private void LoadVillage(Village village, IntersectionData data)
{
positionedUnit = village;
type = data.type;
owned = true;
switch (positionedUnit.Owner.myColor)
{
case 0: color = Color.red; break;
case 1: color = Color.blue; break;
case 2: color = Color.green; break;
case 3: color = new Color(255, 128, 0); break;
}
metropolis = data.metropolis;
}
/// <summary>
/// Give it the start of the vein and the list to look through and it'll find its own end point
/// </summary>
/// <param name="dataStartIndex"></param>
/// <param name="interdataStart"></param>
/// <param name="intersectionData"></param>
public Vein(int dataStartIndex, IntersectionData interdataStart, List <IntersectionData> intersectionData)
: this(dataStartIndex, interdataStart)
{
int dataCount = intersectionData.Count;
//Find the end of the vein of changes
for (int iData = dataStartIndex; iData < dataStartIndex + dataCount; iData++)
{
IntersectionData interdata = intersectionData[iData % dataCount];
if (interdata.type == IntersectionData.IntersectionType.EXIT)
{
this.dataEndIndex = iData;
this.interdataEnd = interdata;
this.origVeinEnd = VeinEnd;
break;
}
}
}
void GetIntersections()
{
// Update world position vertices.
targetTriangulation.UpdateWorldPosition(target.transform);
cutterTriangulation.UpdateWorldPosition(cutter.transform);
// Intersection data.
IntersectionData targetToCutterIntersection = new IntersectionData(targetTriangulation, cutterTriangulation, cutter);
IntersectionData cutterToTargetIntersection = new IntersectionData(cutterTriangulation, targetTriangulation, target);
// In/out points.
SetupTargetVerticesType(targetToCutterIntersection);
SetupTargetVerticesType(cutterToTargetIntersection);
// Intersections.
IntersectionsAToB(targetToCutterIntersection);
IntersectionsAToB(cutterToTargetIntersection);
}
public void Load(IntersectionData data, IntersectionUnit u)
{
this.harbor = data.harbourKind;
this.isFishingInter = data.isFishing;
this.owned = data.owned;
if (u != null)
{
if (u is Village)
{
var village = (Village)u;
LoadVillage(village, data);
}
else if (u is Knight)
{
var knight = (Knight)u;
LoadKnight(knight);
}
}
}
void RaycastIntersection(int originVertice, int toVertice, IntersectionData intersection)
{
intersection.ray1.origin = intersection.target.vertices[intersection.target.triangles[intersection.targetTriangle].verticesIndexes[originVertice]].pos;
intersection.ray2.origin = intersection.target.vertices[intersection.target.triangles[intersection.targetTriangle].verticesIndexes[toVertice]].pos;
intersection.ray1.direction = (intersection.ray2.origin - intersection.ray1.origin).normalized;
intersection.ray2.direction = (intersection.ray1.origin - intersection.ray2.origin).normalized;
intersection.customDistance = Vector3.Distance(intersection.ray1.origin, intersection.ray2.origin);
if (intersection.target.vertices[intersection.target.triangles[intersection.targetTriangle].verticesIndexes[originVertice]].type == Vertex.VertexType.OutOrLocal)
{
if (intersection.cutterCollider.Raycast(intersection.ray1, out intersection.hit, intersection.customDistance))
{
SetIntersectionPointOnIntersection(intersection);
}
}
if (intersection.target.vertices[intersection.target.triangles[intersection.targetTriangle].verticesIndexes[toVertice]].type == Vertex.VertexType.OutOrLocal)
{
if (intersection.cutterCollider.Raycast(intersection.ray2, out intersection.hit, intersection.customDistance))
{
SetIntersectionPointOnIntersection(intersection);
}
}
}
private Vein(int dataStartIndex, IntersectionData interdataStart)
{
this.dataStartIndex = dataStartIndex;
this.interdataStart = interdataStart;
this.origVeinStart = VeinStart;
}
public Vein(int dataStartIndex, IntersectionData interdataStart, int dataEndIndex, IntersectionData interdataEnd)
{
this.dataStartIndex = dataStartIndex;
this.interdataStart = interdataStart;
this.dataEndIndex = dataEndIndex;
this.interdataEnd = interdataEnd;
this.origVeinStart = VeinStart;
this.origVeinEnd = VeinEnd;
}
public void slice(Vein other)
{
this.interdataEnd = other.interdataEnd;
}
public static ArterialData NewArterial(ServiceVolumeTableFDOT arterialInputs, AnalysisMode ProjectAnalMode, float analysisDirectionDemandVol = 800, int numLanes = 2)
{
arterialInputs.Signal.EffGreen = arterialInputs.Signal.CalcEffectiveGreen(arterialInputs.Signal.EffGreenToCycleLengthRatio, arterialInputs.Signal.CycleLengthSec);
arterialInputs.Signal.EffGreenLeft = arterialInputs.Signal.CalcEffectiveGreen(0.1f, arterialInputs.Signal.CycleLengthSec);
List <SegmentData> Segments = new List <SegmentData>();
IntersectionData newIntersection = CreateIntersection(numLanes, arterialInputs.Signal.CycleLengthSec, arterialInputs.SerVolAreaType, ProjectAnalMode);
newIntersection.Signal.ControlType = arterialInputs.Signal.SigType;
LinkData newLink;
float segmentLength;
for (int intIndex = 0; intIndex < arterialInputs.Roadway.NumIntersections; intIndex++)
{
if (intIndex == 0)
{
segmentLength = 0;
}
else
{
segmentLength = arterialInputs.Roadway.ArterialLenghtFt / (arterialInputs.Roadway.NumIntersections - 1);
}
newLink = new LinkData(segmentLength - newIntersection.CrossStreetWidth, numLanes, arterialInputs.Roadway.PostedSpeedMPH, arterialInputs.Roadway.PropCurbRightSide, arterialInputs.Roadway.Median);
Segments.Add(new SegmentData(intIndex, newLink, newIntersection, arterialInputs.SerVolAreaType, arterialInputs.Roadway.PostedSpeedMPH, newIntersection.CrossStreetWidth));
}
ArterialData newArterial = new ArterialData(arterialInputs, Segments);
ChangeArterialVolume(ref newArterial, analysisDirectionDemandVol);
// Calcs Arterial code
foreach (SegmentData segment in newArterial.Segments)
{
foreach (ApproachData approach in segment.Intersection.Approaches)
{
approach.PctLeftTurns = arterialInputs.Traffic.PctLeftTurns;
approach.PctRightTurns = arterialInputs.Traffic.PctRightTurns;
foreach (LaneGroupData laneGroup in approach.LaneGroups)
{
if (laneGroup.Type == LaneMovementsAllowed.LeftOnly)
{
laneGroup.SignalPhase.GreenEffectiveSec = arterialInputs.Signal.EffGreenLeft;
laneGroup.TurnBayLeftLengthFeet = arterialInputs.Roadway.TurnBayLeftLengthFeet;
}
else
{
laneGroup.SignalPhase.GreenEffectiveSec = arterialInputs.Signal.EffGreen;
}
laneGroup.BaseSatFlow = arterialInputs.Traffic.BaseSatFlow;
laneGroup.PctHeavyVehicles = arterialInputs.Traffic.PctHeavyVeh;
laneGroup.ArvType = arterialInputs.Signal.ArvType;
float[] PlatoonRatioValues = new float[] { 0.333f, 0.667f, 1.0f, 1.333f, 1.667f, 2.0f };
laneGroup.PlatoonRatio = PlatoonRatioValues[laneGroup.ArvType - 1];
laneGroup.PeakHourFactor = arterialInputs.Traffic.PHF;
}
}
}
newArterial.Thresholds.Delay = newArterial.Thresholds.GetLOSBoundaries_Delay(newArterial.Area);
newArterial.Thresholds.Speed = newArterial.Thresholds.GetLOSBoundaries_Speed(arterialInputs.Roadway.PostedSpeedMPH);
newArterial.AnalysisTravelDir = arterialInputs.Roadway.AnalysisTravelDir;
return(newArterial);
}
public void cutShape(Shape stencil, bool splitFurther = true)
{
if (stencil.Direction != this.Direction)
{
throw new UnityException("Trying to cut shape with stencil of different thread type! shape: " + Direction + ", stencil: " + stencil.Direction);
}
//Show paths (for debugging)
//showPath(points);
//showPath(stencilPoints);
//Gather overlap info
List <IntersectionData> intersectionData = new List <IntersectionData>();
for (int i = 0; i < GlobalPoints.Count; i++)
{
int i2 = (i + 1) % GlobalPoints.Count;
//Line Checking
LineSegment targetLine = new LineSegment(GlobalPoints, i);
//Check to see if the bounds overlap
if (stencil.bounds.Intersects(targetLine.Bounds))
{
bool startInStencil = stencil.OverlapPoint(targetLine.startPos);
bool endInStencil = stencil.OverlapPoint(targetLine.endPos);
//Check which stencil edges intersect the line segment
bool intersectsSegment = false;
for (int j = 0; j < stencil.GlobalPoints.Count; j++)
{
LineSegment stencilLine = new LineSegment(stencil.GlobalPoints, j);
Vector2 intersection = Vector2.zero;
bool intersects = targetLine.Intersects(stencilLine, ref intersection);
//If it intersects,
if (intersects)
{
//Record a data point
intersectsSegment = true;
float distanceToPoint = (intersection - targetLine.startPos).magnitude;
IntersectionData interdata = new IntersectionData(intersection, i, j, intersects, startInStencil, endInStencil, distanceToPoint);
intersectionData.Add(interdata);
}
}
//If no line segment intersections were found,
if (!intersectsSegment)
{
//but one or more end points are in the stencil,
if (startInStencil || endInStencil)
{
//Make an intersection data point anyway, with slightly different arguments
IntersectionData interdata = new IntersectionData(Vector2.zero, i, -1, IntersectionData.IntersectionType.INSIDE);
intersectionData.Add(interdata);
}
}
//else,
else
{
//do nothing because the bounds lied about the line segment and stencil colliding
//don't worry, it's a known thing that can happen:
//bounds checking is quick but liable to give false positives
}
}
}
//
// Refine intersection data entries
//
//Sort the data entries
intersectionData.Sort(new IntersectionData.IntersectionDataComparer());
//Set the intersection type of the data
int side = 0;//0 =not set, 1 =inside, -1 =outside
foreach (IntersectionData interdata in intersectionData)
{
if (side == 0)
{
side = (interdata.startsInStencil) ? 1 : -1;
}
if (interdata.segmentIntersection)
{
side *= -1;
interdata.type = (side > 0) ? IntersectionData.IntersectionType.ENTER : IntersectionData.IntersectionType.EXIT;
}
else
{
interdata.type = (side > 0) ? IntersectionData.IntersectionType.INSIDE : IntersectionData.IntersectionType.OUTSIDE;
}
}
IntersectionData.printDataList(intersectionData, GlobalPoints);
//
//Start cutting
//
//Replace line segments inside the stencil
int dataCount = intersectionData.Count;
//Search for start of vein of changes
List <Vein> veins = new List <Vein>();
//only need to go through the loop once,
//because the veins will find their own end points:
//here we just need to find the start of each vein
for (int iData = 0; iData < dataCount; iData++)
{
IntersectionData interdata = intersectionData[iData];
//if this segment enters the stencil at this data point,
if (interdata.type == IntersectionData.IntersectionType.ENTER)
{
//then it's a vein start
Vein vein = new Vein(iData, interdata, intersectionData);
veins.Add(vein);
}
}
//Process found veins
if (veins.Count == 1)
{
Vector2[] newPath = veins[0].getStencilPath(stencil.GlobalPoints);
//Replace vein with stencil path
int removeCount = veins[0].getRemoveCount(GlobalPoints.Count);
replacePoints(newPath, veins[0].VeinStart + 1, removeCount);
}
else
{
//Process all the veins
IndexOffset.IndexOffsetContainer offsets = new IndexOffset.IndexOffsetContainer(GlobalPoints.Count);
for (int i = 0; i < veins.Count; i++)
{
Vein vein = veins[i];
//Update vein with new offsets
vein.updateIndexes(offsets);
//Check next vein
bool slices = false;
if (i < veins.Count - 1)
{
Vein vein2 = veins[i + 1];
vein.updateIndexes(offsets);
slices = vein.formsSlice(vein2, stencil.GlobalPoints.Count);
Debug.Log("slices: " + slices);
if (slices)
{
vein.slice(vein2);
if (splitFurther)
{
if (this.pc2d)
{
//make a new collider to make the new piece
PolygonCollider2D pc2dNew = GameObject.Instantiate(pc2d.gameObject)
.GetComponent <PolygonCollider2D>();
Shape newShape = new Shape(pc2dNew);
newShape.rotatePoints(vein2.VeinStart);
newShape.finalize();
childrenShapes.Add(newShape);
pc2dNew.transform.parent = pc2d.transform.parent;
pc2dNew.transform.position = pc2d.transform.position;
newShape.cutShape(stencil, false);
}
}
//skip the next vein
i++;
}
}
if (true || !slices)
{
//Replace vein with stencil path
Vector2[] newPath = vein.getStencilPath(stencil.GlobalPoints);
int removeCount = vein.getRemoveCount(GlobalPoints.Count);
replacePoints(newPath, vein.VeinStart + 1, removeCount);
//Add offset to the collection
IndexOffset offset = new IndexOffset(vein.VeinStart, newPath.Length - removeCount);
offsets.Add(offset);
}
}
}
//
// Finish up
//
finalize();
}
/// <summary>
/// Appends a grazing intersection.
/// </summary>
/// <param name="x1">Easting of the 1st intersection.</param>
/// <param name="y1">Northing of the 1st intersection.</param>
/// <param name="x2">Easting of the 2nd intersection.</param>
/// <param name="y2">Northing of the 2nd intersection.</param>
internal void Append(double x1, double y1, double x2, double y2)
{
IntersectionData xsect = new IntersectionData(x1, y1, x2, y2);
Append(xsect);
}
private static IntersectionResult SplitChain(Chain _chain, IntersectionData data)
{
bool backface = (_chain.m_vertexGroups[0].m_vertices.Count > 2);
int lowerChainFirstIndex = data.m_intersectionPoint + 1;
Vector3 coreDelta = (_chain.m_corePoints[lowerChainFirstIndex]
- _chain.m_corePoints[data.m_intersectionPoint]);
Vector3 corePoint = _chain.m_corePoints[data.m_intersectionPoint]
+ (coreDelta * data.m_intersectionDelta);
Vector3 leftDelta = _chain.m_mesh.vertices[_chain.m_vertexGroups[lowerChainFirstIndex].m_vertices[0]] -
_chain.m_mesh.vertices[_chain.m_vertexGroups[data.m_intersectionPoint].m_vertices[0]];
Vector3 leftCutPosition = _chain.m_mesh.vertices[_chain.m_vertexGroups[data.m_intersectionPoint].m_vertices[0]] +
(leftDelta * data.m_intersectionDelta);
Vector3 rightDelta = _chain.m_mesh.vertices[_chain.m_vertexGroups[lowerChainFirstIndex].m_vertices[1]] -
_chain.m_mesh.vertices[_chain.m_vertexGroups[data.m_intersectionPoint].m_vertices[1]];
Vector3 rightCutPosition = _chain.m_mesh.vertices[_chain.m_vertexGroups[data.m_intersectionPoint].m_vertices[1]] +
(rightDelta * data.m_intersectionDelta);
int upperVertexIntersection = (data.m_intersectionPoint + 1) * 2;
if (upperVertexIntersection < 0)
{
upperVertexIntersection = 0;
}
/////////////////////////////////////////////////////////////////////////////
Chain upperChain = new GameObject("UpperChain").AddComponent <Chain>();
upperChain.transform.position = _chain.transform.position;
MeshFilter upperFilter = upperChain.gameObject.AddComponent <MeshFilter>();
MeshRenderer upperRender = upperChain.gameObject.AddComponent <MeshRenderer>();
upperRender.sharedMaterial = _chain.gameObject.GetComponent <MeshRenderer>().sharedMaterial;
List <Vector3> upperCorePoints = _chain.m_corePoints.GetRange(0, lowerChainFirstIndex);
upperCorePoints.Add(corePoint);
Mesh upperMesh = SplitMesh(_chain, 0, data.m_intersectionPoint,
leftCutPosition, rightCutPosition, true);
upperMesh.vertices[upperVertexIntersection] = leftCutPosition;
upperMesh.vertices[upperVertexIntersection + 1] = rightCutPosition;
if (backface)
{
upperMesh.vertices[upperVertexIntersection] = leftCutPosition;
upperMesh.vertices[upperVertexIntersection + 1] = rightCutPosition;
}
upperMesh.RecalculateNormals();
List <VertexGroup> upperVertexGroups = _chain.m_vertexGroups.GetRange(0, lowerChainFirstIndex);
if (backface)
{
int upperBackSideStartDelta = upperVertexGroups[0].m_vertices[2] - (upperCorePoints.Count * 2);
for (int groupIter = 0; groupIter < upperVertexGroups.Count; groupIter++)
{
for (int vertexIter = 2; vertexIter < upperVertexGroups[groupIter].m_vertices.Count; vertexIter++)
{
upperVertexGroups[groupIter].m_vertices[vertexIter] -= upperBackSideStartDelta;
}
}
}
VertexGroup upperGroup = new VertexGroup();
upperGroup.SetAveragePosition(corePoint);
upperGroup.m_vertices.Add(upperVertexIntersection);
upperGroup.m_vertices.Add(upperVertexIntersection + 1);
if (_chain.m_mesh.vertexCount > _chain.m_corePoints.Count * 2)
{
upperGroup.m_vertices.Add(upperMesh.vertexCount - 2);
upperGroup.m_vertices.Add(upperMesh.vertexCount - 1);
}
upperVertexGroups.Add(upperGroup);
upperChain.Initialise(upperCorePoints, upperVertexGroups, upperMesh);
upperFilter.sharedMesh = upperMesh;
///////////////////////////////////////////////////////////////////////////////
Chain lowerChain = new GameObject("LowerChain").AddComponent <Chain>();
lowerChain.transform.position = _chain.transform.position;
MeshFilter lowerFilter = lowerChain.gameObject.AddComponent <MeshFilter>();
MeshRenderer lowerRender = lowerChain.gameObject.AddComponent <MeshRenderer>();
lowerRender.sharedMaterial = _chain.gameObject.GetComponent <MeshRenderer>().sharedMaterial;
List <Vector3> lowerCorePoints = _chain.m_corePoints.GetRange(lowerChainFirstIndex,
_chain.m_corePoints.Count - lowerChainFirstIndex);
lowerCorePoints.Insert(0, corePoint);
int lastVertexGroup = _chain.m_corePoints.Count - 1;
Mesh lowerMesh = SplitMesh(_chain, lowerChainFirstIndex,
lastVertexGroup, leftCutPosition, rightCutPosition, false);
lowerMesh.vertices[0] = leftCutPosition;
lowerMesh.vertices[1] = rightCutPosition;
if (backface)
{
lowerMesh.vertices[(_chain.m_corePoints.Count - lowerChainFirstIndex)] = leftCutPosition;
lowerMesh.vertices[(_chain.m_corePoints.Count - lowerChainFirstIndex) + 1] = rightCutPosition;
}
lowerMesh.RecalculateNormals();
List <VertexGroup> lowerVertexGroups = _chain.m_vertexGroups.GetRange(lowerChainFirstIndex,
_chain.m_corePoints.Count - lowerChainFirstIndex);
int lowerStartDelta = data.m_intersectionPoint * 2;
int lowerBackStartDelta = 0;
if (backface)
{
lowerBackStartDelta = (data.m_intersectionPoint - 1) * 4;
}
for (int groupIter = 0; groupIter < lowerVertexGroups.Count; groupIter++)
{
for (int vertexIter = 0; vertexIter < lowerVertexGroups[groupIter].m_vertices.Count; vertexIter++)
{
lowerVertexGroups[groupIter].m_vertices[vertexIter] -= lowerStartDelta;
if (vertexIter > 1)
{
lowerVertexGroups[groupIter].m_vertices[vertexIter] -= lowerBackStartDelta;
}
}
}
VertexGroup lowerGroup = new VertexGroup();
lowerGroup.SetAveragePosition(corePoint);
lowerGroup.m_vertices.Add(0);
lowerGroup.m_vertices.Add(1);
if (backface)
{
lowerGroup.m_vertices.Add((lowerMesh.vertexCount / 2));
lowerGroup.m_vertices.Add((lowerMesh.vertexCount / 2) + 1);
}
lowerVertexGroups.Insert(0, lowerGroup);
lowerChain.Initialise(lowerCorePoints, lowerVertexGroups, lowerMesh);
lowerFilter.sharedMesh = lowerMesh;
////////////////////////////////////////////////////////////////////////
IntersectionResult result = new IntersectionResult();
result.m_upperChain = upperChain;
result.m_lowerChain = lowerChain;
return(result);
}
void SetIntersectionPointOnIntersection(IntersectionData intersection)
{
intersection.target.AddWorldPointOnTriangle(intersection.hit.point, intersection.targetTriangle);
intersection.cutter.AddWorldPointOnTriangle(intersection.hit);
}
// Illegal XML characters: < (less than), > (greater than), & (ampersand), ' (apostrophe), " (quotation mark)
public void ReadXmlFile(string filename, ProjectData project, ArterialData Art, List <IntersectionData> ints, List <LinkData> segs)
{
XmlTextReader xtr = new XmlTextReader(filename);
int Index = 0; //index for intersection number
//int SubSegNum = 0; //index for ped subsegment number
int TotInts = 1; //total number of intersections
IntersectionData newInt = new IntersectionData(); // (Art.Area, Art.Classification, Art.SigControl); //first intersection is "dummy" intersection
ints.Add(newInt);
LinkData newSeg = new LinkData(); // (Art.Area, Art.Classification); //first segment is "dummy" segment
segs.Add(newSeg);
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.Whitespace)
{
continue;
}
if (xtr.IsStartElement("PROJECT"))
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "PROJECT")
{
break;
}
}
switch (xtr.Name)
{
//Project Data Elements
case "FileName":
break;
case "Analyst":
project.AnalystName = xtr.ReadElementContentAsString();
break;
case "Date":
//project.AnalDate = xtr.ReadElementContentAsDateTime();
project.AnalysisDate = Convert.ToDateTime(xtr.ReadElementContentAsString());
break;
case "Agency":
project.Agency = xtr.ReadElementContentAsString();
break;
case "AgencyName": //for compatibality with Artplan 2007 files
project.Agency = xtr.ReadElementContentAsString();
break;
case "Comment":
project.UserNotes = xtr.ReadElementContentAsString();
break;
case "PeriodID":
string period = xtr.ReadElementContentAsString();
if (period == "Standard K" || period == "K100")
{
project.Period = StudyPeriod.StandardK;
}
else if (period == "Kother")
{
project.Period = StudyPeriod.Kother;
}
else if (period == "Dir Hr Demand Vol")
{
project.Period = StudyPeriod.PeakHour;
}
break;
case "AnalysisType":
string AnalType = xtr.ReadElementContentAsString();
if (AnalType == "Peak Direction")
{
project.DirectionAnalysisMode = DirectionType.PeakDirection;
}
else if (AnalType == "Peak and Off-Peak Directions")
{
project.DirectionAnalysisMode = DirectionType.BothDirections;
}
break;
case "ModalAnalysis":
string Mode = xtr.ReadElementContentAsString();
if (Mode == "Multimodal")
{
project.Mode = ModeType.Multimodal;
}
else if (Mode == "Auto Only")
{
project.Mode = ModeType.AutoOnly;
}
else if (Mode == "Isolated Signal")
{
project.Mode = ModeType.SignalOnly;
}
break;
case "MultiModal": //for compatibality with Artplan 2007 files
string Mode2 = xtr.ReadElementContentAsString();
if (Mode2 == "True")
{
project.Mode = ModeType.Multimodal;
}
else
{
project.Mode = ModeType.AutoOnly;
}
//signal only analysis was handled through Class field in Artplan 2007
//signal only analysis files are not handled because all the inputs were handled through the general facility data screen (i.e., ArterialInfo), which no longer exists
break;
}
}
}
else if (xtr.IsStartElement("ARTERIALINFO"))
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "ARTERIALINFO")
{
break;
}
}
switch (xtr.Name)
{
//Arterial Values
case "ArterialName":
Art.ArtName = xtr.ReadElementContentAsString();
break;
case "From":
Art.From = xtr.ReadElementContentAsString();
break;
case "To":
Art.To = xtr.ReadElementContentAsString();
break;
case "FwdDirection":
string peakDir = xtr.ReadElementContentAsString();
if (peakDir == "Northbound")
{
Art.AnalysisTravelDir = TravelDirection.Northbound;
}
else if (peakDir == "Southbound")
{
Art.AnalysisTravelDir = TravelDirection.Southbound;
}
else if (peakDir == "Eastbound")
{
Art.AnalysisTravelDir = TravelDirection.Eastbound;
}
else if (peakDir == "Westbound")
{
Art.AnalysisTravelDir = TravelDirection.Westbound;
}
break;
case "AreaType":
string areaType = xtr.ReadElementContentAsString();
if (areaType == "Large Urbanized")
{
Art.Area = AreaType.LargeUrbanized;
}
else if (areaType == "Other Urbanized")
{
Art.Area = AreaType.OtherUrbanized;
}
else if (areaType == "Transitioning/Urban")
{
Art.Area = AreaType.Transitioning;
}
else if (areaType == "Rural Developed")
{
Art.Area = AreaType.RuralDeveloped;
}
break;
case "ArterialClass_HCM":
Art.Classification = (ArterialClass)xtr.ReadElementContentAsInt();
if ((int)Art.Classification > 2) //code to handle legacy projects that used 4 classes
{
Art.Classification = ArterialClass.ClassII;
}
break;
case "ArtLength":
Art.LengthMiles = xtr.ReadElementContentAsFloat();
break;
case "KFactor_PLN":
Art.Kfactor = xtr.ReadElementContentAsFloat();
break;
case "DFactor_PLN":
Art.Dfactor = xtr.ReadElementContentAsFloat();
break;
case "PHF":
//Art.PHF = xtr.ReadElementContentAsFloat();
break;
case "BaseSatFlowPerLane":
//Art.BaseSatFlow = xtr.ReadElementContentAsInt();
break;
case "NumberOfIntersections":
TotInts = xtr.ReadElementContentAsInt();
break;
}
}
}
else if (xtr.IsStartElement("ARTERIALDIR")) // || xtr.IsStartElement("APPROACH")) //The 'APPROACH ' tag is to provide support to Artplan 2007 version
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "ARTERIALDIR") // || xtr.Name == "APPROACH")
{
break;
}
}
switch (xtr.Name)
{
//Direction specific approach items
case "HVPct":
//Art.PctHeavyVeh = xtr.ReadElementContentAsFloat();
break;
}
}
}
else if (xtr.IsStartElement("INTERSECTIONINFO"))
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "INTERSECTIONINFO")
{
break;
}
}
newInt = new IntersectionData(1, Art.Area, Art.Classification, null, new SignalCycleData());
ints.Add(newInt);
newSeg = new LinkData();
segs.Add(newSeg);
switch (xtr.Name)
{
//Intersection Data Elements
case "CrossStreetName":
Index++; //increment intersection counter
ints[Index].CrossStreetName = xtr.ReadElementContentAsString();
break;
}
}
}
else if (xtr.IsStartElement("CONTROLLER"))
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "CONTROLLER")
{
break;
}
}
switch (xtr.Name)
{
case "ControlMode":
string controlMode = xtr.ReadElementContentAsString();
//if (controlMode == "Pretimed")
// Art.SigControl = SigControlType.Pretimed;
//else if (controlMode == "CoordinatedActuated")
// Art.SigControl = SigControlType.CoordinatedActuated;
//else if (controlMode == "FullyActuated")
// Art.SigControl = SigControlType.FullyActuated;
break;
case "CycleLength":
//ints[Index].CycleLen = xtr.ReadElementContentAsInt();
break;
case "LeftTurnPhasing":
string LTphasing = xtr.ReadElementContentAsString();
//if (LTphasing == "Protected")
// ints[Index].LTphasing = PhasingType.Protect;
//else if (LTphasing == "ProtPerm")
// ints[Index].LTphasing = PhasingType.ProtPerm;
//else
// ints[Index].LTphasing = PhasingType.None;
break;
}
}
}
else if (xtr.IsStartElement("LANEGROUP"))
{
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement)
{
if (xtr.Name == "LANEGROUP")
{
//SubSegNum = 0; //reset subsegment counter for next segment
break;
}
}
switch (xtr.Name)
{
case "GCRatio":
ints[Index].Approaches[0].LaneGroups[0].SignalPhase.gC = xtr.ReadElementContentAsFloat();
break;
case "LeftTurnBayYN":
string LTBay = xtr.ReadElementContentAsString();
//if (LTBay == "No")
// ints[Index].isLTbay = false;
//else
// ints[Index].isLTbay = true;
break;
case "NumberLTlanes":
string LTlanes = xtr.ReadElementContentAsString();
//if (LTlanes != "N/A")
// ints[Index].NumLTlanes = Convert.ToInt32(LTlanes);
break;
case "LTBayLength":
string LTbayLen = xtr.ReadElementContentAsString();
//if (LTbayLen != "N/A")
// ints[Index].LTbayLen = Convert.ToInt32(LTbayLen);
break;
case "GCRatioLT":
string LTgCratio = xtr.ReadElementContentAsString();
//if (LTgCratio != "N/A")
// ints[Index].gClt = Convert.ToSingle(LTgCratio);
break;
case "RightTurnBayYN":
string RTBay = xtr.ReadElementContentAsString();
//if (RTBay == "No")
// ints[Index].isRTbay = false;
//else
// ints[Index].isRTbay = true;
break;
case "PctTurn_Left":
//ints[Index].PctLT = xtr.ReadElementContentAsInt();
break;
case "PctTurn_Right":
//nts[Index].PctRT = xtr.ReadElementContentAsInt();
break;
case "ArrivalType":
//ints[Index].ArvType = xtr.ReadElementContentAsInt();
break;
case "NumberOfLanes_INT":
//ints[Index].NumThLanes = xtr.ReadElementContentAsFloat();
break;
//Segment Data Elements
case "LinkLength":
//subtract 1 from index since there is one less segment than # of intersections
float SegLength = xtr.ReadElementContentAsFloat();
if (SegLength < 10)
{
segs[Index - 1].LengthFt = SegLength * 5280;
}
else
{
segs[Index - 1].LengthFt = SegLength;
}
break;
case "AADT":
segs[Index - 1].AADT = xtr.ReadElementContentAsLong();
break;
case "DDHV":
segs[Index - 1].DDHV = xtr.ReadElementContentAsFloat();
break;
case "NumberOfLanes_SEG":
segs[Index - 1].NumLanes = xtr.ReadElementContentAsInt();
break;
case "PostedSpeed":
segs[Index - 1].PostSpeedMPH = xtr.ReadElementContentAsInt();
break;
case "FreeFlowSpeed":
//segs[Index - 1].FFSpeed = xtr.ReadElementContentAsFloat();
break;
case "MedianType":
string MedType = xtr.ReadElementContentAsString();
if (MedType == "None")
{
segs[Index - 1].MedType = MedianType.None;
}
else if (MedType == "Non-Restrictive")
{
segs[Index - 1].MedType = MedianType.Nonrestrictive;
}
else if (MedType == "Restrictive")
{
segs[Index - 1].MedType = MedianType.Restrictive;
}
//SegNum++;
break;
case "OnStreetParkingYN":
string OnStreetParkingYN = xtr.ReadElementContentAsString();
if (OnStreetParkingYN == "No")
{
segs[Index - 1].OnStreetParkingExists = false;
}
else
{
segs[Index - 1].OnStreetParkingExists = true;
}
break;
case "ParkingActivity":
string ParkingActivity = xtr.ReadElementContentAsString();
if (ParkingActivity == "Low")
{
segs[Index - 1].ParkingActivity = ParkingActivityLevel.Low;
}
else if (ParkingActivity == "Medium")
{
segs[Index - 1].ParkingActivity = ParkingActivityLevel.Medium;
}
else if (ParkingActivity == "High")
{
segs[Index - 1].ParkingActivity = ParkingActivityLevel.High;
}
else // N/A (on-street parking not present)
{
segs[Index - 1].ParkingActivity = ParkingActivityLevel.NotApplicable;
}
break;
//Multimodal Segment Data Elements
case "OutsideLnWidth":
string LaneWidth = xtr.ReadElementContentAsString();
if (LaneWidth == "Narrow")
{
segs[Index - 1].OutsideLaneWidth = OutLaneWidth.Narrow;
}
else if (LaneWidth == "Typical")
{
segs[Index - 1].OutsideLaneWidth = OutLaneWidth.Typical;
}
else if (LaneWidth == "Wide")
{
segs[Index - 1].OutsideLaneWidth = OutLaneWidth.Wide;
}
else //custom
{
segs[Index - 1].OutsideLaneWidth = OutLaneWidth.Custom;
//Seg[Index - 1].NumOutsideLaneWidth = Convert.ToInt32(LaneWidth);
}
break;
case "PavementCondition":
string PaveCond = xtr.ReadElementContentAsString();
//if (PaveCond == "Desirable")
// Seg[Index - 1].PaveCond = PavementCondition.Desirable;
//else if (PaveCond == "Typical")
// Seg[Index - 1].PaveCond = PavementCondition.Typical;
//else if (PaveCond == "Undesirable")
// Seg[Index - 1].PaveCond = PavementCondition.Undesirable;
break;
case "BikeLnYN":
string BikeLaneYN = xtr.ReadElementContentAsString();
//if (BikeLaneYN == "No")
// SegMM[Index - 1].BikeLaneExists = false;
//else
// SegMM[Index - 1].BikeLaneExists = true;
break;
case "SidewalkYN":
string SidewalkYN = xtr.ReadElementContentAsString();
//if (SidewalkYN == "No")
// SegMM[Index - 1].SidewalkExists = false;
//else
// SegMM[Index - 1].SidewalkExists = true;
break;
}
}
}
}
/*
* if (Index == TotInts + 1)
* {
* xtr.Close();
* Art.TotalInts = Index;
* Art.TotalSegs = Index - 1;
* return;
* }
*/
Art.TotalInts = Index;
Art.TotalSegs = Index - 1;
xtr.Close();
}
public static IntersectionData NewIntersection(List <TimerData> Timers, int numThruLanes, AnalysisMode ProjectAnalMode, int crossStreetWidth)
{
List <ApproachData> newApproaches = new List <ApproachData>();
List <LaneGroupData> newLaneGroups = new List <LaneGroupData>();
List <LaneData> newLanes;
List <SignalPhaseData> Phases = new List <SignalPhaseData>();
// Intersection Signal Data
//Example problem specifies permitted left turn for NB LT. Use protected until permitted delay calculations are implemented.
SignalPhaseData WBLSignalPhase = new SignalPhaseData(nemaPhaseId: 1, nemaMvmtId: NemaMovementNumbers.WBLeft, phaseType: PhasingType.Protected, greenTime: 20, yellowTime: 3, allRedTime: 1, startUpLostTime: 2, timer: Timers[0]);
SignalPhaseData EBLSignalPhase = new SignalPhaseData(5, NemaMovementNumbers.EBLeft, PhasingType.Protected, 20, 3, 1, 2, Timers[1]);
SignalPhaseData EBTSignalPhase = new SignalPhaseData(2, NemaMovementNumbers.EBThru, PhasingType.Protected, 45, 3, 1, 2, Timers[2]);
SignalPhaseData WBTSignalPhase = new SignalPhaseData(6, NemaMovementNumbers.WBThru, PhasingType.Protected, 45, 3, 1, 2, Timers[3]);
SignalPhaseData NBLSignalPhase = new SignalPhaseData(3, NemaMovementNumbers.NBLeft, PhasingType.Protected, 8, 3, 1, 2, Timers[4]);
SignalPhaseData SBLSignalPhase = new SignalPhaseData(7, NemaMovementNumbers.SBLeft, PhasingType.Protected, 8, 3, 1, 2, Timers[5]);
SignalPhaseData SBTSignalPhase = new SignalPhaseData(4, NemaMovementNumbers.SBThru, PhasingType.Protected, 35, 3, 1, 2, Timers[6]);
SignalPhaseData NBTSignalPhase = new SignalPhaseData(8, NemaMovementNumbers.NBThru, PhasingType.Protected, 35, 3, 1, 2, Timers[7]);
Phases.Add(WBLSignalPhase);
Phases.Add(EBTSignalPhase);
Phases.Add(NBLSignalPhase);
Phases.Add(SBTSignalPhase);
Phases.Add(EBLSignalPhase);
Phases.Add(WBTSignalPhase);
Phases.Add(SBLSignalPhase);
Phases.Add(NBTSignalPhase);
LaneData[] numLeftLanes = new LaneData[1];
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "NB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.NBThru, TravelDirection.Northbound, newLanes, NBTSignalPhase, arvType: 3));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "NB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.NBLeft, TravelDirection.Northbound, newLanes, NBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(1, TravelDirection.Northbound, "NB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "EB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.EBThru, TravelDirection.Eastbound, newLanes, EBTSignalPhase, arvType: 4));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "EB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.EBLeft, TravelDirection.Eastbound, newLanes, EBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(2, TravelDirection.Eastbound, "EB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "SB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.SBThru, TravelDirection.Southbound, newLanes, SBTSignalPhase, arvType: 3));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "SB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.SBLeft, TravelDirection.Southbound, newLanes, SBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(3, TravelDirection.Southbound, "SB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "WB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.WBThru, TravelDirection.Westbound, newLanes, WBTSignalPhase, arvType: 4));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "WB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.WBLeft, TravelDirection.Westbound, newLanes, WBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(4, TravelDirection.Westbound, "WB", 0, newLaneGroups));
SignalCycleData newSignalData = new SignalCycleData(SigControlType.Pretimed, 124, Phases);
IntersectionData newIntersection = new IntersectionData(1, AreaType.LargeUrbanized, ArterialClass.ClassI, newApproaches, newSignalData, ProjectAnalMode, crossStreetWidth);
return(newIntersection);
}
/*
// Multisegment
uint Intersect(IPointGeometry[] locs)
{
return m_Object.Intersect(this, locs);
}
*/
/// <summary>
/// Append intersection info to this object.
/// </summary>
/// <param name="xsect">The intersection info to append.</param>
void Append(IntersectionData xsect)
{
m_Data.Add(xsect);
}
public void update(int dataEndIndex, IntersectionData interdataEnd)
{
this.dataEndIndex = dataEndIndex;
this.interdataEnd = interdataEnd;
this.origVeinEnd = VeinEnd;
}
public void FindIntersections(Path p, Vector2 offset1, Vector2 offset2) {
float pos = 0;
for (int i = 0; i < points.Length; i++) {
Vector2 p1p1 = points[i] + offset1;
Vector2 p1p2 = points[(i + 1) % points.Length] + offset1;
for (int j = 0; j < p.points.Length; j++) {
Vector2 p2p1 = p.points[j] + offset2;
Vector2 p2p2 = p.points[(j + 1) % p.points.Length] + offset2;
float r = lineLineIntersectionRatio(p1p1, p1p2, p2p1, p2p2);
if (r >= 0 && r <= 1) {
IntersectionData data = new IntersectionData(pos + r * segmentLengths[i], this.parentAdherent, p.parentAdherent);
intersectionPositions.Add(data);
}
}
pos += segmentLengths[i];
}
}
/// <summary>
/// Appends a simple intersection.
/// </summary>
/// <param name="xi">Easting of the intersection.</param>
/// <param name="yi">Northing of the intersection.</param>
/// <param name="sortval">Sort value (default=0.0).</param>
internal void Append(double xi, double yi, double sortval)
{
IntersectionData xsect = new IntersectionData(xi, yi, sortval);
Append(xsect);
}
