EXPORTED int flann_find_nearest_neighbors_index(FLANN_INDEX index_ptr, float* testset, int tcount, int* result, float* dists, int nn, int checks, FLANNParameters* flann_params)
{
try {
init_flann_parameters(flann_params);
if (index_ptr==NULL) {
throw FLANNException("Invalid index");
}
NNIndexPtr index = NNIndexPtr(index_ptr);
int length = index->veclen();
StartStopTimer t;
t.start();
Params searchParams;
searchParams["checks"] = checks;
Dataset<int> result_set(tcount, nn, result);
Dataset<float> dists_set(tcount, nn, dists);
search_for_neighbors(*index, Dataset<float>(tcount, length, testset), result_set, dists_set, searchParams);
t.stop();
logger.info("Searching took %g seconds\n",t.value);
return 0;
}
catch(runtime_error& e) {
logger.error("Caught exception: %s\n",e.what());
return -1;
}
}
EXPORTED FLANN_INDEX flann_build_index(float* dataset, int rows, int cols, float* speedup, FLANNParameters* flann_params)
{
try {
if (flann_params == NULL) {
throw FLANNException("The index_params agument must be non-null");
}
init_flann_parameters(flann_params);
DatasetPtr inputData = new Dataset<float>(rows,cols,dataset);
float target_precision = flann_params->target_precision;
NNIndex* index = NULL;
if (flann_params->target_precision < 0) {
Params params = parametersToParams(*flann_params);
logger.info("Building index\n");
index = create_index((flann_algorithm_t)(int)params["algorithm"],*inputData,params);
StartStopTimer t;
t.start();
index->buildIndex();
t.stop();
logger.info("Building index took: %g\n",t.value);
}
else {
if (flann_params->build_weight < 0) {
throw FLANNException("The index_params.build_weight must be positive.");
}
if (flann_params->memory_weight < 0) {
throw FLANNException("The index_params.memory_weight must be positive.");
}
Autotune autotuner(flann_params->build_weight, flann_params->memory_weight, flann_params->sample_fraction);
Params params = autotuner.estimateBuildIndexParams(*inputData, target_precision);
index = create_index((flann_algorithm_t)(int)params["algorithm"],*inputData,params);
index->buildIndex();
autotuner.estimateSearchParams(*index,*inputData,target_precision,params);
paramsToParameters(params, flann_params);
if (speedup != NULL) {
*speedup = float(params["speedup"]);
}
}
return index;
}
catch (runtime_error& e) {
logger.error("Caught exception: %s\n",e.what());
return NULL;
}
}
EXPORTED int flann_find_nearest_neighbors(float* dataset, int rows, int cols, float* testset, int tcount, int* result, float* dists, int nn, FLANNParameters* flann_params)
{
try {
init_flann_parameters(flann_params);
DatasetPtr inputData = new Dataset<float>(rows,cols,dataset);
float target_precision = flann_params->target_precision;
StartStopTimer t;
NNIndexPtr index;
if (target_precision < 0) {
Params params = parametersToParams(*flann_params);
logger.info("Building index\n");
index = create_index((flann_algorithm_t)(int)params["algorithm"],*inputData,params);
t.start();
index->buildIndex();
t.stop();
logger.info("Building index took: %g\n",t.value);
}
else {
logger.info("Build index: %g\n", flann_params->build_weight);
Autotune autotuner(flann_params->build_weight, flann_params->memory_weight, flann_params->sample_fraction);
Params params = autotuner.estimateBuildIndexParams(*inputData, target_precision);
index = create_index((flann_algorithm_t)(int)params["algorithm"],*inputData,params);
index->buildIndex();
autotuner.estimateSearchParams(*index,*inputData,target_precision,params);
paramsToParameters(params, flann_params);
}
logger.info("Finished creating the index.\n");
logger.info("Searching for nearest neighbors.\n");
Params searchParams;
searchParams["checks"] = flann_params->checks;
Dataset<int> result_set(tcount, nn, result);
Dataset<float> dists_set(tcount, nn, dists);
search_for_neighbors(*index, Dataset<float>(tcount, cols, testset), result_set, dists_set, searchParams);
delete index;
delete inputData;
return 0;
}
catch(runtime_error& e) {
logger.error("Caught exception: %s\n",e.what());
return -1;
}
}
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;
}
