C++ IntervalTree::addInterval方法代码示例

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);
//.........这里部分代码省略.........

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();
}