flann.h

Go to the documentation of this file.

/***********************************************************************
 * Software License Agreement (BSD License)
 *
 * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
 * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
 *
 * THE BSD LICENSE
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *************************************************************************/
 
#ifndef FLANN_H_
#define FLANN_H_
 
#include "defines.h"
 
#ifdef __cplusplus
extern "C"
{
    using namespace flann;
#endif
 
 
struct FLANNParameters
{
    enum flann_algorithm_t algorithm; /* the algorithm to use */
 
    /* search time parameters */
    int checks;                /* how many leafs (features) to check in one search */
    float eps;     /* eps parameter for eps-knn search */
    int sorted;     /* indicates if results returned by radius search should be sorted or not */
    int max_neighbors;  /* limits the maximum number of neighbors should be returned by radius search */
    int cores;      /* number of paralel cores to use for searching */
 
    /*  kdtree index parameters */
    int trees;                 /* number of randomized trees to use (for kdtree) */
    int leaf_max_size;
 
    /* kmeans index parameters */
    int branching;             /* branching factor (for kmeans tree) */
    int iterations;            /* max iterations to perform in one kmeans cluetering (kmeans tree) */
    enum flann_centers_init_t centers_init;  /* algorithm used for picking the initial cluster centers for kmeans tree */
    float cb_index;            /* cluster boundary index. Used when searching the kmeans tree */
 
    /* autotuned index parameters */
    float target_precision;    /* precision desired (used for autotuning, -1 otherwise) */
    float build_weight;        /* build tree time weighting factor */
    float memory_weight;       /* index memory weigthing factor */
    float sample_fraction;     /* what fraction of the dataset to use for autotuning */
 
    /* LSH parameters */
    unsigned int table_number_; 
    unsigned int key_size_;     
    unsigned int multi_probe_level_; 
    /* other parameters */
    enum flann_log_level_t log_level;    /* determines the verbosity of each flann function */
    long random_seed;            /* random seed to use */
};
 
 
typedef void* FLANN_INDEX; /* deprecated */
typedef void* flann_index_t;
 
FLANN_EXPORT extern struct FLANNParameters DEFAULT_FLANN_PARAMETERS;
 
FLANN_EXPORT void flann_log_verbosity(int level);
 
 
FLANN_EXPORT void flann_set_distance_type(enum flann_distance_t distance_type, int order);
 
FLANN_EXPORT enum flann_distance_t flann_get_distance_type();
 
FLANN_EXPORT int flann_get_distance_order();
 
FLANN_EXPORT flann_index_t flann_build_index(float* dataset,
                                             int rows,
                                             int cols,
                                             float* speedup,
                                             struct FLANNParameters* flann_params);
 
FLANN_EXPORT flann_index_t flann_build_index_float(float* dataset,
                                                   int rows,
                                                   int cols,
                                                   float* speedup,
                                                   struct FLANNParameters* flann_params);
 
FLANN_EXPORT flann_index_t flann_build_index_double(double* dataset,
                                                    int rows,
                                                    int cols,
                                                    float* speedup,
                                                    struct FLANNParameters* flann_params);
 
FLANN_EXPORT flann_index_t flann_build_index_byte(unsigned char* dataset,
                                                  int rows,
                                                  int cols,
                                                  float* speedup,
                                                  struct FLANNParameters* flann_params);
 
FLANN_EXPORT flann_index_t flann_build_index_int(int* dataset,
                                                 int rows,
                                                 int cols,
                                                 float* speedup,
                                                 struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_add_points(flann_index_t index_ptr, float* points,
                                  int rows, int columns,
                                  float rebuild_threshold);
 
FLANN_EXPORT int flann_add_points_float(flann_index_t index_ptr, float* points,
                                        int rows, int columns,
                                        float rebuild_threshold);
 
FLANN_EXPORT int flann_add_points_double(flann_index_t index_ptr,
                                         double* points, int rows, int columns,
                                         float rebuild_threshold);
 
FLANN_EXPORT int flann_add_points_byte(flann_index_t index_ptr,
                                       unsigned char* points, int rows,
                                       int columns, float rebuild_threshold);
 
FLANN_EXPORT int flann_add_points_int(flann_index_t index_ptr, int* points,
                                      int rows, int columns,
                                      float rebuild_threshold);
 
FLANN_EXPORT int flann_remove_point(flann_index_t index_ptr,
                                    unsigned int point_id);
 
FLANN_EXPORT int flann_remove_point_float(flann_index_t index_ptr,
                                          unsigned int point_id);
 
FLANN_EXPORT int flann_remove_point_double(flann_index_t index_ptr,
                                           unsigned int point_id);
 
FLANN_EXPORT int flann_remove_point_byte(flann_index_t index_ptr,
                                         unsigned int point_id);
 
FLANN_EXPORT int flann_remove_point_int(flann_index_t index_ptr,
                                        unsigned int point_id);
 
FLANN_EXPORT float* flann_get_point(flann_index_t index_ptr,
                                    unsigned int point_id);
 
FLANN_EXPORT float* flann_get_point_float(flann_index_t index_ptr,
                                          unsigned int point_id);
 
FLANN_EXPORT double* flann_get_point_double(flann_index_t index_ptr,
                                            unsigned int point_id);
 
FLANN_EXPORT unsigned char* flann_get_point_byte(flann_index_t index_ptr,
                                                 unsigned int point_id);
 
FLANN_EXPORT int* flann_get_point_int(flann_index_t index_ptr,
                                      unsigned int point_id);
 
FLANN_EXPORT unsigned int flann_veclen(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_veclen_float(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_veclen_double(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_veclen_byte(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_veclen_int(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_size(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_size_float(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_size_double(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_size_byte(flann_index_t index_ptr);
 
FLANN_EXPORT unsigned int flann_size_int(flann_index_t index_ptr);
 
FLANN_EXPORT int flann_used_memory(flann_index_t index_ptr);
 
FLANN_EXPORT int flann_used_memory_float(flann_index_t index_ptr);
 
FLANN_EXPORT int flann_used_memory_double(flann_index_t index_ptr);
 
FLANN_EXPORT int flann_used_memory_byte(flann_index_t index_ptr);
 
FLANN_EXPORT int flann_used_memory_int(flann_index_t index_ptr);
 
 
FLANN_EXPORT int flann_save_index(flann_index_t index_id,
                                  char* filename);
 
FLANN_EXPORT int flann_save_index_float(flann_index_t index_id,
                                        char* filename);
 
FLANN_EXPORT int flann_save_index_double(flann_index_t index_id,
                                         char* filename);
 
FLANN_EXPORT int flann_save_index_byte(flann_index_t index_id,
                                       char* filename);
 
FLANN_EXPORT int flann_save_index_int(flann_index_t index_id,
                                      char* filename);
 
FLANN_EXPORT flann_index_t flann_load_index(char* filename,
                                            float* dataset,
                                            int rows,
                                            int cols);
 
FLANN_EXPORT flann_index_t flann_load_index_float(char* filename,
                                                  float* dataset,
                                                  int rows,
                                                  int cols);
 
FLANN_EXPORT flann_index_t flann_load_index_double(char* filename,
                                                   double* dataset,
                                                   int rows,
                                                   int cols);
 
FLANN_EXPORT flann_index_t flann_load_index_byte(char* filename,
                                                 unsigned char* dataset,
                                                 int rows,
                                                 int cols);
 
FLANN_EXPORT flann_index_t flann_load_index_int(char* filename,
                                                int* dataset,
                                                int rows,
                                                int cols);
 
 
FLANN_EXPORT int flann_find_nearest_neighbors(float* dataset,
                                              int rows,
                                              int cols,
                                              float* testset,
                                              int trows,
                                              int* indices,
                                              float* dists,
                                              int nn,
                                              struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_float(float* dataset,
                                                    int rows,
                                                    int cols,
                                                    float* testset,
                                                    int trows,
                                                    int* indices,
                                                    float* dists,
                                                    int nn,
                                                    struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_double(double* dataset,
                                                     int rows,
                                                     int cols,
                                                     double* testset,
                                                     int trows,
                                                     int* indices,
                                                     double* dists,
                                                     int nn,
                                                     struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_byte(unsigned char* dataset,
                                                   int rows,
                                                   int cols,
                                                   unsigned char* testset,
                                                   int trows,
                                                   int* indices,
                                                   float* dists,
                                                   int nn,
                                                   struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_int(int* dataset,
                                                  int rows,
                                                  int cols,
                                                  int* testset,
                                                  int trows,
                                                  int* indices,
                                                  float* dists,
                                                  int nn,
                                                  struct FLANNParameters* flann_params);
 
 
FLANN_EXPORT int flann_find_nearest_neighbors_index(flann_index_t index_id,
                                                    float* testset,
                                                    int trows,
                                                    int* indices,
                                                    float* dists,
                                                    int nn,
                                                    struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_index_float(flann_index_t index_id,
                                                          float* testset,
                                                          int trows,
                                                          int* indices,
                                                          float* dists,
                                                          int nn,
                                                          struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_index_double(flann_index_t index_id,
                                                           double* testset,
                                                           int trows,
                                                           int* indices,
                                                           double* dists,
                                                           int nn,
                                                           struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_index_byte(flann_index_t index_id,
                                                         unsigned char* testset,
                                                         int trows,
                                                         int* indices,
                                                         float* dists,
                                                         int nn,
                                                         struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_find_nearest_neighbors_index_int(flann_index_t index_id,
                                                        int* testset,
                                                        int trows,
                                                        int* indices,
                                                        float* dists,
                                                        int nn,
                                                        struct FLANNParameters* flann_params);
 
 
FLANN_EXPORT int flann_radius_search(flann_index_t index_ptr, /* the index */
                                     float* query, /* query point */
                                     int* indices, /* array for storing the indices found (will be modified) */
                                     float* dists, /* similar, but for storing distances */
                                     int max_nn,  /* size of arrays indices and dists */
                                     float radius, /* search radius (squared radius for euclidian metric) */
                                     struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_radius_search_float(flann_index_t index_ptr, /* the index */
                                           float* query, /* query point */
                                           int* indices, /* array for storing the indices found (will be modified) */
                                           float* dists, /* similar, but for storing distances */
                                           int max_nn,  /* size of arrays indices and dists */
                                           float radius, /* search radius (squared radius for euclidian metric) */
                                           struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_radius_search_double(flann_index_t index_ptr, /* the index */
                                            double* query, /* query point */
                                            int* indices, /* array for storing the indices found (will be modified) */
                                            double* dists, /* similar, but for storing distances */
                                            int max_nn,  /* size of arrays indices and dists */
                                            float radius, /* search radius (squared radius for euclidian metric) */
                                            struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_radius_search_byte(flann_index_t index_ptr, /* the index */
                                          unsigned char* query, /* query point */
                                          int* indices, /* array for storing the indices found (will be modified) */
                                          float* dists, /* similar, but for storing distances */
                                          int max_nn,  /* size of arrays indices and dists */
                                          float radius, /* search radius (squared radius for euclidian metric) */
                                          struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_radius_search_int(flann_index_t index_ptr, /* the index */
                                         int* query, /* query point */
                                         int* indices, /* array for storing the indices found (will be modified) */
                                         float* dists, /* similar, but for storing distances */
                                         int max_nn,  /* size of arrays indices and dists */
                                         float radius, /* search radius (squared radius for euclidian metric) */
                                         struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_free_index(flann_index_t index_id,
                                  struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_free_index_float(flann_index_t index_id,
                                        struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_free_index_double(flann_index_t index_id,
                                         struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_free_index_byte(flann_index_t index_id,
                                       struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_free_index_int(flann_index_t index_id,
                                      struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_compute_cluster_centers(float* dataset,
                                               int rows,
                                               int cols,
                                               int clusters,
                                               float* result,
                                               struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_compute_cluster_centers_float(float* dataset,
                                                     int rows,
                                                     int cols,
                                                     int clusters,
                                                     float* result,
                                                     struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_compute_cluster_centers_double(double* dataset,
                                                      int rows,
                                                      int cols,
                                                      int clusters,
                                                      double* result,
                                                      struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_compute_cluster_centers_byte(unsigned char* dataset,
                                                    int rows,
                                                    int cols,
                                                    int clusters,
                                                    float* result,
                                                    struct FLANNParameters* flann_params);
 
FLANN_EXPORT int flann_compute_cluster_centers_int(int* dataset,
                                                   int rows,
                                                   int cols,
                                                   int clusters,
                                                   float* result,
                                                   struct FLANNParameters* flann_params);
 
 
#ifdef __cplusplus
}
 
 
#include "flann.hpp"
 
#endif
 
 
#endif /*FLANN_H_*/