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);
}
}
}
}
static void DebugVerifyRectsDisjoint(Rectangle rect1, Rectangle rect2, double dblPaddingX, double dblPaddingY, double dblEpsilon)
{
rect1.PadWidth(dblPaddingX/2.0 - dblEpsilon);
rect1.PadHeight(dblPaddingY/2.0 - dblEpsilon);
rect2.PadWidth(dblPaddingX/2.0 - dblEpsilon);
rect2.PadHeight(dblPaddingY/2.0 - dblEpsilon);
Debug.Assert(!rect1.Intersects(rect2));
}
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>
/// Returns the distance between two given rectangles or zero if they intersect.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
static double GetDistanceRects(Rectangle a, Rectangle b) {
if (a.Intersects(b))
return 0;
double dx = 0, dy = 0;
if (a.Right < b.Left) {
dx = a.Left - b.Right;
}
else if (b.Right < a.Left) {
dx = a.Left - b.Right;
}
if (a.Top < b.Bottom) {
dy = b.Bottom - a.Top;
}
else if (b.Top < a.Bottom) {
dy = a.Bottom - b.Top;
}
double euclid = Math.Sqrt(dx*dx + dy*dy);
return euclid;
}
static bool CurveOverlapsBox(ICurve curve, ref Rectangle box, Polyline boxPolyline) {
// if the curve bounding box doesn't intersect the invalidated region then no overlap!
if (!box.Intersects(curve.BoundingBox)) {
return false;
}
// if either end of the curve is inside the box then there is definitely overlap!
if (box.Contains(curve.Start) || box.Contains(curve.End)) {
return true;
}
// we have already determined that the curve is close but not fully contained so now we
// need to check for a more expensive intersection
return Curve.CurveCurveIntersectionOne(boxPolyline, curve, false) != null;
}
void SelectEntitiesForDraggingWithRectangle(MsaglMouseEventArgs args) {
var rect =
new Rectangle(mouseDownGraphPoint, viewer.ScreenToSource(args));
foreach (IViewerNode node in ViewerNodes())
if (rect.Intersects(node.Node.BoundingBox))
SelectObjectForDragging(node);
args.Handled = true;
}
RectangleNode<Node> FindClusterNodeRecurse(RectangleNode<Node> node, Node cluster, Rectangle previousBox) {
if (node.UserData != null)
return node.UserData == cluster ? node : null;
RectangleNode<Node> n0=null;
if (previousBox.Intersects(node.Left.Rectangle))
n0 = FindClusterNodeRecurse(node.Left, cluster, previousBox);
if (n0 != null) return n0;
if (previousBox.Intersects(node.Right.Rectangle))
return FindClusterNodeRecurse(node.Right, cluster, previousBox);
return null;
}
/// <summary>
/// Returns the intersection of two rectangles.
/// </summary>
/// <param name="rect1"></param>
/// <param name="rect2"></param>
/// <returns></returns>
public static Rectangle Intersect(Rectangle rect1,Rectangle rect2) {
if (rect1.Intersects(rect2))
return new Rectangle(new Point(Math.Max(rect1.Left, rect2.Left), Math.Max(rect1.Bottom, rect2.Bottom)),
new Point(Math.Min(rect1.Right, rect2.Right), Math.Min(rect1.Top, rect2.Top)));
return Rectangle.CreateAnEmptyBox();
}
