public void RTreeQuery_PointIntersectionTest()
{
for (int seed = 0; seed < 1; ++seed)
{
int n = 100000;
var points = new Point[n];
var rand = new Random(seed);
double scale = 1000;
for (int i = 0; i < n; ++i)
{
points[i] = new Point(rand.NextDouble() * scale, rand.NextDouble() * scale);
}
var bsptree = new RTree <Point>(
from p in points
select new KeyValuePair <Rectangle, Point>(new Rectangle(p), p));
Assert.AreEqual(bsptree.GetAllLeaves().Count(), n);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(0, 0, scale, scale)).Count(), n);
int intersecting = 0;
for (int i = 0; i < 10000; ++i)
{
double s = scale / 100;
var query = new Rectangle(rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s);
if (bsptree.IsIntersecting(query))
{
++intersecting;
}
}
System.Diagnostics.Debug.WriteLine(intersecting);
}
}
public void RTreeQuery_Rectangles()
{
const int Seeds = 100;
const int RectCount = 1000;
const int RegionSize = 1000;
const int RectSize = 10;
for (int seed = 0; seed < Seeds; ++seed)
{
var rects = new Rectangle[RectCount];
var rand = new Random(seed);
for (int i = 0; i < RectCount; ++i)
{
rects[i] = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), new Point(RectSize, RectSize));
}
var bsptree = new RTree <Rectangle>(
from r in rects
select new KeyValuePair <Rectangle, Rectangle>(r, r));
Assert.AreEqual(bsptree.GetAllLeaves().Count(), RectCount);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(0, 0, RegionSize + RectSize, RegionSize + RectSize)).Count(), RectCount);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
var query = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize));
var checkList = (from r in rects
where query.Intersects(r)
select r).ToList();
var checkSet = new HashSet <Rectangle>(checkList);
var result = bsptree.GetAllIntersecting(query).ToList();
Assert.AreEqual(result.Count, checkList.Count, "result and check are different sizes: seed={0}", seed);
foreach (var r in result)
{
Assert.IsTrue(query.Intersects(r), "rect doesn't intersect query: seed={0}, rect={1}, query={2}", seed, r, query);
Assert.IsTrue(checkSet.Contains(r), "check set does not contain rect: seed={0}", seed);
}
}
}
public void RTreeQuery_IncrementalRectangles()
{
const int RectsCount = 1000;
const int RegionSize = 1000;
const int RectSize = 10;
for (int seed = 0; seed < 1; ++seed)
{
var rects = new Rectangle[RectsCount];
var rand = new Random(seed);
for (int i = 0; i < RectsCount; ++i)
{
rects[i] = new Rectangle(new Point(rand.Next(RegionSize), rand.Next(RegionSize)));
}
// create rTree with just the first rectangle
var l = new List <KeyValuePair <Rectangle, Rectangle> >
{
new KeyValuePair <Rectangle, Rectangle>(rects[0], rects[0])
};
var queryTree = new RTree <Rectangle>(l);
// add remaining rectangles 10 at a time
for (int a = 1, b = 10; b < RectsCount; a = b, b += 10)
{
for (int i = a; i < b; ++i)
{
queryTree.Add(rects[i], rects[i]);
}
Assert.AreEqual(queryTree.GetAllLeaves().Count(), b, "did we lose leaves?");
Assert.AreEqual(queryTree.GetAllIntersecting(
new Rectangle(0, 0, RegionSize + RectSize, RegionSize + RectSize)).Count(), b,
"are all leaves inside the max range?");
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0,
"should be no leaves inside this rectangle!");
var query = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize));
var checkList = (from r in rects.Take(b)
where query.Intersects(r)
select r).ToList();
var checkSet = new HashSet <string>(checkList.Select(r => r.ToString()));
var result = queryTree.GetAllIntersecting(query).ToList();
Assert.AreEqual(result.Count, checkList.Count, "result and check are different sizes: seed={0}", seed);
foreach (var r in result)
{
Assert.IsTrue(query.Intersects(r), "rect doesn't intersect query: seed={0}, rect={1}, query={2}", seed, r, query);
Assert.IsTrue(checkSet.Contains(r.ToString()), "check set does not contain rect: seed={0}", seed);
}
}
}
}
List <Segment> GetAllSegmentsIntersecting(Rectangle rect)
{
var segmentsIntersecting = new List <Segment>();
var boxIntersecting = _segmentTree.GetAllIntersecting(rect);
foreach (var seg in boxIntersecting)
{
if (RectSegIntersection.Intersect(rect, seg.p1, seg.p2))
{
segmentsIntersecting.Add(seg);
}
}
return(segmentsIntersecting);
}
public static bool IsSegmentInsideBoundaryOfSomeRectangle(Point p1, Point p2, RTree <Rectangle> rtree,
double tolerance)
{
var searchRect = new Rectangle(p1, p2);
searchRect = GetDilated(searchRect, tolerance);
var intersected = rtree.GetAllIntersecting(searchRect);
var boxesContaining = new List <Rectangle>();
foreach (var r in intersected)
{
var boxBig = GetDilated(r, tolerance);
var boxSmall = GetDilated(r, -tolerance);
var insideBoundary = true;
insideBoundary &= boxBig.Contains(p1);
insideBoundary &= boxBig.Contains(p2);
insideBoundary &= !boxSmall.Contains(p1);
insideBoundary &= !boxSmall.Contains(p2);
if (insideBoundary)
{
boxesContaining.Add(r);
}
}
return(boxesContaining.Any());
}
Set <SymmetricSegment> GetSymmetricSegmentsIntersectedBySeg(Point a, Point b)
{
var rect = new Rectangle(a, b);
return(new Set <SymmetricSegment>(_symmetricSegmentsTree.GetAllIntersecting(rect).Where(ss =>
SymmetricSegmentIntersects(ss, a, b))));
}
Set <LgNodeInfo> IntersectedByLineSegNodeInfos(Point p1, Point p2)
{
var nodes = _nodesTree.GetAllIntersecting(new Rectangle(p1, p2));
return
(new Set <LgNodeInfo>(nodes.Where(node => Curve.CurvesIntersect(node.BoundaryOnLayer, new LineSegment(p1, p2)))));
}
void SaveCurrentOverlapsBoxes()
{
// assume all Rtrees are updated
oldOverlapsBoxes = new Dictionary <TreeNode, List <TreeNode> >();
foreach (var v in _moveableRectanglesTree.GetAllLeaves())
{
var vOverlaps = _rectNodesRtree.GetAllIntersecting(v.rect);
if (vOverlaps.Count() <= 1)
{
continue;
}
var vOverlapsList = new List <TreeNode>();
foreach (var u in vOverlaps)
{
if (u != v)
{
vOverlapsList.Add(u);
}
}
if (vOverlapsList.Any())
{
oldOverlapsBoxes.Add(v, vOverlapsList);
}
}
}
public void RTreeQuery_IncrementalRectangles()
{
const int RectsCount = 1000;
const int RegionSize = 1000;
const int RectSize = 10;
var rects = new Rectangle[RectsCount];
var rand = new Random(0);
for (int i = 0; i < RectsCount; ++i)
{
rects[i] = new Rectangle(new Point(rand.Next(RegionSize), rand.Next(RegionSize)));
}
// create rTree with just the first rectangle
var rtree = new RTree <Rectangle, Point>();
rtree.Add(rects[0], rects[0]);
// add remaining rectangles 10 at a time
for (int a = 1, b = 10; b < RectsCount; a = b, b += 10)
{
for (int i = a; i < b; ++i)
{
rtree.Add(rects[i], rects[i]);
}
var allLeaves = rtree.GetAllLeaves().ToArray();
Assert.AreEqual(allLeaves.Length, b, "did we lose leaves?");
Assert.AreEqual(rtree.GetAllIntersecting(
new Rectangle(0, 0, RegionSize + RectSize, RegionSize + RectSize)).Count(), b,
"are all leaves inside the max range?");
Assert.AreEqual(rtree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0,
"should be no leaves inside this rectangle!");
var rect = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize));
var checkList = (from r in rects.Take(b)
where rect.Intersects(r)
select r).ToList();
var checkSet = new HashSet <string>(checkList.Select(r => r.ToString()));
var result = rtree.GetAllIntersecting(rect).ToList();
Assert.AreEqual(result.Count, checkList.Count, "result and check are different sizes");
foreach (var r in result)
{
Assert.IsTrue(rect.Intersects(r), "rect doesn't intersect query: rect={1}, query={2}", r, rect);
Assert.IsTrue(checkSet.Contains(r.ToString()), "check set does not contain rect");
}
}
}
internal List<VisibilityEdge> GetAllGraphEdgesWithEndpointInInteriorOf(IEnumerable<Rectangle> rects,
double slack = 0.01) {
var rtree = new RTree<Rectangle>();
foreach (var rect in rects) {
var shrinkedRect = rect.Clone();
shrinkedRect.ScaleAroundCenter(1 - slack);
rtree.Add(shrinkedRect, shrinkedRect);
}
var edges = (from edge in PathRouter.GetAllEdgesVisibilityEdges()
let qrect1 = new Rectangle(edge.SourcePoint, edge.SourcePoint)
let qrect2 = new Rectangle(edge.TargetPoint, edge.TargetPoint)
where rtree.GetAllIntersecting(qrect1).Any() || rtree.GetAllIntersecting(qrect2).Any()
select edge).ToList();
return edges;
}
public void RTreeQuery_RandomPoints()
{
var bspQueryTime = new Stopwatch();
var checkQueryTime = new Stopwatch();
const int Seeds = 5;
const int Repeats = 5;
for (int seed = 0; seed < Seeds; ++seed)
{
int n = 100000;
var points = new Point[n];
var rand = new Random(seed);
double scale = 1000;
for (int i = 0; i < n; ++i)
{
points[i] = new Point(rand.NextDouble() * scale, rand.NextDouble() * scale);
}
var queryTree = new RTree <Point>(
from p in points
select new KeyValuePair <Rectangle, Point>(new Rectangle(p), p));
Assert.AreEqual(queryTree.GetAllLeaves().Count(), n);
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(0, 0, scale, scale)).Count(), n);
for (int i = 0; i < Repeats; ++i)
{
double s = scale / 100;
var query = new Rectangle(rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s);
bspQueryTime.Start();
var result = queryTree.GetAllIntersecting(query).ToList();
bspQueryTime.Stop();
checkQueryTime.Start();
var checkList = (from p in points
where query.Contains(p)
select p).ToList();
checkQueryTime.Stop();
var checkSet = new HashSet <Point>(checkList);
Assert.AreEqual(result.Count, checkList.Count);
foreach (var r in result)
{
Assert.IsTrue(query.Contains(r));
Assert.IsTrue(checkSet.Contains(r));
}
}
Assert.IsTrue(bspQueryTime.ElapsedMilliseconds < checkQueryTime.ElapsedMilliseconds);
}
}
public void RTreeQuery_RandomPoints()
{
var bspQueryTime = new Stopwatch();
var checkQueryTime = new Stopwatch();
const int Seeds = 5;
const int Repeats = 5;
for (int seed = 0; seed < Seeds; ++seed)
{
int n = 100000;
var points = new Point[n];
var rand = new Random(seed);
double scale = 1000;
for (int i = 0; i < n; ++i)
{
points[i] = new Point(rand.NextDouble() * scale, rand.NextDouble() * scale);
}
var queryTree = new RTree<Point>(
from p in points
select new KeyValuePair<Rectangle, Point>(new Rectangle(p), p));
Assert.AreEqual(queryTree.GetAllLeaves().Count(), n);
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(0, 0, scale, scale)).Count(), n);
for (int i = 0; i < Repeats; ++i)
{
double s = scale / 100;
var query = new Rectangle(rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s);
bspQueryTime.Start();
var result = queryTree.GetAllIntersecting(query).ToList();
bspQueryTime.Stop();
checkQueryTime.Start();
var checkList = (from p in points
where query.Contains(p)
select p).ToList();
checkQueryTime.Stop();
var checkSet = new HashSet<Point>(checkList);
Assert.AreEqual(result.Count, checkList.Count);
foreach (var r in result)
{
Assert.IsTrue(query.Contains(r));
Assert.IsTrue(checkSet.Contains(r));
}
}
Assert.IsTrue(bspQueryTime.ElapsedMilliseconds < checkQueryTime.ElapsedMilliseconds);
}
}
internal IEnumerable <Rail> GetRailsIntersectingRect(Rectangle visibleRectange)
{
var ret = new Set <Rail>();
foreach (var rail in _railTree.GetAllIntersecting(visibleRectange))
{
ret.Insert(rail);
}
return(ret);
}
public static bool IsSegmentTouchingSomeRectangle(Point p1, Point p2, RTree <Rectangle> rtree, double tolerance)
{
var searchRect = new Rectangle(p1, p2);
searchRect = GetDilated(searchRect, tolerance);
var intersected = rtree.GetAllIntersecting(searchRect);
var touching =
(from r in intersected
let boxBig = GetScaled(r, 1 + tolerance)
let boxSmall = GetScaled(r, 1 - tolerance)
where Intersect(boxBig, p1, p2) && !Intersect(boxSmall, p1, p2)
select r);
return(touching.Any());
}
List <Point> GetPointsOverlappingSeg(SymmetricTuple <int> seg, RTree <Point> tree, Point[] indexToPoints)
{
Point p0 = indexToPoints[seg.A];
Point p1 = indexToPoints[seg.B];
var rect = new Rectangle(p0, p1);
rect.Pad(1e-5);
Point[] vts = tree.GetAllIntersecting(rect).ToArray();
double t;
var vtsOverlapping = vts.Where(p => Point.DistToLineSegment(p, p0, p1, out t) < 1e-5).ToList();
vtsOverlapping = vtsOverlapping.OrderBy(p => (p - p0).Length).ToList();
return(vtsOverlapping);
}
internal void InitNodePortEdges(IEnumerable <LgNodeInfo> nodes, IEnumerable <SymmetricSegment> segments)
{
NodePortEdges.Clear();
NodeCenters.Clear();
RTree <SymmetricSegment> rtree = new RTree <SymmetricSegment>();
RTree <Point> pointRtree = new RTree <Point>();
foreach (var seg in segments)
{
rtree.Add(new Rectangle(seg.A, seg.B), seg);
pointRtree.Add(new Rectangle(seg.A), seg.A);
pointRtree.Add(new Rectangle(seg.B), seg.B);
}
foreach (var node in nodes)
{
var bbox = node.BoundingBox.Clone();
bbox.ScaleAroundCenter(0.9);
NodePortEdges[node] = new List <SymmetricSegment>();
var segInt = rtree.GetAllIntersecting(bbox).ToList();
foreach (var seg in segInt)
{
if (RectSegIntersection.Intersect(bbox, seg.A, seg.B))
{
NodePortEdges[node].Add(seg);
}
if (!(node.BoundingBox.Contains(seg.A) && node.BoundingBox.Contains(seg.B)))
{
Debug.Assert(false, "found long edge");
}
}
bbox = node.BoundingBox.Clone();
bbox.ScaleAroundCenter(0.01);
Point x;
if (pointRtree.OneIntersecting(bbox, out x))
{
NodeCenters[node] = x;
}
}
}
internal List <VisibilityEdge> GetAllGraphEdgesWithEndpointInInteriorOf(IEnumerable <Rectangle> rects,
double slack = 0.01)
{
var rtree = new RTree <Rectangle>();
foreach (var rect in rects)
{
var shrinkedRect = rect.Clone();
shrinkedRect.ScaleAroundCenter(1 - slack);
rtree.Add(shrinkedRect, shrinkedRect);
}
var edges = (from edge in PathRouter.GetAllEdgesVisibilityEdges()
let qrect1 = new Rectangle(edge.SourcePoint, edge.SourcePoint)
let qrect2 = new Rectangle(edge.TargetPoint, edge.TargetPoint)
where rtree.GetAllIntersecting(qrect1).Any() || rtree.GetAllIntersecting(qrect2).Any()
select edge).ToList();
return(edges);
}
void FindOverlapsWithInterval(int i)
{
if (_intervalTree == null)
{
return;
}
var interval = GetInterval(i);
foreach (int j in _intervalTree.GetAllIntersecting(interval))
{
var tuple = GTreeOverlapRemoval.GetIdealEdgeLength(i, j,
_nodePositions[i], _nodePositions[j], _nodeSizes, _forLayers);
if (!(tuple.Item3 > 1))
{
return;
}
_proximityEdges.Add(tuple);
_numberOfOverlaps++;
}
}
void AddVoronoiCite(CdtTriangle triangle)
{
Point p;
var goodTriangle = GetCenterOfDescribedCircle(triangle, out p);
if (!goodTriangle)
{
return;
}
if (!BoundingBox.Contains(p))
{
return;
}
var rect = new Rectangle(p);
rect.Pad(eps);
if (voronoiSiteTree.GetAllIntersecting(rect).Count() > 0)
{
return;
}
voronoiSiteTree.Add(rect, p);
}
public void RTreeQuery_IncrementalRectangles()
{
const int RectsCount = 1000;
const int RegionSize = 1000;
const int RectSize = 10;
for (int seed = 0; seed < 1; ++seed)
{
var rects = new Rectangle[RectsCount];
var rand = new Random(seed);
for (int i = 0; i < RectsCount; ++i)
{
rects[i] = new Rectangle(new Point(rand.Next(RegionSize), rand.Next(RegionSize)));
}
// create rTree with just the first rectangle
var l = new List<KeyValuePair<Rectangle, Rectangle>>
{
new KeyValuePair<Rectangle, Rectangle>(rects[0], rects[0])
};
var queryTree = new RTree<Rectangle>(l);
// add remaining rectangles 10 at a time
for (int a = 1, b = 10; b < RectsCount; a = b, b += 10)
{
for (int i = a; i < b; ++i)
{
queryTree.Add(rects[i], rects[i]);
}
Assert.AreEqual(queryTree.GetAllLeaves().Count(), b, "did we lose leaves?");
Assert.AreEqual(queryTree.GetAllIntersecting(
new Rectangle(0, 0, RegionSize + RectSize, RegionSize + RectSize)).Count(), b,
"are all leaves inside the max range?");
Assert.AreEqual(queryTree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0,
"should be no leaves inside this rectangle!");
var query = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize));
var checkList = (from r in rects.Take(b)
where query.Intersects(r)
select r).ToList();
var checkSet = new HashSet<Rectangle>(checkList);
var result = queryTree.GetAllIntersecting(query).ToList();
Assert.AreEqual(result.Count, checkList.Count, "result and check are different sizes: seed={0}", seed);
foreach (var r in result)
{
Assert.IsTrue(query.Intersects(r), "rect doesn't intersect query: seed={0}, rect={1}, query={2}", seed, r, query);
Assert.IsTrue(checkSet.Contains(r), "check set does not contain rect: seed={0}", seed);
}
}
}
}
public void RTreeQuery_Rectangles()
{
const int Seeds = 100;
const int RectCount = 1000;
const int RegionSize = 1000;
const int RectSize = 10;
for (int seed = 0; seed < Seeds; ++seed)
{
var rects = new Rectangle[RectCount];
var rand = new Random(seed);
for (int i = 0; i < RectCount; ++i)
{
rects[i] = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), new Point(RectSize, RectSize));
}
var bsptree = new RTree<Rectangle>(
from r in rects
select new KeyValuePair<Rectangle, Rectangle>(r, r));
Assert.AreEqual(bsptree.GetAllLeaves().Count(), RectCount);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(0, 0, RegionSize + RectSize, RegionSize + RectSize)).Count(), RectCount);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
var query = new Rectangle(rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize), rand.Next(RegionSize));
var checkList = (from r in rects
where query.Intersects(r)
select r).ToList();
var checkSet = new HashSet<Rectangle>(checkList);
var result = bsptree.GetAllIntersecting(query).ToList();
Assert.AreEqual(result.Count, checkList.Count, "result and check are different sizes: seed={0}", seed);
foreach (var r in result)
{
Assert.IsTrue(query.Intersects(r), "rect doesn't intersect query: seed={0}, rect={1}, query={2}", seed, r, query);
Assert.IsTrue(checkSet.Contains(r), "check set does not contain rect: seed={0}", seed);
}
}
}
/// <summary>
/// ignoring crossing at ls.Start
/// </summary>
/// <param name="ls"></param>
/// <param name="rTree"></param>
/// <param name="segsToIgnore"></param>
/// <returns></returns>
static bool IsCrossing(LineSegment ls, RTree<SegWithIndex> rTree, SegWithIndex[] segsToIgnore) {
return rTree.GetAllIntersecting(ls.BoundingBox).Where(seg => !segsToIgnore.Contains(seg)).Any();
}
public static bool IsSegmentInsideBoundaryOfSomeRectangle(Point p1, Point p2, RTree<Rectangle> rtree,
double tolerance)
{
var searchRect = new Rectangle(p1, p2);
searchRect = GetDilated(searchRect, tolerance);
var intersected = rtree.GetAllIntersecting(searchRect);
var boxesContaining = new List<Rectangle>();
foreach (var r in intersected)
{
var boxBig = GetDilated(r, tolerance);
var boxSmall = GetDilated(r, -tolerance);
var insideBoundary = true;
insideBoundary &= boxBig.Contains(p1);
insideBoundary &= boxBig.Contains(p2);
insideBoundary &= !boxSmall.Contains(p1);
insideBoundary &= !boxSmall.Contains(p2);
if(insideBoundary)
boxesContaining.Add(r);
}
return boxesContaining.Any();
}
internal void InitNodePortEdges(IEnumerable<LgNodeInfo> nodes, IEnumerable<SymmetricSegment> segments) {
NodePortEdges.Clear();
NodeCenters.Clear();
RTree<SymmetricSegment> rtree = new RTree<SymmetricSegment>();
RTree<Point> pointRtree = new RTree<Point>();
foreach (var seg in segments) {
rtree.Add(new Rectangle(seg.A, seg.B), seg);
pointRtree.Add(new Rectangle(seg.A), seg.A);
pointRtree.Add(new Rectangle(seg.B), seg.B);
}
foreach (var node in nodes) {
var bbox = node.BoundingBox.Clone();
bbox.ScaleAroundCenter(0.9);
NodePortEdges[node] = new List<SymmetricSegment>();
var segInt = rtree.GetAllIntersecting(bbox).ToList();
foreach (var seg in segInt) {
if (RectSegIntersection.Intersect(bbox, seg.A, seg.B)) {
NodePortEdges[node].Add(seg);
}
if (!(node.BoundingBox.Contains(seg.A) && node.BoundingBox.Contains(seg.B)))
Debug.Assert(false, "found long edge");
}
bbox = node.BoundingBox.Clone();
bbox.ScaleAroundCenter(0.01);
Point x;
if (pointRtree.OneIntersecting(bbox, out x))
NodeCenters[node] = x;
}
}
/// <summary>
/// ignoring crossing at ls.Start
/// </summary>
/// <param name="ls"></param>
/// <param name="rTree"></param>
/// <param name="segsToIgnore"></param>
/// <returns></returns>
static bool IsCrossing(LineSegment ls, RTree <SegWithIndex> rTree, SegWithIndex[] segsToIgnore)
{
return(rTree.GetAllIntersecting(ls.BoundingBox).Where(seg => !segsToIgnore.Contains(seg)).Any());
}
/*
void AddSegsHandlingOverlaps(SymmetricTuple<int> seg, RTree<Point> tree, Point[] indexToPoints) {
var overlaps = GetPointsOverlappingSeg(seg, tree,indexToPoints);
if (overlaps.Count <= 2) {
_segments.Insert(seg);
return;
}
Point ep0 = indexToPoints[seg.A];
AddSegment(ep0, overlaps[1]);
AddSegment(overlaps[overlaps.Count - 2], indexToPoints[seg.B]);
if (overlaps.Count > 3) {
AddSegsHandlingOverlaps(new SymmetricTuple<int>(_pointIndices[overlaps[1]],_pointIndices[overlaps[overlaps.Count - 2]]), tree, indexToPoints);
}
}
*/
List<Point> GetPointsOverlappingSeg(SymmetricTuple<int> seg, RTree<Point> tree, Point[] indexToPoints) {
Point p0 = indexToPoints[seg.A];
Point p1 = indexToPoints[seg.B];
var rect = new Rectangle(p0, p1);
rect.Pad(1e-5);
Point[] vts = tree.GetAllIntersecting(rect).ToArray();
double t;
var vtsOverlapping = vts.Where(p => Point.DistToLineSegment(p, p0, p1, out t) < 1e-5).ToList();
vtsOverlapping = vtsOverlapping.OrderBy(p => (p - p0).Length).ToList();
if (vtsOverlapping.Count > 2) {
Console.WriteLine("overlapping points");
foreach (var v in vtsOverlapping)
Console.WriteLine(v);
}
return vtsOverlapping;
}
public void RTreeQuery_PointIntersectionTest()
{
for (int seed = 0; seed < 1; ++seed)
{
int n = 100000;
var points = new Point[n];
var rand = new Random(seed);
double scale = 1000;
for (int i = 0; i < n; ++i)
{
points[i] = new Point(rand.NextDouble() * scale, rand.NextDouble() * scale);
}
var bsptree = new RTree<Point>(
from p in points
select new KeyValuePair<Rectangle, Point>(new Rectangle(p), p));
Assert.AreEqual(bsptree.GetAllLeaves().Count(), n);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(0, 0, scale, scale)).Count(), n);
int intersecting = 0;
for (int i = 0; i < 10000; ++i)
{
double s = scale / 100;
var query = new Rectangle(rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s);
if (bsptree.IsIntersecting(query))
{
++intersecting;
}
}
System.Console.WriteLine(intersecting);
}
}
public static bool IsSegmentTouchingSomeRectangle(Point p1, Point p2, RTree<Rectangle> rtree, double tolerance)
{
var searchRect = new Rectangle(p1, p2);
searchRect = GetDilated(searchRect, tolerance);
var intersected = rtree.GetAllIntersecting(searchRect);
var touching =
(from r in intersected
let boxBig = GetScaled(r, 1 + tolerance)
let boxSmall = GetScaled(r, 1 - tolerance)
where Intersect(boxBig, p1, p2) && !Intersect(boxSmall, p1, p2)
select r);
return touching.Any();
}
