public void CreateContour(BlockTableRecord btr)
{
if (panelBtr.ExtentsByTile.Diagonal() < endOffset)
{
return;
}
// из всех плиток отделить торцевые плитки????
// дерево границ плиток
TreeTiles = new RTree<Tuple<ObjectId, Extents3d>>();
panelBtr.Tiles.ForEach(t =>
{
try
{
var r = new Rectangle(t.Item2.MinPoint.X, t.Item2.MinPoint.Y, t.Item2.MaxPoint.X, t.Item2.MaxPoint.Y, 0, 0);
TreeTiles.Add(r, t);
}
catch { }
});
// Первый угол панели - левый нижний
var pt1 = getCoordTileNoEnd(panelBtr.ExtentsByTile.MinPoint, EnumCorner.LeftLower);
var pt2 = getCoordTileNoEnd(new Point3d(panelBtr.ExtentsByTile.MinPoint.X, panelBtr.ExtentsByTile.MaxPoint.Y, 0), EnumCorner.LeftTop);
var pt3 = getCoordTileNoEnd(panelBtr.ExtentsByTile.MaxPoint, EnumCorner.RightTop);
var pt4 = getCoordTileNoEnd(new Point3d(panelBtr.ExtentsByTile.MaxPoint.X, panelBtr.ExtentsByTile.MinPoint.Y, 0), EnumCorner.RightLower);
Extents3d extNoEnd = new Extents3d(pt1, pt2);
extNoEnd.AddPoint(pt3);
extNoEnd.AddPoint(pt4);
panelBtr.ExtentsNoEnd = extNoEnd;
Point3dCollection pts = new Point3dCollection();
pts.Add(pt1);
pts.Add(pt2);
pts.Add(pt3);
pts.Add(pt4);
using (Polyline3d poly = new Polyline3d(Poly3dType.SimplePoly, pts, true))
{
poly.LayerId = panelBtr.CPS.IdLayerContour;
btr.AppendEntity(poly);
btr.Database.TransactionManager.TopTransaction.AddNewlyCreatedDBObject(poly, true);
}
}
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 void TestSimpleInserts()
{
RTree tree = new RTree(4, 2);
tree.Insert<int>(new Box(0, 0, 10, 10), 1); tree.ThrowOnInvariantsViolated();
tree.Insert<int>(new Box(20, 0, 30, 10), 2); tree.ThrowOnInvariantsViolated();
AssertSetIsEqual(tree.Find<int>(new Box(-5, -5, 5, 5)), 1);
// Cause the first split:
tree.Insert<int>(new Box(20, 0, 30, 10), 3); tree.ThrowOnInvariantsViolated();
tree.Insert<int>(new Box(20, 20, 30, 30), 4); tree.ThrowOnInvariantsViolated();
tree.Insert<int>(new Box(40, 0, 50, 30), 5); tree.ThrowOnInvariantsViolated();
AssertSetIsEqual(tree.Find<int>(new Box(-5, -5, 5, 5)), 1);
AssertSetIsEqual(tree.Find<int>(new Box(5, 5, 25, 25)), 1, 2, 3, 4);
AssertSetIsEqual(tree.Find<int>(new Box(-1000, -1000, 1000, 1000)), 1, 2, 3, 4, 5);
// Cause another set of splits:
for (int i = 0; i < 1000; i++)
{
tree.Insert<int>(new Box(100 + i * 10, 0, 100 + i * 10 + 10, 10), 6 + i);
tree.ThrowOnInvariantsViolated();
}
AssertSetIsEqual(tree.Find<int>(new Box(-5, -5, 5, 5)), 1);
AssertSetIsEqual(tree.Find<int>(new Box(5, 5, 25, 25)), 1, 2, 3, 4);
AssertSetIsEqual(tree.Find<int>(new Box(-1000, -1000, 45, 1000)), 1, 2, 3, 4, 5);
}
static void Main(string[] args)
{
//Console.WriteLine(BitConverter.DoubleToInt64Bits(15.2335344534));
RTree<string, int> rtree = new RTree<string, int>();
rtree.Vloz("Rr", new PointF(33, 63), new PointF(38, 52), 110);
rtree.Vloz("Rm", new PointF(30, 70), new PointF(33, 63), 111);
rtree.Vloz("Ra", new PointF(5, 5), new PointF(10, 10), 101);
rtree.Vloz("Rx", new PointF(10, 10), new PointF(20, 25), 102);
rtree.Vloz("Rs", new PointF(20, 25), new PointF(35, 12), 103);
rtree.Vloz("Rt", new PointF(30, 30), new PointF(35, 12), 104);
rtree.Vloz("Rw", new PointF(30, 30), new PointF(38, 52), 105);
rtree.Vloz("Rk", new PointF(15, 45), new PointF(28, 50), 106);
rtree.Vloz("Rz", new PointF(15, 45), new PointF(22, 60), 107);
rtree.Vloz("Rf", new PointF(25, 55), new PointF(28, 50), 108);
rtree.Vloz("Rd", new PointF(25, 55), new PointF(33, 63), 109);
rtree.PostavStrom();
List<int> listBodove = rtree.VyhledejBodove(new PointF(10, 10));
List<int> listIntervalove = rtree.VyhledejIntervalove(new Rectangle(7, 3, 10, 12));
Debug.WriteLine("");
Debug.WriteLine(string.Format("{0,-5}\t{1}\t{2,15}\t{3,10}\t{4,10}\t{5,5}\t{6,5}\t{7,5}\t{8,5}\t{9,5}\t{10,5}", "Data", "Key", "Z-order", "X order", "Y ordr", "V1.X", "V1.Y", "V2.X", "V2.Y", "Width", "Height"));
foreach (RTree<string, int>.RVrchol item in rtree.poleListu) {
item.GetZOrder();
//Debug.WriteLine(item.Data + "\t" + item.Key);
}
rtree.DebugStrom();
Console.ReadLine();
}
/// <summary>
///
/// </summary>
/// <param name="pushedNodes">nodes that are being pushed</param>
/// <param name="separation"></param>
/// <param name="pushingNodes"></param>
public BumperPusher(IEnumerable<Node> pushedNodes, double separation, Node[] pushingNodes) {
this.separation = separation;
rtree = new RTree<Node>(RectangleNode<Node>.CreateRectangleNodeOnEnumeration(
pushedNodes.Select(n => new RectangleNode<Node>(n, GetPaddedBoxOfNode(n)))));
//LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(rtree.GetAllLeaves().Select(n=>new DebugCurve(n.BoundaryCurve)));
this.pushingNodes = pushingNodes;
}
public void Setup()
{
Instance = new RTree <string>();
Instance.Add(new Rectangle(0, 0, 0, 0, 0, 0), "Origin");
Instance.Add(new Rectangle(1, 1, 1, 1, 1, 1), "Box1");
Instance.Add(new Rectangle(2, 2, 3, 3, 2, 3), "Box 2-3");
}
private static List <PlayerCluster> ClusterTree(RTree <Player> tree, List <Player> players, int viewRadius)
{
var playerClusterInformations = buildPlayerClusterInformations(tree, players, viewRadius);
var playerClusters = buildPlayerClusters(players, playerClusterInformations);
return(playerClusters);
}
public void Collides_When_Search_Finds_Matching_Points()
{
var tree = new RTree <int>(4);
tree.Load(_data);
Assert.IsTrue(tree.Collides(new BoundingBox(40, 20, 80, 70)));
}
public void Collides_Returns_False_If_Nothing_Found()
{
var tree = new RTree <int>(4);
tree.Load(_data);
Assert.IsFalse(tree.Collides(new BoundingBox(200, 200, 210, 210)));
}
public void Bulk_Load()
{
var tree = new RTree <int>(4);
tree.Load(_data);
CompareNodes(_data, tree.All().ToArray(), true);
}
public void SearchReturnsEmptyResultIfNothingFound()
{
var tree = new RTree <Point>(maxEntries: 4);
tree.BulkLoad(points);
Assert.AreEqual(new Point[] { }, tree.Search(new Envelope(200, 200, 210, 210)));
}
public void SetUp()
{
this.factory = new GeometryFactory();
this.geometries = new List <IPoint>(Enumerable.Range(1, 1000).Select(value => this.factory.CreatePoint(value, value, value)));
this.tree = new RTree();
this.tree.Add(this.geometries);
}
public TestableIndexBuilder(IndexSettings settings, IObjectPool objectPool, ITrace trace)
: base(settings, objectPool, trace)
{
Store = new ElementStore(new KeyValueStore(new KeyValueIndex(1000, 3),
new KeyValueUsage(new MemoryStream()), new MemoryStream()),
new MemoryStream(), TestHelper.GetObjectPool());
Tree = new RTree <uint>();
}
public void NonExistentItemCanBeDeleted()
{
var tree = new RTree <Point>(maxEntries: 4);
tree.BulkLoad(points);
tree.Delete(new Point(13, 13, 13, 13));
Assert.AreEqual(points.Length, tree.Count);
}
public void RTreeCustomShapesCanBeRecycled()
{
var filename = Path.GetTempFileName();
long indexId = 0;
// create the new storage manager
using (var storageManager = new DiskStorageManager(filename))
{
var options = new RTreeOptions()
{
Dimensions = 2,
EnsureTightMBRs = true,
TreeVariant = RTreeVariant.RStar,
FillFactor = 0.9
};
storageManager.DatafileSuffix = "data";
storageManager.IndexfileSuffix = "index";
storageManager.Overwrite = true;
storageManager.PageSize = 1024;
using (var rtree = new RTree <byte[]>(options, storageManager))
{
rtree.Add(new Circle(new Point(0, 0), 16), DataHelpers.GenerateSomeBytes(0x123021));
// verify that our circle is a circle
var circle = rtree.IntersectsWith(new Point(0, 0));
Assert.Equal(1, circle.Count());
Assert.Equal(0, rtree.IntersectsWith(new Point(15.99, 15.99)).Count());
indexId = rtree.Options.IndexIdentifier;
}
}
// recycle the storage manager
using (var storageManager = new DiskStorageManager(filename))
{
storageManager.DatafileSuffix = "data";
storageManager.IndexfileSuffix = "index";
storageManager.Overwrite = false;
storageManager.PageSize = 1024;
var options = new RTreeOptions(indexId)
{
Dimensions = 2,
EnsureTightMBRs = true,
TreeVariant = RTreeVariant.RStar,
FillFactor = 0.9
};
using (var rtree = new RTree <byte[]>(options, storageManager))
{
// verify that our circle is a circle
Assert.Equal(1, rtree.IntersectsWith(new Point(0, 0)).Count());
Assert.Equal(0, rtree.IntersectsWith(new Point(15.5, 15.5)).Count());
}
}
}
public void ShouldAddAnElement()
{
var shape = Shape2DFactory.GetShape();
var tree = new RTree <Int32>();
tree.Add(shape);
Assert.AreEqual(1, tree.Count);
}
internal void CreateRailTree()
{
_railTree =
new RTree <Rail>(
_railDictionary.Values.Select(rail => new KeyValuePair <Rectangle, Rail>(rail.BoundingBox, rail)));
Console.WriteLine("edges = {0}, rails = {1}, edge segments = {2}", _railsOfEdges.Count, _railDictionary.Count,
_railsOfEdges.Values.Sum(s => s.Count));
}
public void BulkLoadTestData()
{
var tree = new RTree <Point>();
tree.BulkLoad(points);
Assert.AreEqual(points.Length, tree.Count);
Assert.AreEqual(points.OrderBy(x => x).ToList(), tree.Search().OrderBy(x => x).ToList());
}
/// <summary>
///
/// </summary>
/// <param name="pushedNodes">nodes that are being pushed</param>
/// <param name="separation"></param>
/// <param name="pushingNodes"></param>
public BumperPusher(IEnumerable <Node> pushedNodes, double separation, Node[] pushingNodes)
{
this.separation = separation;
rtree = new RTree <Node, Point>(RectangleNode <Node, Point> .CreateRectangleNodeOnEnumeration(
pushedNodes.Select(n => new RectangleNode <Node, Point>(n, GetPaddedBoxOfNode(n)))));
//LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(rtree.GetAllLeaves().Select(n=>new DebugCurve(n.BoundaryCurve)));
this.pushingNodes = pushingNodes;
}
////////////////////////////////////////////////////////////////////////////
//--------------------------------- REVISIONS ------------------------------
// Date Name Tracking # Description
// --------- ------------------- ------------- ----------------------
// 21DEC2008 James Shen Initial Creation
////////////////////////////////////////////////////////////////////////////
protected void Initialize(RTree tree, int dimension, float fillFactor,
int capacity, int treeType)
{
Dimension = dimension;
FillFactor = fillFactor;
NodeCapacity = capacity;
TreeType = treeType;
Tree = tree;
PageSize = capacity * (8 * dimension + 4) + 12;
}
public void Search_Returns_Empty_Enumerable_If_Nothing_Found()
{
var tree = new RTree <int>(4);
tree.Load(_data);
var result = tree.Search(new BoundingBox(200, 200, 210, 210)).ToList();
Assert.AreEqual(0, result.Count);
}
public void All_Returns_All_Points_In_The_Tree()
{
var tree = new RTree <int>(4);
tree.Load(_data);
var all = tree.All();
CompareNodes(_data, all.ToArray(), true);
}
/// <summary>
/// 设置荷载对象的单元编号
/// </summary>
/// <param name="rt">所有梁单元中点，RTree存储</param>
/// <param name="beamLoad">被检查的梁单元线荷载</param>
/// <param name="err">检测误差</param>
///
private void SetBeamLoadEleNo(RTree rt, BeamLoadCls beamLoad, double err)
{
Point3d chkPt = beamLoad.LoadLine.PointAt(0.5);
EventHandler <RTreeEventArgs> rTreeCallback = (object sender, RTreeEventArgs args) =>
{
beamLoad.EleNo = args.Id + 1;
};
rt.Search(new Sphere(chkPt, err), rTreeCallback);
}
public void ClearWorks()
{
var tree = new RTree <Point>(maxEntries: 4);
tree.BulkLoad(points);
tree.Clear();
Assert.AreEqual(0, tree.Count);
Assert.IsEmpty(tree.Root.children);
}
private RTree <double, Point> CreateOnRecs(List <Rectangle> rects)
{
var r = new RTree <double, Point>();
foreach (var p in rects)
{
r.Add(p, p.Area);
}
return(r);
}
/// <summary>
/// Покраска блоков плитки в Модели (без блоков АКР-Панелей)
/// </summary>
public static void PaintTileInModel(RTree <ColorArea> rtreeColorAreas)
{
Database db = HostApplicationServices.WorkingDatabase;
using (var t = db.TransactionManager.StartTransaction())
{
PaintTileInBtr(SymbolUtilityServices.GetBlockModelSpaceId(db), rtreeColorAreas, Matrix3d.Identity);
t.Commit();
}
}
public static void RtreeSearch(RTree pointsCloud, List <int> PointsIndex, Point3d chkPt, double err, List <int> vertices)
{
EventHandler <RTreeEventArgs> rTreeCallback =
(object sender, RTreeEventArgs args) =>
{
vertices.Add(PointsIndex[args.Id]); //点云中找到某个点跟chkPt比较近的时候，将该点的索引赋予vertices
};
pointsCloud.Search(new Sphere(chkPt, err), rTreeCallback);//在空间点云pointsCloud中搜索点chkPt,如果距离小于err，则调用rTreeCallback
}
public void BulkLoadSplitsTreeProperly()
{
var tree = new RTree <Point>(maxEntries: 4);
tree.BulkLoad(points);
tree.BulkLoad(points);
Assert.AreEqual(points.Length * 2, tree.Count);
Assert.AreEqual(4, tree.Root.Height);
}
// . . . . . . . . . . . . . . . . . . . . . . constructor
public ParticleSystem(List <Point3d> positions, Mesh M)
{
Particles = new List <Particle>();
for (int i = 0; i < positions.Count; i++)
{
Particles.Add(new Particle(this, positions[i], RandomVectorOnMesh(M, positions[i], i) * 1.5));
}
MeshRTree = PopulateMeshRTree(M);
}
static void Main(string[] args)
{
var tree = new RTree();
tree.Insert(new BoundingBox(20, 3, 5, 10), "value1");
tree.Insert(new BoundingBox(30, 32, 5, 15), "value2");
tree.Insert(new BoundingBox(40, 1, 25, 10), "value3");
tree.Insert(new BoundingBox(40, 1, 25, 12), "value5");
Console.WriteLine("Hello World!");
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
List <Point3d> PointsCloud_3D = new List <Point3d>();
List <int> PointsIndex_2D = new List <int>();
List <Point3d> PointsCoords_2D = new List <Point3d>();
List <Line> Lines_2D = new List <Line>();
List <Line> Lines_3D = new List <Line>();
double err = 20;
RTree PointsCoords_2DRtree = new RTree();
bool bool1 = DA.GetDataList(0, PointsCloud_3D);
bool bool2 = DA.GetDataList(1, PointsIndex_2D);
bool bool3 = DA.GetDataList(2, PointsCoords_2D);
bool bool4 = DA.GetDataList(3, Lines_2D);
bool bool5 = DA.GetData(4, ref err);
ModelCls model = new ModelCls();
if (bool1)
{
model.Nodes = PointsCloud_3D;
}
if (bool2 && bool3)
{
for (int i = 0; i < PointsCoords_2D.Count; i++)
{
PointsCoords_2DRtree.Insert(PointsCoords_2D[i], i);
}
}
if (bool1 && bool2 && bool3 && bool4)
{
List <BeamElementCls> BeamElements = new List <BeamElementCls>();
Lines_2D.ForEach(x => BeamElements.Add(new BeamElementCls(x, 1, 1)));
int num = BeamElements.Count;
for (int i = 0; i < num; i++)
{
List <int> verticesIndex = new List <int>();
for (int j = 0; j < 2; j++)
{
Point3d chkPt = BeamElements[i].Line.PointAt((double)j);
FunctionClass.RtreeSearch(PointsCoords_2DRtree, PointsIndex_2D, chkPt, err, verticesIndex);
}
if (verticesIndex.Count == 2)
{
BeamElements[i].Nodes_no = verticesIndex;
BeamElements[i].Line = new Line(PointsCloud_3D[verticesIndex[0] - 1], PointsCloud_3D[verticesIndex[1] - 1]);
}
}
model.BeamElements = BeamElements;
BeamElements.ForEach(x => Lines_3D.Add(x.Line));
DA.SetDataList(0, Lines_3D);
DA.SetData(2, model);
}
}
RTree PopulateMeshRTree(Mesh M)
{
RTree rt = new RTree();
for (int i = 0; i < M.Vertices.Count; i++)
{
rt.Insert((Point3d)M.Vertices[i], i);
}
return(rt);
}
public void Load_Properly_Splits_Tree_Root_When_Merging_Trees_Of_Same_Height()
{
var tree = new RTree <int>(4);
tree.Load(_data);
tree.Load(_data);
Assert.AreEqual(4, tree.Height);
CompareNodes(_data.Concat(_data).ToArray(), tree.All().ToArray(), true);
}
public void AllVertexes()
{
iFacadeVertexes = new List <Point3d>();
iFacadeRTree = new RTree();
for (int i = 0; i < meshBodies[0].PtMesh.Vertices.Count; i++)
{
iFacadeVertexes.Add(meshBodies[0].PtMesh.Vertices[i].ToPoint3d());
iFacadeRTree.Insert(meshBodies[0].PtMesh.Vertices[i].ToPoint3d(), i);
}
}
private static RTree <BlockSectionKP> GetRtreeBs(List <BlockSectionKP> blocks)
{
RTree <BlockSectionKP> rtree = new RTree <BlockSectionKP> ();
foreach (var item in blocks)
{
Rectangle r = item.Rectangle;
rtree.Add(r, item);
}
return(rtree);
}
private static void BuildTree()
{
Stopwatch watch = new Stopwatch ();
watch.Start ();
sensable_tree = new RTree<Sensable> (sensables.Count, sensables.Count);
foreach (Sensable sensable in sensables) {
var pos = sensable.transform.position;
var rect = new Rectangle (new float[]{ pos.x, pos.y, pos.z }, new float[]{ pos.x, pos.y, pos.z });
sensable_tree.Add (rect, sensable);
}
watch.Stop ();
if (watch.Elapsed.TotalMilliseconds > 0)
UnityEngine.Debug.Log ("BUILD TREE: " + watch.Elapsed.TotalMilliseconds.ToString ());
}
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;
}
static void run(ArrayList words)
{
double ec = words.Count;
DateTime st = DateTime.Now;
rts = new RTree<string>[32];
for (int i = 0; i < 32; i++) rts[i] = new RTree<string>(100, 50);
long word_c = searchRtrees(words);
DateTime t2 = DateTime.Now;
TimeSpan ts2 = t2 - st;
Console.WriteLine("level " + level + " exact " + exact);
Console.WriteLine(ts2);
//Console.WriteLine(ts1);
Console.WriteLine(ts2);
// Console.WriteLine("Count " + word_c);
}
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);
}
}
static void Main(string[] args)
{
RTree<int> rtree1 = new RTree<int>(4, 0);
//rtree1.Add(new Rectangle(30, 30, 30, 30, 0, 0), 101);
//rtree1.Add(new Rectangle(12, 12, 12, 12, 0, 0), 102);
//rtree1.Add(new Rectangle(14, 14, 14, 14, 0, 0), 103);
//rtree1.Add(new Rectangle(16, 16, 16, 16, 0, 0), 104);
//rtree1.Add(new Rectangle(35, 35, 35, 35, 0, 0), 105);
rtree1.Add(new Rectangle(2, 6, 2, 6, 0, 0), 1);
rtree1.Add(new Rectangle(2.5f, 6, 2.5f, 6, 0, 0), 2);
rtree1.Add(new Rectangle(3, 5, 3, 5, 0, 0), 3);
rtree1.Add(new Rectangle(3, 6, 3, 6, 0, 0), 4);
rtree1.Add(new Rectangle(3.5f, 6, 3.5f, 6, 0, 0), 5);
rtree1.Add(new Rectangle(4, 6, 4, 6, 0, 0), 6);
rtree1.Add(new Rectangle(1.5f, 5.5f, 1.5f, 5.5f, 0, 0), 7);
rtree1.Add(new Rectangle(1.5f, 5.1f, 1.5f, 5.1f, 0, 0), 8);
rtree1.Add(new Rectangle(3.5f, 5.5f, 3.5f, 5.5f, 0, 0), 9);
rtree1.Add(new Rectangle(4, 5.5f, 4, 5.5f, 0, 0), 10);
rtree1.Add(new Rectangle(4.5f, 5.5f, 4.5f, 5.5f, 0, 0), 11); //k
Console.WriteLine("End Of Program");
}
private RTree<int> LoadRTree(string dataPath, int maxNode)
{
string rex = @"\w+ (\S+) (\S+)";
RTree<int> rtree = null;
StreamReader streamReader = null;
int count = 0;
try
{
rtree = new RTree<int>(maxNode, 0);
streamReader = new StreamReader(dataPath);
for (string line = streamReader.ReadLine();
line != null;
line = streamReader.ReadLine())
{
Match match = Regex.Match(line, rex);
if (match.Success)
{
float lat = float.Parse(match.Groups[2].Value);
float lon = float.Parse(match.Groups[1].Value);
rtree.Add(new Rectangle(lat, lon, lat, lon, 0, 0), count);
count++;
}
}
return rtree;
}
catch (Exception ex)
{
Console.WriteLine("Unable to load RTree data: " +
ex.Message);
return null;
}
finally
{
if (streamReader != null) streamReader.Close();
}
}
internal bool Run() {
if (metroGraphData.Edges.Count() == 0) return false;
var splittingPoints = new Dictionary<PointPair, List<Point>>();
var treeOfVertices = new RTree<Point>();
foreach (var vertex in Vertices()) {
var r = new Rectangle(vertex.Point);
r.Pad(ApproximateComparer.IntersectionEpsilon);
treeOfVertices.Add(r, vertex.Point);
}
var treeOfEdges = RectangleNode<PointPair>.CreateRectangleNodeOnData(Edges(), e => new Rectangle(e.First, e.Second));
RectangleNodeUtils.CrossRectangleNodes<PointPair>(treeOfEdges, treeOfEdges, (a, b) => IntersectTwoEdges(a, b, splittingPoints, treeOfVertices));
SortInsertedPoints(splittingPoints);
bool pointsInserted = InsertPointsIntoPolylines(splittingPoints);
bool progress = FixPaths();
bool pointsRemoved = RemoveUnimportantCrossings();
return progress || pointsInserted || pointsRemoved;
}
public static ModelTree BTree(double[] error_level)
{
int period = ts.freq[ts.freq.Length - 1];
int n = ts.Length / period;
ArrayList ranges = new ArrayList();
for (int i = 0; i < n; i++)
{
Range r = new Range(i * period, (i + 1) * period - 1);
r.computed = 1;
r.matched=1;
ranges.Add(r);
}
ArrayList all_ranges = new ArrayList();
//all_ranges.Add(ranges);
ArrayList nr;
foreach (double i in error_level)
{
nr = Level(ranges, i);
all_ranges.Add(nr);
ranges = nr;
}
ArrayList top = (ArrayList)all_ranges[all_ranges.Count - 1];
if (top.Count == 0)
{
top.Add(new Range(0, ts.Length - 1));
all_ranges[all_ranges.Count - 1] = top;
}
top = (ArrayList)all_ranges[all_ranges.Count - 1];
if (top.Count != 1)
{
ArrayList a=new ArrayList();
a.Add(new Range(0, ts.Length - 1));
all_ranges.Add(a);
}
RTree rt = new RTree(all_ranges,ts);
return rt.root.t;
}
StaircaseRemover(List<Path> paths, RectangleNode<Polyline> hierarchyOfObstacles) {
HierarchyOfObstacles = new RTree<Polyline>(hierarchyOfObstacles);
Paths = paths;
}
/// <summary>
///
/// </summary>
/// <param name="center"></param>
/// <param name="k"></param>
/// <returns></returns>
public override int KnnQuery(RTree.Point center, int k)
{
return 0;
/*
//Stage 1
SortedList<float, List<MBR>> nearestMBR =
new SortedList<float, List<MBR>>();
foreach (MBR mbr in this.mbrs)
{
//Get distance between center and node MBR.
List<float> bounds = mbr.getBounts();
Rectangle tempRec = new Rectangle(bounds[0], bounds[1], bounds[2], bounds[3], 0, 0);
float dist = tempRec.distance(center);
//See if this node can be ignored.
if (nearestMBR.Count >= k &&
dist >= nearestMBR.Keys[nearestMBR.Count - 1])
continue;
if (nearestMBR.ContainsKey(dist))
{
nearestMBR[dist].Add(mbr);
}
else
{
List<MBR> l = new List<MBR>();
l.Add(mbr);
nearestMBR.Add(dist, l);
}
//if (nearestNodes.Count > 2 * k)
// nearestNodes.Capacity = k;
}
//nearestNodes.Capacity = k;
//Stage 2
//Get a list of closest objects and their
//containing node.
SortedList<float, List<int>> nearestObj = new SortedList<float, List<int>>();
foreach (List<MBR> list in nearestMBR.Values)
{
foreach (Node<int> node in list)
{
for (int i = 0; i < node.getEntryCount(); i++)
{
Rectangle rec = node.getEntry(i);
float dist = rec.distance(center);
//If the distance is larger than k-th object, ignore.
if (nearestObj.Count >= k &&
dist >= nearestObj.Keys[nearestObj.Count - 1])
continue;
if (nearestObj.ContainsKey(dist))
{
nearestObj[dist].Add(node.NodeId);
}
else
{
List<int> l = new List<int>();
l.Add(node.NodeId);
nearestObj.Add(dist, l);
}
}
//if (nearestObj.Count > 2 * k)
// nearestObj.Capacity = k;
}
}
//if (nearestObj.Count > k)
// nearestObj.Capacity = k;
//Stage 3
HashSet<int> NodeIdSet = new HashSet<int>();
int result = 0;
int count = 0;
foreach (List<int> list in nearestObj.Values)
{
foreach (int id in list)
{
count++;
if (!NodeIdSet.Contains(id))
{
result += nodeMap[id].getEntryCount();
NodeIdSet.Add(id);
}
if (count >= k)
return result;
}
}
return result;*/
}
internal void CreateEmptyRailTree() {
_railTree = new RTree<Rail>();
}
bool TopologyForCallingTriangleIsCorrect() {
Point[] indexToPoints = new Point[_pointsToIndices.Count];
foreach (var pp in _pointsToIndices) {
indexToPoints[pp.Value] = pp.Key;
}
var tree =
new RTree<Point>(_pointsToIndices.Keys.Select(p => new KeyValuePair<Rectangle, Point>(new Rectangle(p), p)));
var badSegs = (from e in _segments let overlaps = GetPointsOverlappingSeg(e, tree, indexToPoints) where overlaps.Count > 2 select e).ToList();
#if TEST_MSAGL
if (badSegs.Any())
ShowInputSegments(badSegs, indexToPoints);
#endif
return !badSegs.Any();
}
public override int RangeQuery(RTree.Point center, float range)
{
throw new NotImplementedException();
}
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 run()
{
ArrayList words = readinput("c:\\data\\web2.txt");
double ec = words.Count;
DateTime st = DateTime.Now;
FilterTree ft = new FilterTree(words);
TimeSpan ts = DateTime.Now - st;
pair xx1 = ft.join(ft, 1);
//pair xx2 = ft.join(ft, 2);
DateTime et = DateTime.Now;
Console.WriteLine(ts);
Console.WriteLine(et - st);
long c1 = (long)xx1.second;
// long c2 = (long)xx2.second;
Console.WriteLine(ec);
Console.WriteLine(c1 / ec / ec);
RTree<Node> rt = new RTree<Node>();
foreach (Node w in ft.root.children.Values)
{
rt.Add(new Rectangle(w.p), w);
}
RTree<Node> rt1 = new RTree<Node>();
//ArrayList leafs1 = ft.getLeafs(1);
foreach (Node w1 in ft.root.children.Values)
{
rt1.Add(new Rectangle(w1.p), w1);
}
List<pair> a= rt.joins(rt1, 1);
long matches = 0;
foreach (pair p in a)
{
Node p1 = (Node)p.first;
Node p2 = (Node)p.second;
matches+=p1.words.Count * p2.words.Count;
}
//Console.WriteLine(c2 / ec / ec);
}
/// <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 DrawFixedRectsSegments(RTree<Rectangle> fixedRectanglesTree,
RTree<SymmetricSegment> fixedSegmentsTree) {
foreach (var fr in fixedRectanglesTree.GetAllLeaves())
DrawRectDilated(fr);
foreach (var seg in fixedSegmentsTree.GetAllLeaves()) {
DrawLineSegDilated(seg.A, seg.B);
}
}
public int PositionAllMoveableRectsSameSize(int startInd, RTree<Rectangle> fixedRectanglesTree,
RTree<SymmetricSegment> fixedSegmentsTree) {
Console.WriteLine("\nRemoving overlaps");
int i;
if (_moveableRectangles.Length == 0) return 0;
InitInsertRectSize(_moveableRectangles[startInd]);
DrawFixedRectsSegments(fixedRectanglesTree, fixedSegmentsTree);
for (i = startInd; i < _moveableRectangles.Length; i++) {
var rect = _moveableRectangles[i];
bool couldInsert;
if (IsPositionFree(rect.Center)) {
movedRectangles[i] = rect;
couldInsert = true;
}
else {
Point newPos;
couldInsert = FindClosestFreePos(rect.Center, out newPos);
movedRectangles[i] = Translate(rect, newPos - rect.Center);
}
if (!couldInsert) {
return i;
}
fixedRectanglesTree.Add(movedRectangles[i], movedRectangles[i]);
DrawRectDilated(movedRectangles[i]);
if (i%10 == 0) {
Console.Write(".");
}
}
return _moveableRectangles.Length;
}
/// <summary>
/// Construct an instance with data and RTree max node.
/// </summary>
/// <param name="dataPath">The data of the RTree. This file
/// must be in the specified format.</param>
/// <param name="maxNode">The maximum number of entries in a
/// node of the RTree.</param>
public RTreeQueryEvaluator(string dataPath, int maxNode)
{
if (dataPath == null) throw new ArgumentNullException();
if ((this.rtree = LoadRTree(dataPath, maxNode)) == null)
throw new ApplicationException("Unable to load RTree");
}
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);
}
}
}
private static List<PlayerCluster> ClusterTree(RTree<Player> tree, List<Player> players, int viewRadius)
{
var playerClusterInformations = buildPlayerClusterInformations(tree, players, viewRadius);
var playerClusters = buildPlayerClusters(players, playerClusterInformations);
return playerClusters;
}
private static Dictionary<Player, PlayerClusterInfo> buildPlayerClusterInformations(RTree<Player> tree, List<Player> players, int viewRadius)
{
Dictionary<Player, PlayerClusterInfo> playerClusterInformations = new Dictionary<Player, PlayerClusterInfo>();
for (int index = 0; index < players.Count; index++)
{
var currentPlayer = players[index];
List<Player> nearest = tree.Nearest(new Point(currentPlayer.X, currentPlayer.Y), viewRadius);
PlayerClusterInfo playerClusterInfo = new PlayerClusterInfo(currentPlayer);
for (int i = 0; i < nearest.Count; i++)
{
var nearPlayer = nearest[i];
if (nearPlayer == currentPlayer) continue;
playerClusterInfo.Neighbors.Add(new Tuple<double, Player>(pointDistance(nearPlayer, currentPlayer), nearPlayer));
}
playerClusterInformations.Add(currentPlayer, playerClusterInfo);
}
return playerClusterInformations;
}
private static void start()
{
canvas = (CanvasElement)Document.GetElementById("canvas");
context = (CanvasRenderingContext2D)canvas.GetContext(CanvasContextId.Render2D);
Offset = new Vector2(0, 0);
Vector2 draggingPos = null;
canvas.OnMousedown = @event =>
{
int mouseX = ((dynamic)@event).pageX;
int mouseY = ((dynamic)@event).pageY;
draggingPos = new Vector2(mouseX, mouseY);
};
canvas.OnMouseup = @event =>
{
/*
if (draggingPos == null) return;
int mouseX = ((dynamic)@event).pageX;
int mouseY = ((dynamic)@event).pageY;
draggingPos = new Vector2(draggingPos.X - mouseX, draggingPos.Y - mouseY);
Offset = new Vector2(Offset.X + draggingPos.X, Offset.Y + draggingPos.Y);
draw();
*/
draggingPos = null;
};
Document.OnMousemove = @event =>
{
if (draggingPos == null) return;
int mouseX = ((dynamic)@event).pageX;
int mouseY = ((dynamic)@event).pageY;
Offset = new Vector2(Offset.X + (draggingPos.X - mouseX) * 6, Offset.Y + (draggingPos.Y - mouseY) * 6);
draggingPos = new Vector2(mouseX, mouseY);
Draw();
};
canvas.Width = Document.Body.ClientWidth - 100;
canvas.Height = Document.Body.ClientHeight - 100;
context.Save();
context.Font = "50px Arial";
context.FillText("Loading...", canvas.Width / 2, canvas.Height / 2);
context.Restore();
Window.OnKeydown = @event =>
{
if (((dynamic)@event).keyCode == 17)
{
drawLines = !drawLines;
}
Draw();
};
Window.SetTimeout(() =>
{
Console.WriteLine("Started");
Console.Profile();
Stopwatch sw = new Stopwatch();
sw.Start();
tree = new RTree<Player>();
players = new List<Player>();
for (int j = 0; j < numberOfPlayers; j++)
{
var player = new Player(nextId());
player.X = rand.Next(0, gameSize);
player.Y = rand.Next(0, gameSize);
players.Add(player);
tree.Add(new Rectangle(player.X, player.Y), player);
}
buildClusters(viewRadius);
sw.Stop();
Console.ProfileEnd();
Console.WriteLine(string.Format("Time {0}", sw.ElapsedMilliseconds));
Console.WriteLine("Done");
Draw();
});
}
/*
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 static List<FacadeFrontBlock> GetFacadeFrontBlocks(BlockTableRecord ms, List<FloorMounting> floors)
{
List<FacadeFrontBlock> facadeFrontBlocks = new List<FacadeFrontBlock>();
foreach (ObjectId idEnt in ms)
{
var blRef = idEnt.GetObject(OpenMode.ForRead, false, true) as BlockReference;
if (blRef == null) { continue; }
// Если это блок обозначения стороны фасада - по имени блока
if (string.Equals(blRef.GetEffectiveName(), Settings.Default.BlockFacadeName, StringComparison.CurrentCultureIgnoreCase))
{
FacadeFrontBlock front = new FacadeFrontBlock(blRef);
facadeFrontBlocks.Add(front);
}
}
// Найти все блоки монтажных панелей входящих в фасад
RTree<FloorMounting> rtreeFloors = new RTree<FloorMounting>();
foreach (var front in floors)
{
try
{
rtreeFloors.Add(front.RectangleRTree, front);
}
catch { }
}
foreach (var front in facadeFrontBlocks)
{
// найти соотв обозн стороны фасада
var frontsIntersects = rtreeFloors.Intersects(front.RectangleRTree);
// если нет пересечений фасадов - пропускаем блок монтажки - он не входит в
// фасады, просто так вставлен
if (frontsIntersects.Count == 0)
{
Inspector.AddError($"Для блока обозначения стороны фасада не найдены монтажные планы.", front.IdBlRef, System.Drawing.SystemIcons.Error);
continue;
}
foreach (var item in frontsIntersects)
{
front.AddPanels(item);
}
front.DefineMinMax();
}
return facadeFrontBlocks;
}
