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); }