bool FileIntersect::processSortedFiles() { // use the chromsweep algorithm to detect overlaps on the fly. NewChromSweep sweep(_context); if (!sweep.init()) { return false; } if (!_recordOutputMgr->init(_context)) { return false; } RecordKeyList hitSet; while (sweep.next(hitSet)) { if (_context->getObeySplits()) { RecordKeyList keySet(hitSet.getKey()); RecordKeyList resultSet(hitSet.getKey()); _blockMgr->findBlockedOverlaps(keySet, hitSet, resultSet); processHits(resultSet); } else { processHits(hitSet); } } return true; }
QSharedPointer<ResultSet> SQLite::exec(const QString &query, int &rc) { logMsg(query); char *errmsg = 0; QSharedPointer<ResultSet> resultSet(new ResultSet); rc = sqlite3_exec(m_pDb, query.toStdString().c_str(), &execCallback, resultSet.data(), &errmsg); if (errmsg) { logMsg(QString(errmsg)); } return resultSet; }
void FindClosestPointForEach(PointCloud &sourceCloud, cv::Mat &destPoints, vector<float> &distances, vector<size_t> &indices) { int nVerts2 = destPoints.rows; typedef nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, PointCloud>, PointCloud, 3> kdTree; kdTree tree(3, sourceCloud); tree.buildIndex(); #pragma omp parallel for for (int i = 0; i < nVerts2; i++) { nanoflann::KNNResultSet<float> resultSet(1); resultSet.init(&indices[i], &distances[i]); tree.findNeighbors(resultSet, (float*)destPoints.row(i).data, nanoflann::SearchParams()); } }
float search_with_ground_truth(NNIndex& index, const Matrix<float>& inputData, const Matrix<float>& testData, const Matrix<int>& matches, int nn, int checks, float& time, float& dist, int skipMatches) { if (matches.cols<nn) { logger.info("matches.cols=%d, nn=%d\n",matches.cols,nn); throw FLANNException("Ground truth is not computed for as many neighbors as requested"); } KNNResultSet resultSet(nn+skipMatches); SearchParams searchParams(checks); int correct = 0; float distR = 0; StartStopTimer t; int repeats = 0; while (t.value<0.2) { repeats++; t.start(); correct = 0; distR = 0; for (int i = 0; i < testData.rows; i++) { float* target = testData[i]; resultSet.init(target, testData.cols); index.findNeighbors(resultSet,target, searchParams); int* neighbors = resultSet.getNeighbors(); neighbors = neighbors+skipMatches; correct += countCorrectMatches(neighbors,matches[i], nn); distR += computeDistanceRaport(inputData, target,neighbors,matches[i], testData.cols, nn); } t.stop(); } time = (float)(t.value/repeats); float precicion = (float)correct/(nn*testData.rows); dist = distR/(testData.rows*nn); logger.info("%8d %10.4g %10.5g %10.5g %10.5g\n", checks, precicion, time, 1000.0 * time / testData.rows, dist); return precicion; }
bool FileMap::mapFiles() { NewChromSweep sweep(_context); if (!sweep.init()) { return false; } RecordKeyList hitSet; while (sweep.next(hitSet)) { if (_context->getObeySplits()) { RecordKeyList keySet(hitSet.getKey()); RecordKeyList resultSet(hitSet.getKey()); _blockMgr->findBlockedOverlaps(keySet, hitSet, resultSet); _recordOutputMgr->printRecord(resultSet.getKey(), _context->getColumnOpsVal(resultSet)); } else { _recordOutputMgr->printRecord(hitSet.getKey(), _context->getColumnOpsVal(hitSet)); } } return true; }
void IntersectFile::checkSplits(RecordKeyVector &hitSet) { if (upCast(_context)->getObeySplits()) { RecordKeyVector keySet(hitSet.getKey()); RecordKeyVector resultSet(hitSet.getKey()); RecordKeyVector overlapSet(hitSet.getKey()); upCast(_context)->getSplitBlockInfo()->findBlockedOverlaps(keySet, hitSet, resultSet, overlapSet); // when using coverage, we need a list of the sub-intervals of coverage // so that per-base depth can be properly calculated when obeying splits if (_context->getProgram() == ContextBase::COVERAGE) { hitSet.swap(overlapSet); } else { hitSet.swap(resultSet); } } }
void search_for_neighbors(NNIndex& index, const Matrix<float>& testset, Matrix<int>& result, Matrix<float>& dists, const SearchParams& searchParams, int skip) { assert(testset.rows == result.rows); int nn = result.cols; KNNResultSet resultSet(nn+skip); for (int i = 0; i < testset.rows; i++) { float* target = testset[i]; resultSet.init(target, testset.cols); index.findNeighbors(resultSet,target, searchParams); int* neighbors = resultSet.getNeighbors(); float* distances = resultSet.getDistances(); memcpy(result[i], neighbors+skip, nn*sizeof(int)); memcpy(dists[i], distances+skip, nn*sizeof(float)); } }
int main() { try { mysqlppc::Connection conn("localhost",3306,"root","","test"); std::auto_ptr<mysqlppc::Statement> stmt(conn.prepare("select * from student where name=?")); //stmt->bindIntParam(0,1); stmt->bindStrParam(0,"yang"); stmt->execute(); std::auto_ptr<mysqlppc::ResultSet> resultSet(stmt->getResultSet()); while(resultSet->next()) { std::cout<<"id:"<<resultSet->getInt("id")<<" name:"<<resultSet->getString("name")<<" regtime:"<<resultSet->getString("regtime")<<" salary:"<<resultSet->getFloat("salary")<<std::endl; resultSet->getInt(8); } } catch(mysqlppc::MysqlException &e) { std::cout<<e.what()<<std::endl; } return 0; }
bool Fisher::getFisher() { NewChromSweep sweep(_context); if (!sweep.init()) { return false; } RecordKeyVector hitSet; while (sweep.next(hitSet)) { if (_context->getObeySplits()) { RecordKeyVector keySet(hitSet.getKey()); RecordKeyVector resultSet(hitSet.getKey()); _blockMgr->findBlockedOverlaps(keySet, hitSet, resultSet); _intersectionVal += getTotalIntersection(resultSet); } else { _intersectionVal += getTotalIntersection(hitSet); } } sweep.closeOut(); _queryLen = sweep.getQueryTotalRecordLength(); _dbLen = sweep.getDatabaseTotalRecordLength(); _unionVal = _queryLen + _dbLen; return true; }
bool Jaccard::getIntersectionAndUnion() { NewChromSweep sweep(_context); if (!sweep.init()) { return false; } RecordKeyList hitSet; while (sweep.next(hitSet)) { if (_context->getObeySplits()) { RecordKeyList keySet(hitSet.getKey()); RecordKeyList resultSet(hitSet.getKey()); _blockMgr->findBlockedOverlaps(keySet, hitSet, resultSet); _intersectionVal += getTotalIntersection(&resultSet); } else { _intersectionVal += getTotalIntersection(&hitSet); } } sweep.closeOut(); unsigned long queryUnion = sweep.getQueryTotalRecordLength(); unsigned long dbUnion = sweep.getDatabaseTotalRecordLength(); _unionVal = queryUnion + dbUnion; return true; }
//-------------------------------------------------------------- void ofApp::feed(unsigned char* result) { int i = remaining - 3; size_t pix_pos; size_t pix_index; unsigned char pix_value[3]; if (is_random) { pix_index = rand_pos; pix_value[0] = rand_value[0]; pix_value[1] = rand_value[1]; pix_value[2] = rand_value[2]; int value = rand_pos + (std::rand() % RAND_POS_RANGE) - RAND_POS_RANGE/2; value += ((std::rand() % RAND_POS_RANGE) - RAND_POS_RANGE/2) * templateImagePixels.getWidth(); rand_pos = (value >= dataset.pix_num) ? dataset.pix_num - 1 : (value < 0) ? 0 : value; value = rand_value[0] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value[0] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; value = rand_value[1] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value[1] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; value = rand_value[2] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value[2] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; if (++rand_count >= RAND_RESET) { value = rand_pos_center + (std::rand() % RAND_POS_RANGE) - RAND_POS_RANGE/2; value += ((std::rand() % RAND_POS_RANGE) - RAND_POS_RANGE/2) * templateImagePixels.getWidth(); rand_pos_center = (value >= dataset.pix_num) ? dataset.pix_num - 1 : (value < 0) ? 0 : value; rand_pos = rand_pos_center; value = rand_value_center[0] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value_center[0] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; value = rand_value_center[1] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value_center[1] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; value = rand_value_center[2] + (std::rand() % RAND_VALUE_RANGE) - RAND_VALUE_RANGE/2; rand_value_center[2] = ( value > 255 ) ? 255 : (value < 0 ) ? 0 : value; rand_value[0] = rand_value_center[0]; rand_value[1] = rand_value_center[1]; rand_value[2] = rand_value_center[2]; rand_count = 0; }; } else { // do a knn search const size_t num_results = 1; int shortest_sqrdist; nanoflann::KNNResultSet<int> resultSet(1); resultSet.init(&pix_index, &shortest_sqrdist); kdtree.findNeighbors(resultSet, &data_ptr[i], nanoflann::SearchParams(10)); dataset.remove(pix_index); pix_value[0] = data_ptr[i]; pix_value[1] = data_ptr[i+1]; pix_value[2] = data_ptr[i+2]; } pix_pos = pix_index * 3; result[pix_pos] = pix_value[0]; result[pix_pos+1] = pix_value[1]; result[pix_pos+2] = pix_value[2]; remaining = i; to_feed--; //cout << to_feed << " " << remaining << "\n"; }