int rtree_insert_test() {
ISpatialIndex *rtree;
try {
// Create a new storage manager with the provided base name and a 4K page size.
//std::string baseName = "rtree";
//IStorageManager* diskfile = StorageManager::createNewDiskStorageManager(baseName, 4096);
memfile = StorageManager::createNewMemoryStorageManager();
//StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*memfile, 100, false);
// applies a main memory random buffer on top of the persistent storage manager
// (LRU buffer, etc can be created the same way).
// Create a new, empty, RTree with dimensionality 2, minimum load 70%, using "file" as
// the StorageManager and the RSTAR splitting policy.
id_type indexIdentifier;
rtree = RTree::createNewRTree(*memfile, 0.7, 100, 100, MAX_DIM_NUM, SpatialIndex::RTree::RV_RSTAR, indexIdentifier);
id_type id;
uint32_t op;
double x1, x2, y1, y2, z1, z2;
double plow[3], phigh[3];
std::ifstream fin("/root/mbj/data/data");
while (fin)
{
fin >> op >> id >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
if (! fin.good()) continue; // skip newlines, etc.
if (op == RTREE_INSERT)
{
plow[0] = x1; plow[1] = y1; plow[2] = z1;
phigh[0] = x2; phigh[1] = y2; phigh[2] = z2;
Region r = Region(plow, phigh, 3);
std::ostringstream os;
os << r;
std::string data = os.str();
rtree->insertData(data.size() + 1, reinterpret_cast<const byte*>(data.c_str()), r, id);
}
}
} catch (Tools::Exception& e) {
std::cerr << "******ERROR******" << std::endl;
std::string s = e.what();
std::cerr << s << std::endl;
return FALSE;
}
return TRUE;
}
int main(int argc, const char* argv[])
{
/*
* Build 48 Index with Links
*/
// Load Circuit
Experiment experiment;
experiment.open(blue_config_filename);
Microcircuit & microcircuit = experiment.microcircuit();
const Targets & targets = experiment.targets();
const Cell_Target target = targets.cell_target("Column");
microcircuit.load(target, NEURONS | MORPHOLOGIES);
//Make Neuron Rtrees
ISpatialIndex *neuronTrees[MORPHOLOGIES_COUNT];
string *morphologyLabels[MORPHOLOGIES_COUNT];
int cm=0;
Morphologies & myMorphologies = microcircuit.morphologies();
Morphologies::iterator myMorphologiesEnd = myMorphologies.end();
for (Morphologies::iterator i = myMorphologies.begin(); i != myMorphologiesEnd; ++i)
{
morphologyLabels[cm] = i->label();
neuronTrees[cm] = RTree::createNewRTree (createNewMemoryStorageManager(), 0.7, 127, 127, 3,RTree::RV_RSTAR,indexIdentifier);
cm++;
}
Neurons & myNeurons = microcircuit.neurons();
Neurons::iterator myNeuronsEnd = myNeurons.end();
for (Neurons::iterator i = myNeurons.begin(); i != myNeuronsEnd; ++i)
{
cm=0;
for (cm=0;cm<MORPHOLOGIES_COUNT;cm++)
if (strcmp(i->morphology().label(),morphologyLabels[cm])==0) break;
Transform_3D<Micron> trafo = i->global_transform();
Sections mySections = i->morphology().all_sections();
Sections::iterator mySectionsEnd = mySections.end();
for (Sections::iterator s = mySections.begin(); s != mySectionsEnd; ++s)
{
Segments segments = s->segments();
Segments::const_iterator segments_end = segments.end();
for (Segments::const_iterator j = segments.begin(); j != segments_end ; ++j)
{
vect plow, phigh;
get_segment_mbr (*j, trafo, &plow, &phigh);
SpatialIndex::Region mbr = SpatialIndex::Region(plow.data(),phigh.data(),3);
std::stringstream strStream;
strStream << i->gid() <<"-"<< s->id()<< "-" << j->id();
neuronTrees[cm]->insertData (strStream.str().length(), (byte*)(strStream.str().c_str()), mbr, segmentid);
}
}
}
// Make Morphology Rtrees
Morphologies & myMorphologies = microcircuit.morphologies();
Morphologies::iterator myMorphologiesEnd = myMorphologies.end();
for (Morphologies::iterator i = myMorphologies.begin(); i != myMorphologiesEnd; ++i)
{
cout << "Indexing Morphology: " << i->label();
string baseName = i->label();
IStorageManager* diskfile = StorageManager::createNewDiskStorageManager(baseName, 4096);
ISpatialIndex *tree = RTree::createNewRTree (*diskfile, 0.7, 127, 127, 3,RTree::RV_RSTAR,indexIdentifier);
indexIdentifier++; segmentid=0;
Sections mySections = i->all_sections();
Sections::iterator mySectionsEnd = mySections.end();
for (Sections::iterator s = mySections.begin(); s != mySectionsEnd; ++s)
{
Segments segments = s->segments();
Segments::const_iterator segments_end = segments.end();
for (Segments::const_iterator j = segments.begin(); j != segments_end ; ++j)
{
Box<bbp::Micron> Mbr = AABBCylinder::calculateAABBForCylinder(j->begin().center(),
j->begin().radius(),j->end().center(),j->begin().radius());
vect plow, phigh;
plow[0] = Mbr.center().x() - Mbr.dimensions().x() / 2;
phigh[0] = Mbr.center().x() + Mbr.dimensions().x() / 2;
plow[1] = Mbr.center().y() - Mbr.dimensions().y() / 2;
phigh[1] = Mbr.center().y() + Mbr.dimensions().y() / 2;
plow[2] = Mbr.center().z() - Mbr.dimensions().z() / 2;
phigh[2] = Mbr.center().z() + Mbr.dimensions().z() / 2;
SpatialIndex::Region mbr = SpatialIndex::Region(plow.data(),phigh.data(),3);
std::stringstream strStream;
strStream << s->id()<< "-" << j->id();
tree->insertData (strStream.str().length(), (byte*)(strStream.str().c_str()), mbr, segmentid);
segmentid++;
}
}
cout << ".. Total Segments: " << segmentid << "\n";
tree->~ISpatialIndex();
diskfile->~IStorageManager();
}
// PRELOAD the Trees amd Neuron Morphology Mapping
ISpatialIndex *neurons[NEURONS_COUNT];
global_transformer *transforms[NEURONS_COUNT];
int cm=0;
int cn=0;
string baseName = "";
Morphologies & myMorphologies = microcircuit.morphologies();
Neurons & myNeurons = microcircuit.neurons();
cout << "PreLoading Mappings \n";
Morphologies::iterator myMorphologiesEnd = myMorphologies.end();
for (Morphologies::iterator m = myMorphologies.begin(); m != myMorphologiesEnd; ++m)
{
baseName = m->label();
m->
IStorageManager* diskfile = StorageManager::loadDiskStorageManager(baseName);
trees[cm] = RTree::loadRTree(*diskfile, 1);
std::cout << "Checking R-tree structure... ";
if (!trees[cm]->isIndexValid()) std::cerr << "R-tree internal checks failed!\n"; else std::cout << "OK\n";
IStatistics * tree_stats;
trees[cm]->getStatistics (&tree_stats);
cout << *tree_stats;
Neurons::iterator myNeuronsEnd = myNeurons.end();
for (Neurons::iterator n = myNeurons.begin(); n != myNeuronsEnd; ++n)
{
if (strcmp(n->morphology().label().c_str(),m->label().c_str())==0)
{
transforms[cn] = n->global_transform().inverse();
neurons[cn] = trees[cm];
}
cn++;
if (cn>=NEURONS_COUNT) break;
}
cn=0;cm++;
}
/*
* Query the Index
*/
}
int main(int argc, char** argv)
{
uint32_t dim = 2;
uint32_t n = 8;
uint32_t N = 100;
/*read static data set*/
vector <Point> P;
P = genPoints(dim, N, 1, 0);
// displayPset(P);
try {
IStorageManager* memfile = StorageManager::createNewMemoryStorageManager();
StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*memfile, 10, false);
id_type indexIdentifier;
ISpatialIndex* tree = RTree::createNewRTree(*file, 0.7, CAPACITY, CAPACITY, dim, SpatialIndex::RTree::RV_RSTAR, indexIdentifier);
id_type id = 0;
for(uint32_t i = 0; i < N; ++i)
{
std::ostringstream os;
os << P[i];
std::string data = os.str();
tree->insertData(data.size() + 1, reinterpret_cast<const byte*>(data.c_str()), P[i], id);
id++;
}
for(uint32_t loop = 1; loop <= LOOPNUM; ++loop)
{
cout << "/**************** BEGIN " << loop << " ***************/" << endl;
/*generate query set*/
vector <Point> Q;
Q = genPoints(dim, n, 1, loop);
/*double pdata1[] = {0, 0};
double pdata2[] = {0, 1};
double pdata3[] = {1, 1};
Point q1(pdata1, dim), q2(pdata2, dim), q3(pdata3, dim);
Q.push_back(q1);
Q.push_back(q2);
Q.push_back(q3);
displayPset(Q); */
/*************** BEGIN BF MBM method ******************/
/* MBM method for finding ANN of Q */
CATCH mbmcost;
mbmcost.catch_time();
Region M = getMBR(Q, dim, n);
MyQueryStrategy qs(M, Q, FUN);
tree->queryStrategy(qs);
mbmcost.catch_time();
cout << "MBM: cpu cost is " << mbmcost.get_cost(2) << " millisecond(s)" << endl;
cout << "MBM: best_dist is " << qs.best_dist << endl;
cout << "MBM: best_NN is ";
displayCoordinates(qs.best_NN);
cout << "MBM: leafIO = " << qs.mbm_leafIO << "; indexIO = " << qs.mbm_indexIO << endl << endl;
/*************** END BF MBM method *******************/
cout << "/**************** END " << loop << " ****************/" << endl << endl;
} // end loop
delete tree;
delete file;
delete memfile;
}
catch(Tools::Exception& e)
{
cerr << "*********ERROR**********" << endl;
std::string s = e.what();
cerr << s << endl;
return -1;
}
catch(...)
{
cerr << "**********ERROR********" << endl;
return -1;
}
return 1;
}
int main(int argc, char** argv)
{
if (argc != 4)
{
cerr << "Usage: " << argv[0] << " dim n area." << endl;
return -1;
}
int dim = atol(argv[1]);
int n = atol(argv[2]);
double area = atof(argv[3]);
if(dim <= 0)
{
cerr << "Dimension should be larger than 0." << endl;
return -1;
}
if(n <= 0)
{
cerr << "The number of query points should be larger than 0." << endl;
return -1;
}
if(area <= 0 || area > 1)
{
cerr << "the area of query points should be in (0, 1]." << endl;
return -1;
}
/*read static data set*/
vector <Point> P;
ifstream in("../data.ini");
if(!in)
{
cerr << "Cannot open file data.ini.\n";
return -1;
}
P = readPoints(in, dim);
uint32_t N = P.size();
try {
IStorageManager* memfile = StorageManager::createNewMemoryStorageManager();
StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*memfile, 10, false);
id_type indexIdentifier;
ISpatialIndex* tree = RTree::createNewRTree(*file, 0.7, CAPACITY, CAPACITY, dim, SpatialIndex::RTree::RV_RSTAR, indexIdentifier);
id_type id = 0;
for(uint32_t i = 0; i < N; ++i)
{
std::ostringstream os;
os << P[i];
std::string data = os.str();
tree->insertData(data.size() + 1, reinterpret_cast<const byte*>(data.c_str()), P[i], id);
id++;
}
//for(uint32_t loop = 1; loop <= LOOPNUM; ++loop)
for(uint32_t loop = 55; loop <= LOOPNUM; ++loop)
{
cout << "/**************** BEGIN " << loop << " ***************/" << endl;
/*generate query set*/
vector <Point> Q;
//Q = genPoints(dim, n, area, loop);
stringstream ss;
ss << "../query/n" << n << "M" << area << "/loop" << loop;
cout << ss.str().c_str() << endl;
ifstream qin(ss.str().c_str());
if(!qin)
{
cerr << "Cannot open query file";
return -1;
}
Q = readPoints(qin, dim);
/*************** BEGIN MQM method ******************/
//double err_arr[] = {0, 0.001, 0.005, 0.01, 0.05, 0.1};
double err_arr[] = {0, 0.01, 0.1};
for (uint32_t i = 0; i < sizeof(err_arr) / sizeof(double); ++i)
{
MQM(tree, Q, n, FUN, err_arr[i]); // MQM method for finding ANN of Q
}
/*************** END MQM method *******************/
/*************** BEGIN BF MBM method ******************/
/* MBM method for finding ANN of Q */
/*CATCH mbmcost;
mbmcost.catch_time();
Region M = getMBR(Q, dim, n);
MyQueryStrategy qs(M, Q, FUN);
tree->queryStrategy(qs);
mbmcost.catch_time();
cout << "MBM: cpu cost is " << mbmcost.get_cost(2) << " millisecond(s)" << endl;
cout << "MBM: best_dist is " << qs.best_dist << endl;
cout << "MBM: best_NN is ";
displayCoordinates(qs.best_NN);
cout << "MBM: leafIO = " << qs.mbm_leafIO << "; indexIO = " << qs.mbm_indexIO << endl << endl; */
/*************** END BF MBM method *******************/
/*************** BEGIN brute method ******************/
/* brute method for finding ANN of Q*/
/*CATCH brute_cost;
brute_cost.catch_time();
uint32_t ANNid = brute_ANN(Q, n, P, N, FUN);
brute_cost.catch_time();
cout << "brute method: cpu cost is " << brute_cost.get_cost(2) << " millisecond(s)" << endl;
double adist = getAdist(P[ANNid], Q, n, FUN);
cout << "brute method: best_dist is " << adist << endl;
cout << "brute method: best_NN is ";
displayCoordinates(P[ANNid]); */
/*************** END brute method *******************/
cout << "/**************** END " << loop << " ****************/" << endl << endl;
} // end loop
delete tree;
delete file;
delete memfile;
}
catch(Tools::Exception& e)
{
cerr << "*********ERROR**********" << endl;
std::string s = e.what();
cerr << s << endl;
return -1;
}
catch(...)
{
cerr << "**********ERROR********" << endl;
return -1;
}
return 1;
}
int main(int argc, char** argv)
{
if (argc != 4)
{
cerr << "Usage: " << argv[0] << " dim n area." << endl;
return -1;
}
int dim = atol(argv[1]);
int n = atol(argv[2]);
double area = atof(argv[3]);
if(dim <= 0)
{
cerr << "Dimension should be larger than 0." << endl;
return -1;
}
if(n <= 0)
{
cerr << "The number of query points should be larger than 0." << endl;
return -1;
}
if(area <= 0 || area > 1)
{
cerr << "the area of query points should be in (0, 1]." << endl;
return -1;
}
/*read static data set*/
vector <Point> P;
ifstream in("../data.ini");
if(!in)
{
cerr << "Cannot open file data.ini.\n";
return -1;
}
P = readPoints(in, dim);
uint32_t N = P.size();
try {
IStorageManager* memfile = StorageManager::createNewMemoryStorageManager();
StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*memfile, 10, false);
id_type indexIdentifier;
ISpatialIndex* tree = RTree::createNewRTree(*file, 0.7, CAPACITY, CAPACITY, dim, SpatialIndex::RTree::RV_RSTAR, indexIdentifier);
id_type id = 0;
for(uint32_t i = 0; i < N; ++i)
{
std::ostringstream os;
os << P[i];
std::string data = os.str();
tree->insertData(data.size() + 1, reinterpret_cast<const byte*>(data.c_str()), P[i], id);
id++;
}
/*std::cerr << "Operations: " << N << std::endl;
std::cerr << *tree;
std::cerr << "Buffer hits: " << file->getHits() << std::endl;
std::cerr << "Index ID: " << indexIdentifier << std::endl;
bool ret = tree->isIndexValid();
if (ret == false) std::cerr << "ERROR: Structure is invalid!" << std::endl;
else std::cerr << "The stucture seems O.K." << std::endl; */
for(uint32_t loop = 1; loop <= LOOPNUM; ++loop)
{
cout << "/**************** BEGIN " << loop << " ***************/" << endl;
/*generate query set*/
vector <Point> Q;
//Q = genPoints(dim, n, area, loop);
stringstream ss;
ss << "../query/n" << n << "M" << area << "/loop" << loop;
cout << ss.str().c_str() << endl;
ifstream qin(ss.str().c_str());
if(!qin)
{
cerr << "Cannot open query file";
return -1;
}
Q = readPoints(qin, dim);
/*************** BEGIN MQM method ******************/
MQM(tree, Q, n, FUN); // MQM method for finding ANN of Q
/*************** END MQM method *******************/
/*************** BEGIN ADM method ******************/
CATCH cost1;
cost1.catch_time();
vector <uint32_t> nnIDs = nearestNeighborSet(tree, Q, n); // find the NN for every qi in Q as qi'
vector <Point> newQ;
for(uint32_t i = 0; i < n; ++i)
{
newQ.push_back(P[nnIDs[i]]);
}
cost1.catch_time();
cout << "proposal method: cpu cost for finding NNs of Q as Q' is " << cost1.get_cost(2) << " millisecond(s)" << endl;
/***** read dist-matrix index for Q' ********/
uint32_t maxK = P.size() / RATIO; // the length of dist-matrix index
uint32_t * dmindex[n];
for(uint32_t i = 0; i < n; ++i)
{ // read the dist-matrix index of qi'
dmindex[i] = readDMIndex(nnIDs[i], maxK);
if (dmindex[i] == NULL)
{
cerr << "error for loading Dist-Matrix Index." << endl;
return -1;
}
}
double minadist = 0;
/* ADM method for finding approxiamte ANN */
Point adm_ANN = ADM(newQ, n, P, N, dmindex, maxK, FUN, minadist, ERROR_RATE);
cout << "ADM: best_dist is " << getAdist(adm_ANN, Q, n, FUN) << endl << endl;
/*************** END ADM method *******************/
/*************** BEGIN approxiamte vp-ANN method ******************/
/* approximate vp-ANN method for finding ANN of Q'*/
CATCH cost2;
cost2.catch_time();
Point centroid = findCentroid(Q, dim, n);
minadist = getAdist(centroid, Q, n, FUN);
uint32_t vpID = nearestNeighbor(tree, centroid);
uint32_t best_id_Q = epsilonANN(Q, n, P, N, vpID, dmindex, maxK, FUN);
cost2.catch_time();
cout << "approxiamte vp-ANN method: cpu cost is " << cost2.get_cost(2) << " millisecond(s)" << endl;
cout << "approximate vp-ANN method: best_dist is " << getAdist(P[best_id_Q], Q, n, FUN) << endl;
cout << "approxiamte vp-ANN method: best_NN is ";
displayCoordinates(P[best_id_Q]);
cout << endl;
/*************** END approxiamte vp-ANN method *******************/
/*************** BEGIN BF MBM method ******************/
/* MBM method for finding ANN of Q */
CATCH mbmcost;
mbmcost.catch_time();
Region M = getMBR(Q, dim, n);
MyQueryStrategy qs = MyQueryStrategy(M, Q, FUN);
tree->queryStrategy(qs);
mbmcost.catch_time();
cout << "MBM: cpu cost is " << mbmcost.get_cost(2) << " millisecond(s)" << endl;
cout << "MBM: best_dist is " << qs.best_dist << endl;
cout << "MBM: best_NN is ";
displayCoordinates(qs.best_NN);
cout << "MBM: leafIO = " << qs.mbm_leafIO << "; indexIO = " << qs.mbm_indexIO << endl << endl;
/*************** END BF MBM method *******************/
/*************** BEGIN brute method ******************/
/* brute method for finding ANN of Q*/
CATCH brute_cost;
brute_cost.catch_time();
uint32_t ANNid = brute_ANN(Q, n, P, N, FUN);
brute_cost.catch_time();
cout << "brute method: cpu cost is " << brute_cost.get_cost(2) << " millisecond(s)" << endl;
double adist = getAdist(P[ANNid], Q, n, FUN);
cout << "brute method: best_dist is " << adist << endl;
cout << "brute method: best_NN is ";
displayCoordinates(P[ANNid]);
/*************** END brute method *******************/
cout << "/**************** END " << loop << " ****************/" << endl << endl;
} // end loop
delete tree;
delete file;
delete memfile;
}
catch(Tools::Exception& e)
{
cerr << "*********ERROR**********" << endl;
std::string s = e.what();
cerr << s << endl;
return -1;
}
catch(...)
{
cerr << "**********ERROR********" << endl;
return -1;
}
return 1;
}
