static void Main(string[] args) { //Point p1 = new Point() { X = 0, Y = 1 }; //Point p2 = new Point() { X = 1, Y = 0 }; Point p3 = new Point() { X = 0, Y = -1 }; Point p4 = new Point() { X = 1, Y = -1 }; Point p5 = new Point() { X = 2, Y = -1 }; //Point p6 = new Point() { X = 2, Y = 0 }; //Point p7 = new Point() { X = 2, Y = 1 }; //Point p1 = new Point() { X = 0, Y = 1 }; //Point p2 = new Point() { X = 1, Y = 0 }; //Point p3 = new Point() { X = 0, Y = -1 }; //Point p4 = new Point() { X = -1, Y = -1 }; //Point p5 = new Point() { X = -2, Y = -1 }; //Point p6 = new Point() { X = -2, Y = 0 }; //Point p7 = new Point() { X = -2, Y = 1 }; List<Point> points = new List<Point>(); //double result = cal(p3, p2, p1); //points.Add(p1); //points.Add(p2); points.Add(p3); points.Add(p4); points.Add(p5); //points.Add(p6); //points.Add(p7); ClockDirection vDirection = Polygon.CalculateClockDirection(points, false); PolygonType type = Polygon.CalculatePolygonType(points, false); bool flag = Polygon.IsPolyClockwise(points); }
public GetNodeSegmentIdsEnumerable(ushort nodeId, ushort initialSegmentId, ClockDirection clockDirection, NetSegment[] segmentBuffer) { this.nodeId = nodeId; this.initialSegmentId = initialSegmentId; this.clockDirection = clockDirection; this.segmentBuffer = segmentBuffer; }
public static Direction rotate(this Direction dir, ClockDirection cd) { if (cd == ClockDirection.clockwise) { switch (dir) { case Direction.down: return Direction.left; case Direction.left: return Direction.up; case Direction.up: return Direction.right; case Direction.right: return Direction.down; default: break; } } else if (cd == ClockDirection.counterclockwise) { switch (dir) { case Direction.down: return Direction.right; case Direction.right: return Direction.up; case Direction.up: return Direction.left; case Direction.left: return Direction.down; default: break; } } return Direction.none; }
//-------------------------------------------------------------------------------------------------- public bool SearchCircle( Map map, int radius, ClockDirection clockDirection, Tour tour ) { SearchSet ss = m_SearchSets[radius]; SortedList<double,CircleEntry> entries = ss.Entries; if( entries == null ) return false; IList<CircleEntry> values; if( clockDirection == ClockDirection.Clockwise ) { List<CircleEntry> list = new List<CircleEntry>( entries.Values ); list.Reverse(); values = list; } else values = entries.Values; foreach( CircleEntry entry in values ) { if( tour( map, entry.X, entry.Y ) ) return true; } return false; }
public static bool Circle( Map map, int radius, ClockDirection clockDirection, Tour tour ) { return(m_CircleSearch.SearchCircle(map, radius, clockDirection, tour)); }
public static bool Circle( Map map, int radius, ClockDirection clockDirection, Tour tour ) { return m_CircleSearch.SearchCircle( map, radius, clockDirection, tour ); }
public GetNodeSegmentIdsEnumerator(ushort nodeId, ushort initialSegmentId, ClockDirection clockDirection, NetSegment[] segmentBuffer) { this.nodeId = nodeId; this.initialSegment = initialSegmentId; this.clockDirection = clockDirection; this.segmentBuffer = segmentBuffer ?? throw new ArgumentNullException(nameof(segmentBuffer)); this.firstRun = true; this.currentSegmentId = default; }
public void IterateNodeSegments(ushort nodeId, ClockDirection dir, NetSegmentHandler handler) { NetManager netManager = Singleton <NetManager> .instance; ProcessNode(nodeId, delegate(ushort nId, ref NetNode node) { if (dir == ClockDirection.None) { for (int i = 0; i < 8; ++i) { ushort segmentId = node.GetSegment(i); if (segmentId != 0) { if (!handler(segmentId, ref netManager.m_segments.m_buffer[segmentId])) { break; } } } } else { ushort segmentId = node.GetSegment(0); ushort initSegId = segmentId; while (true) { if (segmentId != 0) { if (!handler(segmentId, ref netManager.m_segments.m_buffer[segmentId])) { break; } } switch (dir) { case ClockDirection.Clockwise: default: segmentId = netManager.m_segments.m_buffer[segmentId].GetLeftSegment(nodeId); break; case ClockDirection.CounterClockwise: segmentId = netManager.m_segments.m_buffer[segmentId].GetRightSegment(nodeId); break; } if (segmentId == initSegId || segmentId == 0) { break; } } } return(true); }); }
//-------------------------------------------------------------------------------------------------- public bool SearchConcentricCircles( Map map, int start, ClockDirection clockDirection, SearchDirection searchDirection, Tour tour ) { int incr = (searchDirection == SearchDirection.Outwards ? 1 : -1); for (int i = start;; i += incr) { if (i < 0 || i > m_Radius) { return(false); } SearchSet ss = m_SearchSets[i]; SortedList <double, CircleEntry> entries = ss.Entries; if (entries == null) { continue; } IList <CircleEntry> values; if (clockDirection == ClockDirection.Clockwise) { List <CircleEntry> list = new List <CircleEntry>(entries.Values); list.Reverse(); values = list; } else { values = entries.Values; } foreach (CircleEntry entry in values) { if (tour(map, entry.X, entry.Y)) { return(true); } } return(false); } }
/* The next two methods are overrides from IPGameObject. In addition to the * base class methods, we save and restore variables specific to this class. */ public override void SaveCheckpointState() { base.SaveCheckpointState(); savedAttachPlayer = attachPlayer; savedDirection = direction; savedRotationAxis = rotationAxis; savedStepDegrees = stepDegrees; savedStepDelay = stepDelay; savedSpeed = speed; savedAxis = axis; savedAngle = angle; savedDelayed = delayed; }
/// <summary> /// creats a sorted list of segmetns connected to nodeId. /// roads without outgoing lanes are excluded as they do not need traffic lights /// the segments are arranged in a clockwise direction (Counter clock wise for LHT). /// </summary> /// <param name="nodeId">the junction</param> /// <returns>a list of segments aranged in counter clockwise direction.</returns> private static List <ushort> ArrangedSegments(ushort nodeId) { ClockDirection clockDir = RHT ? ClockDirection.Clockwise : ClockDirection.CounterClockwise; List <ushort> segList = new List <ushort>(); netService.IterateNodeSegments( nodeId, clockDir, (ushort segId, ref NetSegment _) => { if (CountOutgoingLanes(segId, nodeId) > 0) { segList.Add(segId); } return(true); }); ; return(segList); }
/// <summary> /// creats a sorted list of segmetns connected to nodeId. /// roads without outgoing lanes are excluded as they do not need traffic lights /// the segments are arranged in a clockwise direction (Counter clock wise for LHT). /// </summary> /// <param name="nodeId">the junction</param> /// <returns>a list of segments aranged in counter clockwise direction.</returns> private static List <ushort> ArrangedSegments(ushort nodeId) { ClockDirection clockDirection = RHT ? ClockDirection.Clockwise : ClockDirection.CounterClockwise; List <ushort> segList = new List <ushort>(); foreach (var segmentId in netService.GetNodeSegmentIds(nodeId, clockDirection)) { if (CountOutgoingLanes(segmentId, nodeId) > 0) { segList.Add(segmentId); } } return(segList); }
/// <summary> /// creats a sorted list of segmetns connected to nodeId. /// roads without outgoing lanes are excluded as they do not need traffic lights /// the segments are arranged in a clockwise direction (Counter clock wise for LHT). /// </summary> /// <param name="nodeId">the junction</param> /// <returns>a list of segments aranged in counter clockwise direction.</returns> private static List <ushort> ArrangedSegments(ushort nodeId) { ClockDirection clockDirection = Shortcuts.LHT ? ClockDirection.CounterClockwise : ClockDirection.Clockwise; List <ushort> segList = new List <ushort>(); ExtNodeManager extNodeManager = ExtNodeManager.Instance; foreach (var segmentId in extNodeManager.GetNodeSegmentIds(nodeId, clockDirection)) { if (CountOutgoingLanes(segmentId, nodeId) > 0) { segList.Add(segmentId); } } return(segList); }
private static Direction UpdateDirection(Direction current, int degrees, ClockDirection clockDirection) { int steps = degrees / 90; int cur = (int)current; for (int i = 0; i < steps; i++) { cur += clockDirection == ClockDirection.Clockwise ? 1 : -1; if (cur < 0) { cur = 3; } if (cur > 3) { cur = 0; } } return((Direction)(cur)); }
public override void RestoreCheckpointState() { StopCoroutine("WaitForDelay"); base.RestoreCheckpointState(); attachPlayer = savedAttachPlayer; direction = savedDirection; rotationAxis = savedRotationAxis; stepDegrees = savedStepDegrees; stepDelay = savedStepDelay; speed = savedSpeed; delayed = savedDelayed; angle = savedAngle; axis = savedAxis; Debug.Log("Angle = " + angle + "Rot Angle = " + transform.eulerAngles.y); if (delayed) StartCoroutine("WaitForDelay"); }
//-------------------------------------------------------------------------------------------------- public bool SearchCircle( Map map, int radius, ClockDirection clockDirection, Tour tour ) { SearchSet ss = m_SearchSets[radius]; SortedList <double, CircleEntry> entries = ss.Entries; if (entries == null) { return(false); } IList <CircleEntry> values; if (clockDirection == ClockDirection.Clockwise) { List <CircleEntry> list = new List <CircleEntry>(entries.Values); list.Reverse(); values = list; } else { values = entries.Values; } foreach (CircleEntry entry in values) { if (tour(map, entry.X, entry.Y)) { return(true); } } return(false); }
private void Gen(List <Polyline> pls, double t, out List <Polyline> outPls, out List <double> areaLis) { List <Polyline> nextGen = new List <Polyline>(); List <double> nextArea = new List <double>(); foreach (Polyline pl in pls) { Point3d[] pts = pl.ToArray(); double[] ptsLength = new double[pts.Length - 1]; for (int i = 0; i < pts.Length; i++) { if (i > 0) { Point3d prev = pts[i - 1]; ptsLength[i - 1] = pts[i].DistanceTo(prev); } } int maxIdx = Array.IndexOf(ptsLength, ptsLength.Max()); Line longestLine = new Line(pts[maxIdx], pts[maxIdx + 1]); Vector3d normal = new Vector3d(longestLine.Direction); Point3d basePoint = longestLine.PointAt(t); Plane basePlane = new Plane(basePoint, normal); var intersection = Intersection.CurvePlane(pl.ToPolylineCurve(), basePlane, 0); Line divider = new Line(intersection[0].PointA, intersection[1].PointA); dividers.Add(divider); Vector3d dividerDir = divider.Direction; Polyline leftPl = new Polyline(); Polyline rightPl = new Polyline(); for (int i = 0; i < pl.Count; i++) { if (X2D(divider, pts[i]) == LineSide.Right) { rightPl.Add(pts[i]); } else if (X2D(divider, pts[i]) == LineSide.Left) { leftPl.Add(pts[i]); } } ClockDirection cDir = CalculateClockDirection(pl.ToList()); LineSide cSide = X2D(divider, pl.First); if (cDir == ClockDirection.Clockwise && cSide == LineSide.Left) { rightPl.Add(divider.From); rightPl.Add(divider.To); rightPl.Add(rightPl[0]); int index = pl.IndexOf(rightPl[0]); leftPl.Insert(index, divider.To); leftPl.Insert(index + 1, divider.From); } else if (cDir == ClockDirection.Counterclockwise && cSide == LineSide.Left) { rightPl.Add(divider.To); rightPl.Add(divider.From); rightPl.Add(rightPl[0]); int index = pl.IndexOf(rightPl[0]); leftPl.Insert(index, divider.From); leftPl.Insert(index + 1, divider.To); } else if (cDir == ClockDirection.Clockwise && cSide == LineSide.Right) { leftPl.Add(divider.To); leftPl.Add(divider.From); leftPl.Add(leftPl[0]); int index = pl.IndexOf(leftPl[0]); rightPl.Insert(index, divider.From); rightPl.Insert(index + 1, divider.To); } else if (cDir == ClockDirection.Counterclockwise && cSide == LineSide.Right) { leftPl.Add(divider.From); leftPl.Add(divider.To); leftPl.Add(leftPl[0]); int index = pl.IndexOf(leftPl[0]); rightPl.Insert(index, divider.To); rightPl.Insert(index + 1, divider.From); } nextGen.Add(leftPl); nextGen.Add(rightPl); double areaL = AreaMassProperties.Compute(leftPl.ToPolylineCurve()).Area; double areaR = AreaMassProperties.Compute(leftPl.ToPolylineCurve()).Area; nextArea.Add(areaL); nextArea.Add(areaR); } areaLis = nextArea; outPls = nextGen; }
//-------------------------------------------------------------------------------------------------- public bool SearchConcentricCircles( Map map, int start, ClockDirection clockDirection, SearchDirection searchDirection, Tour tour ) { int incr = ( searchDirection == SearchDirection.Outwards ? 1 : -1 ); for( int i=start;;i+=incr) { if( i < 0 || i > m_Radius ) return false; SearchSet ss = m_SearchSets[i]; SortedList<double,CircleEntry> entries = ss.Entries; if( entries == null ) continue; IList<CircleEntry> values; if( clockDirection == ClockDirection.Clockwise ) { List<CircleEntry> list = new List<CircleEntry>( entries.Values ); list.Reverse(); values = list; } else values = entries.Values; foreach( CircleEntry entry in values ) { if( tour( map, entry.X, entry.Y ) ) return true; } return false; } }
public GetNodeSegmentIdsEnumerable GetNodeSegmentIds(ushort nodeId, ClockDirection clockDirection) { ref NetNode netNode = ref nodeId.ToNode();