Ice Sheet System Model  4.18
Code documentation
Quadtree.cpp
Go to the documentation of this file.
1 #include "../classes.h"
2 
3 /*DOCUMENTATION What is a Quadtree? {{{
4  * A Quadtree is a very simple way to group vertices according
5  * to their locations. A square that holds all the points of the mesh
6  * (or the geometry) is divided into 4 boxes. As soon as one box
7  * hold more than 4 vertices, it is divided into 4 new boxes, etc...
8  * There cannot be more than MAXDEEP (=30) subdivision.
9  * This process is like a Dichotomy in dimension 2
10  *
11  * + - - - - - - - - + - - + - + - + - - - - +
12  * | | | | X | |
13  * + - + - +
14  * | | | | | |
15  * + - - + - + - + +
16  * | | | | |
17  *
18  * | | | | |
19  * + - - - - - - - - + - - + - - + - - - - +
20  * | | | |
21  *
22  * | | | |
23  *
24  * | | | |
25  * | | | |
26  * + - - - - - - - - + - - - - + - - - - +
27  * | | |
28  *
29  * | | |
30  *
31  * | | |
32  *
33  * | | |
34  * | | |
35  * | | |
36  * | | |
37  * | | |
38  * + - - - - - - - - + - - - - - - - - +
39  *
40  * The coordinate system used in a quadtree are integers to avoid
41  * round-off errors. The vertex in the lower left box has the coordinates
42  * (0 0)
43  * The upper right vertex has the follwing coordinates:
44  * 2^30 -1 2^30 -1 in decimal
45  * 0 1 1 1 .... 1 0 1 1 1 .... 1 in binary
46  * \-- 29 --/ \-- 29 --/
47  * Using binaries is therefore very easy to locate a vertex in a box:
48  * we just need to look at the bits from the left to the right (See ::Add)
49  }}}*/
50 /*MACROS {{{*/
51 /*
52  *
53  * J j
54  * ^ ^
55  * | | +--------+--------+
56  * | | | | |
57  * 1X | | | 2 | 3 |
58  * | | | | |
59  * | | +--------+--------+
60  * | | | | |
61  * 0X | | | 0 | 1 |
62  * | | | | |
63  * | | +--------+--------+
64  * | +-----------------------> i
65  * |
66  * |----------------------------> I
67  * X0 X1
68  *
69  * box 0 -> I=0 J=0 IJ=00 = 0
70  * box 1 -> I=1 J=0 IJ=01 = 1
71  * box 2 -> I=0 J=1 IJ=10 = 2
72  * box 3 -> I=1 J=1 IJ=11 = 3
73  */
74 //IJ(i,j,l) returns the box number of i and j with respect to l
75 //if !j&l and !i&l -> 0 (box zero: lower left )
76 //if !j&l and i&l -> 1 (box one: lower right)
77 //if j&l and !i&l -> 2 (box two: upper left )
78 //if j&l and i&l -> 3 (box three:upper right)
79 #define IJ(i,j,l) ((j&l) ? ((i&l) ? 3:2 ) :((i&l) ? 1:0 ))
80 /*}}}*/
81 
82  /*Constructors/Destructors*/
83 Quadtree::Quadtree(){/*{{{*/
84  _error_("Constructor not supported");
85 
86 }
87 /*}}}*/
88 Quadtree::Quadtree(double xmin,double xmax,double ymin,double ymax,int maxdepth){/*{{{*/
89 
90  /*Intermediaries*/
91  double length;
92 
93  /*Initialize fields*/
94  this->MaxDepth=maxdepth;
95  this->NbQuadtreeBox=0;
96  this->NbObs=0;
97 
98  /*Create container*/
99  this->boxcontainer=new DataSet();
100 
101  /*Create Root, pointer toward the main box*/
102  length=max(xmax-xmin,ymax-ymin);
103  this->root=NewQuadtreeBox(xmin+length/2,ymin+length/2,length);
104 }
105 /*}}}*/
106  Quadtree::~Quadtree(){/*{{{*/
107 
108  delete boxcontainer;
109  root=NULL;
110 
111  }
112  /*}}}*/
113 
114  /*Methods*/
115 void Quadtree::Add(Observation* observation){/*{{{*/
116 
117  /*Intermediaries*/
118  int xi,yi,ij,level,levelbin;
119  QuadtreeBox **pbox = NULL; // pointer toward current box b
120  QuadtreeBox **pmaster = NULL; // pointer toward master of b
121  QuadtreeBox *box = NULL; // current box b
122  QuadtreeBox *slave = NULL; // suslaveox of b (if necessary)
123  Observation *obs[4];
124 
125  /*Get integer coodinates*/
126  xi = observation->xi;
127  yi = observation->yi;
128 
129  /*Initialize levels*/
130  level = 0;
131  levelbin = (1L<<this->MaxDepth);// = 2^30
132 
133  /*Get inital box (the largest)*/
134  pmaster = &root;
135  pbox = &root;
136 
137  /*Find the smallest box where the observation is located*/
138  while((box=*pbox) && (box->nbitems<0)){
139 
140  /*Go down one level (levelbin = 00100 -> 00010)*/
141  levelbin>>=1; level+=1; _assert_(level<this->MaxDepth);
142 
143  /*Get next box according to the bit value (levelbin)*/
144  pmaster = pbox;
145  pbox = &box->box[IJ(xi,yi,levelbin)];
146  }
147  _assert_(levelbin>0);
148 
149  /*Now, try to add the vertex, if the box is full (nbitems=4), we have to divide it in 4 new boxes*/
150  while((box=*pbox) && (box->nbitems==4)){
151 
152  /*Copy the 4 observation in the current Quadtreebox*/
153  obs[0] = box->obs[0];
154  obs[1] = box->obs[1];
155  obs[2] = box->obs[2];
156  obs[3] = box->obs[3];
157 
158  /*set nbitems as -1 (now holding boxes instead of observations)*/
159  box->nbitems = -1;
160  box->box[0] = NULL;
161  box->box[1] = NULL;
162  box->box[2] = NULL;
163  box->box[3] = NULL;
164 
165  /*Go down one level (levelbin = 00010 -> 00001)*/
166  levelbin>>=1; level+=1; _assert_(level<this->MaxDepth);
167 
168  /*Put the four observations in the new boxes*/
169  for (int k=0;k<4;k++){
170 
171  /*Get box for observation number k*/
172  ij = IJ(obs[k]->xi,obs[k]->yi,levelbin);
173  slave = box->box[ij];
174  if(!slave){
175  box->box[ij] = NewQuadtreeBox(box,ij);
176  slave = box->box[ij];
177  }
178  slave->obs[slave->nbitems++] = obs[k];
179  }
180 
181  /*Get the suslaveox where the current observation is located*/
182  ij = IJ(xi,yi,levelbin);
183  pmaster = pbox;
184  pbox = &box->box[ij];
185  }
186 
187  /*alloc the QuadtreeBox if necessary and add current observation*/
188  box = *pbox;
189  if(!box){
190  ij = IJ(xi,yi,levelbin);
191  box = *pbox = NewQuadtreeBox(*pmaster,ij);
192  }
193  box->obs[box->nbitems++]=observation;
194  NbObs++;
195 
196 }/*}}}*/
197 void Quadtree::AddAndAverage(double x,double y,double value){/*{{{*/
198 
199  QuadtreeBox **pbox = NULL;
200  QuadtreeBox *box = NULL;
201  int xi,yi;
202  int levelbin;
203  int index;
204  double length,length2;
205 
206  /*Get integer coodinates*/
207  this->IntergerCoordinates(&xi,&yi,x,y);
208 
209  /*Initialize level*/
210  levelbin = (1L<<this->MaxDepth);// = 2^30
211 
212  /*Get inital box (the largest)*/
213  pbox=&root;
214 
215  /*Find the smallest box where this point is located*/
216  while((box=*pbox) && (box->nbitems<0)){
217  levelbin>>=1;
218  pbox = &box->box[IJ(xi,yi,levelbin)];
219  }
220 
221  /*Add obervation in this box (should be full)*/
222  if(box && box->nbitems==4){
223  index = 0;
224  length = pow(box->obs[0]->x - x,2) + pow(box->obs[0]->y - y,2);
225  for(int i=1;i<4;i++){
226  length2 = pow(box->obs[i]->x - x,2) + pow(box->obs[i]->y - y,2);
227  if(length2<length){
228  index = i;
229  length = length2;
230  }
231  }
232 
233  /*We found the closest observation, now average observation (do not change xi and yi to avoid round off errors*/
234  box->obs[index]->x = (box->obs[index]->weight*box->obs[index]->x + x)/(box->obs[index]->weight+1.);
235  box->obs[index]->y = (box->obs[index]->weight*box->obs[index]->y + y)/(box->obs[index]->weight+1.);
236  box->obs[index]->xi= int((box->obs[index]->weight*double(box->obs[index]->xi) + double(xi))/(box->obs[index]->weight+1.));
237  box->obs[index]->yi= int((box->obs[index]->weight*double(box->obs[index]->yi) + double(yi))/(box->obs[index]->weight+1.));
238  box->obs[index]->value = (box->obs[index]->weight*box->obs[index]->value + value)/(box->obs[index]->weight+1.);
239  box->obs[index]->weight += 1.;
240  }
241  else{
242  _error_("Box is not full");
243  }
244 }/*}}}*/
245 void Quadtree::ClosestObs(int *pindex,double x,double y){/*{{{*/
246 
247  QuadtreeBox **pbox = NULL;
248  QuadtreeBox *box = NULL;
249  int xi,yi;
250  int levelbin;
251  int index = -1;
252  double length,length2;
253 
254  /*Get integer coodinates*/
255  this->IntergerCoordinates(&xi,&yi,x,y);
256 
257  /*Initialize level*/
258  levelbin = (1L<<this->MaxDepth);// = 2^30
259 
260  /*Get inital box (the largest)*/
261  pbox=&root;
262 
263  /*Find the smallest box where this point is located*/
264  while((box=*pbox) && (box->nbitems<0)){
265  levelbin>>=1;
266  pbox = &box->box[IJ(xi,yi,levelbin)];
267  }
268 
269  /*Add obervation in this box (should be full)*/
270  if(box && box->nbitems>0){
271  index = box->obs[0]->index;
272  length = pow(box->obs[0]->x - x,2) + pow(box->obs[0]->y - y,2);
273  for(int i=1;i<box->nbitems;i++){
274  length2 = pow(box->obs[i]->x - x,2) + pow(box->obs[i]->y - y,2);
275  if(length2<length){
276  index = box->obs[i]->index;
277  length = length2;
278  }
279  }
280  }
281 
282  *pindex=index;
283 }/*}}}*/
284 void Quadtree::DeepEcho(void){/*{{{*/
285 
286  _printf_("Quadtree:\n");
287  _printf_(" MaxDepth = " << this->MaxDepth << "\n");
288  _printf_(" NbQuadtreeBox = " << this->NbQuadtreeBox << "\n");
289  _printf_(" NbObs = " << this->NbObs << "\n");
290  _printf_(" root = " << this->root << "\n");
291  boxcontainer->Echo();
292 
293 }/*}}}*/
294 void Quadtree::Echo(void){/*{{{*/
295 
296  _printf_("Quadtree:\n");
297  _printf_(" MaxDepth = " << this->MaxDepth << "\n");
298  _printf_(" NbQuadtreeBox = " << this->NbQuadtreeBox << "\n");
299  _printf_(" NbObs = " << this->NbObs << "\n");
300  _printf_(" root = " << this->root << "\n");
301 
302 }/*}}}*/
303 void Quadtree::IntergerCoordinates(int *xi,int *yi,double x,double y){/*{{{*/
304 
305  /*Intermediaries*/
306  double coefficient;
307  double xmin,ymin;
308 
309  /*Checks in debugging mode*/
310  _assert_(xi && yi);
311  _assert_(this->root);
312 
313  /*coeffIcoor is the coefficient used for integer coordinates:
314  * (x-xmin)
315  * xi = (2^30 -1) ---------
316  * length
317  * coefficient = (2^30 -1)/length
318  */
319  coefficient = double((1L<<this->MaxDepth)-1)/(this->root->length);
320  xmin = this->root->xcenter - this->root->length/2;
321  ymin = this->root->ycenter - this->root->length/2;
322 
323  *xi=int(coefficient*(x - xmin));
324  *yi=int(coefficient*(y - ymin));
325 }/*}}}*/
326 Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(double xcenter,double ycenter,double length){/*{{{*/
327 
328  /*Output*/
329  QuadtreeBox* newbox=NULL;
330 
331  /*Create and initialize a new box*/
332  newbox=new QuadtreeBox();
333  newbox->nbitems=0;
334  newbox->xcenter=xcenter;
335  newbox->ycenter=ycenter;
336  newbox->length=length;
337  newbox->box[0]=NULL;
338  newbox->box[1]=NULL;
339  newbox->box[2]=NULL;
340  newbox->box[3]=NULL;
341 
342  /*Add to container*/
343  this->boxcontainer->AddObject(newbox);
344  NbQuadtreeBox++;
345 
346  /*currentbox now points toward next quadtree box*/
347  return newbox;
348 }/*}}}*/
349 Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(QuadtreeBox* master,int index){/*{{{*/
350 
351  /*Output*/
352  QuadtreeBox* newbox=NULL;
353 
354  /*Checks in debugging mode*/
355  _assert_(master);
356 
357  /*Create and initialize a new box*/
358  newbox=new QuadtreeBox();
359  newbox->nbitems=0;
360  newbox->box[0]=NULL;
361  newbox->box[1]=NULL;
362  newbox->box[2]=NULL;
363  newbox->box[3]=NULL;
364  switch(index){
365  case 0:
366  newbox->xcenter=master->xcenter - master->length/4;
367  newbox->ycenter=master->ycenter - master->length/4;
368  break;
369  case 1:
370  newbox->xcenter=master->xcenter + master->length/4;
371  newbox->ycenter=master->ycenter - master->length/4;
372  break;
373  case 2:
374  newbox->xcenter=master->xcenter - master->length/4;
375  newbox->ycenter=master->ycenter + master->length/4;
376  break;
377  case 3:
378  newbox->xcenter=master->xcenter + master->length/4;
379  newbox->ycenter=master->ycenter + master->length/4;
380  break;
381  default:
382  _error_("Case " << index << " not supported");
383  }
384  newbox->length=master->length/2;
385 
386  /*Add to container*/
387  this->boxcontainer->AddObject(newbox);
388  NbQuadtreeBox++;
389 
390  /*currentbox now points toward next quadtree box*/
391  return newbox;
392 }/*}}}*/
393 void Quadtree::RangeSearch(int **pindices,int *pnobs,double x,double y,double range){/*{{{*/
394 
395  /*Intermediaries*/
396  int nobs;
397  int *indices = NULL;
398 
399  /*Allocate indices (maximum by default*/
400  if(this->NbObs) indices = xNew<int>(this->NbObs);
401  nobs = 0;
402 
403  if(this->root) this->root->RangeSearch(indices,&nobs,x,y,range);
404 
405  /*Clean-up and return*/
406  *pnobs=nobs;
407  *pindices=indices;
408 
409 }/*}}}*/
410 void Quadtree::QuadtreeDepth(int* A,int xi,int yi){/*{{{*/
411 
412  QuadtreeBox **pbox = NULL;
413  QuadtreeBox *box = NULL;
414  int level,levelbin;
415 
416  /*Initialize levels*/
417  level = 0;
418  levelbin = (1L<<this->MaxDepth);// = 2^30
419 
420  /*Get inital box (the largest)*/
421  pbox=&root;
422 
423  /*Find the smallest box where this point is located*/
424  while((box=*pbox) && (box->nbitems<0)){
425 
426  levelbin>>=1; level+=1; _assert_(level<this->MaxDepth);
427 
428  pbox = &box->box[IJ(xi,yi,levelbin)];
429  }
430  if(box && box->nbitems>0){
431  /*This box is not empty, add one level*/
432  level+=1;
433  }
434 
435  *A=level;
436 }/*}}}*/
437 void Quadtree::QuadtreeDepth2(int* A,int xi,int yi){/*{{{*/
438 
439  QuadtreeBox **pbox = NULL;
440  QuadtreeBox *box = NULL;
441  int level,levelbin;
442 
443  /*Initialize levels*/
444  level = 0;
445  levelbin = (1L<<this->MaxDepth);// = 2^30
446 
447  /*Get inital box (the largest)*/
448  pbox=&root;
449 
450  /*Find the smallest box where this point is located*/
451  while((box=*pbox) && (box->nbitems<0)){
452 
453  levelbin>>=1; level+=1;
454 
455  pbox = &box->box[IJ(xi,yi,levelbin)];
456  }
457  if(box && box->nbitems>0){
458  /*This box is not empty, add one level*/
459  level+=1;
460  }
461 
462  /*If we were to add the vertex, get level*/
463  if(box && box->nbitems==4){
464  int ij;
465  bool flag=true;
466  while(flag){
467 
468  levelbin>>=1; level+=1;
469  if(level>this->MaxDepth){
470  level+=1;
471  break;
472  }
473 
474  /*loop over the four observations*/
475  ij=IJ(box->obs[0]->xi,box->obs[0]->yi,levelbin);
476  for (int k=1;k<4;k++){
477  if(IJ(box->obs[k]->xi,box->obs[k]->yi,levelbin) != ij){
478  flag = false;
479  }
480  }
481  if(IJ(xi,yi,levelbin)!=ij){
482  flag = false;
483  }
484  }
485  }
486 
487  *A=level;
488 }/*}}}*/
489 
490 /*QuadtreeBox methos*/
491 Object* Quadtree::QuadtreeBox::copy(void){/*{{{*/
492 
493  QuadtreeBox* qtreebox = new QuadtreeBox(*this);
494 
495  for (int i=0; i<4; ++i){
496  if(this->box[i]) qtreebox->box[i] = reinterpret_cast<QuadtreeBox*>(this->box[i]->copy());
497  else qtreebox->box[i] = NULL;
498  }
499  for (int i=0; i<4; ++i){
500  if(this->obs[i]) qtreebox->obs[i] = reinterpret_cast<Observation*>(this->obs[i]->copy());
501  else qtreebox->obs[i] = NULL;
502  }
503 
504  return (Object*) qtreebox;
505 }
506 /*}}}*/
507 void Quadtree::QuadtreeBox::Echo(void){/*{{{*/
508 
509  _printf_("QuadtreeBox:\n");
510  _printf_(" nbitems = " << this->nbitems << "\n");
511  _printf_(" xcenter = " << this->xcenter << "\n");
512  _printf_(" ycenter = " << this->ycenter << "\n");
513  _printf_(" length = " << this->length << "\n");
514 
515 }/*}}}*/
516 int Quadtree::QuadtreeBox::IsWithinRange(double x,double y,double range){/*{{{*/
517 
518  /*Return 0 if the 2 boxes do not overlap*/
519  if(this->xcenter+this->length/2 < x-range) return 0;
520  if(this->xcenter-this->length/2 > x+range) return 0;
521  if(this->ycenter+this->length/2 < y-range) return 0;
522  if(this->ycenter-this->length/2 > y+range) return 0;
523 
524  /*Return 2 if the this box is included in the range*/
525  if(this->xcenter+this->length/2 <= x+range &&
526  this->ycenter+this->length/2 <= y+range &&
527  this->xcenter-this->length/2 >= x-range &&
528  this->ycenter-this->length/2 >= y-range) return 2;
529 
530  /*This is a simple overlap*/
531  return 1;
532 
533 }/*}}}*/
534 void Quadtree::QuadtreeBox::RangeSearch(int* indices,int *pnobs,double x,double y,double range){/*{{{*/
535 
536  /*Intermediaries*/
537  int i,nobs;
538 
539  /*Recover current number of observations*/
540  nobs = *pnobs;
541 
542  switch(this->IsWithinRange(x,y,range)){
543  case 0:
544  /*If this box is not within range, return*/
545  break;
546  case 2:
547  /*This box is included in range*/
548  this->WriteObservations(indices,&nobs);
549  break;
550  case 1:
551  /*This box is partly included*/
552  if(this->nbitems>0){
553  /*If this box has only observations, add indices that are within range*/
554  for(i=0;i<this->nbitems;i++){
555  if(fabs(this->obs[i]->x-x) <= range && fabs(this->obs[i]->y-y) <= range){
556  indices[nobs++]=this->obs[i]->index;
557  }
558  }
559  }
560  else{
561  /*This box points toward boxes*/
562  if(this->box[0]) this->box[0]->RangeSearch(indices,&nobs,x,y,range);
563  if(this->box[1]) this->box[1]->RangeSearch(indices,&nobs,x,y,range);
564  if(this->box[2]) this->box[2]->RangeSearch(indices,&nobs,x,y,range);
565  if(this->box[3]) this->box[3]->RangeSearch(indices,&nobs,x,y,range);
566  }
567  break;
568  default:
569  _error_("Case " << this->IsWithinRange(x,y,range) << " not supported");
570  }
571 
572  /*Assign output pointers: */
573  *pnobs=nobs;
574 }/*}}}*/
575 void Quadtree::QuadtreeBox::WriteObservations(int* indices,int *pnobs){/*{{{*/
576 
577  /*Intermediaries*/
578  int i,nobs;
579 
580  /*Recover current number of observations*/
581  nobs = *pnobs;
582 
583  if(this->nbitems>0){
584  /*If this box has only observations, add all indices*/
585  for(i=0;i<this->nbitems;i++){
586  indices[nobs++]=this->obs[i]->index;
587  }
588  }
589  else{
590  /*This box points toward boxes, */
591  if(this->box[0]) this->box[0]->WriteObservations(indices,&nobs);
592  if(this->box[1]) this->box[1]->WriteObservations(indices,&nobs);
593  if(this->box[2]) this->box[2]->WriteObservations(indices,&nobs);
594  if(this->box[3]) this->box[3]->WriteObservations(indices,&nobs);
595  }
596 
597  /*Assign output pointers: */
598  *pnobs=nobs;
599 }/*}}}*/
Quadtree::~Quadtree
~Quadtree()
Definition: Quadtree.cpp:106
Quadtree::boxcontainer
DataSet * boxcontainer
Definition: Quadtree.h:44
_assert_
#define _assert_(ignore)
Definition: exceptions.h:37
Quadtree::QuadtreeBox::copy
Object * copy()
Definition: Quadtree.cpp:491
Observation
Definition: Observation.h:10
Observation::x
double x
Definition: Observation.h:13
Quadtree::QuadtreeBox::ycenter
double ycenter
Definition: Quadtree.h:20
DataSet::AddObject
int AddObject(Object *object)
Definition: DataSet.cpp:252
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
Quadtree::Echo
void Echo(void)
Definition: Quadtree.cpp:294
Quadtree::QuadtreeDepth
void QuadtreeDepth(int *A, int xi, int yi)
Definition: Quadtree.cpp:410
Quadtree::root
QuadtreeBox * root
Definition: Quadtree.h:48
Quadtree::QuadtreeBox
Definition: Quadtree.h:16
Observation::yi
int yi
Definition: Observation.h:14
Quadtree::QuadtreeBox::IsWithinRange
int IsWithinRange(double x, double y, double range)
Definition: Quadtree.cpp:516
Quadtree::DeepEcho
void DeepEcho(void)
Definition: Quadtree.cpp:284
Quadtree::QuadtreeBox::obs
Observation * obs[4]
Definition: Quadtree.h:24
Object
Definition: Object.h:13
Observation::xi
int xi
Definition: Observation.h:14
Quadtree::Quadtree
Quadtree()
Definition: Quadtree.cpp:83
DataSet::Echo
void Echo()
Definition: DataSet.cpp:307
Quadtree::MaxDepth
int MaxDepth
Definition: Quadtree.h:47
Quadtree::AddAndAverage
void AddAndAverage(double x, double y, double value)
Definition: Quadtree.cpp:197
IJ
#define IJ(i, j, l)
Definition: Quadtree.cpp:79
Observation::y
double y
Definition: Observation.h:13
Observation::index
int index
Definition: Observation.h:15
Quadtree::QuadtreeBox::length
double length
Definition: Quadtree.h:21
Observation::weight
double weight
Definition: Observation.h:16
Quadtree::NewQuadtreeBox
QuadtreeBox * NewQuadtreeBox(double xcenter, double ycenter, double length)
Definition: Quadtree.cpp:326
Quadtree::QuadtreeBox::box
QuadtreeBox * box[4]
Definition: Quadtree.h:23
Quadtree::NbQuadtreeBox
int NbQuadtreeBox
Definition: Quadtree.h:49
Quadtree::QuadtreeBox::RangeSearch
void RangeSearch(int *indices, int *pnobs, double x, double y, double range)
Definition: Quadtree.cpp:534
Quadtree::ClosestObs
void ClosestObs(int *pindex, double x, double y)
Definition: Quadtree.cpp:245
Quadtree::RangeSearch
void RangeSearch(int **pindices, int *pnobs, double x, double y, double range)
Definition: Quadtree.cpp:393
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
Quadtree::Add
void Add(Observation *observation)
Definition: Quadtree.cpp:115
Quadtree::QuadtreeBox::nbitems
int nbitems
Definition: Quadtree.h:18
Quadtree::IntergerCoordinates
void IntergerCoordinates(int *xi, int *yi, double x, double y)
Definition: Quadtree.cpp:303
Observation::value
double value
Definition: Observation.h:17
Quadtree::NbObs
int NbObs
Definition: Quadtree.h:50
Quadtree::QuadtreeDepth2
void QuadtreeDepth2(int *A, int xi, int yi)
Definition: Quadtree.cpp:437
Quadtree::QuadtreeBox::WriteObservations
void WriteObservations(int *indices, int *pnobs)
Definition: Quadtree.cpp:575
max
IssmDouble max(IssmDouble a, IssmDouble b)
Definition: extrema.cpp:24
DataSet
Declaration of DataSet class.
Definition: DataSet.h:14
Quadtree::QuadtreeBox::Echo
void Echo()
Definition: Quadtree.cpp:507
Quadtree::QuadtreeBox::xcenter
double xcenter
Definition: Quadtree.h:19
Observation::copy
Object * copy()
Definition: Observation.cpp:43
Generated on Thu Jul 2 2020 08:09:18 for Ice Sheet System Model by   doxygen 1.8.19