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";
}
