public static Point2D GetClosestPointOnSegment(Segment2D segment, Point2D point, out double distance) { double bot; int i; double t; //the relative position of the point Pn to the SEGMENT // // If the line segment is actually a point, then the answer is easy. // if (segment.Length == 0) { t = 0.0; } else { bot = Math.Pow(segment.x2 - segment.x1, 2) + Math.Pow(segment.y2 - segment.y1, 2); t = (point.x - segment.x1) * (segment.x2 - segment.x1) + (point.y - segment.y1) * (segment.y2 - segment.y1); t = t / bot; t = Math.Min( Math.Max(t, 0.0), 1.0 ); } Point2D closestPoint; closestPoint.x = segment.x1 + t * (segment.x2 - segment.x1); closestPoint.y = segment.y1 + t * (segment.y2 - segment.y1); distance = point.GetDistance(closestPoint); return closestPoint; }
public MazeArc(MazeNode from, MazeNode to) { this.from = from; this.to = to; Weight = new Segment2D(from.position, to.position).Length; }
public void IsVertical_DifferencesInY_ReturnsExpectedValue(double difference, bool isVertical) { // Setup var random = new Random(22); double x = random.NextDouble(); double y = random.NextDouble(); var firstPoint = new Point2D(x, y); var secondPoint = new Point2D(x, y + difference); var segment = new Segment2D(firstPoint, secondPoint); // Call bool result = segment.IsVertical(); // Assert Assert.AreEqual(isVertical, result); }
public void IntersectWithSegment2D_SharedEndPoints_CloseToTolerance() { var edge1 = new Segment2D(new Point2D(Unit.Inches, 247.5672, 78.58992105222), new Point2D(Unit.Inches, 116.954391, 24.1687020923795)); var edge2 = new Segment2D(new Point2D(Unit.Inches, 266.817596, 70.540802), new Point2D(Unit.Inches, 247.5672, 78.5615942974942)); var intersection = edge1.IntersectWithSegment(edge2).CastTo <Point2D>(); intersection.Should().Be(edge1.BasePoint); intersection.Should().Be(edge2.EndPoint); }
public Triangle(Segment2D a, Segment2D b, Segment2D c) { Vertices = new Vector2[3]; Vertices[0] = a.PointA; Vertices[1] = a.PointB; if (b.PointA == a.PointA) { Vertices[2] = b.PointB; } else { Vertices[2] = b.PointA; } Init(); rotation = 0; }
/// <summary> /// Returns the furthest point of this polygon to a segment. /// </summary> /// <param name="segment"></param> /// <returns>The furthest point of this polygon to another segment.</returns> public virtual Vector2 FurthestPointFrom(Segment2D segment) { float furthestDistance = int.MinValue; int index = 0; for (int i = 0; i < Vertices.Length; i++) { float distance = segment.PerpendicularDistance(Vertices[i]); if (distance > furthestDistance) { furthestDistance = distance; index = i; } } return(Vertices[index]); }
/// <summary> /// Calculates the intersection point of a segment with this polygon. /// </summary> /// <param name="segment"></param> /// <returns>The intersection points of a segment with this polygon.</returns> public virtual List <Vector2> IntersectionPoints(Segment2D segment) { List <Vector2> intersections = new List <Vector2>(); Vector2 point; for (int i = 0; i < Edges.Length; i++) { point = segment.IntersectionPoint(Edges[i]); if (!point.IsNaN() && !point.IsInfinity()) { intersections.Add(point); } } return(intersections); }
/// <summary> /// Detects circles on gasket image /// </summary> private static void DetectCircles(Image gasketImage, out Circle2D[] detectedCircles, out Segment2D[] conntectingSegments, CoordinateSystem2D localSystem) { using (CircleFittingMap circleMap1 = new CircleFittingMap(), circleMap2 = new CircleFittingMap()) { AVL.CreateCircleFittingMap(new ImageFormat(gasketImage), new CircleFittingField(largeExpectedCircle, 35.0f), localSystem, 16, 5, InterpolationMethod.Bilinear, circleMap1); AVL.CreateCircleFittingMap(new ImageFormat(gasketImage), new CircleFittingField(smallExpectedCircle, 35.0f), localSystem, 16, 5, InterpolationMethod.Bilinear, circleMap2); Circle2D?largeCircle, smallCircle; AVL.FitCircleToEdges(gasketImage, circleMap1, scanParams, Selection.Best, 0.1f, CircleFittingMethod.GeometricLandau, out largeCircle); AVL.FitCircleToEdges(gasketImage, circleMap2, scanParams, Selection.Best, 0.1f, CircleFittingMethod.GeometricLandau, out smallCircle); conntectingSegments = new Segment2D[2]; if (largeCircle.HasValue && smallCircle.HasValue) { detectedCircles = new[] { largeCircle.Value, smallCircle.Value }; conntectingSegments[0] = new Segment2D(detectedCircles[0].Center, detectedCircles[1].Center); } else { detectedCircles = new Circle2D[0]; } } }
public void IntersectsBoundingRectangle(Segment2D segment, BoundingRectangle boundingRectangle, bool expectedResult, Point2 expectedIntersectionPoint) { Point2 actualIntersectionPoint; var actualResult = segment.Intersects(boundingRectangle, out actualIntersectionPoint); Assert.AreEqual(expectedResult, actualResult); if (actualResult) { Assert.AreEqual(expectedIntersectionPoint, actualIntersectionPoint); } else { Assert.IsTrue(float.IsNaN(actualIntersectionPoint.X)); Assert.IsTrue(float.IsNaN(actualIntersectionPoint.Y)); } }
// Revisar - Closest Point deberÃa ser el punto con menos distancia, no la intersección al centro. #region ClosestPointTo /// <summary> /// Returns the closest point of this polygon to a point. /// </summary> /// <param name="point"></param> /// <returns>The closest point of this polygon to a point.</returns> public virtual Vector2 ClosestPointTo(Vector2 point) { Segment2D cast = new Segment2D(Center, point); List <Vector2> intersections = IntersectionPoints(cast); if (intersections.Count == 0) // Point is inside polygon { Line2D line = new Line2D(Center, point); intersections = IntersectionPoints(line); return(Hedra.ClosestPoint(point, intersections)); } else if (intersections.Count == 1) { return(intersections[0]); } return(Hedra.ClosestPoint(point, intersections)); }
public void Property_IfSegmentsAreParallelAndIntersect_ItShouldBeAnEndPoint ( Segment2D segment1, Segment2D segment2 ) { var intersection = segment1.IntersectWithSegment(segment2); if ( segment1.GetDirection().IsParallelTo(segment2.GetDirection()) && intersection.Is <Point2D>(out var point2D)) { var point = point2D.ToPoint3D(); var isEndOfOneOf = point.IsBaseOrEndPointOf(segment1.To3D()) || point.IsBaseOrEndPointOf(segment2.To3D()); isEndOfOneOf.Should().BeTrue(); } }
public static double[] GetIntersectionAngles(Segment2D line, Circle2D circle) { Vector2D delta = line.GetDelta(); double num1 = delta.X * delta.X + delta.Y * delta.Y; Vector2D vector2D = line.Start - circle.Center; double num2 = 2.0 * (vector2D.X * delta.X + vector2D.Y * delta.Y); double num3 = vector2D.X * vector2D.X + vector2D.Y * vector2D.Y - circle.Radius * circle.Radius; double d = num2 * num2 - 4.0 * num1 * num3; if (d < 0.0) { return(new double[0]); } double num4 = System.Math.Sqrt(d); double num5 = (-num2 - num4) / (2.0 * num1); List <double> doubleList = new List <double>(2); if (num5 >= 0.0 && num5 <= 1.0) { double x = vector2D.X + delta.X * num5; double num6 = System.Math.Atan2(vector2D.Y + delta.Y * num5, x); if (num6 < 0.0) { num6 += 2.0 * System.Math.PI; } doubleList.Add(num6); } if (num4 != 0.0) { double num6 = (-num2 + num4) / (2.0 * num1); if (num6 >= 0.0 && num6 <= 1.0) { double x = vector2D.X + delta.X * num6; double num7 = System.Math.Atan2(vector2D.Y + delta.Y * num6, x); if (num7 < 0.0) { num7 += 2.0 * System.Math.PI; } doubleList.Add(num7); } } return(doubleList.ToArray()); }
internal static int smethod_0(Ray2D ray, Polyline2D polyline) { int num1 = 0; int num2 = polyline.Count + (polyline.Closed ? 1 : 0); int count = polyline.Count; Point2D start = polyline[0]; for (int index = 1; index < num2; ++index) { Point2D end = polyline[index % count]; Segment2D b = new Segment2D(start, end); if (Ray2D.Intersects(ray, b)) { ++num1; } start = end; } return(num1); }
protected virtual void CreateNormals() { if (Edges.Length <= 0) { return; } Normals = new Segment2D[Edges.Length]; for (int i = 0; i < Edges.Length; i++) { Vector2 middlePoint = Edges[i].MiddlePoint; // We look for the normal value furthest from the Center Vector2 normal = Hedra.FurthestObject(Edges[i].Normals.ToList(), (vector => { return(Vector2.Distance(middlePoint + vector, Center)); })); Normals[i] = new Segment2D(middlePoint, middlePoint + normal); } }
protected virtual Vector2 ComplexCollisionOffset(Polygon pastSelf, Polygon obstacle, Vector2 p_vertex, Vector2 o_vertex) { if (this.ContainsInEdge(o_vertex)) { return(obstacle.ClosestPerpendicularPointTo(p_vertex) - p_vertex); } if (obstacle.ContainsInEdge(p_vertex)) { return(o_vertex - this.ClosestPerpendicularPointTo(o_vertex)); } Vector2 vertexPathOffset = PathCollisionOffset(pastSelf, obstacle, p_vertex); if (vertexPathOffset.magnitude > 0 && CheckSolution(obstacle, vertexPathOffset)) { Debug.Log("A"); return(vertexPathOffset); } Vector2 obstaclePathOffset = ObstacleCollisionOffset(pastSelf, p_vertex, o_vertex); if (obstaclePathOffset.magnitude > 0 && CheckSolution(obstacle, obstaclePathOffset)) { Debug.Log("B"); return(obstaclePathOffset); } Vector2 obstacleSolution = ObstaclePerpendicularPointsOffsets(obstacle, p_vertex, o_vertex); if (obstacleSolution.magnitude > 0) { Debug.Log("C"); return(obstacleSolution); } Debug.Log("D"); Segment2D lastResort = new Segment2D(p_vertex, Center); Segment2D intersectingEdge = obstacle.IntersectingEdges(lastResort)[0]; return(intersectingEdge.PerpendicularPoint(p_vertex) - p_vertex); }
protected override bool InsideOrCrossingScreenPolygon(ScreenPolygonParams data) { // Computes the lines that are inside or crossing the screen polygon for (int i = 0; i < Lines.Length; i++) { Segment2D seg; IndexLine line = Lines[i]; Point3D pt1 = Vertices[line.V1]; Point3D pt2 = Vertices[line.V2]; Point3D screenP1 = vp.Camera.WorldToScreen(pt1, data.ViewFrame); Point3D screenP2 = vp.Camera.WorldToScreen(pt2, data.ViewFrame); if (screenP1.Z > 1 || screenP2.Z > 1) { return(false); // for perspective } seg = new Segment2D(screenP1, screenP2); if (UtilityEx.PointInPolygon(screenP1, data.ScreenPolygon) || UtilityEx.PointInPolygon(screenP2, data.ScreenPolygon)) { SelectedSubItems.Add(i); continue; } for (int j = 0; j < data.ScreenSegments.Count; j++) { Point2D i0; if (Segment2D.Intersection(data.ScreenSegments[j], seg, out i0)) { SelectedSubItems.Add(i); break; } } } return(false); }
public virtual Segment2D ClosestEdgeTo(Segment2D segment) { Vector2 closestVertex = ClosestVertexTo(segment); int vertexIndex = GetVertexIndex(closestVertex); int previousVertex = vertexIndex > 0 ? vertexIndex - 1 : Vertices.Length - 1; int nextVertex = vertexIndex < Vertices.Length - 1 ? vertexIndex + 1 : 0; float previousDistance = segment.PerpendicularDistance(Vertices[previousVertex]); float nextDistance = segment.PerpendicularDistance(Vertices[nextVertex]); if (previousDistance >= nextDistance) { return(new Segment2D(closestVertex, Vertices[previousVertex])); } else { return(new Segment2D(closestVertex, Vertices[nextVertex])); } }
private void Awake() { m_segments = new Segment2D[segmentCount]; for (int i = 0; i < segmentCount; i++) { if (i == 0) { m_segments[i] = new Segment2D(null, startTransform.position, segmentLength); } else { m_segments[i] = new Segment2D(m_segments[i - 1], Vector2.zero, segmentLength); } } for (int i = segmentCount - 2; i >= 0; i--) { m_segments[i].child = m_segments[i + 1]; } }
void OnDrawGizmos() { polygons = new List <Polygon>(); for (int i = 0; i < shapes.Count; i++) { polygons.Add(shapes[i].GetPolygon(this.transform)); } Gizmos.color = Color.white; DrawPolygons(); for (int i = 0; i < polygons.Count; i++) { Segment2D segment = new Segment2D(polygons[i].Center, point.position); DrawSegment(segment); ProcessPolygon(polygons[i], segment); } Gizmos.color = Color.white; }
private static Segment2D?smethod_0( Segment2D segment, BlinnClipper2D.IInsideTester insideTester) { bool flag1 = insideTester.IsInside(segment.Start); bool flag2 = insideTester.IsInside(segment.End); if (flag1) { if (flag2) { return(new Segment2D?(segment)); } return(new Segment2D?(new Segment2D(segment.Start, insideTester.GetIntersection(segment.Start, segment.End)))); } if (flag2) { return(new Segment2D?(new Segment2D(insideTester.GetIntersection(segment.End, segment.Start), segment.End))); } return(new Segment2D?()); }
void ProcessPolygon(Polygon P, Segment2D S) { if (P.ContainsInEdge(point.position)) { Gizmos.color = Color.red; } else if (P.Contains(point.position)) { Gizmos.color = Color.green; } else { Gizmos.color = Color.white; } Gizmos.DrawWireSphere(point.position, gizmosSize); DrawPointIntersections(P, S); DrawSegmentIntersections(P, S); }
protected virtual Vector2 PathCollisionOffset(Polygon pastSelf, Polygon obstacle, Vector2 p_vertex) { Segment2D p_vertexPath = new Segment2D(pastSelf.Vertices[GetVertexIndex(p_vertex)], p_vertex); List <Segment2D> o_edges = obstacle.IntersectingEdges(p_vertexPath); if (o_edges == null || o_edges.Count <= 0) { throw new ImpossibleCollisionException(); } Segment2D o_edge = o_edges[0]; Vector2 p_PPoint = o_edge.ToLine().PerpendicularPoint(p_vertex); if (o_edge.Contains(p_PPoint)) { Vector2 offset = p_PPoint - p_vertex; return(offset); } return(Vector2.zero); }
public void Property_NonNullResultIfAnyEndPointIsWithinDistanceToleranceOfOtherSegment ( Segment2D segment1, Segment2D segment2 ) { var intersection = segment1.IntersectWithSegment(segment2); var ends = Enumerable .Concat ( segment1.EndPoints.Where(e => e.ToPoint3D().DistanceTo(segment2.To3D()) == ZeroDistance), segment2.EndPoints.Where(e => e.ToPoint3D().DistanceTo(segment1.To3D()) == ZeroDistance) ) .ToList(); if (ends.Any()) { intersection.Should().NotBe(Null.Instance); } }
public static bool SegmentsLieOnTopOfEachOther(Segment2D firstSegment, Segment2D secondSegment) { bool onTop = false; Vector2D[] firstSegmentsVertices = firstSegment.GetVertices(); Vector2D firstSegmentsStart_A = firstSegmentsVertices[0]; Vector2D firstSegmentsEnd_B = firstSegmentsVertices[1]; Vector2D firstSegmentsDirection = firstSegmentsEnd_B.Difference(firstSegmentsStart_A); double firstsegmentsLength = firstSegmentsDirection.normalize(); Vector2D secondSegmentsStart_C = secondSegment.GetVertices()[0]; Vector2D secondSegmentsEnd_D = secondSegment.GetVertices()[1]; Vector2D secondSegmentsDirection = secondSegmentsEnd_D.Difference(secondSegmentsStart_C); double secondSegmentsLength = secondSegmentsDirection.normalize(); Vector2D vectorAC = secondSegmentsStart_C.Difference(firstSegmentsStart_A); Vector2D vectorAD = secondSegmentsEnd_D.Difference(firstSegmentsStart_A); if (VectorsAreLinearDependent(vectorAC, vectorAD)) { double cos = firstSegmentsDirection.Dot(secondSegmentsDirection) / (firstsegmentsLength * secondSegmentsLength); if (cos < 0) { firstSegmentsStart_A = firstSegmentsVertices[1]; firstSegmentsEnd_B = firstSegmentsVertices[0]; } vectorAC = secondSegmentsStart_C.Difference(firstSegmentsStart_A); Vector2D vectorDB = firstSegmentsEnd_B.Difference(secondSegmentsEnd_D); cos = vectorAC.Dot(vectorDB) / (vectorAC.normalize() * vectorDB.normalize()); if (cos > 0) { onTop = true; } } return(onTop); }
private static bool IsValidLoop(Segment2D[] segments) { int segmentCount = segments.Length; if (segmentCount == 2) { return(segments[0].Equals(segments[1])); } for (var i = 0; i < segmentCount; i++) { Segment2D segmentA = segments[i]; Segment2D segmentB = segments[(i + 1) % segmentCount]; if (!segmentA.SecondPoint.Equals(segmentB.FirstPoint)) { return(false); } } return(true); }
public static Segment2D GetLineSegment2D(Polygon2D polygon, int index) { Segment2D lineSegment = null; Vector2D[] polygonVertices = polygon.GetVertices(); Vector2D startPoint; Vector2D endPoint; if (index <= polygonVertices.Length - 2) { startPoint = polygonVertices[index]; endPoint = polygonVertices[index + 1]; lineSegment = CreateSegment2D(new Vector2D[] { startPoint, endPoint }, polygon.Name); } else { lineSegment = null; } return(lineSegment); }
private static IEnumerable <TestCaseData> GetSoilLayerWithInvalidGeometry() { var pointA = new Point2D(0.0, 0.0); var pointB = new Point2D(1.0, 0.0); var segmentOne = new Segment2D(pointA, pointB); var segmentTwo = new Segment2D(pointB, pointA); Segment2D[] validGeometry = { segmentOne, segmentTwo }; yield return(new TestCaseData(SoilLayer2DTestFactory.CreateSoilLayer2D(new IEnumerable <Segment2D> [0], Enumerable.Empty <Segment2D>()))); yield return(new TestCaseData(SoilLayer2DTestFactory.CreateSoilLayer2D(new[] { Enumerable.Empty <Segment2D>() }, validGeometry))); }
public override float GetParamAtPoint(Point2D pt) { for (int i = 1; i < Points.Count; i++) { float dist = (pt - Points[i - 1]).Length; Segment2D seg = new Segment2D(Points[i - 1], Points[i]); bool onSegment = seg.Contains(pt, PointOnLineTolerance, out float t); if (!onSegment && t < 0 && i - 1 == 0) { return(StartParam); } else if (!onSegment && t > 1 && i == Points.Count - 1) { return(EndParam); } else if (!onSegment) { continue; } float segmentLength = seg.Length; if (MathF.IsZero(dist)) { return(i - 1); } else if (MathF.IsEqual(dist, segmentLength)) { return(i); } else if (segmentLength > dist) { return(dist / segmentLength + (i - 1)); } } return(EndParam); }
private static List <Segment2D> toEdgeList(Rect aRect, List <Segment2D> boundSegments) { var result = new List <Segment2D>(); var cornerList = new List <Vector2>() { new Vector2(aRect.xMin, aRect.yMin), new Vector2(aRect.xMin, aRect.yMax), new Vector2(aRect.xMax, aRect.yMax), new Vector2(aRect.xMax, aRect.yMin), }; for (int i = 0; i < 4; i++) { var tRay = new Segment2D(cornerList[i], cornerList[(i + 1) % 4]); if (boundSegments.Any(x => tRay.getRightAngleOverlap(x).HasValue)) { continue; } result.Add(tRay); } return(result); }
internal static bool IsInside(Point2D p, Polyline3D polyline) { if (polyline == null) { return(false); } int num1 = 0; Ray2D a = new Ray2D(p, Vector2D.XAxis); int num2 = polyline.Count + (polyline.Closed ? 1 : 0); int count = polyline.Count; Point3D point3D1 = polyline[0]; for (int index = 1; index < num2; ++index) { Point3D point3D2 = polyline[index % count]; Segment2D b = new Segment2D(point3D1.X, point3D1.Y, point3D2.X, point3D2.Y); if (Ray2D.Intersects(a, b)) { ++num1; } point3D1 = point3D2; } return(num1 % 2 == 1); }
protected List <VertexNetwork2D> BuildNetworks(Triangulation2D tri, Dictionary <Vertex2D, VertexNetwork2D> networkTable) { var network = new Dictionary <Vertex2D, HashSet <Vertex2D> >(); var triangles = tri.Triangles; for (int i = 0, n = triangles.Length; i < n; i++) { var t = triangles[i]; Segment2D s0 = t.s0, s1 = t.s1, s2 = t.s2; if (!network.ContainsKey(t.a)) { network.Add(t.a, new HashSet <Vertex2D>()); } if (!network.ContainsKey(t.b)) { network.Add(t.b, new HashSet <Vertex2D>()); } if (!network.ContainsKey(t.c)) { network.Add(t.c, new HashSet <Vertex2D>()); } network[s0.a].Add(s0.b); network[s0.b].Add(s0.a); network[s1.a].Add(s1.b); network[s1.b].Add(s1.a); network[s2.a].Add(s2.b); network[s2.b].Add(s2.a); } return(network.Keys.Select(v => { var n = networkTable[v]; foreach (Vertex2D to in network[v]) { n.Connect(networkTable[to]); } return n; }).ToList()); }
public void DrawLine(Segment2D segment) { this.DrawLine(segment.Start, segment.End); }
public void DrawLineCentered(Segment2D segment, Color color, float lineThickness) { this.DrawLineCentered(segment.Start, color, FlaiMath.GetAngle(segment.Direction), segment.Length(), lineThickness); }
void CollectVertices () { // Collect all gameobjects, with tag Wall GameObject[] gos = GameObject.FindGameObjectsWithTag("Wall"); // Get all vertices from those gameobjects // WARNING: Should only use 2D objects, like unity Quads for now.. foreach (GameObject go in gos) { Mesh goMesh = go.GetComponent<MeshFilter>().mesh; int[] tris = goMesh.triangles; List<int> uniqueTris = new List<int>(); uniqueTris.Clear(); // Collect unique tri's for (int i = 0; i < tris.Length; i++) { if (!uniqueTris.Contains(tris[i])) { uniqueTris.Add(tris[i]); } } // for tris // Sort by pseudoangle List<pseudoObj> all = new List<pseudoObj>(); for (int n=0;n<uniqueTris.Count;n++) { float x= goMesh.vertices[uniqueTris[n]].x; float y= goMesh.vertices[uniqueTris[n]].y; float a = copysign(1-x/(Mathf.Abs (x)+Mathf.Abs(y)),y); pseudoObj o = new pseudoObj(); o.pAngle = a; o.point = goMesh.vertices[uniqueTris[n]]; all.Add(o); } // Actual sorting all.Sort(delegate(pseudoObj c1, pseudoObj c2) { return c1.pAngle.CompareTo(c2.pAngle); }); // Get unique vertices to list List<Vector3> uniqueVerts = new List<Vector3>(); uniqueTris.Clear(); for (int n=0;n<all.Count;n++) { uniqueVerts.Add(all[n].point); } // Add world borders int tempRange = 990; Camera cam = Camera.main; Vector3 b1 = cam.ScreenToWorldPoint(new Vector3(-tempRange, -tempRange, Camera.main.nearClipPlane + 0.1f+tempRange)); // bottom left Vector3 b2 = cam.ScreenToWorldPoint(new Vector3(-tempRange, cam.pixelHeight+tempRange, cam.nearClipPlane + 0.1f+tempRange)); // top left Vector3 b3 = cam.ScreenToWorldPoint(new Vector3(cam.pixelWidth+tempRange, cam.pixelHeight, cam.nearClipPlane + 0.1f+tempRange)); // top right Vector3 b4 = cam.ScreenToWorldPoint(new Vector3(cam.pixelWidth+tempRange, -tempRange, cam.nearClipPlane + 0.1f+tempRange)); // bottom right // Get world borders as vertices Segment2D seg1 = new Segment2D(); seg1.a = new Vector2(b1.x,b1.y); seg1.b = new Vector2(b2.x,b2.y); segments.Add(seg1); seg1.a = new Vector2(b2.x,b2.y); seg1.b = new Vector2(b3.x,b3.y); segments.Add(seg1); seg1.a = new Vector2(b3.x,b3.y); seg1.b = new Vector2(b4.x,b4.y); segments.Add(seg1); seg1.a = new Vector2(b4.x,b4.y); seg1.b = new Vector2(b1.x,b1.y); segments.Add(seg1); // Get segments from unique vertices for (int n=0;n<uniqueVerts.Count;n++) { // Segment start Vector3 wPos1 = go.transform.TransformPoint(uniqueVerts[n]); // Segment end Vector3 wPos2 = go.transform.TransformPoint(uniqueVerts[(n+1) % uniqueVerts.Count]); // TODO: duplicate of unique verts? uniquePoints.Add(wPos1); Segment2D seg = new Segment2D(); seg.a = new Vector2(wPos1.x,wPos1.y); seg.b = new Vector2(wPos2.x, wPos2.y); segments.Add(seg); //GLDebug.DrawLine(wPos1, wPos2,Color.white,10); } } // foreach gameobject } // CollectVertices
} // CollectVertices // Find intersection of RAY & SEGMENT Intersection getIntersection(Ray2D ray, Segment2D segment) { Intersection o = new Intersection(); // RAY in parametric: Point + Delta*T1 float r_px = ray.a.x; float r_py = ray.a.y; float r_dx = ray.b.x-ray.a.x; float r_dy = ray.b.y-ray.a.y; // SEGMENT in parametric: Point + Delta*T2 float s_px = segment.a.x; float s_py = segment.a.y; float s_dx = segment.b.x-segment.a.x; float s_dy = segment.b.y-segment.a.y; // Are they parallel? If so, no intersect var r_mag = Mathf.Sqrt(r_dx*r_dx+r_dy*r_dy); var s_mag = Mathf.Sqrt(s_dx*s_dx+s_dy*s_dy); if(r_dx/r_mag==s_dx/s_mag && r_dy/r_mag==s_dy/s_mag) // Unit vectors are the same { return o; } // SOLVE FOR T1 & T2 // r_px+r_dx*T1 = s_px+s_dx*T2 && r_py+r_dy*T1 = s_py+s_dy*T2 // ==> T1 = (s_px+s_dx*T2-r_px)/r_dx = (s_py+s_dy*T2-r_py)/r_dy // ==> s_px*r_dy + s_dx*T2*r_dy - r_px*r_dy = s_py*r_dx + s_dy*T2*r_dx - r_py*r_dx // ==> T2 = (r_dx*(s_py-r_py) + r_dy*(r_px-s_px))/(s_dx*r_dy - s_dy*r_dx) var T2 = (r_dx*(s_py-r_py) + r_dy*(r_px-s_px))/(s_dx*r_dy - s_dy*r_dx); var T1 = (s_px+s_dx*T2-r_px)/r_dx; // Must be within parametic whatevers for RAY/SEGMENT if(T1<0) return o; if(T2<0 || T2>1) return o; o.v = new Vector3(r_px+r_dx*T1, r_py+r_dy*T1, 0); o.angle = T1; // Return the POINT OF INTERSECTION return o; } // getIntersection
//----------------------------------------------------------------------- // //ORIGINAL LINE: void _findAllIntersections(const Shape& STLAllocator<U, AllocPolicy>, List<IntersectionInShape>& intersections) const private void _findAllIntersections(Shape other, ref std_vector<IntersectionInShape> intersections) { for (ushort i = 0; i < getSegCount(); i++) { Segment2D seg1 = new Segment2D(getPoint(i), getPoint(i + 1)); for (ushort j = 0; j < other.getSegCount(); j++) { Segment2D seg2 = new Segment2D(other.getPoint(j), other.getPoint(j + 1)); Vector2 intersect = new Vector2(); if (seg1.findIntersect(seg2, ref intersect)) { IntersectionInShape inter = new IntersectionInShape(i, j, intersect); // check if intersection is "borderline" : too near to a vertex if ((seg1.mA - intersect).SquaredLength < 1e-8) { inter.onVertex[0] = true; } if ((seg1.mB - intersect).SquaredLength < 1e-8) { inter.onVertex[0] = true; inter.index[0]++; } if ((seg2.mA - intersect).SquaredLength < 1e-8) { inter.onVertex[1] = true; } if ((seg2.mB - intersect).SquaredLength < 1e-8) { inter.onVertex[1] = true; inter.index[1]++; } intersections.push_back(inter); } } } }
public void DrawLine(Segment2D segment, Color color) { this.DrawLine(segment.Start, segment.End, color); }
private static bool DoesSegmentIntersectWithSegmentArray(Segment2D segment, Segment2D[] segmentArray) { // Consider intersections and overlaps similarly return(segmentArray.Any(sls => Math2D.GetIntersectionBetweenSegments(segment, sls).IntersectionType != Intersection2DType.DoesNotIntersect)); }
public void DrawLine(Segment2D segment, Color color, float lineThickness) { this.DrawLine(segment.Start, segment.End, color, lineThickness); }