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