void search_ND(int items){ std::vector< Rect<size> > rectangles; unsigned int edge_size = (unsigned int)ceil(pow((double)items, 1.0 / (double)size)); int no_iterations = std::max(max_elements / items, 10); generateRectangles(items, edge_size, rectangles); RTree<int, unsigned int, size, float> tree; for (size_t i = 0; i < rectangles.size(); ++i){ tree.Insert(rectangles[i].min, rectangles[i].max, i); } auto begin = std::chrono::high_resolution_clock::now(); for (int i = 0; i < no_iterations; i++){ std::vector<unsigned int> min(size, 0); for (unsigned int j = 0; j < edge_size; ++j){ std::vector<unsigned int> max(size, (j + 1)*tile_size); Rect<size> search_rect(min, max); int nhits = tree.Search(search_rect.min, search_rect.max, MySearchCallback, NULL); } } auto end = std::chrono::high_resolution_clock::now(); of << "Running " << edge_size << "queries on " << size << "D items:" << (double)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() / (double)no_iterations << "ns" << std::endl; }
void pointQueries_ND(int items){ std::vector< Rect<size> > rectangles; std::vector< Rect<size> > queries; unsigned int edge_size = (unsigned int)ceil(pow((double)items, 1.0 / (double)size)); int no_iterations = std::max(max_elements / items, 10); generateRectangles(items, edge_size, rectangles); RTree<int, unsigned int, size, float> tree; for (size_t i = 0; i < rectangles.size(); ++i){ tree.Insert(rectangles[i].min, rectangles[i].max, i); std::vector<unsigned int> min(size, i*tile_size+1); std::vector<unsigned int> max(size, i*tile_size+1); Rect<size> pointQuery(min, max); queries.push_back(pointQuery); } auto begin = std::chrono::high_resolution_clock::now(); for (int i = 0; i < no_iterations; i++){ for (size_t j = 0; j < queries.size(); j++){ tree.Search(queries[j].min, queries[j].max, MySearchCallback, NULL); } } auto end = std::chrono::high_resolution_clock::now(); of << "Running " << queries.size() << " point queries " << size << "D items:" << (double)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() / (double)no_iterations << "ns" << std::endl; }
void TestRTree::testIntersectingPairs() { RTree<SharedTestClass> tree; tree.insert(QRect(1, 1, 1, 1), new DerivedClass(QString("foo"))); QList< QPair<QRectF, SharedTestClass> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QVERIFY(pairs.count() == 1); QCOMPARE(pairs[0].first, QRectF(1, 1, 1, 1)); QCOMPARE(pairs[0].second->member, QString("foo")); QCOMPARE(pairs[0].second->type(), 1); }
void TestRTree::testRemoveRows() { RTree<QString> tree; tree.insert(QRect(1, 1, 1, 2), QString("1")); tree.insert(QRect(2, 1, 1, 3), QString("2")); tree.insert(QRect(3, 2, 1, 4), QString("3")); tree.insert(QRect(4, 2, 1, 5), QString("4")); tree.insert(QRect(5, 3, 1, 3), QString("5")); tree.insert(QRect(6, 3, 1, 4), QString("6")); tree.insert(QRect(7, 4, 1, 2), QString("7")); tree.insert(QRect(8, 4, 1, 3), QString("8")); tree.insert(QRect(9, 6, 1, 3), QString("9")); QList< QPair<QRectF, QString> > undo = tree.removeRows(3, 3); QList< QPair<QRectF, QString> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QCOMPARE(pairs.count(), 7); QCOMPARE(pairs[0].first, QRectF(1, 1, 1, 2)); QCOMPARE(pairs[0].second, QString("1")); QCOMPARE(pairs[1].first, QRectF(2, 1, 1, 2)); QCOMPARE(pairs[1].second, QString("2")); QCOMPARE(pairs[2].first, QRectF(3, 2, 1, 1)); QCOMPARE(pairs[2].second, QString("3")); QCOMPARE(pairs[3].first, QRectF(4, 2, 1, 2)); QCOMPARE(pairs[3].second, QString("4")); QCOMPARE(pairs[4].first, QRectF(6, 3, 1, 1)); QCOMPARE(pairs[4].second, QString("6")); QCOMPARE(pairs[5].first, QRectF(8, 3, 1, 1)); QCOMPARE(pairs[5].second, QString("8")); QCOMPARE(pairs[6].first, QRectF(9, 3, 1, 3)); QCOMPARE(pairs[6].second, QString("9")); QCOMPARE(undo.count(), 2); QCOMPARE(undo[0].first.toRect(), QRect(5, 3, 1, 3)); QCOMPARE(undo[0].second, QString("5")); QCOMPARE(undo[1].first.toRect(), QRect(7, 4, 1, 2)); QCOMPARE(undo[1].second, QString("7")); }
void TestRTree::testInsertShiftDown() { RTree<SharedTestClass> tree; tree.insert(QRect(2, 2, 1, 2), new DerivedClass(QString("foo"))); tree.insertShiftDown(QRect(2, 1, 4, 3)); QList< QPair<QRectF, SharedTestClass> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QCOMPARE(pairs.count(), 3); QCOMPARE(pairs[0].first, QRectF(2, 2, 1, 2)); QCOMPARE(pairs[0].second->member, QString("foo")); QCOMPARE(pairs[1].first, QRectF(2, 1, 4, KS_rowMax)); QCOMPARE(pairs[1].second->member, QString("")); QCOMPARE(pairs[2].first, QRectF(2, 5, 1, 2)); QCOMPARE(pairs[2].second->member, QString("foo")); }
void TestRTree::testRemoveShiftLeft() { RTree<SharedTestClass> tree; tree.insert(QRect(5, 2, 2, 1), new DerivedClass(QString("foo"))); tree.removeShiftLeft(QRect(2, 1, 3, 4)); QList< QPair<QRectF, SharedTestClass> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QCOMPARE(pairs.count(), 3); QCOMPARE(pairs[0].first, QRectF(5, 2, 2, 1)); QCOMPARE(pairs[0].second->member, QString("foo")); QCOMPARE(pairs[1].first, QRectF(2, 1, KS_colMax - 1, 4)); QCOMPARE(pairs[1].second->member, QString("")); QCOMPARE(pairs[2].first, QRectF(2, 2, 2, 1)); QCOMPARE(pairs[2].second->member, QString("foo")); }
void main() { RTree<int, int, 2, float> tree; int i, nhits; printf("nrects = %d\n", nrects); for(i=0; i<nrects; i++) { tree.Insert(rects[i].min, rects[i].max, i); // Note, all values including zero are fine in this version } nhits = tree.Search(search_rect.min, search_rect.max, MySearchCallback, NULL); printf("Search resulted in %d hits\n", nhits); // Iterator test int itIndex = 0; RTree<int, int, 2, float>::Iterator it; for( tree.GetFirst(it); !tree.IsNull(it); tree.GetNext(it) ) { int value = tree.GetAt(it); int boundsMin[2] = {0,0}; int boundsMax[2] = {0,0}; it.GetBounds(boundsMin, boundsMax); printf("it[%d] %d = (%d,%d,%d,%d)\n", itIndex++, value, boundsMin[0], boundsMin[1], boundsMax[0], boundsMax[1]); } // Iterator test, alternate syntax itIndex = 0; tree.GetFirst(it); while( !it.IsNull() ) { int value = *it; ++it; printf("it[%d] %d\n", itIndex++, value); } getchar(); // Wait for keypress on exit so we can read console output // Output: // // nrects = 4 // Hit data rect 1 // Hit data rect 2 // Search resulted in 2 hits // it[0] 0 = (0,0,2,2) // it[1] 1 = (5,5,7,7) // it[2] 2 = (8,5,9,6) // it[3] 3 = (7,1,9,2) // it[0] 0 // it[1] 1 // it[2] 2 // it[3] 3 }
bool inExclusionZone( SPoint2 &p, RTree<surfacePointWithExclusionRegion *, double, 2, double> &rtree, std::vector<surfacePointWithExclusionRegion *> &all) { // should assert that the point is inside the domain // OLD BGM if(old_algo_hexa()) { if(!backgroundMesh::current()->inDomain(p.x(), p.y(), 0)) return true; } else { // NEW BGM if(!BGMManager::current2D()->inDomain(p.x(), p.y(), 0)) return true; } my_wrapper w(p); double _min[2] = {p.x() - 1.e-1, p.y() - 1.e-1}, _max[2] = {p.x() + 1.e-1, p.y() + 1.e-1}; rtree.Search(_min, _max, rtree_callback, &w); return w._tooclose; for(unsigned int i = 0; i < all.size(); ++i) { if(all[i]->inExclusionZone(p)) { // printf("%g %g is in exclusion zone of %g // %g\n",p.x(),p.y(),all[i]._center.x(),all[i]._center.y()); return true; } } return false; }
bool filteringCallback( PointSet *pset, void *ctx ) { RTree<LabelPosition*, double, 2, double> *cdtsIndex = (( FilterContext* ) ctx )->cdtsIndex; double scale = (( FilterContext* ) ctx )->scale; Pal* pal = (( FilterContext* )ctx )->pal; double amin[2], amax[2]; pset->getBoundingBox( amin, amax ); LabelPosition::PruneCtx pruneContext; pruneContext.scale = scale; pruneContext.obstacle = pset; pruneContext.pal = pal; cdtsIndex->Search( amin, amax, LabelPosition::pruneCallback, ( void* ) &pruneContext ); return true; }
void read(const cv::FileNode& node, RTree &f, const RTree& default_value) { if (node.empty()) { f = default_value; cout << "! One default Regressor." << endl; } else f.read(node); }
bool filteringCallback( FeaturePart *featurePart, void *ctx ) { RTree<LabelPosition *, double, 2, double> *cdtsIndex = ( reinterpret_cast< FilterContext * >( ctx ) )->cdtsIndex; Pal *pal = ( reinterpret_cast< FilterContext * >( ctx ) )->pal; if ( pal->isCanceled() ) return false; // do not continue searching double amin[2], amax[2]; featurePart->getBoundingBox( amin, amax ); LabelPosition::PruneCtx pruneContext; pruneContext.obstacle = featurePart; pruneContext.pal = pal; cdtsIndex->Search( amin, amax, LabelPosition::pruneCallback, static_cast< void * >( &pruneContext ) ); return true; }
void insert_ND(int items){ std::vector< Rect<size> > rectangles; int no_iterations = std::max(max_elements / items, 10); unsigned int edge_size = (unsigned int)ceil(pow((double)items, 1.0 / (double)size)); generateRectangles(items, edge_size, rectangles); auto begin = std::chrono::high_resolution_clock::now(); for (int i = 0; i < no_iterations; i++){ RTree<unsigned int, unsigned int, size, float> tree; for (size_t j = 0; j < rectangles.size(); ++j){ tree.Insert(rectangles[j].min, rectangles[j].max, j); } } auto end = std::chrono::high_resolution_clock::now(); of << "Inserting " << rectangles.size() << " " << size << "D items:" << (double)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() / (double)no_iterations << "ns" << std::endl; }
void TestRTree::testPrimitive() { RTree<bool> tree; tree.insert(QRect(2, 5, 1, 2), true); QCOMPARE(tree.contains(QPoint(2, 2)).isEmpty(), true); QCOMPARE(tree.contains(QPoint(2, 5)).first(), true); QCOMPARE(tree.contains(QPoint(3, 5)).isEmpty(), true); QCOMPARE(tree.contains(QPoint(2, 6)).first(), true); const QList< QPair<QRectF, bool> > pairs = tree.intersectingPairs(QRect(2, 5, 1, 2)).values(); QCOMPARE(pairs.count(), 1); QCOMPARE(pairs.first().first.toRect(), QRect(2, 5, 1, 2)); QCOMPARE(pairs.first().second, true); }
void search_ND_All(int items){ std::vector< Rect<size> > rectangles; unsigned int edge_size = (unsigned int)ceil(pow((double)items, 1.0 / (double)size)); int no_iterations = std::max(max_elements / items, 10); generateRectangles(items, edge_size, rectangles); RTree<int, unsigned int, size, float> tree; for (size_t i = 0; i < rectangles.size(); ++i){ tree.Insert(rectangles[i].min, rectangles[i].max, i); } auto begin = std::chrono::high_resolution_clock::now(); for (int i = 0; i < no_iterations; i++){ for (size_t j = 0; j < rectangles.size(); j++){ tree.Search(rectangles[j].min, rectangles[j].max, MySearchCallback, NULL); } } auto end = std::chrono::high_resolution_clock::now(); of << "Querying tree with " << rectangles.size() << " tiles using " << items << " queries over " << size << "D items:" << (double)std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() / (double)no_iterations << "ns" << std::endl; }
int main() { RTree tree; for(int i = 0;i < DATA_NUMBER; ++i) { double min[2],max[2]; min[0] = rand() % MAP_SIZE; max[0] = min[0]; min[1] = rand() % MAP_SIZE; max[1] = min[1]; tree.Insert(min, max, i); //Insert (x,y,id) } outFileData(&tree); //tree.fileInsert("data.txt"); //tree.printRec(tree.getMBR(tree.getRoot())); RTree::Iterator it; for( tree.GetFirst(it); !tree.IsNull(it); tree.GetNext(it) ) { int value = tree.GetAt(it); double x,y; it.GetCard(&x,&y); cout << "ID " << value << " : " << "(" << x << "," << y << ")" << endl; } Table1 table1; Table2 table2; Table3 table3; generateTable(&tree,&table1,&table2,&table3); printTable(&table1,&table2,&table3); outFileTable(&table1,&table2,&table3); TimeCounter tc; double CreateTime = 0.0; tc.StartTime(); cout << QueryPlan(&tree,K_NEAREST) << endl; CreateTime = tc.EndTime(); cout << "QueryPlan Time: " << CreateTime << " ms" << endl; // outFileRect(&tree); system("pause"); return 0; }
void TestRTree::testInsertColumns() { // RTree::InsertMode = RTree::CopyPrevious RTree<QString> tree; tree.insert(QRect(1, 1, 2, 1), QString("1")); tree.insert(QRect(1, 2, 3, 1), QString("2")); tree.insert(QRect(2, 3, 4, 1), QString("3")); tree.insert(QRect(2, 4, 5, 1), QString("4")); tree.insert(QRect(3, 5, 3, 1), QString("5")); tree.insert(QRect(3, 6, 4, 1), QString("6")); tree.insert(QRect(4, 7, 2, 1), QString("7")); tree.insert(QRect(4, 8, 3, 1), QString("8")); tree.insert(QRect(6, 9, 3, 1), QString("9")); QList< QPair<QRectF, QString> > undo = tree.insertColumns(3, 3); QList< QPair<QRectF, QString> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QCOMPARE(pairs.count(), 9); QCOMPARE(pairs[0].first, QRectF(1, 1, 5, 1)); QCOMPARE(pairs[0].second, QString("1")); QCOMPARE(pairs[1].first, QRectF(1, 2, 6, 1)); QCOMPARE(pairs[1].second, QString("2")); QCOMPARE(pairs[2].first, QRectF(2, 3, 7, 1)); QCOMPARE(pairs[2].second, QString("3")); QCOMPARE(pairs[3].first, QRectF(2, 4, 8, 1)); QCOMPARE(pairs[3].second, QString("4")); QCOMPARE(pairs[4].first, QRectF(6, 5, 3, 1)); QCOMPARE(pairs[4].second, QString("5")); QCOMPARE(pairs[5].first, QRectF(6, 6, 4, 1)); QCOMPARE(pairs[5].second, QString("6")); QCOMPARE(pairs[6].first, QRectF(7, 7, 2, 1)); QCOMPARE(pairs[6].second, QString("7")); QCOMPARE(pairs[7].first, QRectF(7, 8, 3, 1)); QCOMPARE(pairs[7].second, QString("8")); QCOMPARE(pairs[8].first, QRectF(9, 9, 3, 1)); QCOMPARE(pairs[8].second, QString("9")); QCOMPARE(undo.count(), 0); #if 0 // RTree::InsertMode = RTree::CopyCurrent tree.clear(); tree.insert(QRect(1, 1, 2, 1), QString("1")); tree.insert(QRect(1, 2, 3, 1), QString("2")); undo = tree.insertColumns(3, 3, RTree<QString>::CopyCurrent); pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)); QCOMPARE(pairs.count(), 2); QCOMPARE(pairs[0].first, QRectF(1, 1, 2, 1)); QCOMPARE(pairs[1].first, QRectF(1, 2, 6, 1)); QCOMPARE(undo.count(), 0); // RTree::InsertMode = RTree::CopyNone tree.clear(); tree.insert(QRect(1, 1, 2, 1), QString("1")); tree.insert(QRect(1, 2, 3, 1), QString("2")); undo = tree.insertColumns(3, 3, RTree<QString>::CopyNone); pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)); QCOMPARE(pairs.count(), 3); QCOMPARE(pairs[0].first, QRectF(1, 1, 2, 1)); QCOMPARE(pairs[1].first, QRectF(1, 2, 2, 1)); QCOMPARE(pairs[2].first, QRectF(6, 2, 1, 1)); QCOMPARE(undo.count(), 0); #endif }
Status MultiIndexBlock::init(const std::vector<BSONObj>& indexSpecs) { WriteUnitOfWork wunit(_txn); invariant(_indexes.empty()); _txn->recoveryUnit()->registerChange(new CleanupIndexesVectorOnRollback(this)); const string& ns = _collection->ns().ns(); Status status = _collection->getIndexCatalog()->checkUnfinished(); if ( !status.isOK() ) return status; for ( size_t i = 0; i < indexSpecs.size(); i++ ) { BSONObj info = indexSpecs[i]; string pluginName = IndexNames::findPluginName( info["key"].Obj() ); //log() << "PLUGIN IS " << pluginName; // CUSTOM if (pluginName == "test") { // YOU SHOULD BE ABLE TO MAKE TE INDEX HERE //log() << "INX_CREATE NUM REC:" << _collection->numRecords(_txn); RecordIterator* ri = _collection->getIterator(_txn); std::vector<Entry*> initialEntries; while (!ri->isEOF()) { //log() << "SEE ITEM"; RecordData recordData = ri->dataFor(ri->curr()); //log() << "VALU IS " << recordData.toBson(); std::vector<double> lower; std::vector<double> upper; bool foundOK = false; if (recordData.toBson().getFieldDotted("loc")["lng"].ok()) { // A POINT log() << "ELE IS A POINT: " << recordData.toBson().getFieldDotted("loc")["lng"].Double() << " AND " << recordData.toBson().getFieldDotted("loc")["lat"].Double(); lower.push_back(recordData.toBson().getFieldDotted("loc")["lng"].Double()); lower.push_back(recordData.toBson().getFieldDotted("loc")["lat"].Double()); upper.push_back(recordData.toBson().getFieldDotted("loc")["lng"].Double()); upper.push_back(recordData.toBson().getFieldDotted("loc")["lat"].Double()); foundOK = true; } else { //log() << "NOT OK LINE!"; } if (recordData.toBson().getFieldDotted("loc")["type"].ok()) { if (recordData.toBson().getFieldDotted("loc")["type"].String() == "Polygon") { //log() << "ITS A POLY"; // << recordData.toBson().getFieldDotted("loc")["rew"].Double(); lower.push_back(recordData.toBson().getFieldDotted("loc")["coordinates"].Array().at(0).Array().at(0).Array().at(0).Double()); lower.push_back(recordData.toBson().getFieldDotted("loc")["coordinates"].Array().at(0).Array().at(0).Array().at(1).Double()); upper.push_back(recordData.toBson().getFieldDotted("loc")["coordinates"].Array().at(0).Array().at(2).Array().at(0).Double()); upper.push_back(recordData.toBson().getFieldDotted("loc")["coordinates"].Array().at(0).Array().at(2).Array().at(1).Double()); foundOK = true; } } else { //log() << "NOT OK POLY!"; } if (foundOK) { std::unordered_map<int, std::string> newDoc; BoundingBox I = BoundingBox(lower, upper); Entry* myEnt = new Entry(I, newDoc); initialEntries.push_back(myEnt); } ri->getNext(); } int dimensions = 2; int max = 6; int min = 3; log() << "RTRee creation has begun!"; //create a new Node, this will be the root node std::vector<Entry*> newV; Node* R = new Node(dimensions, newV, max, min, true); //create a new RTree RTree myIndex = RTree(dimensions, R, max, min); //insert the entries we created into myIndex RTree for (int i = 0; i<initialEntries.size(); i++){ //log() << "started inserting entry " << i << " which has lat "; Entry* current = initialEntries.at(i); //log() << "started inserting entry " << i << " which has lat " << current->getI().get_ithLower(0) << "," << current->getI().get_ithLower(1); //log() << "started inserting entry " << i << " which has lat " << current->getI().get_ithUpper(0) << "," << current->getI().get_ithUpper(1); myIndex.insert(current); //log() << "finished inserting entry " << i; } log() << "inserted all initial entries!"; myIndex.theTree = &myIndex; double rand1 = -100;//0;//-2.0;// 2.0;// double rand2 = -100;//0;//-3.0;// 1.0;// double rand3 = 100;//50;//2.0;// 4.0;// double rand4 = 100;//50;//3.0;// 4.0;// std::vector<double> lowerBB; lowerBB.push_back(rand1); lowerBB.push_back(rand2); std::vector<double> upperBB; upperBB.push_back(rand3); upperBB.push_back(rand4); BoundingBox* IBB = new BoundingBox(lowerBB, upperBB);//this is the bounding box we will be searching for std::vector<Entry*> overlapping = myIndex.search(IBB); // just leave this for now //cout << "found: " << overlapping.size() << " search results when searching for I = "; //cout << "lower bounds: " << I.getLower() << endl; //cout << "upper bounds: " << I.getUpper() << endl; /*log() << "SEARCH FOUND " << overlapping.size() << " RESULTS" << endl; for(int i=0; i<overlapping.size();i++){ log() << "Entry " << i << endl; //TODO print Entry log() << overlapping.at(i)->getI().get_ithLower(0)<< " "<< overlapping.at(i)->getI().get_ithLower(1) << endl; log() << overlapping.at(i)->getI().get_ithUpper(0)<< " " << overlapping.at(i)->getI().get_ithUpper(1) << endl; }*/ return Status::OK(); } // CUSTOM if ( pluginName.size() ) { Status s = _collection->getIndexCatalog()->_upgradeDatabaseMinorVersionIfNeeded(_txn, pluginName); if ( !s.isOK() ) return s; } // Any foreground indexes make all indexes be built in the foreground. _buildInBackground = (_buildInBackground && info["background"].trueValue()); } for ( size_t i = 0; i < indexSpecs.size(); i++ ) { BSONObj info = indexSpecs[i]; StatusWith<BSONObj> statusWithInfo = _collection->getIndexCatalog()->prepareSpecForCreate( _txn, info ); Status status = statusWithInfo.getStatus(); if ( !status.isOK() ) return status; info = statusWithInfo.getValue(); IndexToBuild index; index.block = boost::make_shared<IndexCatalog::IndexBuildBlock>(_txn, _collection, info); status = index.block->init(); if ( !status.isOK() ) return status; index.real = index.block->getEntry()->accessMethod(); status = index.real->initializeAsEmpty(_txn); if ( !status.isOK() ) return status; if (!_buildInBackground) { // Bulk build process requires foreground building as it assumes nothing is changing // under it. index.bulk.reset(index.real->initiateBulk(_txn)); } const IndexDescriptor* descriptor = index.block->getEntry()->descriptor(); index.options.logIfError = false; // logging happens elsewhere if needed. index.options.dupsAllowed = !descriptor->unique() || _ignoreUnique || repl::getGlobalReplicationCoordinator() ->shouldIgnoreUniqueIndex(descriptor); log() << "build index on: " << ns << " properties: " << descriptor->toString(); if (index.bulk) log() << "\t building index using bulk method"; // TODO SERVER-14888 Suppress this in cases we don't want to audit. audit::logCreateIndex(_txn->getClient(), &info, descriptor->indexName(), ns); _indexes.push_back( index ); } // this is so that operations examining the list of indexes know there are more keys to look // at when doing things like in place updates, etc... _collection->infoCache()->addedIndex(_txn); if (_buildInBackground) _backgroundOperation.reset(new BackgroundOperation(ns)); wunit.commit(); return Status::OK(); }
int main() { tree.insert(generateBound(1, 2), 1); tree.insert(generateBound(1, 2), 2); tree.insert(generateBound(1, 2), 3); tree.insert(generateBound(1, 2), 4); tree.insert(generateBound(1, 2), 5); tree.insert(generateBound(1, 2), 6); tree.insert(generateBound(1, 2), 7); tree.insert(generateBound(1, 2), 8); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.remove(generateBound(1, 2)); tree.travel(); tree.insert(generateBound(1, 2), 1); tree.insert(generateBound(1, 2), 2); tree.insert(generateBound(1, 2), 3); tree.insert(generateBound(1, 2), 4); tree.insert(generateBound(1, 2), 5); tree.insert(generateBound(1, 2), 6); tree.insert(generateBound(1, 2), 7); tree.insert(generateBound(1, 2), 8); auto ret = tree.getPointSet(generateBound(1, 2)); printf("%d\n", (int)ret.size()); std::sort(ret.begin(), ret.end()); for (auto element : ret) { printf("%d\n", element); } return 0; }
extern "C" _declspec(dllexport) int getsearch(int record[],char * filename ) { fstream file; file.open(filename, ios::in); RTFileStream rts;//creat a file stream with necessary check, or tree.Load directly is also ok. hitcount=0; if(havebuild==0) tree.Load("h:\\projectdata\\database3.rtr"); havebuild=1; double value; int length; Rect searchrec; file>>length; for(int j=0;j<length;j++) file>>value; file>>length; for(int j=0;j<length;j++) { file>>value; searchrec.min[j]=value; searchrec.max[j]=value; } for(int i=0;i<length;i++) { int tempmax=-99,tempmin=99; for(int j=max(i-K,0);j<=min(length-1,i+K);j++) { if(searchrec.min[i]<tempmin) tempmin=searchrec.min[i]; if(searchrec.max[i]>tempmax) tempmax=searchrec.max[i]; } searchrec.max[i]=tempmax; searchrec.min[i]=tempmin; } file.close(); // double * searchseq=paa(des,length); /*Rect searchrec; for(int i=0;i<DIM;i++) { searchrec.max[i]=T; searchrec.min[i]=-T; }*/ for(int j=0;j<length;j++) { searchrec.min[j]-=T; searchrec.max[j]+=T; } tree.Search(searchrec.min,searchrec.max,MySearchCallback,NULL); for(int i=0;i<hitcount;i++) record[i]=localrecord[i]; return hitcount; }
/** * \Brief Problem Factory * Select features from user's choice layers within * a specific bounding box * param nbLayers # wanted layers * param layersFactor layers importance * param layersName layers in problem * param lambda_min west bbox * param phi_min south bbox * param lambda_max east bbox * param phi_max north bbox * param scale the scale */ Problem* Pal::extract( int nbLayers, char **layersName, double *layersFactor, double lambda_min, double phi_min, double lambda_max, double phi_max, double scale, std::ofstream *svgmap ) { // to store obstacles RTree<PointSet*, double, 2, double> *obstacles = new RTree<PointSet*, double, 2, double>(); Problem *prob = new Problem(); int i, j; double bbx[4]; double bby[4]; double amin[2]; double amax[2]; int max_p = 0; LabelPosition* lp; bbx[0] = bbx[3] = amin[0] = prob->bbox[0] = lambda_min; bby[0] = bby[1] = amin[1] = prob->bbox[1] = phi_min; bbx[1] = bbx[2] = amax[0] = prob->bbox[2] = lambda_max; bby[2] = bby[3] = amax[1] = prob->bbox[3] = phi_max; prob->scale = scale; prob->pal = this; LinkedList<Feats*> *fFeats = new LinkedList<Feats*> ( ptrFeatsCompare ); FeatCallBackCtx *context = new FeatCallBackCtx(); context->fFeats = fFeats; context->scale = scale; context->obstacles = obstacles; context->candidates = prob->candidates; context->bbox_min[0] = amin[0]; context->bbox_min[1] = amin[1]; context->bbox_max[0] = amax[0]; context->bbox_max[1] = amax[1]; #ifdef _EXPORT_MAP_ context->svgmap = svgmap; #endif #ifdef _VERBOSE_ std::cout << nbLayers << "/" << layers->size() << " layers to extract " << std::endl; std::cout << "scale is 1:" << scale << std::endl << std::endl; #endif /* First step : extract feature from layers * * */ int oldNbft = 0; Layer *layer; std::list<char*> *labLayers = new std::list<char*>(); lyrsMutex->lock(); for ( i = 0; i < nbLayers; i++ ) { for ( std::list<Layer*>::iterator it = layers->begin(); it != layers->end(); it++ ) // iterate on pal->layers { layer = *it; // Only select those who are active and labellable (with scale constraint) or those who are active and which must be treated as obstaclewhich must be treated as obstacle if ( layer->active && ( layer->obstacle || ( layer->toLabel && layer->isScaleValid( scale ) ) ) ) { // check if this selected layers has been selected by user if ( strcmp( layersName[i], layer->name ) == 0 ) { // check for connected features with the same label text and join them if ( layer->getMergeConnectedLines() ) layer->joinConnectedFeatures(); context->layer = layer; context->priority = layersFactor[i]; // lookup for feature (and generates candidates list) #ifdef _EXPORT_MAP_ *svgmap << "<g inkscape:label=\"" << layer->name << "\"" << std::endl << " inkscape:groupmode=\"layer\"" << std::endl << " id=\"" << layer->name << "\">" << std::endl << std::endl; #endif context->layer->modMutex->lock(); context->layer->rtree->Search( amin, amax, extractFeatCallback, ( void* ) context ); context->layer->modMutex->unlock(); #ifdef _EXPORT_MAP_ *svgmap << "</g>" << std::endl << std::endl; #endif #ifdef _VERBOSE_ std::cout << "Layer's name: " << layer->getName() << std::endl; std::cout << " scale range: " << layer->getMinScale() << "->" << layer->getMaxScale() << std::endl; std::cout << " active:" << layer->isToLabel() << std::endl; std::cout << " obstacle:" << layer->isObstacle() << std::endl; std::cout << " toLabel:" << layer->isToLabel() << std::endl; std::cout << " # features: " << layer->getNbFeatures() << std::endl; std::cout << " # extracted features: " << context->fFeats->size() - oldNbft << std::endl; #endif if ( context->fFeats->size() - oldNbft > 0 ) { char *name = new char[strlen( layer->getName() ) +1]; strcpy( name, layer->getName() ); labLayers->push_back( name ); } oldNbft = context->fFeats->size(); break; } } } } delete context; lyrsMutex->unlock(); prob->nbLabelledLayers = labLayers->size(); prob->labelledLayersName = new char*[prob->nbLabelledLayers]; for ( i = 0; i < prob->nbLabelledLayers; i++ ) { prob->labelledLayersName[i] = labLayers->front(); labLayers->pop_front(); } delete labLayers; if ( fFeats->size() == 0 ) { #ifdef _VERBOSE_ std::cout << std::endl << "Empty problem" << std::endl; #endif delete fFeats; delete prob; delete obstacles; return NULL; } prob->nbft = fFeats->size(); prob->nblp = 0; prob->featNbLp = new int [prob->nbft]; prob->featStartId = new int [prob->nbft]; prob->inactiveCost = new double[prob->nbft]; Feats *feat; #ifdef _VERBOSE_ std::cout << "FIRST NBFT : " << prob->nbft << std::endl; #endif // Filtering label positions against obstacles amin[0] = amin[1] = -DBL_MAX; amax[0] = amax[1] = DBL_MAX; FilterContext filterCtx; filterCtx.cdtsIndex = prob->candidates; filterCtx.scale = prob->scale; filterCtx.pal = this; obstacles->Search( amin, amax, filteringCallback, ( void* ) &filterCtx ); int idlp = 0; for ( i = 0; i < prob->nbft; i++ ) /* foreach feature into prob */ { feat = fFeats->pop_front(); #ifdef _DEBUG_FULL_ std::cout << "Feature:" << feat->feature->layer->name << "/" << feat->feature->uid << std::endl; #endif prob->featStartId[i] = idlp; prob->inactiveCost[i] = pow( 2, 10 - 10 * feat->priority ); switch ( feat->feature->getGeosType() ) { case GEOS_POINT: max_p = point_p; break; case GEOS_LINESTRING: max_p = line_p; break; case GEOS_POLYGON: max_p = poly_p; break; } // sort candidates by cost, skip less interesting ones, calculate polygon costs (if using polygons) max_p = CostCalculator::finalizeCandidatesCosts( feat, max_p, obstacles, bbx, bby ); #ifdef _DEBUG_FULL_ std::cout << "All Cost are setted" << std::endl; #endif // only keep the 'max_p' best candidates for ( j = max_p; j < feat->nblp; j++ ) { // TODO remove from index feat->lPos[j]->removeFromIndex( prob->candidates ); delete feat->lPos[j]; } feat->nblp = max_p; // update problem's # candidate prob->featNbLp[i] = feat->nblp; prob->nblp += feat->nblp; // add all candidates into a rtree (to speed up conflicts searching) for ( j = 0; j < feat->nblp; j++, idlp++ ) { lp = feat->lPos[j]; //lp->insertIntoIndex(prob->candidates); lp->setProblemIds( i, idlp ); // bugfix #1 (maxence 10/23/2008) } fFeats->push_back( feat ); } #ifdef _DEBUG_FULL_ std::cout << "Malloc problem...." << std::endl; #endif idlp = 0; int nbOverlaps = 0; prob->labelpositions = new LabelPosition*[prob->nblp]; //prob->feat = new int[prob->nblp]; #ifdef _DEBUG_FULL_ std::cout << "problem malloc'd" << std::endl; #endif j = 0; while ( fFeats->size() > 0 ) // foreach feature { feat = fFeats->pop_front(); for ( i = 0; i < feat->nblp; i++, idlp++ ) // foreach label candidate { lp = feat->lPos[i]; lp->resetNumOverlaps(); // make sure that candidate's cost is less than 1 lp->validateCost(); prob->labelpositions[idlp] = lp; //prob->feat[idlp] = j; lp->getBoundingBox( amin, amax ); // lookup for overlapping candidate prob->candidates->Search( amin, amax, LabelPosition::countOverlapCallback, ( void* ) lp ); nbOverlaps += lp->getNumOverlaps(); #ifdef _DEBUG_FULL_ std::cout << "Nb overlap for " << idlp << "/" << prob->nblp - 1 << " : " << lp->nbOverlap << std::endl; #endif } j++; delete[] feat->lPos; delete feat; } delete fFeats; //delete candidates; delete obstacles; nbOverlaps /= 2; prob->all_nblp = prob->nblp; prob->nbOverlap = nbOverlaps; #ifdef _VERBOSE_ std::cout << "nbOverlap: " << prob->nbOverlap << std::endl; std::cerr << scale << "\t" << prob->nbft << "\t" << prob->nblp << "\t" << prob->nbOverlap << "\t"; #endif return prob; }
void Filler2D::pointInsertion2D(GFace* gf, vector<MVertex*> &packed, vector<SMetric3> &metrics) { // NB/ do not use the mesh in GFace, use the one in backgroundMesh2D! // if(debug) cout << " ------------------ OLD -------------------" << endl; // stringstream ssa; //// ssa << "oldbgm_angles_" << gf->tag() << ".pos"; //// backgroundMesh::current()->print(ssa.str(),gf,1); // ssa << "oldbgm_sizes_" << gf->tag() << ".pos"; // backgroundMesh::current()->print(ssa.str(),gf,0); // // // // // if(debug) cout << " ------------------ NEW -------------------" << endl; // backgroundMesh2D *bgm2 = dynamic_cast<backgroundMesh2D*>(BGMManager::get(gf)); // stringstream ss2; // ss2 << "basebg_sizefield_" << gf->tag() << ".pos"; // bgm2->exportSizeField(ss2.str()); // // // // return; // BGMManager::set_use_cross_field(true); const bool goNonLinear = true; const bool debug=false; const bool export_stuff=true; if (debug) cout << "ENTERING POINTINSERTION2D" << endl; double a; // acquire background mesh if(debug) cout << "pointInsertion2D: recover BGM" << endl; a=Cpu(); frameFieldBackgroundMesh2D *bgm = dynamic_cast<frameFieldBackgroundMesh2D*>(BGMManager::get(gf)); time_bgm_and_smoothing += (Cpu() - a); if (!bgm){ Msg::Error("BGM dynamic cast failed in filler2D::pointInsertion2D"); return; } // export BGM size field if(export_stuff){ cout << "pointInsertion2D: export size field " << endl; stringstream ss; ss << "bg2D_sizefield_" << gf->tag() << ".pos"; bgm->exportSizeField(ss.str()); cout << "pointInsertion2D : export crossfield " << endl; stringstream sscf; sscf << "bg2D_crossfield_" << gf->tag() << ".pos"; bgm->exportCrossField(sscf.str()); cout << "pointInsertion2D : export smoothness " << endl; stringstream sss; sss << "bg2D_smoothness_" << gf->tag() << ".pos"; bgm->exportSmoothness(sss.str()); } // point insertion algorithm: a=Cpu(); // for debug check... int priority_counter=0; map<MVertex*,int> vert_priority; // get all the boundary vertices if(debug) cout << "pointInsertion2D : get bnd vertices " << endl; set<MVertex*> bnd_vertices = bgm->get_vertices_of_maximum_dim(1); // put boundary vertices in a fifo queue set<smoothness_point_pair, compareSurfacePointWithExclusionRegionPtr_Smoothness> fifo; vector<surfacePointWithExclusionRegion*> vertices; // initiate the rtree if(debug) cout << "pointInsertion2D : initiate RTree " << endl; RTree<surfacePointWithExclusionRegion*,double,2,double> rtree; SMetric3 metricField(1.0); SPoint2 newp[4][NUMDIR]; set<MVertex*>::iterator it = bnd_vertices.begin() ; for (; it != bnd_vertices.end() ; ++it){ SPoint2 midpoint; computeFourNeighbors(bgm,*it, midpoint, goNonLinear, newp, metricField); surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion (*it, newp, midpoint,metricField); smoothness_point_pair mp; mp.ptr = sp; mp.rank=(1.-bgm->get_smoothness(midpoint[0],midpoint[1])); fifo.insert(mp); vertices.push_back(sp); double _min[2],_max[2]; sp->minmax(_min,_max); rtree.Insert(_min,_max,sp); } // ---------- main loop ----------------- while(!fifo.empty()){ if(debug) cout << " -------- fifo.size() = " << fifo.size() << endl; int count_nbaddedpt = 0; surfacePointWithExclusionRegion * parent = (*fifo.begin()).ptr; fifo.erase(fifo.begin()); for (int dir=0;dir<NUMDIR;dir++){ for (int i=0;i<4;i++){ if (!inExclusionZone (parent->_p[i][dir], rtree, vertices) ){ GPoint gp = gf->point(parent->_p[i][dir]); MFaceVertex *v = new MFaceVertex(gp.x(),gp.y(),gp.z(),gf,gp.u(),gp.v()); SPoint2 midpoint; computeFourNeighbors(bgm,v, midpoint, goNonLinear, newp, metricField); surfacePointWithExclusionRegion *sp = new surfacePointWithExclusionRegion (v, newp, midpoint, metricField, parent); smoothness_point_pair mp;mp.ptr = sp;mp.rank=(1.-bgm->get_smoothness(gp.u(),gp.v())); if (debug) vert_priority[v] = priority_counter++; fifo.insert(mp); vertices.push_back(sp); double _min[2],_max[2]; sp->minmax(_min,_max); rtree.Insert(_min,_max,sp); if (debug){ cout << " adding node (" << sp->_v->x() << "," << sp->_v->y() << "," << sp->_v->z() << ")" << endl; cout << " ----------------------------- sub --- fifo.size() = " << fifo.size() << endl; } count_nbaddedpt++; } } } if(debug) cout << "////////// nbre of added point: " << count_nbaddedpt << endl; } time_insertion += (Cpu() - a); if (debug){ stringstream ss; ss << "priority_" << gf->tag() << ".pos"; print_nodal_info(ss.str().c_str(),vert_priority); ss.clear(); } // add the vertices as additional vertices in the // surface mesh char ccc[256]; sprintf(ccc,"points%d.pos",gf->tag()); FILE *f = Fopen(ccc,"w"); if(f){ fprintf(f,"View \"\"{\n"); for (unsigned int i=0;i<vertices.size();i++){ vertices[i]->print(f,i); if(vertices[i]->_v->onWhat() == gf) { packed.push_back(vertices[i]->_v); metrics.push_back(vertices[i]->_meshMetric); SPoint2 midpoint; reparamMeshVertexOnFace(vertices[i]->_v, gf, midpoint); } delete vertices[i]; } fprintf(f,"};"); fclose(f); } }
bool Filler3D::treat_region(GRegion *gr) { BGMManager::set_use_cross_field(true); bool use_vectorial_smoothness; bool use_fifo; string algo; // readValue("param.dat","SMOOTHNESSALGO",algo); algo.assign("SCALAR"); if (!algo.compare("SCALAR")){ use_vectorial_smoothness = false; use_fifo = false; } else if (!algo.compare("FIFO")){ use_vectorial_smoothness = false; use_fifo = true; } else{ cout << "unknown SMOOTHNESSALGO !" << endl; throw; } const bool debug=false; const bool export_stuff=true; double a; cout << "ENTERING POINTINSERTION3D" << endl; // acquire background mesh cout << "pointInsertion3D: recover BGM" << endl; a = Cpu(); frameFieldBackgroundMesh3D *bgm = dynamic_cast<frameFieldBackgroundMesh3D*>(BGMManager::get(gr)); time_smoothing += (Cpu() - a); if (!bgm){ cout << "pointInsertion3D:: BGM dynamic cast failed ! " << endl; throw; } // export BGM fields if(export_stuff){ cout << "pointInsertion3D: export size field " << endl; stringstream ss; ss << "bg3D_sizefield_" << gr->tag() << ".pos"; bgm->exportSizeField(ss.str()); cout << "pointInsertion3D : export crossfield " << endl; stringstream sscf; sscf << "bg3D_crossfield_" << gr->tag() << ".pos"; bgm->exportCrossField(sscf.str()); cout << "pointInsertion3D : export smoothness " << endl; stringstream sss; sss << "bg3D_smoothness_" << gr->tag() << ".pos"; bgm->exportSmoothness(sss.str()); if (use_vectorial_smoothness){ cout << "pointInsertion3D : export vectorial smoothness " << endl; stringstream ssvs; ssvs << "bg3D_vectorial_smoothness_" << gr->tag() << ".pos"; bgm->exportVectorialSmoothness(ssvs.str()); } } // ---------------- START FILLING NEW POINTS ---------------- cout << "pointInsertion3D : inserting points in region " << gr->tag() << endl; //ProfilerStart("/home/bernard/profile"); a = Cpu(); // ----- initialize fifo list ----- RTree<MVertex*,double,3,double> rtree; listOfPoints *fifo; if (use_fifo) fifo = new listOfPointsFifo(); else if (use_vectorial_smoothness) fifo = new listOfPointsVectorialSmoothness(); else fifo = new listOfPointsScalarSmoothness(); set<MVertex*> temp; vector<MVertex*> boundary_vertices; map<MVertex*,int> vert_priority; map<MVertex*,double> smoothness_forplot; MElement *element; MVertex *vertex; list<GFace*> faces = gr->faces(); for(list<GFace*>::iterator it=faces.begin();it!=faces.end();it++){// for all faces GFace *gf = *it; // int limit = code_kesskessai(gf->tag()); for(unsigned int i=0;i<gf->getNumMeshElements();i++){ element = gf->getMeshElement(i); for(int j=0;j<element->getNumVertices();j++){// for all vertices vertex = element->getVertex(j); temp.insert(vertex); // limits.insert(make_pair(vertex,limit)); } } } int geodim; for(set<MVertex*>::iterator it=temp.begin();it!=temp.end();it++){ geodim = (*it)->onWhat()->dim(); if ((geodim==0) || (geodim==1) || (geodim==2)) boundary_vertices.push_back(*it); } double min[3],max[3],x,y,z,h; for(unsigned int i=0;i<boundary_vertices.size();i++){ x = boundary_vertices[i]->x(); y = boundary_vertices[i]->y(); z = boundary_vertices[i]->z(); // "on boundary since working on boundary_vertices ... MVertex *closest = bgm->get_nearest_neighbor_on_boundary(boundary_vertices[i]); h = bgm->size(closest);// get approximate size, closest vertex, faster ?! fill_min_max(x,y,z,h,min,max); rtree.Insert(min,max,boundary_vertices[i]); if (!use_vectorial_smoothness){ smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = boundary_vertices[i]; svp->rank = bgm->get_smoothness(x,y,z); svp->dir = 0; svp->layer = 0; svp->size = h; bgm->eval_approximate_crossfield(closest, svp->cf); fifo->insert(svp); if (debug){ smoothness_forplot[svp->v] = svp->rank; } } else{ STensor3 temp; bgm->eval_approximate_crossfield(closest, temp); for (int idir=0;idir<3;idir++){ smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = boundary_vertices[i]; svp->rank = bgm->get_vectorial_smoothness(idir,x,y,z); svp->dir = idir; svp->layer = 0; svp->size = h; svp->cf = temp; for (int k=0;k<3;k++) svp->direction(k) = temp(k,idir); // cout << "fifo size=" << fifo->size() << " inserting " ; fifo->insert(svp); // cout << " -> fifo size=" << fifo->size() << endl; } } } // TODO: si fifo était list of *PTR -> pas de copies, gain temps ? Wrapper3D wrapper; wrapper.set_bgm(bgm); MVertex *parent,*individual; new_vertices.clear(); bool spawn_created; int priority_counter=0; STensor3 crossfield; int parent_layer; while(!fifo->empty()){ parent = fifo->get_first_vertex(); // parent_limit = fifo->get_first_limit(); parent_layer = fifo->get_first_layer(); // if(parent_limit!=-1 && parent_layer>=parent_limit()){ // continue; // } vector<MVertex*> spawns; if (!use_vectorial_smoothness){ spawns.resize(6); computeSixNeighbors(bgm,parent,spawns,fifo->get_first_crossfield(), fifo->get_first_size()); } else{ spawns.resize(2); computeTwoNeighbors(bgm,parent,spawns,fifo->get_first_direction(), fifo->get_first_size()); } fifo->erase_first(); // cout << "while, fifo->size()=" << fifo->size() << " parent=(" << // parent->x() << "," << parent->y() << "," << parent->z() << ")" << // endl; for(unsigned int i=0;i<spawns.size();i++){ spawn_created = false; individual = spawns[i]; x = individual->x(); y = individual->y(); z = individual->z(); // cout << " working on candidate " << "(" << individual->x() << "," // << individual->y() << "," << individual->z() << ")" << endl; if(bgm->inDomain(x,y,z)){ // cout << " spawn " << i << " in domain" << endl; MVertex *closest = bgm->get_nearest_neighbor(individual); h = bgm->size(closest);// get approximate size, closest vertex, faster ?! if(far_from_boundary_3D(bgm,individual,h)){ // cout << " spawn " << i << " far from bnd" << endl; bgm->eval_approximate_crossfield(closest, crossfield); wrapper.set_ok(true); wrapper.set_individual(individual); wrapper.set_parent(parent); wrapper.set_size(&h); wrapper.set_crossfield(&crossfield); fill_min_max(x,y,z,h,min,max); rtree.Search(min,max,rtree_callback_3D,&wrapper); if(wrapper.get_ok()){ // cout << " spawn " << i << " wrapper OK" << endl; if (!use_vectorial_smoothness){ smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = individual; svp->rank=bgm->get_smoothness(individual->x(),individual->y(),individual->z()); svp->dir = 0; svp->layer = parent_layer+1; svp->size = h; svp->cf = crossfield; fifo->insert(svp); if (debug){ smoothness_forplot[svp->v] = svp->rank; vert_priority[individual] = priority_counter++; } } else{ if (debug) vert_priority[individual] = priority_counter++; for (int idir=0;idir<3;idir++){ smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = individual; svp->rank = bgm->get_vectorial_smoothness(idir,x,y,z); svp->dir = idir; svp->layer = parent_layer+1; svp->size = h; for (int k=0;k<3;k++) svp->direction(k) = crossfield(k,idir); svp->cf = crossfield; fifo->insert(svp); } } rtree.Insert(min,max,individual); new_vertices.push_back(individual); spawn_created = true; } } } if(!spawn_created){ delete individual; } }// end loop on spawns } //ProfilerStop(); time_insert_points += (Cpu() - a); // --- output --- if (debug){ stringstream ss; ss << "priority_3D_" << gr->tag() << ".pos"; print_nodal_info(ss.str().c_str(),vert_priority); ss.clear(); stringstream sss; sss << "smoothness_3D_" << gr->tag() << ".pos"; print_nodal_info(sss.str().c_str(),smoothness_forplot); sss.clear(); } // ------- meshing using new points cout << "tets in gr before= " << gr->tetrahedra.size() << endl; cout << "nb new vertices= " << new_vertices.size() << endl; a=Cpu(); int option = CTX::instance()->mesh.algo3d; CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY; deMeshGRegion deleter; deleter(gr); std::vector<GRegion*> regions; regions.push_back(gr); meshGRegion mesher(regions); //? mesher(gr); //? MeshDelaunayVolume(regions); time_meshing += (Cpu() - a); cout << "tets in gr after= " << gr->tetrahedra.size() << endl; cout << "gr tag=" << gr->tag() << endl; CTX::instance()->mesh.algo3d = option; delete fifo; for(unsigned int i=0;i<new_vertices.size();i++) delete new_vertices[i]; new_vertices.clear(); rtree.RemoveAll(); return true; }
void Filler::treat_region(GRegion* gr){ int NumSmooth = CTX::instance()->mesh.smoothCrossField; std::cout << "NumSmooth = " << NumSmooth << std::endl ; if(NumSmooth && (gr->dim() == 3)){ double scale = gr->bounds().diag()*1e-2; Frame_field::initRegion(gr,NumSmooth); Frame_field::saveCrossField("cross0.pos",scale); Frame_field::smoothRegion(gr,NumSmooth); Frame_field::saveCrossField("cross1.pos",scale); } #if defined(HAVE_RTREE) unsigned int i; int j; int count; int limit; bool ok2; double x,y,z; SPoint3 point; Node *node,*individual,*parent; MVertex* vertex; MElement* element; MElementOctree* octree; deMeshGRegion deleter; Wrapper wrapper; GFace* gf; std::queue<Node*> fifo; std::vector<Node*> spawns; std::vector<Node*> garbage; std::vector<MVertex*> boundary_vertices; std::set<MVertex*> temp; std::list<GFace*> faces; std::map<MVertex*,int> limits; std::set<MVertex*>::iterator it; std::list<GFace*>::iterator it2; std::map<MVertex*,int>::iterator it3; RTree<Node*,double,3,double> rtree; Frame_field::init_region(gr); Size_field::init_region(gr); Size_field::solve(gr); octree = new MElementOctree(gr->model()); garbage.clear(); boundary_vertices.clear(); temp.clear(); new_vertices.clear(); faces.clear(); limits.clear(); faces = gr->faces(); for(it2=faces.begin();it2!=faces.end();it2++){ gf = *it2; limit = code(gf->tag()); for(i=0;i<gf->getNumMeshElements();i++){ element = gf->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); limits.insert(std::pair<MVertex*,int>(vertex,limit)); } } } /*for(i=0;i<gr->getNumMeshElements();i++){ element = gr->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); } }*/ for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==0){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==1){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==2){ boundary_vertices.push_back(*it); } } /*for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()<3){ boundary_vertices.push_back(*it); } }*/ //std::ofstream file("nodes.pos"); //file << "View \"test\" {\n"; for(i=0;i<boundary_vertices.size();i++){ x = boundary_vertices[i]->x(); y = boundary_vertices[i]->y(); z = boundary_vertices[i]->z(); node = new Node(SPoint3(x,y,z)); compute_parameters(node,gr); node->set_layer(0); it3 = limits.find(boundary_vertices[i]); node->set_limit(it3->second); rtree.Insert(node->min,node->max,node); fifo.push(node); //print_node(node,file); } count = 1; while(!fifo.empty()){ parent = fifo.front(); fifo.pop(); garbage.push_back(parent); if(parent->get_limit()!=-1 && parent->get_layer()>=parent->get_limit()){ continue; } spawns.clear(); spawns.resize(6); for(i=0;i<6;i++){ spawns[i] = new Node(); } create_spawns(gr,octree,parent,spawns); for(i=0;i<6;i++){ ok2 = 0; individual = spawns[i]; point = individual->get_point(); x = point.x(); y = point.y(); z = point.z(); if(inside_domain(octree,x,y,z)){ compute_parameters(individual,gr); individual->set_layer(parent->get_layer()+1); individual->set_limit(parent->get_limit()); if(far_from_boundary(octree,individual)){ wrapper.set_ok(1); wrapper.set_individual(individual); wrapper.set_parent(parent); rtree.Search(individual->min,individual->max,rtree_callback,&wrapper); if(wrapper.get_ok()){ fifo.push(individual); rtree.Insert(individual->min,individual->max,individual); vertex = new MVertex(x,y,z,gr,0); new_vertices.push_back(vertex); ok2 = 1; //print_segment(individual->get_point(),parent->get_point(),file); } } } if(!ok2) delete individual; } if(count%100==0){ printf("%d\n",count); } count++; } //file << "};\n"; int option = CTX::instance()->mesh.algo3d; CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY; deleter(gr); std::vector<GRegion*> regions; regions.push_back(gr); meshGRegion mesher(regions); //? mesher(gr); //? MeshDelaunayVolume(regions); CTX::instance()->mesh.algo3d = option; for(i=0;i<garbage.size();i++) delete garbage[i]; for(i=0;i<new_vertices.size();i++) delete new_vertices[i]; new_vertices.clear(); delete octree; rtree.RemoveAll(); Size_field::clear(); Frame_field::clear(); #endif }
std::unique_ptr<Problem> Pal::extract( const QgsRectangle &extent, const QgsGeometry &mapBoundary ) { // to store obstacles RTree<FeaturePart *, double, 2, double> *obstacles = new RTree<FeaturePart *, double, 2, double>(); std::unique_ptr< Problem > prob = qgis::make_unique< Problem >(); int i, j; double bbx[4]; double bby[4]; double amin[2]; double amax[2]; int max_p = 0; LabelPosition *lp = nullptr; bbx[0] = bbx[3] = amin[0] = prob->bbox[0] = extent.xMinimum(); bby[0] = bby[1] = amin[1] = prob->bbox[1] = extent.yMinimum(); bbx[1] = bbx[2] = amax[0] = prob->bbox[2] = extent.xMaximum(); bby[2] = bby[3] = amax[1] = prob->bbox[3] = extent.yMaximum(); prob->pal = this; QLinkedList<Feats *> *fFeats = new QLinkedList<Feats *>; FeatCallBackCtx context; // prepare map boundary geos::unique_ptr mapBoundaryGeos( QgsGeos::asGeos( mapBoundary ) ); geos::prepared_unique_ptr mapBoundaryPrepared( GEOSPrepare_r( QgsGeos::getGEOSHandler(), mapBoundaryGeos.get() ) ); context.fFeats = fFeats; context.obstacles = obstacles; context.candidates = prob->candidates; context.mapBoundary = mapBoundaryPrepared.get(); ObstacleCallBackCtx obstacleContext; obstacleContext.obstacles = obstacles; obstacleContext.obstacleCount = 0; // first step : extract features from layers int previousFeatureCount = 0; int previousObstacleCount = 0; QStringList layersWithFeaturesInBBox; mMutex.lock(); const auto constMLayers = mLayers; for ( Layer *layer : constMLayers ) { if ( !layer ) { // invalid layer name continue; } // only select those who are active if ( !layer->active() ) continue; // check for connected features with the same label text and join them if ( layer->mergeConnectedLines() ) layer->joinConnectedFeatures(); layer->chopFeaturesAtRepeatDistance(); layer->mMutex.lock(); // find features within bounding box and generate candidates list context.layer = layer; layer->mFeatureIndex->Search( amin, amax, extractFeatCallback, static_cast< void * >( &context ) ); // find obstacles within bounding box layer->mObstacleIndex->Search( amin, amax, extractObstaclesCallback, static_cast< void * >( &obstacleContext ) ); layer->mMutex.unlock(); if ( context.fFeats->size() - previousFeatureCount > 0 || obstacleContext.obstacleCount > previousObstacleCount ) { layersWithFeaturesInBBox << layer->name(); } previousFeatureCount = context.fFeats->size(); previousObstacleCount = obstacleContext.obstacleCount; } mMutex.unlock(); prob->nbLabelledLayers = layersWithFeaturesInBBox.size(); prob->labelledLayersName = layersWithFeaturesInBBox; if ( fFeats->isEmpty() ) { delete fFeats; delete obstacles; return nullptr; } prob->nbft = fFeats->size(); prob->nblp = 0; prob->featNbLp = new int [prob->nbft]; prob->featStartId = new int [prob->nbft]; prob->inactiveCost = new double[prob->nbft]; Feats *feat = nullptr; // Filtering label positions against obstacles amin[0] = amin[1] = std::numeric_limits<double>::lowest(); amax[0] = amax[1] = std::numeric_limits<double>::max(); FilterContext filterCtx; filterCtx.cdtsIndex = prob->candidates; filterCtx.pal = this; obstacles->Search( amin, amax, filteringCallback, static_cast< void * >( &filterCtx ) ); if ( isCanceled() ) { const auto constFFeats = *fFeats; for ( Feats *feat : constFFeats ) { qDeleteAll( feat->lPos ); feat->lPos.clear(); } qDeleteAll( *fFeats ); delete fFeats; delete obstacles; return nullptr; } int idlp = 0; for ( i = 0; i < prob->nbft; i++ ) /* foreach feature into prob */ { feat = fFeats->takeFirst(); prob->featStartId[i] = idlp; prob->inactiveCost[i] = std::pow( 2, 10 - 10 * feat->priority ); switch ( feat->feature->getGeosType() ) { case GEOS_POINT: max_p = point_p; break; case GEOS_LINESTRING: max_p = line_p; break; case GEOS_POLYGON: max_p = poly_p; break; } // sort candidates by cost, skip less interesting ones, calculate polygon costs (if using polygons) max_p = CostCalculator::finalizeCandidatesCosts( feat, max_p, obstacles, bbx, bby ); // only keep the 'max_p' best candidates while ( feat->lPos.count() > max_p ) { // TODO remove from index feat->lPos.last()->removeFromIndex( prob->candidates ); delete feat->lPos.takeLast(); } // update problem's # candidate prob->featNbLp[i] = feat->lPos.count(); prob->nblp += feat->lPos.count(); // add all candidates into a rtree (to speed up conflicts searching) for ( j = 0; j < feat->lPos.count(); j++, idlp++ ) { lp = feat->lPos.at( j ); //lp->insertIntoIndex(prob->candidates); lp->setProblemIds( i, idlp ); // bugfix #1 (maxence 10/23/2008) } fFeats->append( feat ); } int nbOverlaps = 0; while ( !fFeats->isEmpty() ) // foreach feature { if ( isCanceled() ) { const auto constFFeats = *fFeats; for ( Feats *feat : constFFeats ) { qDeleteAll( feat->lPos ); feat->lPos.clear(); } qDeleteAll( *fFeats ); delete fFeats; delete obstacles; return nullptr; } feat = fFeats->takeFirst(); while ( !feat->lPos.isEmpty() ) // foreach label candidate { lp = feat->lPos.takeFirst(); lp->resetNumOverlaps(); // make sure that candidate's cost is less than 1 lp->validateCost(); prob->addCandidatePosition( lp ); //prob->feat[idlp] = j; lp->getBoundingBox( amin, amax ); // lookup for overlapping candidate prob->candidates->Search( amin, amax, LabelPosition::countOverlapCallback, static_cast< void * >( lp ) ); nbOverlaps += lp->getNumOverlaps(); } delete feat; } delete fFeats; //delete candidates; delete obstacles; nbOverlaps /= 2; prob->all_nblp = prob->nblp; prob->nbOverlap = nbOverlaps; return prob; }
void TestRTree::testInsertRows() { // RTree::InsertMode = RTree::CopyPrevious RTree<QString> tree; tree.insert(QRect(1, 1, 1, 2), QString("1")); tree.insert(QRect(2, 1, 1, 3), QString("2")); tree.insert(QRect(3, 2, 1, 4), QString("3")); tree.insert(QRect(4, 2, 1, 5), QString("4")); tree.insert(QRect(5, 3, 1, 3), QString("5")); tree.insert(QRect(6, 3, 1, 4), QString("6")); tree.insert(QRect(7, 4, 1, 2), QString("7")); tree.insert(QRect(8, 4, 1, 3), QString("8")); tree.insert(QRect(9, 6, 1, 3), QString("9")); QList< QPair<QRectF, QString> > undo = tree.insertRows(3, 3); QList< QPair<QRectF, QString> > pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)).values(); QCOMPARE(pairs.count(), 9); QCOMPARE(pairs[0].first, QRectF(1, 1, 1, 2)); QCOMPARE(pairs[0].second, QString("1")); QCOMPARE(pairs[1].first, QRectF(2, 1, 1, 6)); QCOMPARE(pairs[1].second, QString("2")); QCOMPARE(pairs[2].first, QRectF(3, 2, 1, 7)); QCOMPARE(pairs[2].second, QString("3")); QCOMPARE(pairs[3].first, QRectF(4, 2, 1, 8)); QCOMPARE(pairs[3].second, QString("4")); QCOMPARE(pairs[4].first, QRectF(5, 6, 1, 3)); QCOMPARE(pairs[4].second, QString("5")); QCOMPARE(pairs[5].first, QRectF(6, 6, 1, 4)); QCOMPARE(pairs[5].second, QString("6")); QCOMPARE(pairs[6].first, QRectF(7, 7, 1, 2)); QCOMPARE(pairs[6].second, QString("7")); QCOMPARE(pairs[7].first, QRectF(8, 7, 1, 3)); QCOMPARE(pairs[7].second, QString("8")); QCOMPARE(pairs[8].first, QRectF(9, 9, 1, 3)); QCOMPARE(pairs[8].second, QString("9")); QCOMPARE(undo.count(), 0); #if 0 // RTree::InsertMode = RTree::CopyCurrent tree.clear(); tree.insert(QRect(1, 1, 1, 2), QString("1")); tree.insert(QRect(2, 1, 1, 3), QString("2")); undo = tree.insertColumns(3, 3, RTree<QString>::CopyCurrent); pairs = tree.intersectingPairs(QRect(1, 1, 10, 10)); QCOMPARE(pairs.count(), 2); QCOMPARE(pairs[0].first, QRectF(1, 1, 1, 2)); QCOMPARE(pairs[1].first, QRectF(2, 1, 1, 6)); QCOMPARE(undo.count(), 0); #endif RTree<bool> boolTree; boolTree.insert(QRect(1, 2, 2, 1), true); boolTree.insert(QRect(1, 3, 1, 2), true); boolTree.insertRows(6, 1); QList< QPair<QRectF, bool> > boolPairs = boolTree.intersectingPairs(QRect(1, 2, 1, 1)).values(); QCOMPARE(boolPairs.count(), 1); QCOMPARE(boolPairs[0].first, QRectF(1, 2, 2, 1)); QCOMPARE(boolPairs[0].second, true); boolPairs = boolTree.intersectingPairs(QRect(1, 3, 1, 1)).values(); QCOMPARE(boolPairs.count(), 1); QCOMPARE(boolPairs[0].first, QRectF(1, 3, 1, 2)); QCOMPARE(boolPairs[0].second, true); }