root / rgbdslam / gicp / ann_1.1.1 / include / ANN / ANNx.h @ 9240aaa3
History | View | Annotate | Download (6.09 KB)
1 |
//----------------------------------------------------------------------
|
---|---|
2 |
// File: ANNx.h
|
3 |
// Programmer: Sunil Arya and David Mount
|
4 |
// Last modified: 03/04/98 (Release 0.1)
|
5 |
// Description: Internal include file for ANN
|
6 |
//
|
7 |
// These declarations are of use in manipulating some of
|
8 |
// the internal data objects appearing in ANN, but are not
|
9 |
// needed for applications just using the nearest neighbor
|
10 |
// search.
|
11 |
//
|
12 |
// Typical users of ANN should not need to access this file.
|
13 |
//----------------------------------------------------------------------
|
14 |
// Copyright (c) 1997-2005 University of Maryland and Sunil Arya and
|
15 |
// David Mount. All Rights Reserved.
|
16 |
//
|
17 |
// This software and related documentation is part of the Approximate
|
18 |
// Nearest Neighbor Library (ANN). This software is provided under
|
19 |
// the provisions of the Lesser GNU Public License (LGPL). See the
|
20 |
// file ../ReadMe.txt for further information.
|
21 |
//
|
22 |
// The University of Maryland (U.M.) and the authors make no
|
23 |
// representations about the suitability or fitness of this software for
|
24 |
// any purpose. It is provided "as is" without express or implied
|
25 |
// warranty.
|
26 |
//----------------------------------------------------------------------
|
27 |
// History:
|
28 |
// Revision 0.1 03/04/98
|
29 |
// Initial release
|
30 |
// Revision 1.0 04/01/05
|
31 |
// Changed LO, HI, IN, OUT to ANN_LO, ANN_HI, etc.
|
32 |
//----------------------------------------------------------------------
|
33 |
|
34 |
#ifndef ANNx_H
|
35 |
#define ANNx_H
|
36 |
|
37 |
#include <iomanip> // I/O manipulators |
38 |
#include <ANN/ANN.h> // ANN includes |
39 |
|
40 |
//----------------------------------------------------------------------
|
41 |
// Global constants and types
|
42 |
//----------------------------------------------------------------------
|
43 |
enum {ANN_LO=0, ANN_HI=1}; // splitting indices |
44 |
enum {ANN_IN=0, ANN_OUT=1}; // shrinking indices |
45 |
// what to do in case of error
|
46 |
enum ANNerr {ANNwarn = 0, ANNabort = 1}; |
47 |
|
48 |
//----------------------------------------------------------------------
|
49 |
// Maximum number of points to visit
|
50 |
// We have an option for terminating the search early if the
|
51 |
// number of points visited exceeds some threshold. If the
|
52 |
// threshold is 0 (its default) this means there is no limit
|
53 |
// and the algorithm applies its normal termination condition.
|
54 |
//----------------------------------------------------------------------
|
55 |
|
56 |
extern int ANNmaxPtsVisited; // maximum number of pts visited |
57 |
extern int ANNptsVisited; // number of pts visited in search |
58 |
|
59 |
//----------------------------------------------------------------------
|
60 |
// Global function declarations
|
61 |
//----------------------------------------------------------------------
|
62 |
|
63 |
void annError( // ANN error routine |
64 |
char *msg, // error message |
65 |
ANNerr level); // level of error
|
66 |
|
67 |
void annPrintPt( // print a point |
68 |
ANNpoint pt, // the point
|
69 |
int dim, // the dimension |
70 |
std::ostream &out); // output stream
|
71 |
|
72 |
//----------------------------------------------------------------------
|
73 |
// Orthogonal (axis aligned) rectangle
|
74 |
// Orthogonal rectangles are represented by two points, one
|
75 |
// for the lower left corner (min coordinates) and the other
|
76 |
// for the upper right corner (max coordinates).
|
77 |
//
|
78 |
// The constructor initializes from either a pair of coordinates,
|
79 |
// pair of points, or another rectangle. Note that all constructors
|
80 |
// allocate new point storage. The destructor deallocates this
|
81 |
// storage.
|
82 |
//
|
83 |
// BEWARE: Orthogonal rectangles should be passed ONLY BY REFERENCE.
|
84 |
// (C++'s default copy constructor will not allocate new point
|
85 |
// storage, then on return the destructor free's storage, and then
|
86 |
// you get into big trouble in the calling procedure.)
|
87 |
//----------------------------------------------------------------------
|
88 |
|
89 |
class ANNorthRect { |
90 |
public:
|
91 |
ANNpoint lo; // rectangle lower bounds
|
92 |
ANNpoint hi; // rectangle upper bounds
|
93 |
//
|
94 |
ANNorthRect( // basic constructor
|
95 |
int dd, // dimension of space |
96 |
ANNcoord l=0, // default is empty |
97 |
ANNcoord h=0)
|
98 |
{ lo = annAllocPt(dd, l); hi = annAllocPt(dd, h); } |
99 |
|
100 |
ANNorthRect( // (almost a) copy constructor
|
101 |
int dd, // dimension |
102 |
const ANNorthRect &r) // rectangle to copy |
103 |
{ lo = annCopyPt(dd, r.lo); hi = annCopyPt(dd, r.hi); } |
104 |
|
105 |
ANNorthRect( // construct from points
|
106 |
int dd, // dimension |
107 |
ANNpoint l, // low point
|
108 |
ANNpoint h) // hight point
|
109 |
{ lo = annCopyPt(dd, l); hi = annCopyPt(dd, h); } |
110 |
|
111 |
~ANNorthRect() // destructor
|
112 |
{ annDeallocPt(lo); annDeallocPt(hi); } |
113 |
|
114 |
ANNbool inside(int dim, ANNpoint p);// is point p inside rectangle? |
115 |
}; |
116 |
|
117 |
void annAssignRect( // assign one rect to another |
118 |
int dim, // dimension (both must be same) |
119 |
ANNorthRect &dest, // destination (modified)
|
120 |
const ANNorthRect &source); // source |
121 |
|
122 |
//----------------------------------------------------------------------
|
123 |
// Orthogonal (axis aligned) halfspace
|
124 |
// An orthogonal halfspace is represented by an integer cutting
|
125 |
// dimension cd, coordinate cutting value, cv, and side, sd, which is
|
126 |
// either +1 or -1. Our convention is that point q lies in the (closed)
|
127 |
// halfspace if (q[cd] - cv)*sd >= 0.
|
128 |
//----------------------------------------------------------------------
|
129 |
|
130 |
class ANNorthHalfSpace { |
131 |
public:
|
132 |
int cd; // cutting dimension |
133 |
ANNcoord cv; // cutting value
|
134 |
int sd; // which side |
135 |
//
|
136 |
ANNorthHalfSpace() // default constructor
|
137 |
{ cd = 0; cv = 0; sd = 0; } |
138 |
|
139 |
ANNorthHalfSpace( // basic constructor
|
140 |
int cdd, // dimension of space |
141 |
ANNcoord cvv, // cutting value
|
142 |
int sdd) // side |
143 |
{ cd = cdd; cv = cvv; sd = sdd; } |
144 |
|
145 |
ANNbool in(ANNpoint q) const // is q inside halfspace? |
146 |
{ return (ANNbool) ((q[cd] - cv)*sd >= 0); } |
147 |
|
148 |
ANNbool out(ANNpoint q) const // is q outside halfspace? |
149 |
{ return (ANNbool) ((q[cd] - cv)*sd < 0); } |
150 |
|
151 |
ANNdist dist(ANNpoint q) const // (squared) distance from q |
152 |
{ return (ANNdist) ANN_POW(q[cd] - cv); }
|
153 |
|
154 |
void setLowerBound(int d, ANNpoint p)// set to lower bound at p[i] |
155 |
{ cd = d; cv = p[d]; sd = +1; }
|
156 |
|
157 |
void setUpperBound(int d, ANNpoint p)// set to upper bound at p[i] |
158 |
{ cd = d; cv = p[d]; sd = -1; }
|
159 |
|
160 |
void project(ANNpoint &q) // project q (modified) onto halfspace |
161 |
{ if (out(q)) q[cd] = cv; }
|
162 |
}; |
163 |
|
164 |
// array of halfspaces
|
165 |
typedef ANNorthHalfSpace *ANNorthHSArray;
|
166 |
|
167 |
#endif
|