void testStringIntervals() { IntervalTree<char, String> tree; tree.addInterval('a', 'c', string("ac")); tree.addInterval('a', 'f', string("af")); tree.addInterval('d', 'k', string("dk")); tree.addInterval('d', 'l', string("dl")); tree.addInterval('d', 'o', string("do")); tree.addInterval('t', 'z', string("tz")); printTree(tree); std::list<String> result; { result = tree.getIntervalSet('b', 'g'); assert(result.size() == 5); assert(!hasNode(result, String(string("tz")))); } { result = tree.getIntervalSet('k', 'z'); assert(result.size() == 3); assert(hasNode(result, String(string("dl")))); assert(hasNode(result, String(string("do")))); assert(hasNode(result, String(string("tz")))); printResultSet(result); } }
void testBoundaries() { // 1. Create new lock and acquire lock from 1-10 IntervalTree<int, LockHolder> tree; LockHolder lockA('A'); tree.addInterval(1, 10, lockA); // 2. Create lock B on the edge LockHolder lockB('B'); tree.addInterval(10, 15, lockB); //3. Query the edge std::list<LockHolder> result = tree.getIntervalSet(10, 10); printResultSet(result); assert((result.size() == 1) && (result.front() == 'B')); }
void testRemoveInterval() { int arr[][2] ={ {1888,1971}, {1874,1951}, {1843,1907}, {1779,1828}, {1756,1791}, {1585, 1672} }; Node a(1888, 1971); Node b(1874, 1951); Node c(1843, 1907); Node d(1779, 1828); Node e(1756, 1791); Node f(1585, 1672); IntervalTree<int,Node> tree; for(size_t i=0; i < ARRAY_SIZE(arr); i++) { Node nd (arr[i][0], arr[i][1]); tree.addInterval( arr[i][0], arr[i][1], nd); } printTree(tree); std::list<Node> result; { tree.removeInterval(1951, 1972, a); result = tree.getIntervalSet(1960, 1970); assert(result.size() == 0); } { result = tree.getIntervalSet(1890, 1900); assert(result.size() == 3); assert(popNode(result, c) && popNode(result, b) && popNode(result, a)); } { tree.removeInterval(1875, 1890, c); result = tree.getIntervalSet(1877, 1889); assert(!hasNode(result, c)); } { result = tree.getIntervalSet(1906, 1910); assert(result.size() == 3); assert(hasNode(result, a)); assert(hasNode(result, b)); assert(hasNode(result, c)); } }
void testRemoveFromMiddle() { // 1. Create new lock and acquire lock from 1-10 IntervalTree<int, LockHolder> tree; LockHolder lockA('A'); tree.addInterval(1, 10, lockA); // 2. Create lock B on the edge LockHolder lockB('B'); tree.addInterval(10, 15, lockB); // 3. Remove all locks from 6-12 tree.removeInterval(6, 12); //4. Query the removed interval std::list<LockHolder> result = tree.getIntervalSet(6, 11); assert(result.size() == 0); //5. Query the interval locked by A result = tree.getIntervalSet(2, 5); assert((result.size() == 1) && (result.front() == 'A')); }
void testNames() { IntervalTree<char, string> tree; tree.addInterval('j', 'y', string("jojy")); tree.addInterval('b', 'n', string("brian")); tree.addInterval('e', 's', string("sage")); tree.addInterval('f', 'g', string("gregsf")); tree.addInterval('h', 'y', string("yehudah")); printTree(tree); std::list<string> result; { result = tree.getIntervalSet('b', 'y'); assert(result.size() == 5); printResultSet(result); } { result = tree.getIntervalSet('j', 'm'); assert(!hasNode(result, string("gregsf"))); printResultSet(result); } { tree.removeAll("jojy"); result = tree.getIntervalSet('b', 'z'); assert(!hasNode(result, string("jojy"))); printResultSet(result); } }
void testIntervalQuery() { int arr[][2] ={ {1888,1971}, {1874,1951}, {1843,1907}, {1779,1828}, {1756,1791}, {1585, 1672} }; Node a(1888, 1971); Node b(1874, 1951); Node c(1843, 1907); Node d(1779, 1828); Node e(1756, 1791); Node f(1585, 1672); IntervalTree<int,Node> tree; for(size_t i=0; i < ARRAY_SIZE(arr); i++) { Node nd (arr[i][0], arr[i][1]); tree.addInterval( arr[i][0], arr[i][1], nd); } std::list<Node> result = tree.getIntervalSet(1843, 1874); assert(result.size() == 1 && (result.front() == c)); result = tree.getIntervalSet(1873, 1974); assert(result.size() == 3); assert(popNode(result, c) && popNode(result,b) && popNode(result,a)); result = tree.getIntervalSet(1910, 1910); assert(result.size() == 2); assert(popNode(result, b) && popNode(result,a)); result = tree.getIntervalSet(1829, 1842); assert(result.size() == 0); result = tree.getIntervalSet(1829, 1845); assert(result.size() == 1); assert(popNode(result, c)); }
void testLocks() { // 1. Create new lock and acquire lock from 1-10 IntervalTree<int, LockHolder> tree; LockHolder lockA('A'); tree.addInterval(1, 10, lockA); printTree(tree); std::list<LockHolder> result; { result = tree.getIntervalSet(1,10); assert(result.size() == 1); printResultSet(result); } // Create new lock and acquire from 3-15 LockHolder lockB('B'); tree.addInterval(3, 15, lockB); { result = tree.getIntervalSet(1,15); assert(result.size() == 2); } // Release all locks from 3-10 tree.removeInterval(3,10); // Query the whole range result = tree.getIntervalSet(1,15); assert(result.size() == 2 && (result.front() == 'A') ); result.pop_front(); assert(result.front() == 'B'); // Query the range held by only A result = tree.getIntervalSet(1,5); assert(result.front().name == 'A'); // Query the range held by none result = tree.getIntervalSet(4,9); printResultSet(result); assert(!result.size()); // Again acquire lock B from 3-15 tree.addInterval(3, 15, lockB); result = tree.getIntervalSet(1,15); assert(result.size() ==2); // Query the range held by only B result = tree.getIntervalSet(4,10); assert((result.size() ==1) && (result.front().name == 'B')); // Again acquire lock A from 3-10 tree.addInterval(3, 10, lockA); result = tree.getIntervalSet(3,10); assert(result.size() ==2); // Release only locks held by B from 3-10 tree.removeInterval(3,10, lockB); // Query interval just released by B result = tree.getIntervalSet(3,9); assert((result.size() ==1) && (result.front().name == 'A')); // Query interval now partially owned by B result = tree.getIntervalSet(3,12); assert(result.size() ==2); // Add one more lock between 4-8 LockHolder lockC('C'); tree.addInterval(4, 8, lockC); printTree(tree); // Query the interval shared by A,B,C result = tree.getIntervalSet(3,12); assert(result.size() ==3); // Query the intervals shared by A, C result = tree.getIntervalSet(3, 6); assert(result.size() == 2 && (result.front() == 'A') ); result.pop_front(); assert(result.front() == 'C'); // Add one more lock between 2-4 LockHolder lockD('D'); tree.addInterval(2, 4, lockD); // Query the intervals owned by A.B,C,D result = tree.getIntervalSet(2, 11); assert(result.size () == 4); assert(popNode(result, lockA) && popNode(result, lockB) && popNode(result, lockC) && popNode(result, lockD)); }
void algorithm2(vector<Square> & squares){ priority_queue<Event, vector<Event>, CompareEvent> events; //vector<SQINTERVAL> intervals; // vector containg all vertical intervals and their rectangles IntervalTree<Square, float> activeTree; // tree containing the vertical intervals vector<SQINTERVAL> results; // contains the intersecting vertical intervals and their rectangles ofstream output; output.open("uitvoerrechthoeken.txt"); // start timer auto start = std::chrono::steady_clock::now(); for (int i = 0; i < squares.size(); i++){ Event e1 = Event(true, squares[i], squares[i].getLB().getX()); Event e2 = Event(false, squares[i], squares[i].getRA().getX()); events.push( e1 ); //left side event of rectangle events.push( e2 ); //right side event of rectangle } while (!events.empty()) { Event current = events.top(); if (current.isLeftEdge()){ if (activeTree.getIntervals().size() > 0){ activeTree.findOverlapping(current.getSquare().getLB().getY(), current.getSquare().getRA().getY(), results); vector<Coordinate> pos; for (int i = 0; i < results.size(); i++){ results[i].value.getIntersection(current.getSquare(), pos); for (int w = 0; w < pos.size(); w++){ output << pos[w].getX() << " " << pos[w].getY() << "\n"; } pos.clear(); } } activeTree.addInterval(SQINTERVAL(current.getSquare().getInterval())); activeTree.sort(); results.clear(); } else { for (vector<SQINTERVAL>::iterator i = activeTree.getIntervals().begin(); i != activeTree.getIntervals().end(); ++i){ if (current.getSquare().getId() == i->value.getId()){ activeTree.getIntervals().erase(i); break; } } results.clear(); } events.pop(); } // stop timer auto end = std::chrono::steady_clock::now(); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); output << elapsed.count() << "\n"; output.close(); cout << "Ready. \n"; cout << elapsed.count(); }