private void OnDrawGizmos() { Polygon2 pol0 = CreatePolygon2(Points0); Polygon2 pol1 = CreatePolygon2(Points1); Orientations orientation0; bool pol0Convex = pol0.IsConvex(out orientation0); Orientations orientation1; bool pol1Convex = pol1.IsConvex(out orientation1); FiguresColor(); DrawPolygon(pol0); DrawPolygon(pol1); if (pol0Convex && pol1Convex && orientation0 == Orientations.CCW && orientation1 == Orientations.CCW) { bool test = Intersection.TestConvexPolygon2ConvexPolygon2(pol0, pol1); Logger.LogInfo("Intersection: " + test); } else { Logger.LogError("Polygons are incorrect." + " Pol0Convex: " + pol0Convex + " Pol0Ori: " + orientation0 + " Pol1Convex: " + pol1Convex + " Pol1Ori: " + orientation1); } }
List <Polygon2> TileColliderDataToPolygons(TileColliderData tileColliderData, Vector2 scale) { List <Polygon2> polygons = new List <Polygon2>(); if (tileColliderData.vertices.Length > 0) { Polygon2 polygon = new Polygon2(tileColliderData.vertices.Length); for (int i = 0; i < tileColliderData.vertices.Length; i++) { Vector2 v = tileColliderData.vertices[i]; polygon.points[i] = v; } if (scale != Vector2.one) { polygon.ToScaleSelf(scale); } polygons.Add(polygon); } return(polygons); }
/// <summary> /// Checks what entities if any intersect any of the specified traces /// </summary> /// <param name="traces">The set of traces to check</param> /// <param name="from">Where the traces start at</param> /// <param name="excludeIds">The set of collidable ids which are excluded from this search</param> /// <param name="excludeFlags">Collidables with any of these flags are excluded</param> /// <returns>A list of all collidables inside any of the specified traces</returns> public List <T> TraceExhaust(List <Polygon2> traces, Vector2 from, HashSet <int> excludeIds, long excludeFlags) { List <T> result = new List <T>(); int tracesLen = traces.Count; for (int i = 0, len = Collidables.Count; i < len; i++) { T collidable = Collidables[i]; if (excludeIds.Contains(collidable.ID)) { continue; } if ((collidable.Flags & excludeFlags) != 0) { continue; } for (int j = 0; j < tracesLen; j++) { if (Polygon2.Intersects(collidable.Bounds, traces[j], collidable.Position, from, true)) { result.Add(collidable); break; } } } return(result); }
/// <summary> /// Checks if there are any entities intersecting any of the given polygons which do not have an ID /// in excludeIds and do not have any of the exclude flags. /// /// Returns true if there are no intersecting entities, returns false if there are intersecting entities /// </summary> /// <param name="traces">The polygons to check if any entities intersect</param> /// <param name="from">The offset for the traces</param> /// <param name="excludeIds">Ids of collidables which will be excluded in this check</param> /// <param name="excludeFlags">Any collibable which has any of these flags is excluded from this check</param> /// <returns>True if there are entities in traces located at from, False otherwise</returns> public bool Trace(List <Polygon2> traces, Vector2 from, HashSet <int> excludeIds, long excludeFlags) { int tracesLen = traces.Count; for (int i = 0, len = Collidables.Count; i < len; i++) { T collidable = Collidables[i]; if (excludeIds.Contains(collidable.ID)) { continue; } if ((collidable.Flags & excludeFlags) != 0) { continue; } for (int j = 0; j < tracesLen; j++) { if (Polygon2.Intersects(collidable.Bounds, traces[j], collidable.Position, from, true)) { return(false); } } } return(true); }
public static List <Polygon2> CreateFromCompositeCollider(CompositeCollider2D compositeCollider) { List <Polygon2> list = new List <Polygon2>(); if (compositeCollider != null) { int pathCount = compositeCollider.pathCount; for (int i = 0; i < pathCount; i++) { int pointCount = compositeCollider.GetPathPointCount(i); Vector2[] pointsInPath = new Vector2[pointCount]; compositeCollider.GetPath(i, pointsInPath); Polygon2 polygon = new Polygon2(pointsInPath); polygon.Normalize(); list.Add(polygon); } } return(list); }
public void InitializeColliders() { localColliders.Clear(); worldColliders.Clear(); colliderTransform.Clear(); foreach (Transform transform in gameObject.transform) { EdgeCollider2D[] edgeColliders = transform.GetComponents <EdgeCollider2D>(); PolygonCollider2D[] polygonColliders = transform.GetComponents <PolygonCollider2D>(); if (edgeColliders.Length > 0) { foreach (EdgeCollider2D collider in edgeColliders) { Polygon2 poly = Polygon2ListCollider2D.CreateFromEdgeCollider(collider); localColliders.Add(poly); colliderTransform.Add(transform); } } if (polygonColliders.Length > 0) { foreach (PolygonCollider2D collider in polygonColliders) { Polygon2 poly = Polygon2ListCollider2D.CreateFromPolygonColliderToLocalSpace(collider)[0]; localColliders.Add(poly); colliderTransform.Add(transform); } } } }
static private void ShadowForVertex(Polygon2 polygon, Vector2 position) { Vector2[] pointsList = polygon.points; int pointsCount = pointsList.Length; for (int x = 0; x < pointsCount; x++) { pair.A.x = pointsList[(x) % pointsCount].x + position.x; pair.A.y = pointsList[(x) % pointsCount].y + position.y; pair.B.x = pointsList[(x + 2) % pointsCount].x + position.x; pair.B.y = pointsList[(x + 2) % pointsCount].y + position.y; Pair2D edge_world = pair; Vector2 edgePosition; edgePosition.x = (float)(pair.A.x + pair.B.x) / 2; edgePosition.y = (float)(pair.A.y + pair.B.y) / 2; float edgeRotation = (float)Math.Atan2(pair.B.y - pair.A.y, pair.B.x - pair.A.x); float edgeSize = (float)Vector2D.Distance(pair.A, pair.B) / 2; pass.edgePosition = edgePosition; pass.edgeRotation = edgeRotation; pass.edgeSize = edgeSize; pass.coreSize = ShadowEngine.light.coreSize; pass.Generate(); pass.SetVars(); pass.Draw(); } }
public static void Main(string[] args) { // var canvas = host.CreateAndAddCanvas(0); // var smp = SectorMetadataPresets.Blank2D; // var punchResult = PolygonOperations.Punch() // .Include(smp.LocalIncludedContours) //// .Exclude(smp.LocalExcludedContours) // .Exclude(Polygon2.CreateRect(-10000, -10000, 20000, 20000)) // .Exclude(new []{(Polygon2.CreateRect(-8000, -8000, 16000, 16000), true)}) // .Execute(); // // canvas.Transform = Matrix4x4.CreateScale(500 / 60000.0f) * Matrix4x4.CreateTranslation(500, 300, 0); // canvas.DrawPolyNode(punchResult); // return; //var subjectPolygon = Polygon2.CreateCircle(0, 0, 100, 16); var n = 128; var random = new Random(0); var subjectPolygon = new Polygon2( Util.Generate( n, i => DoubleVector2.FromRadiusAngle(random.Next(10, 150), -i * Math.PI * 2 / n).LossyToIntVector2()) .ToList()); var clipPolygon = Polygon2.CreateRect(-80, -80, 160, 160); RenderSomething(0, subjectPolygon, clipPolygon); var offsetSubjectPolygon = new Polygon2(subjectPolygon.Points.Map(p => new IntVector2(0, 240) + p).ToList()); RenderSomething(1, offsetSubjectPolygon, clipPolygon); }
public PolyPairTestData(string name, Polygon2 a, Polygon2 b, Polygon2 r) { Name = name; A = a; B = b; R = r; }
void TryCastHealingStrike(JToken parsed) { if (Entity.SpellCooldowns.ContainsKey(SpellFactory.HEALING_STRIKE_INDEX)) { return; } var currWorld = Program.State.World; var currEnt = currWorld.GetByID(Entity.ID); if (!ManaCheck(currEnt, SpellFactory.HEALING_STRIKE_MANA)) { return; } Vector2 target = new Vector2((float)parsed[2]["x"], (float)parsed[2]["y"]); var mind = Polygon2.MinDistance(currEnt.Attributes.Bounds, currEnt.Location, target); if (mind != null && mind.Item2 > SpellFactory.HEALING_STRIKE_RANGE) { return; } var mut = new EntityCastSpellMutation(Entity.ID, SpellFactory.CreateHealingStrike(target)); Program.QueuedMutations[mut.Time].Enqueue(mut); _CastingSpell = true; UpdateVelocity(); }
static void Main(string[] args) { Console.WriteLine("Fact: " + (GeometryFactory2Double.Instance != null)); GeometryFactory2Base <double> factory = GeometryFactory2Double.Instance; Console.WriteLine("Factory is " + (factory == null ? "null" : "not null")); if (factory != null) { Point2 <double> pt = factory.ConstructPoint(43, 22); Console.WriteLine("Created point: " + pt.ToString()); Ring2 <double> rg = factory.ConstructRing(new Point2 <double>[] { factory.ConstructPoint(22.45, 33.33), factory.ConstructPoint(23.45, 33.33), factory.ConstructPoint(22.45, 35.33) }); Polygon2 <double> pl = factory.ConstructPolygon(rg); if (rg != null) { Console.WriteLine("Created ring: " + rg.ToString()); object o = Osrs.Numerics.Spatial.Postgres.NpgSpatialUtils.ToPGis(rg); Console.WriteLine("Created PG Geometry: " + (o != null).ToString()); } if (pl != null) { Console.WriteLine(GeoJsonUtils.ToGeoJson(pl).ToString()); } } Console.WriteLine("ALL DONE"); Console.ReadLine(); }
private Polygon2 FindUntouchedRingsB() { Contract.Ensures(Contract.Result <IEnumerable <Ring2> >() != null); if (VisitedCrossingsRingIndicesB.Count == 0) { return(B); } var missingCount = B.Count - VisitedCrossingsRingIndicesB.Count; var results = new Polygon2(missingCount); if (missingCount == 0) { return(results); } for (int i = 0; i < B.Count; i++) { if (!VisitedCrossingsRingIndicesB.Contains(i)) { results.Add(B[i]); } } return(results); }
private IntersectionResults BuildFinalResults(Polygon2 intersectedPolygon) { Contract.Requires(intersectedPolygon != null); Contract.Ensures(Contract.Result <IntersectionResults>() != null); Contract.Ensures(intersectedPolygon.Count >= Contract.OldValue(intersectedPolygon).Count); if (intersectedPolygon.Count == 0) { var untouchedA = FindUntouchedRingsA(); var untouchedB = FindUntouchedRingsB(); intersectedPolygon.AddRange(QualifyRings(untouchedA, untouchedB, true)); intersectedPolygon.AddRange(QualifyRings(untouchedB, untouchedA, false)); } else { var intersectedResultTree = new RingBoundaryTree(intersectedPolygon); intersectedPolygon.AddRange( FilterQualifiedRingsToBoundaryTree( QualifyRings(FindUntouchedRingsA(), B, true), intersectedResultTree ) ); intersectedPolygon.AddRange( FilterQualifiedRingsToBoundaryTree( QualifyRings(FindUntouchedRingsB(), A, false), intersectedResultTree ) ); } return(new IntersectionResults { Polygon = intersectedPolygon }); }
private void OnDrawGizmos() { List <Vector2> pointsList = new List <Vector2>(); foreach (Transform tr in Points) { if (tr != null) { pointsList.Add(tr.position); } } Polygon2 pol = new Polygon2(pointsList.ToArray()); Gizmos.color = Color.gray; for (int i0 = 0, i1 = pol.VertexCount - 1; i0 < pol.VertexCount; i1 = i0, i0++) { Gizmos.DrawLine(pol[i0], pol[i1]); } Orientations or; bool convex = pol.IsConvex(out or); bool hasDegen = pol.HasZeroCorners(); Logger.LogInfo("Area: " + pol.CalcArea() + " Per: " + pol.CalcPerimeter() + " Convex: " + convex + " Orient: " + or + " ZeroCorners: " + hasDegen); }
static public List <Polygon2> CreateFromPolygonColliderToLocalSpace(PolygonCollider2D collider) { List <Polygon2> result = new List <Polygon2>(); if (collider != null && collider.pathCount > 0) { Vector2[] array = collider.GetPath(0); Polygon2 newPolygon = new Polygon2(array.Length); for (int i = 0; i < array.Length; i++) { Vector2 p = array[i]; newPolygon.points[i] = (p + collider.offset); } result.Add(newPolygon); for (int i = 1; i < collider.pathCount; i++) { Vector2[] arrayHole = collider.GetPath(i); Polygon2 hole = new Polygon2(arrayHole.Length); for (int x = 0; x < arrayHole.Length; x++) { hole.points[i] = arrayHole[x] + collider.offset; } result.Add(hole); } } return(result); }
private static List <Ring2> QualifyRings( Polygon2 untouchedRings, Polygon2 polygon, bool qualifyEqual ) { Contract.Requires(untouchedRings != null); Contract.Requires(polygon != null); Contract.Ensures(Contract.Result <List <Ring2> >() != null); Contract.Ensures(Contract.ForAll(Contract.Result <List <Ring2> >(), x => null != x)); var result = new List <Ring2>(); var ringTree = new RingBoundaryTree(polygon); foreach (var ring in untouchedRings) { Contract.Assume(ring != null); // TODO: speed this up through some kind of magic, like RingBoundaryTree or something // TODO: var eq = new SpatialEqualityComparerThing(ringA); var stuff = otherRings.Where(r = > eq.SpatiallyEqual(r)); if (polygon.Any(r => ring.SpatiallyEqual(r))) { if (qualifyEqual) { result.Add(ring.Clone()); } } else if (ringTree.NonIntersectingContains(ring)) { result.Add(ring.Clone()); } } Contract.Assume(Contract.ForAll(result, x => null != x)); return(result); }
/// <summary> /// Find a smallest bounding rectangle. /// </summary> /// <returns></returns> public Vector2[] FindBounds(Polygon2 polygon) { if (polygon == null) { throw new ArgumentNullException("polygon"); } var minified = new Polygon2(polygon.ToVertices().Distinct()); minified.OrientCounterClockwise(); var vertices = minified.ToVertices().ToArray(); if (vertices.Count() == 0) { return(new Vector2[0]); } // This algorithm assumes the polygon is oriented counter-clockwise. // Get ready; ResetBoundingRect(vertices); // Check all possible bounding rectangles. for (int i = 0; i < vertices.Count(); i++) { CheckNextBoundingRectangle(vertices); } // Return the best result. return(_bestRectangle); }
/// <summary> /// Load existing collision /// </summary> /// <param name="buffer"></param> public void Load(byte[] buffer) { try { using (BinaryReader b = new BinaryReader(new MemoryStream(buffer))) { var polygonCount = b.ReadInt32(); for (int i = 0; i < polygonCount; i++) { var polygon = new Polygon2(); var pointNum = b.ReadInt32(); for (int p = 0; p < pointNum; p++) { var point = new K2DPosition(); point.X = b.ReadInt32(); point.Y = b.ReadInt32(); polygon.Points.Add(point); } Polygons.Add(polygon); } } XLog.WriteLine(Levels.Good, "Ok"); } catch (Exception exception) { Blank(); XLog.WriteLine(Levels.Error, "Failed"); XLog.WriteLine(Levels.Fatal, "NfaManager::Load<Exception> -> {0}", exception); } }
static public List <Polygon2> CreateFromMeshCollider(MeshCollider meshCollider) { List <Polygon2> newPolygons = new List <Polygon2>(); Vector2 size = new Vector2(1, 1); Vector2 offset = Vector2.zero; Mesh mesh = meshCollider.sharedMesh; int length = mesh.triangles.GetLength(0); for (int i = 0; i < length; i = i + 3) { Vector2 vecA = mesh.vertices [mesh.triangles [i]]; Vector2 vecB = mesh.vertices [mesh.triangles [i + 1]]; Vector2 vecC = mesh.vertices [mesh.triangles [i + 2]]; Polygon2 poly = new Polygon2(3); poly.points[0] = vecA; poly.points[1] = vecB; poly.points[2] = vecC; newPolygons.Add(poly); } return(newPolygons); }
protected void DrawPolygon(Polygon2 polygon) { for (int i0 = 0, i1 = polygon.VertexCount - 1; i0 < polygon.VertexCount; i1 = i0, ++i0) { Gizmos.DrawLine(polygon[i0], polygon[i1]); } }
private void OnDrawGizmos() { Ray2 ray = CreateRay2(Ray); Polygon2 polygon = CreatePolygon2(Polygon); Ray2Polygon2Intr info; bool find = Intersection.FindRay2Polygon2(ref ray, polygon, out info); FiguresColor(); DrawRay(ref ray); DrawPolygon(polygon); if (find) { ResultsColor(); if (info.IntersectionType == IntersectionTypes.Point) { DrawPoint(info.Point0); } else if (info.IntersectionType == IntersectionTypes.Segment) { DrawSegment(info.Point0, info.Point1); DrawPoint(info.Point0); DrawPoint(info.Point1); } } LogInfo(info.IntersectionType); }
public static void DrawPolygonContour(this IDebugCanvas canvas, Polygon2 poly, StrokeStyle strokeStyle) { for (var i = 0; i < poly.Points.Count - 1; i++) { canvas.DrawLineStrip(poly.Points.Map(ToDV3), strokeStyle); } }
public PolyPairTestData(RingPairTestData data, Polygon2 result) { Name = data.Name; A = new Polygon2(data.A); B = new Polygon2(data.B); R = null == result ? null : new Polygon2(result); CrossingPoints = (data.CrossingPoints ?? Enumerable.Empty<Point2>()).ToList(); }
private Polygon2 GetRectPolygon() { if (rectPolygon == null) { rectPolygon = new Polygon2(4); } return(rectPolygon); }
public List <Polygon2> GetWorldPolygons(LightTilemapCollider.Base tilemap) { if (worldPolygons == null) { List <Polygon2> localPolygons = GetLocalPolygons(tilemap); if (worldPolygonsCache == null) { worldPolygons = new List <Polygon2>(); worldPolygonsCache = worldPolygons; UpdateTransform(tilemap); foreach (Polygon2 polygon in localPolygons) { Polygon2 worldPolygon = polygon.Copy(); if (scale != Vector2.one) { worldPolygon.ToScaleSelf(scale); } worldPolygon.ToScaleSelf(worldScale); worldPolygon.ToRotationSelf((tilemap.transform.eulerAngles.z + rotation) * Mathf.Deg2Rad); worldPolygon.ToOffsetSelf(worldPosition.Value); worldPolygons.Add(worldPolygon); } } else { worldPolygons = worldPolygonsCache; UpdateTransform(tilemap); for (int i = 0; i < localPolygons.Count; i++) { Polygon2 polygon = localPolygons[i]; Polygon2 worldPolygon = worldPolygons[i]; for (int j = 0; j < polygon.points.Length; j++) { worldPolygon.points[j].x = polygon.points[j].x; worldPolygon.points[j].y = polygon.points[j].y; } if (scale != Vector2.one) { worldPolygon.ToScaleSelf(scale); } worldPolygon.ToScaleSelf(worldScale); worldPolygon.ToRotationSelf(tilemap.transform.eulerAngles.z * Mathf.Deg2Rad); worldPolygon.ToOffsetSelf(worldPosition.Value); } } } return(worldPolygons); }
public static VisualPolygon Create(Polygon2 poly, Pen pen = null, Brush brush = null) { return(new VisualPolygon(poly) { Pen = pen, FillBrush = brush }); }
internal override bool Overlaps(OverlapShape otherShape) { if (otherShape is OverlapBox b) { return(Polygon2.Intersects(b.Poly, Poly, b.Pos, Pos, b.Rot, Rot, false)); } return(false); }
public PolyPairTestData(RingPairTestData data, Polygon2 result) { Name = data.Name; A = new Polygon2(data.A); B = new Polygon2(data.B); R = null == result ? null : new Polygon2(result); CrossingPoints = (data.CrossingPoints ?? Enumerable.Empty <Point2>()).ToList(); }
private static Polygon2 ReverseWinding(Polygon2 p) { if (null == p) { return(null); } return(new Polygon2(p.Select(ReverseWinding))); }
public static PostgisPolygon ToPGis(Polygon2 <double> geom) { if (geom != null) { return(new PostgisPolygon(Points(geom))); } return(null); }
public Polygon2 ToWorldSpace(Transform transform) { Polygon2 newPolygon = this.Copy(); newPolygon.ToWorldSpaceSelf(transform); return(newPolygon); }
private static string PolygonToString(Polygon2 poly) { var sb = new StringBuilder(); for (int index = 0; index < poly.Count; index++) { var ring = poly[index]; sb.AppendFormat("Ring {0}:\n", index); sb.AppendLine(RingToString(ring)); } return sb.ToString(); }
/// <summary> /// Calculates the resulting union of two polygon geometries. /// </summary> /// <param name="a">A polygon.</param> /// <param name="b">A polygon.</param> /// <returns>The union of <paramref name="a"/> and <paramref name="b"/>.</returns> public IPlanarGeometry Union(Polygon2 a, Polygon2 b) { Contract.Ensures((a != null || b != null) || Contract.Result<IPlanarGeometry>() == null); if (null == a) return b; if (null == b) return a; var result = InverseIntersectionOperation.Intersect(a, b) as Polygon2; return result; }
/// <summary> /// Calculates the symmetric difference between two polygons. /// </summary> /// <param name="a">A polygon.</param> /// <param name="b">A polygon.</param> /// <returns>The symmetric difference of <paramref name="a"/> and <paramref name="b"/>.</returns> public IPlanarGeometry Xor(Polygon2 a, Polygon2 b) { if (null == a) return b; if (null == b) return a; var removedFromA = _differenceOperation.Difference(a, b) as Polygon2; var removedFromB = _differenceOperation.Difference(b, a) as Polygon2; var unionedLeftovers = _unionOperation.Union(removedFromA, removedFromB); return unionedLeftovers; }
public void TestPolygon() { Polygon2 poly = new Polygon2() { vertices = new Vector2[]{ new Vector2(1, 1), new Vector2(2, 1), new Vector2(1, 2) } }; Assert.IsTrue(poly.Contains(new Vector2(1.1f, 1.1f))); Assert.IsTrue(poly.Contains(new Vector2(1.1f, 1.8f))); Assert.IsTrue(poly.Contains(new Vector2(1.49f, 1.49f))); Assert.IsFalse(poly.Contains(new Vector2(1.51f, 1.51f))); Assert.IsFalse(poly.Contains(new Vector2(0f, 0f))); Assert.IsTrue(poly.Contains(new Vector2(1f, 1f))); }
private static Polygon2 ReverseWinding(Polygon2 p) { if (null == p) return null; return new Polygon2(p.Select(ReverseWinding)); }
/// <summary> /// Builds required crossing data. /// </summary> /// <param name="crossings">The crossings to calculate. (Note: collection is modified)</param> /// <param name="a">The left hand polygon.</param> /// <param name="b">The right hand polygon.</param> private PolygonCrossingsAlgorithmKernel CreateIntersectionKernelFromCrossings(List<PolygonCrossing> crossings, Polygon2 a, Polygon2 b) { Contract.Requires(crossings != null); Contract.Requires(a != null); Contract.Requires(b != null); Contract.Ensures(Contract.Result<PolygonCrossingsAlgorithmKernel>() != null); var kernel = new PolygonCrossingsAlgorithmKernel(a, b, crossings); if (crossings.Count == 0) return kernel; foreach (var currentCrossing in crossings) { var ringIndexA = currentCrossing.LocationA.RingIndex; Contract.Assume(ringIndexA < a.Count); var ringA = a[ringIndexA]; Contract.Assume(ringA != null); var crossingsOnRingA = kernel.RingCrossingsA.Get(ringIndexA); var priorPointA = FindPreviousRingPoint(currentCrossing, crossingsOnRingA, ringA, GetLocationA, PolygonCrossing.LocationAComparer.Default); var nextPointA = FindNextRingPoint(currentCrossing, crossingsOnRingA, ringA, GetLocationA, PolygonCrossing.LocationAComparer.Default); var ringIndexB = currentCrossing.LocationB.RingIndex; Contract.Assume(ringIndexB < b.Count); var ringB = b[ringIndexB]; Contract.Assume(ringB != null); var crossingsOnRingB = kernel.RingCrossingsB.Get(ringIndexB); var priorPointB = FindPreviousRingPoint(currentCrossing, crossingsOnRingB, ringB, GetLocationB, PolygonCrossing.LocationBComparer.Default); var nextPointB = FindNextRingPoint(currentCrossing, crossingsOnRingB, ringB, GetLocationB, PolygonCrossing.LocationBComparer.Default); // based on the vectors, need to classify the crossing type currentCrossing.CrossType = PolygonCrossing.DetermineCrossingType( (nextPointA - currentCrossing.Point).GetNormalized(), (priorPointA - currentCrossing.Point).GetNormalized(), (nextPointB - currentCrossing.Point).GetNormalized(), (priorPointB - currentCrossing.Point).GetNormalized() ); } foreach (var ringCrossings in kernel.RingCrossingsA.RingCrossings) { Contract.Assume(ringCrossings.Key >= 0 && ringCrossings.Key < a.Count); if (a[ringCrossings.Key].FillSide == RelativeDirectionType.Right) { foreach (var crossing in ringCrossings.Value) { Contract.Assume(crossing != null); var crossLegType = crossing.CrossType & CrossingType.Parallel; if (crossLegType == CrossingType.CrossToRight || crossLegType == CrossingType.DivergeRight) kernel.Entrances.Add(crossing); else if (crossLegType == CrossingType.CrossToLeft || crossLegType == CrossingType.ConvergeRight) kernel.Exits.Add(crossing); } } else { foreach (var crossing in ringCrossings.Value) { Contract.Assume(crossing != null); var crossLegType = crossing.CrossType & CrossingType.Parallel; if (crossLegType == CrossingType.CrossToLeft || crossLegType == CrossingType.DivergeLeft) kernel.Entrances.Add(crossing); else if (crossLegType == CrossingType.CrossToRight || crossLegType == CrossingType.ConvergeLeft) kernel.Exits.Add(crossing); } } } var sortedEntrances = kernel.Entrances.ToArray(); Array.Sort(sortedEntrances, PolygonCrossing.LocationAComparer.CompareNonNull); Contract.Assume(kernel.Exits != null); var sortedExits = kernel.Exits.ToArray(); Array.Sort(sortedExits, PolygonCrossing.LocationBComparer.CompareNonNull); for (int i = 0; i < sortedExits.Length; i++) { var exit = sortedExits[i]; var locationIndex = Array.BinarySearch(sortedEntrances, exit, PolygonCrossing.LocationAComparer.Default); if(locationIndex >= 0) kernel.ExitHops.Add(exit, sortedEntrances[locationIndex]); } for (int i = 0; i < sortedEntrances.Length; i++) { var entrance = sortedEntrances[i]; var locationIndex = Array.BinarySearch(sortedExits, entrance, PolygonCrossing.LocationBComparer.Default); if(locationIndex >= 0) kernel.EntranceHops.Add(entrance, sortedExits[locationIndex]); } return kernel; }
/// <summary> /// Inverts a polygon. /// </summary> /// <param name="polygon">The polygon to get the inverse of.</param> /// <returns>An inverted polygon.</returns> public static Polygon2 Invert(Polygon2 polygon) { Contract.Ensures(polygon == null ? Contract.Result<Polygon2>() == null : Contract.Result<Polygon2>() != null); return null == polygon ? null : new Polygon2(polygon.Select(Invert)); }
public PolyPairTestData(string name, Polygon2 a, Polygon2 b, Polygon2 r) { Name = name; A = a; B = b; R = r; }
/// <summary> /// Determines the points that would need to be inserted into the resulting /// intersection geometry between the two given polygons, at the location where /// their boundaries cross. /// </summary> /// <param name="a">The first polygon to test.</param> /// <param name="b">The second polygon to test.</param> public List<PolygonCrossing> FindPointCrossings(Polygon2 a, Polygon2 b) { Contract.Ensures(Contract.Result<List<PolygonCrossing>>() != null); if (null == a || null == b) return new List<PolygonCrossing>(0); var crossingGenerator = new PolygonPointCrossingGenerator(a, b); var allCrossings = crossingGenerator.GenerateCrossings(); return allCrossings; }
public static void can_perform_box_and_donut_intersection_without_exception() { var donut = new Polygon2 { // outer boundary new Ring2( Enumerable.Range(0,8) .Select(i => i * 45 / 180.0 * Math.PI) .Select(t => new Point2(Math.Cos(t),Math.Sin(t))) ){Hole = false}, // inner hole new Ring2( Enumerable.Range(0,8) .Reverse() .Select(i => i * 45/ 180.0 * Math.PI) .Select(t => new Point2(Math.Cos(t)*0.5,Math.Sin(t)*0.5)) ) {Hole = true} }; var box = new Polygon2(new Ring2(new[]{ new Point2(0,0), new Point2(1,0), new Point2(1,1), new Point2(0,1) }) { Hole = false }); var intersectionOperation = new PolygonIntersectionOperation(); var result = intersectionOperation.Intersect(box, donut); }
/// <summary> /// Calculates the resulting difference of polygon <paramref name="b"/> subtracted from polygon <paramref name="a"/>. /// </summary> /// <param name="a">The polygon to be subtracted from.</param> /// <param name="b">The polygon used to subtract from a.</param> /// <returns>The difference resulting from subtracting <paramref name="b"/> from <paramref name="a"/>.</returns> public IPlanarGeometry Difference(Polygon2 a, Polygon2 b) { var result = RightInverseIntersectionOperation.Intersect(a, b); return result; }
public static void boxes_overlapping_top_half_holes() { var sourceData = _polyPairData["Boxes Overlapping: top half"]; var inverseA = new Polygon2(sourceData.A[0].Reverse(), true); var inverseB = new Polygon2(sourceData.B[0].Reverse(), true); var expectedResult = inverseA; var result = _intersectionOperation.Intersect(inverseA, inverseB) as Polygon2; Assert.True(result.SpatiallyEqual(expectedResult)); result = _intersectionOperation.Intersect(inverseB, inverseA) as Polygon2; Assert.True(result.SpatiallyEqual(expectedResult)); }
private static List<Ring2> QualifyRings( Polygon2 untouchedRings, Polygon2 polygon, bool qualifyEqual ) { Contract.Requires(untouchedRings != null); Contract.Requires(polygon != null); Contract.Ensures(Contract.Result<List<Ring2>>() != null); Contract.Ensures(Contract.ForAll(Contract.Result<List<Ring2>>(), x => null != x)); var result = new List<Ring2>(); var ringTree = new RingBoundaryTree(polygon); foreach (var ring in untouchedRings) { Contract.Assume(ring != null); // TODO: speed this up through some kind of magic, like RingBoundaryTree or something // TODO: var eq = new SpatialEqualityComparerThing(ringA); var stuff = otherRings.Where(r = > eq.SpatiallyEqual(r)); if (polygon.Any(r => ring.SpatiallyEqual(r))) { if (qualifyEqual) result.Add(ring.Clone()); } else if (ringTree.NonIntersectingContains(ring)) result.Add(ring.Clone()); } Contract.Assume(Contract.ForAll(result, x => null != x)); return result; }
public abstract void DrawPolygon(FillMode fill, Polygon2 polygon);
private PolygonCrossingsAlgorithmKernel CreateIntersectionKernel(Polygon2 a, Polygon2 b) { Contract.Requires(a != null); Contract.Requires(b != null); Contract.Ensures(Contract.Result<PolygonCrossingsAlgorithmKernel>() != null); var allCrossings = FindPointCrossings(a,b); return CreateIntersectionKernelFromCrossings(allCrossings, a, b); }
public IntersectionResults Turtle(PointWinding fillWinding) { Contract.Ensures(Contract.Result<IntersectionResults>() != null); // now that it is all sorted the turtle starts scooting around, making new rings: // // --== .-----. | ~ard // --== / \ | // A --== <_______(`~`) B | D E // ---*---------//-----//------*-------------*---*---------*--- // C | // | // // please wait while SPEED TURTLE!!! assembles your new rings var rings = new Polygon2(); PolygonCrossing startEntrance; while ((startEntrance = FindNextStartableEntrance()) != null) { var buildingRing = new List<Point2>(); var entrance = startEntrance; do { var exit = TraverseBSide(entrance, buildingRing); if (exit == null) { VisitEntrance(startEntrance); // may need to do this to be safe break; // unmatched entrance } VisitExit(exit); entrance = TraverseASide(exit, buildingRing); if (entrance == null) { break; // unmatched exit } VisitEntrance(entrance); } while (entrance != startEntrance); if (buildingRing.Count >= 3) rings.Add(new Ring2(buildingRing)); // here is a new ring } if (fillWinding != PointWinding.Unknown) rings.ForceFillWinding(fillWinding); return BuildFinalResults(rings); }
[ContractVerification(false)] // TODO: remove when CC bugs are fixed public PolygonCrossingsAlgorithmKernel(Polygon2 a, Polygon2 b, List<PolygonCrossing> crossings) { Contract.Requires(a != null); Contract.Requires(b != null); Contract.Requires(crossings != null); Contract.Requires(Contract.ForAll(crossings, x => x != null)); A = a; B = b; var ringCrossingsABuilder = new Dictionary<int, List<PolygonCrossing>>(a.Count); var ringCrossingsBBuilder = new Dictionary<int, List<PolygonCrossing>>(b.Count); foreach (var crossing in crossings) { List<PolygonCrossing> list; if (!ringCrossingsABuilder.TryGetValue(crossing.LocationA.RingIndex, out list)) { list = new List<PolygonCrossing>(); ringCrossingsABuilder.Add(crossing.LocationA.RingIndex, list); } Contract.Assume(list != null); list.Add(crossing); Contract.Assume(crossing.LocationB != null); if (!ringCrossingsBBuilder.TryGetValue(crossing.LocationB.RingIndex, out list)) { Contract.Assume(crossing.LocationB != null); list = new List<PolygonCrossing>(); ringCrossingsBBuilder.Add(crossing.LocationB.RingIndex, list); } Contract.Assume(list != null); list.Add(crossing); } RingCrossingsA = PolygonRingCrossingLookup.Build(ringCrossingsABuilder, PolygonCrossing.LocationAComparer.CompareNonNull); RingCrossingsB = PolygonRingCrossingLookup.Build(ringCrossingsBBuilder, PolygonCrossing.LocationBComparer.CompareNonNull); Entrances = new HashSet<PolygonCrossing>(); Exits = new HashSet<PolygonCrossing>(); EntranceHops = new Dictionary<PolygonCrossing, PolygonCrossing>(); ExitHops = new Dictionary<PolygonCrossing, PolygonCrossing>(); VisitedCrossings = new List<PolygonCrossing>(); VisitedCrossingsRingIndicesA = new HashSet<int>(); VisitedCrossingsRingIndicesB = new HashSet<int>(); }
/// <summary> /// Calculates the intersection between two polygons. /// </summary> /// <param name="a">A polygon.</param> /// <param name="b">A polygon.</param> /// <returns>The intersection result, which may be a geometry collection containing points, segments, and polygons.</returns> public IPlanarGeometry Intersect(Polygon2 a, Polygon2 b) { if (null == a || a.Count == 0 || null == b || b.Count == 0) return null; if (ReferenceEquals(a, b)) return a.Clone(); if (Options.InvertLeftHandSide) a = PolygonInverseOperation.Invert(a); if (Options.InvertRightHandSide) b = PolygonInverseOperation.Invert(b); // find all the crossings var fillWinding = DetermineFillWinding(a.Concat(b)); var kernel = CreateIntersectionKernel(a, b); // traverse the rings var results = kernel.Turtle(fillWinding); if (null == results.Polygon) return null; // TODO: this stuff is not so great results.Polygon = (results.Polygon.Count == 0 ? null : results.Polygon); if (null != results.Polygon) { if (fillWinding != PointWinding.Unknown) results.Polygon.ForceFillWinding(fillWinding); } if (Options.InvertResult) results.Polygon = PolygonInverseOperation.Invert(results.Polygon); return results.Polygon; }
private IntersectionResults BuildFinalResults(Polygon2 intersectedPolygon) { Contract.Requires(intersectedPolygon != null); Contract.Ensures(Contract.Result<IntersectionResults>() != null); Contract.Ensures(intersectedPolygon.Count >= Contract.OldValue(intersectedPolygon).Count); if (intersectedPolygon.Count == 0) { var untouchedA = FindUntouchedRingsA(); var untouchedB = FindUntouchedRingsB(); intersectedPolygon.AddRange(QualifyRings(untouchedA, untouchedB, true)); intersectedPolygon.AddRange(QualifyRings(untouchedB, untouchedA, false)); } else { var intersectedResultTree = new RingBoundaryTree(intersectedPolygon); intersectedPolygon.AddRange( FilterQualifiedRingsToBoundaryTree( QualifyRings(FindUntouchedRingsA(), B, true), intersectedResultTree ) ); intersectedPolygon.AddRange( FilterQualifiedRingsToBoundaryTree( QualifyRings(FindUntouchedRingsB(), A, false), intersectedResultTree ) ); } return new IntersectionResults { Polygon = intersectedPolygon }; }
public Polygon2 ToPolygon(int offset = 0, float overrideWidth = -1) { var result = new Polygon2(); var outRadius = (overrideWidth > 0 ? overrideWidth : (offset + this.Radius) / (float)Math.Cos(2 * Math.PI / MaxLineSegmentN)); for (var i = MaxLineSegmentN; i >= CurrentLineSegmentN; i--) { var angle = i * 2 * Math.PI / MaxLineSegmentN; var point = new Vector2(this.Center.X + outRadius * (float)Math.Cos(angle), this.Center.Y + outRadius * (float)Math.Sin(angle)); result.Add(point); } return result; }
private Polygon2 FindUntouchedRingsB() { Contract.Ensures(Contract.Result<IEnumerable<Ring2>>() != null); if (VisitedCrossingsRingIndicesB.Count == 0) return B; var missingCount = B.Count - VisitedCrossingsRingIndicesB.Count; var results = new Polygon2(missingCount); if (missingCount == 0) return results; for (int i = 0; i < B.Count; i++) { if (!VisitedCrossingsRingIndicesB.Contains(i)) results.Add(B[i]); } return results; }