// Slice From Point static public Slice2D SliceFromPoint(Polygon2D polygon, Vector2D point, float rotation) { Slice2D result = Slice2D.Create(point, rotation); // Normalize into clockwise polygon.Normalize(); Vector2D sliceA = new Vector2D(point); Vector2D sliceB = new Vector2D(point); sliceA.Push(rotation, 1e+10f / 2); sliceB.Push(rotation, -1e+10f / 2); if (polygon.PointInPoly(point) == false) { return(result); } // Getting the list of intersections List <Vector2D> intersectionsA = polygon.GetListLineIntersectPoly(new Pair2D(point, sliceA)); List <Vector2D> intersectionsB = polygon.GetListLineIntersectPoly(new Pair2D(point, sliceB)); // Sorting intersections from one point if (intersectionsA.Count > 0 && intersectionsB.Count > 0) { sliceA = Vector2DList.GetListSortedToPoint(intersectionsA, point) [0]; sliceB = Vector2DList.GetListSortedToPoint(intersectionsB, point) [0]; } else { return(result); } List <Pair2D> collisionList = new List <Pair2D>(); collisionList.Add(new Pair2D(sliceA, sliceB)); result.AddPolygon(polygon); foreach (Pair2D id in collisionList) { result.AddCollision(id.A); result.AddCollision(id.B); // Sclice line points generated from intersections list Vector2D vec0 = new Vector2D(id.A); Vector2D vec1 = new Vector2D(id.B); double rot = Vector2D.Atan2(vec0, vec1); // Slightly pushing slice line so it intersect in all cases vec0.Push(rot, LinearSlicer.precision); vec1.Push(rot, -LinearSlicer.precision); // For each in polygons list attempt convex split List <Polygon2D> temp = new List <Polygon2D>(result.polygons); // necessary? foreach (Polygon2D poly in temp) { // NO, that's the problem Slice2D resultList = LinearSlicer.Slice(poly, new Pair2D(vec0, vec1)); if (resultList.slices.Count > 0) { foreach (List <Vector2D> i in resultList.slices) { result.AddSlice(i); } } if (resultList.polygons.Count > 0) { foreach (Polygon2D i in resultList.polygons) { result.AddPolygon(i); } // If it's possible to perform splice, remove parent polygon from result list result.RemovePolygon(poly); } } } result.RemovePolygon(polygon); return(result); }
// Linear Slice static public Slice2D Slice(Polygon polygon, Pair2f slice) { Slice2D result = Slice2D.Create(); // Normalize into clockwise polygon.Normalize(); // Getting the list of intersections List <Vector2f> intersections = polygon.GetListSliceIntersectPoly(slice); // Sorting intersections from one point intersections = VectorList2f.GetListSortedToPoint(intersections, slice.A); if (intersections.Count < 2) { return(result); } List <Pair2f> collisionList = new List <Pair2f>(); // Dividing intersections into single slices - This method doesn't look like very reliable!!! // Optimize this (polygon.PointInPoly) line // Fix this nonsense!!! foreach (Pair2f p in Pair2f.GetList(intersections, false)) { if (polygon.PointInPoly(new Vector2f((p.B.GetX() + p.A.GetX()) / 2, (p.B.GetY() + p.A.GetY()) / 2)) == true) { collisionList.Add(p); intersections.Remove(p.A); intersections.Remove(p.B); } } result.AddPolygon(polygon); // Slice line points generated from intersections list foreach (Pair2f id in collisionList) { result.AddCollision(id.A); result.AddCollision(id.B); Vector2f vec0 = new Vector2f(id.A); Vector2f vec1 = new Vector2f(id.B); float rot = Vector2f.Atan2(vec0, vec1); // Slightly pushing slice line so it intersect in all cases vec0.Push(rot, precision); vec1.Push(rot, -precision); // For each in polygons list attempt convex split foreach (Polygon poly in (new List <Polygon>(result.polygons))) { Slice2D resultList = SingleSlice(poly, new Pair2f(vec0, vec1)); if (resultList.polygons.Count > 0) { foreach (Polygon i in resultList.polygons) { result.AddPolygon(i); } // If it's possible to perform splice, remove currently sliced polygon from result list result.RemovePolygon(poly); } } } result.RemovePolygon(polygon); return(result); }
// Linear Slice static public Slice2D Slice(Polygon2D polygon, Pair2D slice) { Slice2D result = Slice2D.Create(null, slice); // Optimize: Cancel slicing for polygons that are not overlapping Rect sliceRect = Math2D.GetBounds(slice); Rect polygonRect = polygon.GetBounds(); if (sliceRect.Overlaps(polygonRect) == false) { return(result); } // Normalize into clockwise polygon.Normalize(); // Getting the list of intersections List <Vector2D> intersections = polygon.GetListLineIntersectPoly(slice); // Single collision cannot make a proper slice if (intersections.Count < 2) { return(result); } // Sorting intersections from one point intersections = Vector2DList.GetListSortedToPoint(intersections, slice.A); List <Pair2D> collisionList = new List <Pair2D>(); // Dividing intersections into single slices // Optimize this (polygon.PointInPoly) line // This method doesn't look like very reliable!!! foreach (Pair2D p in Pair2D.GetList(intersections, false)) { if (polygon.PointInPoly(new Vector2D((p.B.x + p.A.x) / 2, (p.B.y + p.A.y) / 2)) == true) { collisionList.Add(p); intersections.Remove(p.A); intersections.Remove(p.B); } } result.AddPolygon(polygon); // Slice line points generated from intersections list foreach (Pair2D id in collisionList) { result.AddCollision(id.A); result.AddCollision(id.B); Vector2D vec0 = new Vector2D(id.A); Vector2D vec1 = new Vector2D(id.B); double rot = Vector2D.Atan2(vec0, vec1); // Slightly pushing slice line so it intersect in all cases vec0.Push(rot, precision); vec1.Push(rot, -precision); Pair2D line = new Pair2D(vec0, vec1); // For each in polygons list attempt convex split foreach (Polygon2D poly in (new List <Polygon2D>(result.GetPolygons()))) { Slice2D resultList = SingleSlice(poly, line); if (resultList.slices.Count > 0) { foreach (List <Vector2D> i in resultList.slices) { result.AddSlice(i); } } if (resultList.GetPolygons().Count > 0) { result.AddSlice(line); foreach (Polygon2D i in resultList.GetPolygons()) { result.AddPolygon(i); } // If it's possible to perform splice, remove currently sliced polygon from result list result.RemovePolygon(poly); } } } result.RemovePolygon(polygon); return(result); }
static private Slice2D MultipleSlice(Polygon2D polygon, Pair2D slice) { Slice2D result = Slice2D.Create(null, slice); List <Pair2D> slices = GetSplitSlices(polygon, slice); //Debug.Log(slices.Count); //Debug.Log(slices[0].A.ToVector2() + " " + slices[0].B.ToVector2()); //Debug.Log(slices[1].A.ToVector2() + " " + slices[1].B.ToVector2()); if (slices.Count < 1) { return(result); } result.AddPolygon(polygon); // Slice line points generated from intersections list foreach (Pair2D id in slices) { result.AddCollision(id.A); result.AddCollision(id.B); Vector2D vec0 = new Vector2D(id.A); Vector2D vec1 = new Vector2D(id.B); double rot = Vector2D.Atan2(vec0, vec1); // Slightly pushing slice line so it intersect in all cases vec0.Push(rot, precision); vec1.Push(rot, -precision); Pair2D line = new Pair2D(vec0, vec1); // For each in polygons list attempt convex split foreach (Polygon2D poly in (new List <Polygon2D>(result.GetPolygons()))) { Slice2D resultList = SingleSlice(poly, line); if (resultList.GetPolygons().Count > 0) { if (resultList.slices.Count > 0) { foreach (List <Vector2D> i in resultList.slices) { result.AddSlice(i); } } result.AddSlice(line); foreach (Polygon2D i in resultList.GetPolygons()) { result.AddPolygon(i); } // If it's possible to perform splice, remove currently sliced polygon from result list result.RemovePolygon(poly); } } } result.RemovePolygon(polygon); return(result); }
static public Slice2D Slice(Polygon2D polygon, List <Vector2D> slice) { Slice2D result = Slice2D.Create(null, slice); if (slice.Count < 2) { return(result); } // Normalize into clockwise polygon.Normalize(); // Optimize slicing for polygons that are far away Rect sliceRect = Math2D.GetBounds(slice); Rect polygonRect = polygon.GetBounds(); if (sliceRect.Overlaps(polygonRect) == false) { return(result); } // Change if (Slicer2D.complexSliceType != Slicer2D.SliceType.Regular) { result = SlicePolygonInside(polygon, slice); if (result.GetPolygons().Count > 0) { return(result); } } // Optimization (holes?) // if (polygon.SliceIntersectPoly (slice) == false) // return(result); List <List <Vector2D> > slices = new List <List <Vector2D> >(); bool entered = polygon.PointInPoly(slice.First()); List <Vector2D> currentSlice = new List <Vector2D> (); Pair2D pair = Pair2D.Zero(); for (int i = 0; i < slice.Count - 1; i++) { pair.A = slice[i]; pair.B = slice[i + 1]; List <Vector2D> stackList = polygon.GetListLineIntersectPoly(pair); stackList = Vector2DList.GetListSortedToPoint(stackList, pair.A); foreach (Vector2D id in stackList) { if (entered == true) { currentSlice.Add(id); slices.Add(currentSlice); } else { currentSlice = new List <Vector2D> (); currentSlice.Add(id); } entered = !entered; } if (entered == true) { currentSlice.Add(pair.B); } } // Adjusting split lines before performing convex split result.AddPolygon(polygon); foreach (List <Vector2D> id in slices) { if (id.Count > 1) { foreach (Vector2D p in id) { result.AddCollision(p); } // Sclice line points generated from intersections list Vector2D vec0 = id.First(); vec0.Push(Vector2D.Atan2(vec0, id[1]), precision); Vector2D vec1 = id.Last(); vec1.Push(Vector2D.Atan2(vec1, id[id.Count - 2]), precision); // For each in polygons list attempt convex split List <Polygon2D> temp = new List <Polygon2D>(result.GetPolygons()); // necessary? foreach (Polygon2D poly in temp) { Slice2D resultList = SingleSlice(poly, id); if (resultList.slices.Count > 0) { foreach (List <Vector2D> i in resultList.slices) { result.AddSlice(i); } } if (resultList.GetPolygons().Count > 0) { foreach (Polygon2D i in resultList.GetPolygons()) { result.AddPolygon(i); } // If it's possible to perform convex split, remove parent polygon from result list result.RemovePolygon(poly); } } } } result.RemovePolygon(polygon); return(result); }
static private Slice2D MultipleSlice(Polygon2D polygon, List <Vector2D> slice) { Slice2D result = Slice2D.Create(null, slice); List <SlicerSplit> slices = SlicerSplit.GetSplitSlices(polygon, slice); if (slices.Count < 1) { return(result); } // Adjusting split lines before performing convex split result.AddPolygon(polygon); foreach (SlicerSplit id in slices) { if (id.points.Count > 1) { foreach (Vector2D p in id.points) { result.AddCollision(p); } // Sclice line points generated from intersections list Vector2D vec0 = id.points.First(); vec0.Push(Vector2D.Atan2(vec0, id.points[1]), precision); Vector2D vec1 = id.points.Last(); vec1.Push(Vector2D.Atan2(vec1, id.points[id.points.Count - 2]), precision); // For each in polygons list attempt convex split List <Polygon2D> resultPolygons = new List <Polygon2D>(result.GetPolygons()); // necessary? foreach (Polygon2D poly in resultPolygons) { Slice2D resultList = SingleSlice(poly, id); if (resultList.GetPolygons().Count > 0) { if (resultList.slices.Count > 0) { foreach (List <Vector2D> resultSlice in resultList.slices) { result.AddSlice(resultSlice); } } foreach (Polygon2D resultPoly in resultList.GetPolygons()) { result.AddPolygon(resultPoly); } // If it's possible to perform convex split, remove parent polygon from result list result.RemovePolygon(poly); } } } } //Debug.Log("1 " + slices[0].Count + " " + slices[0][0].ToVector2() + " " + slices[0][1].ToVector2()); //Debug.Log("2 " + slices[1].Count + " " + slices[1][0].ToVector2() + " " + slices[1][1].ToVector2()); // if exist then remove slice was not performed result.RemovePolygon(polygon); return(result); }
static public Slice2D Slice(Polygon polygon, List <Vector2f> slice) { Slice2D result = Slice2D.Create(); if (slice.Count < 2) { return(result); } // Normalize into clockwise polygon.Normalize(); if (Slicer2D.complexSliceType != Slicer2D.SliceType.Regular) { result = SlicePolygonInside(polygon, slice); if (result.polygons.Count > 0) { return(result); } } // Optimization (holes?) // if (polygon.SliceIntersectPoly (slice) == false) // return(result); List <List <Vector2f> > slices = new List <List <Vector2f> >(); bool entered = polygon.PointInPoly(slice.First()); List <Vector2f> currentSlice = new List <Vector2f> (); foreach (Pair2f pair in Pair2f.GetList(slice, false)) { List <Vector2f> stackList = polygon.GetListSliceIntersectPoly(pair); stackList = VectorList2f.GetListSortedToPoint(stackList, pair.A); foreach (Vector2f id in stackList) { if (entered == true) { currentSlice.Add(id); slices.Add(currentSlice); } else { currentSlice = new List <Vector2f> (); currentSlice.Add(id); } entered = !entered; } if (entered == true) { currentSlice.Add(pair.B); } } // Adjusting split lines before performing convex split result.AddPolygon(polygon); foreach (List <Vector2f> id in slices) { if (id.Count > 1) { foreach (Vector2f p in id) { result.AddCollision(p); } // Sclice line points generated from intersections list Vector2f vec0 = id.First(); vec0.Push(Vector2f.Atan2(vec0, id[1]), precision); Vector2f vec1 = id.Last(); vec1.Push(Vector2f.Atan2(vec1, id[id.Count - 2]), precision); // For each in polygons list attempt convex split List <Polygon> temp = new List <Polygon>(result.polygons); // necessary? foreach (Polygon poly in temp) { Slice2D resultList = SingleSlice(poly, id); if (resultList.polygons.Count > 0) { foreach (Polygon i in resultList.polygons) { result.AddPolygon(i); } // If it's possible to perform convex split, remove parent polygon from result list result.RemovePolygon(poly); } } } } result.RemovePolygon(polygon); return(result); }