ANN update

CMakeLists.txt

@@ -55,6 +55,10 @@ include_directories(${PROJECT_SOURCE_DIR}/external/pmp-library/external/eigen)
 include_directories(${PROJECT_SOURCE_DIR}/external/pmp-library/external/glfw/include)
 include_directories(${PROJECT_SOURCE_DIR}/external/pmp-library/external/glew/include)
 
+# ANN
+include_directories(${PROJECT_SOURCE_DIR}/external/ann/ANN)
+link_directories(${PROJECT_SOURCE_DIR}/external/ann)
+
 # set default compiler flags
 if((UNIX OR APPLE) AND CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -pedantic -Wall -Wextra")

external/ann/ANN/ANNperf.h

+//----------------------------------------------------------------------
+//	File:			ANNperf.h
+//	Programmer:		Sunil Arya and David Mount
+//	Last modified:	03/04/98 (Release 0.1)
+//	Description:	Include file for ANN performance stats
+//
+//	Some of the code for statistics gathering has been adapted
+//	from the SmplStat.h package in the g++ library.
+//----------------------------------------------------------------------
+// Copyright (c) 1997-2005 University of Maryland and Sunil Arya and
+// David Mount.  All Rights Reserved.
+// 
+// This software and related documentation is part of the Approximate
+// Nearest Neighbor Library (ANN).  This software is provided under
+// the provisions of the Lesser GNU Public License (LGPL).  See the
+// file ../ReadMe.txt for further information.
+// 
+// The University of Maryland (U.M.) and the authors make no
+// representations about the suitability or fitness of this software for
+// any purpose.  It is provided "as is" without express or implied
+// warranty.
+//----------------------------------------------------------------------
+//      History:
+//      Revision 0.1  03/04/98
+//          Initial release
+//      Revision 1.0  04/01/05
+//          Added ANN_ prefix to avoid name conflicts.
+//----------------------------------------------------------------------
+
+#ifndef ANNperf_H
+#define ANNperf_H
+
+//----------------------------------------------------------------------
+//	basic includes
+//----------------------------------------------------------------------
+
+#include <ANN/ANN.h>					// basic ANN includes
+
+//----------------------------------------------------------------------
+// kd-tree stats object
+//	This object is used for collecting information about a kd-tree
+//	or bd-tree.
+//----------------------------------------------------------------------
+
+class ANNkdStats {			// stats on kd-tree
+public:
+	int		dim;			// dimension of space
+	int		n_pts;			// no. of points
+	int		bkt_size;		// bucket size
+	int		n_lf;			// no. of leaves (including trivial)
+	int		n_tl;			// no. of trivial leaves (no points)
+	int		n_spl;			// no. of splitting nodes
+	int		n_shr;			// no. of shrinking nodes (for bd-trees)
+	int		depth;			// depth of tree
+	float	sum_ar;			// sum of leaf aspect ratios
+	float	avg_ar;			// average leaf aspect ratio
+ //
+							// reset stats
+	void reset(int d=0, int n=0, int bs=0)
+	{
+		dim = d; n_pts = n; bkt_size = bs;
+		n_lf = n_tl = n_spl = n_shr = depth = 0;
+		sum_ar = avg_ar = 0.0;
+	}
+
+	ANNkdStats()			// basic constructor
+	{ reset(); }
+
+	void merge(const ANNkdStats &st);	// merge stats from child 
+};
+
+//----------------------------------------------------------------------
+//  ANNsampStat
+//	A sample stat collects numeric (double) samples and returns some
+//	simple statistics.  Its main functions are:
+//
+//		reset()		Reset to no samples.
+//		+= x		Include sample x.
+//		samples()	Return number of samples.
+//		mean()		Return mean of samples.
+//		stdDev()	Return standard deviation
+//		min()		Return minimum of samples.
+//		max()		Return maximum of samples.
+//----------------------------------------------------------------------
+class DLL_API ANNsampStat {
+	int				n;				// number of samples
+	double			sum;			// sum
+	double			sum2;			// sum of squares
+	double			minVal, maxVal;	// min and max
+public :
+	void reset()				// reset everything
+	{  
+		n = 0;
+		sum = sum2 = 0;
+		minVal = ANN_DBL_MAX;
+		maxVal = -ANN_DBL_MAX; 
+	}
+
+	ANNsampStat() { reset(); }		// constructor
+
+	void operator+=(double x)		// add sample
+	{
+		n++;  sum += x;  sum2 += x*x;
+		if (x < minVal) minVal = x;
+		if (x > maxVal) maxVal = x;
+	}
+
+	int samples() { return n; }		// number of samples
+
+	double mean() { return sum/n; } // mean
+
+									// standard deviation
+	double stdDev() { return sqrt((sum2 - (sum*sum)/n)/(n-1));}
+
+	double min() { return minVal; } // minimum
+	double max() { return maxVal; } // maximum
+};
+
+//----------------------------------------------------------------------
+//		Operation count updates
+//----------------------------------------------------------------------
+
+#ifdef ANN_PERF
+  #define ANN_FLOP(n)	{ann_Nfloat_ops += (n);}
+  #define ANN_LEAF(n)	{ann_Nvisit_lfs += (n);}
+  #define ANN_SPL(n)	{ann_Nvisit_spl += (n);}
+  #define ANN_SHR(n)	{ann_Nvisit_shr += (n);}
+  #define ANN_PTS(n)	{ann_Nvisit_pts += (n);}
+  #define ANN_COORD(n)	{ann_Ncoord_hts += (n);}
+#else
+  #define ANN_FLOP(n)
+  #define ANN_LEAF(n)
+  #define ANN_SPL(n)
+  #define ANN_SHR(n)
+  #define ANN_PTS(n)
+  #define ANN_COORD(n)
+#endif
+
+//----------------------------------------------------------------------
+//	Performance statistics
+//	The following data and routines are used for computing performance
+//	statistics for nearest neighbor searching.  Because these routines
+//	can slow the code down, they can be activated and deactiviated by
+//	defining the ANN_PERF variable, by compiling with the option:
+//	-DANN_PERF
+//----------------------------------------------------------------------
+
+//----------------------------------------------------------------------
+//	Global counters for performance measurement
+//
+//	visit_lfs	The number of leaf nodes visited in the
+//				tree.
+//
+//	visit_spl	The number of splitting nodes visited in the
+//				tree.
+//
+//	visit_shr	The number of shrinking nodes visited in the
+//				tree.
+//
+//	visit_pts	The number of points visited in all the
+//				leaf nodes visited. Equivalently, this
+//				is the number of points for which distance
+//				calculations are performed.
+//
+//	coord_hts	The number of times a coordinate of a 
+//				data point is accessed. This is generally
+//				less than visit_pts*d if partial distance
+//				calculation is used.  This count is low
+//				in the sense that if a coordinate is hit
+//				many times in the same routine we may
+//				count it only once.
+//
+//	float_ops	The number of floating point operations.
+//				This includes all operations in the heap
+//				as well as distance calculations to boxes.
+//
+//	average_err	The average error of each query (the
+//				error of the reported point to the true
+//				nearest neighbor).  For k nearest neighbors
+//				the error is computed k times.
+//
+//	rank_err	The rank error of each query (the difference
+//				in the rank of the reported point and its
+//				true rank).
+//
+//	data_pts	The number of data points.  This is not
+//				a counter, but used in stats computation.
+//----------------------------------------------------------------------
+
+extern int			ann_Ndata_pts;	// number of data points
+extern int			ann_Nvisit_lfs;	// number of leaf nodes visited
+extern int			ann_Nvisit_spl;	// number of splitting nodes visited
+extern int			ann_Nvisit_shr;	// number of shrinking nodes visited
+extern int			ann_Nvisit_pts;	// visited points for one query
+extern int			ann_Ncoord_hts;	// coordinate hits for one query
+extern int			ann_Nfloat_ops;	// floating ops for one query
+extern ANNsampStat	ann_visit_lfs;	// stats on leaf nodes visits
+extern ANNsampStat	ann_visit_spl;	// stats on splitting nodes visits
+extern ANNsampStat	ann_visit_shr;	// stats on shrinking nodes visits
+extern ANNsampStat	ann_visit_nds;	// stats on total nodes visits
+extern ANNsampStat	ann_visit_pts;	// stats on points visited
+extern ANNsampStat	ann_coord_hts;	// stats on coordinate hits
+extern ANNsampStat	ann_float_ops;	// stats on floating ops
+//----------------------------------------------------------------------
+//  The following need to be part of the public interface, because
+//  they are accessed outside the DLL in ann_test.cpp.
+//----------------------------------------------------------------------
+DLL_API extern ANNsampStat ann_average_err;	// average error
+DLL_API extern ANNsampStat ann_rank_err;	// rank error
+
+//----------------------------------------------------------------------
+//	Declaration of externally accessible routines for statistics
+//----------------------------------------------------------------------
+
+DLL_API void annResetStats(int data_size);	// reset stats for a set of queries
+
+DLL_API void annResetCounts();				// reset counts for one queries
+
+DLL_API void annUpdateStats();				// update stats with current counts
+
+DLL_API void annPrintStats(ANNbool validate); // print statistics for a run
+
+#endif

external/ann/ANN/ANNx.h

+//----------------------------------------------------------------------
+// File:			ANNx.h
+// Programmer: 		Sunil Arya and David Mount
+// Description:		Internal include file for ANN
+// Last modified:	01/27/10 (Version 1.1.2)
+//
+//	These declarations are of use in manipulating some of
+//	the internal data objects appearing in ANN, but are not
+//	needed for applications just using the nearest neighbor
+//	search.
+//
+//	Typical users of ANN should not need to access this file.
+//----------------------------------------------------------------------
+// Copyright (c) 1997-2010 University of Maryland and Sunil Arya and
+// David Mount.  All Rights Reserved.
+// 
+// This software and related documentation is part of the Approximate
+// Nearest Neighbor Library (ANN).  This software is provided under
+// the provisions of the Lesser GNU Public License (LGPL).  See the
+// file ../ReadMe.txt for further information.
+// 
+// The University of Maryland (U.M.) and the authors make no
+// representations about the suitability or fitness of this software for
+// any purpose.  It is provided "as is" without express or implied
+// warranty.
+//----------------------------------------------------------------------
+//	History:
+//	Revision 0.1  03/04/98
+//	    Initial release
+//	Revision 1.0  04/01/05
+//	    Changed LO, HI, IN, OUT to ANN_LO, ANN_HI, etc.
+//	Revision 1.1.2  01/27/10
+//		Fixed minor compilation bugs for new versions of gcc
+//----------------------------------------------------------------------
+
+#ifndef ANNx_H
+#define ANNx_H
+
+#include <iomanip>				// I/O manipulators
+#include <ANN/ANN.h>			// ANN includes
+
+//----------------------------------------------------------------------
+//	Global constants and types
+//----------------------------------------------------------------------
+enum	{ANN_LO=0, ANN_HI=1};	// splitting indices
+enum	{ANN_IN=0, ANN_OUT=1};	// shrinking indices
+								// what to do in case of error
+enum ANNerr {ANNwarn = 0, ANNabort = 1};
+
+//----------------------------------------------------------------------
+//	Maximum number of points to visit
+//	We have an option for terminating the search early if the
+//	number of points visited exceeds some threshold.  If the
+//	threshold is 0 (its default)  this means there is no limit
+//	and the algorithm applies its normal termination condition.
+//----------------------------------------------------------------------
+
+extern int		ANNmaxPtsVisited;	// maximum number of pts visited
+extern int		ANNptsVisited;		// number of pts visited in search
+
+//----------------------------------------------------------------------
+//	Global function declarations
+//----------------------------------------------------------------------
+
+void annError(					// ANN error routine
+	const char*		msg,		// error message
+	ANNerr			level);		// level of error
+
+void annPrintPt(				// print a point
+	ANNpoint		pt,			// the point
+	int				dim,		// the dimension
+	std::ostream	&out);		// output stream
+
+//----------------------------------------------------------------------
+//	Orthogonal (axis aligned) rectangle
+//	Orthogonal rectangles are represented by two points, one
+//	for the lower left corner (min coordinates) and the other
+//	for the upper right corner (max coordinates).
+//
+//	The constructor initializes from either a pair of coordinates,
+//	pair of points, or another rectangle.  Note that all constructors
+//	allocate new point storage. The destructor deallocates this
+//	storage.
+//
+//	BEWARE: Orthogonal rectangles should be passed ONLY BY REFERENCE.
+//	(C++'s default copy constructor will not allocate new point
+//	storage, then on return the destructor free's storage, and then
+//	you get into big trouble in the calling procedure.)
+//----------------------------------------------------------------------
+
+class ANNorthRect {
+public:
+	ANNpoint		lo;			// rectangle lower bounds
+	ANNpoint		hi;			// rectangle upper bounds
+//
+	ANNorthRect(				// basic constructor
+	int				dd,			// dimension of space
+	ANNcoord		l=0,		// default is empty
+	ANNcoord		h=0)
+	{  lo = annAllocPt(dd, l);  hi = annAllocPt(dd, h); }
+
+	ANNorthRect(				// (almost a) copy constructor
+	int				dd,			// dimension
+	const			ANNorthRect &r) // rectangle to copy
+	{  lo = annCopyPt(dd, r.lo);  hi = annCopyPt(dd, r.hi);  }
+
+	ANNorthRect(				// construct from points
+	int				dd,			// dimension
+	ANNpoint		l,			// low point
+	ANNpoint		h)			// hight point
+	{  lo = annCopyPt(dd, l);  hi = annCopyPt(dd, h);  }
+
+	~ANNorthRect()				// destructor
+    {  annDeallocPt(lo);  annDeallocPt(hi);  }
+
+	ANNbool inside(int dim, ANNpoint p);// is point p inside rectangle?
+};
+
+void annAssignRect(				// assign one rect to another
+	int				dim,		// dimension (both must be same)
+	ANNorthRect		&dest,		// destination (modified)
+	const ANNorthRect &source);	// source
+
+//----------------------------------------------------------------------
+//	Orthogonal (axis aligned) halfspace
+//	An orthogonal halfspace is represented by an integer cutting
+//	dimension cd, coordinate cutting value, cv, and side, sd, which is
+//	either +1 or -1. Our convention is that point q lies in the (closed)
+//	halfspace if (q[cd] - cv)*sd >= 0.
+//----------------------------------------------------------------------
+
+class ANNorthHalfSpace {
+public:
+	int				cd;			// cutting dimension
+	ANNcoord		cv;			// cutting value
+	int				sd;			// which side
+//
+	ANNorthHalfSpace()			// default constructor
+	{  cd = 0; cv = 0;  sd = 0;  }
+
+	ANNorthHalfSpace(			// basic constructor
+	int				cdd,		// dimension of space
+	ANNcoord		cvv,		// cutting value
+	int				sdd)		// side
+	{  cd = cdd;  cv = cvv;  sd = sdd;  }
+
+	ANNbool in(ANNpoint q) const	// is q inside halfspace?
+	{  return  (ANNbool) ((q[cd] - cv)*sd >= 0);  }
+
+	ANNbool out(ANNpoint q) const	// is q outside halfspace?
+	{  return  (ANNbool) ((q[cd] - cv)*sd < 0);  }
+
+	ANNdist dist(ANNpoint q) const	// (squared) distance from q
+	{  return  (ANNdist) ANN_POW(q[cd] - cv);  }
+
+	void setLowerBound(int d, ANNpoint p)// set to lower bound at p[i]
+	{  cd = d;  cv = p[d];  sd = +1;  }
+
+	void setUpperBound(int d, ANNpoint p)// set to upper bound at p[i]
+	{  cd = d;  cv = p[d];  sd = -1;  }
+
+	void project(ANNpoint &q)		// project q (modified) onto halfspace
+	{  if (out(q)) q[cd] = cv;  }
+};
+
+								// array of halfspaces
+typedef ANNorthHalfSpace *ANNorthHSArray;
+
+#endif

src/mmr/CMakeLists.txt

@@ -62,6 +62,7 @@ target_include_directories(${EXC_NAME} PUBLIC
 
 target_link_libraries(${EXC_NAME}
     pmp_vis
+    ANN
 )
 
 target_compile_definitions(${EXC_NAME} PUBLIC