|
1 //---------------------------------------------------------------------- |
|
2 // File: ann2fig.cpp |
|
3 // Programmer: David Mount |
|
4 // Last modified: 05/03/05 |
|
5 // Description: convert ann dump file to fig file |
|
6 //---------------------------------------------------------------------- |
|
7 // Copyright (c) 1997-2005 University of Maryland and Sunil Arya and |
|
8 // David Mount. All Rights Reserved. |
|
9 // |
|
10 // This software and related documentation is part of the Approximate |
|
11 // Nearest Neighbor Library (ANN). This software is provided under |
|
12 // the provisions of the Lesser GNU Public License (LGPL). See the |
|
13 // file ../ReadMe.txt for further information. |
|
14 // |
|
15 // The University of Maryland (U.M.) and the authors make no |
|
16 // representations about the suitability or fitness of this software for |
|
17 // any purpose. It is provided "as is" without express or implied |
|
18 // warranty. |
|
19 //---------------------------------------------------------------------- |
|
20 // History: |
|
21 // Revision 0.1 03/04/98 |
|
22 // Initial release |
|
23 // Revision 1.0 04/01/05 |
|
24 // Changed dump file suffix from .ann to .dmp. |
|
25 // Revision 1.1 05/03/05 |
|
26 // Fixed usage output string. |
|
27 //---------------------------------------------------------------------- |
|
28 // This program inputs an ann dump file of a search structure |
|
29 // perhaps along with point coordinates, and outputs a fig (Ver 3.1) |
|
30 // file (see fig2dev (1)) displaying the tree. The fig file may |
|
31 // then be displayed using xfig, or converted to any of a number of |
|
32 // other formats using fig2dev. |
|
33 // |
|
34 // If the dimension is 2 then the entire tree is display. If the |
|
35 // dimension is larger than 2 then the user has the option of |
|
36 // selecting which two dimensions will be displayed, and the slice |
|
37 // value for each of the remaining dimensions. All leaf cells |
|
38 // intersecting the slice are shown along with the points in these |
|
39 // cells. See the procedure getArgs() below for the command-line |
|
40 // arguments. |
|
41 //---------------------------------------------------------------------- |
|
42 |
|
43 #include <cstdio> // C standard I/O |
|
44 #include <fstream> // file I/O |
|
45 #include <string> // string manipulation |
|
46 #include <ANN/ANNx.h> // all ANN includes |
|
47 |
|
48 using namespace std; // make std:: accessible |
|
49 |
|
50 //---------------------------------------------------------------------- |
|
51 // Globals and their defaults |
|
52 //---------------------------------------------------------------------- |
|
53 |
|
54 const int STRING_LEN = 500; // string lengths |
|
55 const int MAX_DIM = 1000; // maximum dimension |
|
56 const double DEF_SLICE_VAL = 0; // default slice value |
|
57 const char FIG_HEAD[] = {"#FIG 3.1"}; // fig file header |
|
58 const char DUMP_SUFFIX[] = {".dmp"}; // suffix for dump file |
|
59 const char FIG_SUFFIX[] = {".fig"}; // suffix for fig file |
|
60 |
|
61 char file_name[STRING_LEN]; // (root) file name (say xxx) |
|
62 char infile_name[STRING_LEN];// input file name (xxx.dmp) |
|
63 char outfile_name[STRING_LEN];// output file name (xxx.fig) |
|
64 char caption[STRING_LEN]; // caption line (= command line) |
|
65 ofstream ofile; // output file stream |
|
66 ifstream ifile; // input file stream |
|
67 int dim_x = 0; // horizontal dimension |
|
68 int dim_y = 1; // vertical dimension |
|
69 double slice_val[MAX_DIM]; // array of slice values |
|
70 double u_per_in = 1200; // fig units per inch (version 3.1) |
|
71 double in_size = 5; // size of figure (in inches) |
|
72 double in_low_x = 1; // fig upper left corner (in inches) |
|
73 double in_low_y = 1; // fig upper left corner (in inches) |
|
74 double u_size = 6000; // size of figure (in units) |
|
75 double u_low_x = 1200; // fig upper left corner (in units) |
|
76 double u_low_y = 1200; // fig upper left corner (in units) |
|
77 int pt_size = 10; // point size (in fig units) |
|
78 |
|
79 int dim; // dimension |
|
80 int n_pts; // number of points |
|
81 ANNpointArray pts = NULL; // point array |
|
82 |
|
83 double scale; // scale factor for transformation |
|
84 double offset_x; // offsets for transformation |
|
85 double offset_y; |
|
86 |
|
87 // transformations |
|
88 #define TRANS_X(p) (offset_x + scale*(p[dim_x])) |
|
89 #define TRANS_Y(p) (offset_y - scale*(p[dim_y])) |
|
90 |
|
91 //---------------------------------------------------------------------- |
|
92 // Error handler |
|
93 //---------------------------------------------------------------------- |
|
94 |
|
95 void Error(char *msg, ANNerr level) |
|
96 { |
|
97 if (level == ANNabort) { |
|
98 cerr << "ann2fig: ERROR------->" << msg << "<-------------ERROR\n"; |
|
99 exit(1); |
|
100 } |
|
101 else { |
|
102 cerr << "ann2fig: WARNING----->" << msg << "<-------------WARNING\n"; |
|
103 } |
|
104 } |
|
105 |
|
106 //---------------------------------------------------------------------- |
|
107 // set_slice_val - set all slice values to given value |
|
108 //---------------------------------------------------------------------- |
|
109 |
|
110 void set_slice_val(double val) |
|
111 { |
|
112 for (int i = 0; i < MAX_DIM; i++) { |
|
113 slice_val[i] = val; |
|
114 } |
|
115 } |
|
116 |
|
117 //---------------------------------------------------------------------- |
|
118 // getArgs - get input arguments |
|
119 // |
|
120 // Syntax: |
|
121 // ann2fig [-upi scale] [-x low_x] [-y low_y] |
|
122 // [-sz size] [-dx dim_x] [-dy dim_y] [-sl dim value]* |
|
123 // [-ps pointsize] |
|
124 // file |
|
125 // |
|
126 // where: |
|
127 // -upi scale fig units per inch (default = 1200) |
|
128 // -x low_x x and y offset of upper left corner (inches) |
|
129 // -y low_y ...(default = 1) |
|
130 // -sz size maximum side length of figure (in inches) |
|
131 // ...(default = 5) |
|
132 // -dx dim_x horizontal dimension (default = 0) |
|
133 // -dy dim_y vertical dimension (default = 1) |
|
134 // -sv value default slice value (default = 0) |
|
135 // -sl dim value each such pair defines the value along the |
|
136 // ...given dimension at which to slice. This |
|
137 // ...may be supplied for all dimensions except |
|
138 // ...dim_x and dim_y. |
|
139 // -ps pointsize size of points in fig units (def = 10) |
|
140 // file file (input=file.dmp, output=file.fig) |
|
141 // |
|
142 //---------------------------------------------------------------------- |
|
143 |
|
144 void getArgs(int argc, char **argv) |
|
145 { |
|
146 int i; |
|
147 int sl_dim; // temp slice dimension |
|
148 double sl_val; // temp slice value |
|
149 |
|
150 set_slice_val(DEF_SLICE_VAL); // set initial slice-values |
|
151 |
|
152 if (argc <= 1) { |
|
153 cerr << "Syntax:\n\ |
|
154 ann2fig [-upi scale] [-x low_x] [-y low_y]\n\ |
|
155 [-sz size] [-dx dim_x] [-dy dim_y] [-sl dim value]*\n\ |
|
156 file\n\ |
|
157 \n\ |
|
158 where:\n\ |
|
159 -upi scale fig units per inch (default = 1200)\n\ |
|
160 -x low_x x and y offset of upper left corner (inches)\n\ |
|
161 -y low_y ...(default = 1)\n\ |
|
162 -sz size maximum side length of figure (in inches)\n\ |
|
163 ...(default = 5)\n\ |
|
164 -dx dim_x horizontal dimension (default = 0)\n\ |
|
165 -dy dim_y vertical dimension (default = 1)\n\ |
|
166 -sv value default slice value (default = 0)\n\ |
|
167 -sl dim value each such pair defines the value along the\n\ |
|
168 ...given dimension at which to slice. This\n\ |
|
169 ...may be supplied for each dimension except\n\ |
|
170 ...dim_x and dim_y.\n\ |
|
171 -ps pointsize size of points in fig units (def = 10)\n\ |
|
172 file file (input=file.dmp, output=file.fig)\n"; |
|
173 exit(0); |
|
174 } |
|
175 |
|
176 ANNbool fileSeen = ANNfalse; // file argument seen? |
|
177 |
|
178 for (i = 1; i < argc; i++) { |
|
179 if (!strcmp(argv[i], "-upi")) { // process -upi option |
|
180 sscanf(argv[++i], "%lf", &u_per_in); |
|
181 } |
|
182 else if (!strcmp(argv[i], "-x")) { // process -x option |
|
183 sscanf(argv[++i], "%lf", &in_low_x); |
|
184 } |
|
185 else if (!strcmp(argv[i], "-y")) { // process -y option |
|
186 sscanf(argv[++i], "%lf", &in_low_y); |
|
187 } |
|
188 else if (!strcmp(argv[i], "-sz")) { // process -sz option |
|
189 sscanf(argv[++i], "%lf", &in_size); |
|
190 } |
|
191 else if (!strcmp(argv[i], "-dx")) { // process -dx option |
|
192 sscanf(argv[++i], "%d", &dim_x); |
|
193 } |
|
194 else if (!strcmp(argv[i], "-dy")) { // process -dy option |
|
195 sscanf(argv[++i], "%d", &dim_y); |
|
196 } |
|
197 else if (!strcmp(argv[i], "-sv")) { // process -sv option |
|
198 sscanf(argv[++i], "%lf", &sl_val); |
|
199 set_slice_val(sl_val); // set slice values |
|
200 } |
|
201 else if (!strcmp(argv[i], "-sl")) { // process -sl option |
|
202 sscanf(argv[++i], "%d", &sl_dim); |
|
203 if (sl_dim < 0 || sl_dim >= MAX_DIM) { |
|
204 Error("Slice dimension out of bounds", ANNabort); |
|
205 } |
|
206 sscanf(argv[++i], "%lf", &slice_val[sl_dim]); |
|
207 } |
|
208 if (!strcmp(argv[i], "-ps")) { // process -ps option |
|
209 sscanf(argv[++i], "%i", &pt_size); |
|
210 } |
|
211 else { // must be file name |
|
212 fileSeen = ANNtrue; |
|
213 sscanf(argv[i], "%s", file_name); |
|
214 strcpy(infile_name, file_name); // copy to input file name |
|
215 strcat(infile_name, DUMP_SUFFIX); |
|
216 strcpy(outfile_name, file_name); // copy to output file name |
|
217 strcat(outfile_name, FIG_SUFFIX); |
|
218 } |
|
219 } |
|
220 |
|
221 if (!fileSeen) { // no file seen |
|
222 Error("File argument is required", ANNabort); |
|
223 } |
|
224 |
|
225 ifile.open(infile_name, ios::in); // open for reading |
|
226 if (!ifile) { |
|
227 Error("Cannot open input file", ANNabort); |
|
228 } |
|
229 ofile.open(outfile_name, ios::out); // open for writing |
|
230 if (!ofile) { |
|
231 Error("Cannot open output file", ANNabort); |
|
232 } |
|
233 |
|
234 u_low_x = u_per_in * in_low_x; // convert inches to fig units |
|
235 u_low_y = u_per_in * in_low_y; |
|
236 u_size = u_per_in * in_size; |
|
237 |
|
238 strcpy(caption, argv[0]); // copy command line to caption |
|
239 for (i = 1; i < argc; i++) { |
|
240 strcat(caption, " "); |
|
241 strcat(caption, argv[i]); |
|
242 } |
|
243 } |
|
244 |
|
245 //---------------------------------------------------------------------- |
|
246 // Graphics utilities for fig output |
|
247 // |
|
248 // writeHeader write header for fig file |
|
249 // writePoint write a point |
|
250 // writeBox write a box |
|
251 // writeLine write a line |
|
252 //---------------------------------------------------------------------- |
|
253 |
|
254 void writeHeader() |
|
255 { |
|
256 ofile << FIG_HEAD << "\n" // fig file header |
|
257 << "Portrait\n" |
|
258 << "Center\n" |
|
259 << "Inches\n" |
|
260 << (int) u_per_in << " 2\n"; |
|
261 } |
|
262 |
|
263 void writePoint(ANNpoint p) // write a single point |
|
264 { |
|
265 // filled black point object |
|
266 ofile << "1 3 0 1 -1 7 0 0 0 0.000 1 0.0000 "; |
|
267 int cent_x = (int) TRANS_X(p); // transform center coords |
|
268 int cent_y = (int) TRANS_Y(p); |
|
269 ofile << cent_x << " " << cent_y << " " // write center, radius, bounds |
|
270 << pt_size << " " << pt_size << " " |
|
271 << cent_x << " " << cent_y << " " |
|
272 << cent_x + pt_size << " " << cent_y + pt_size << "\n"; |
|
273 } |
|
274 |
|
275 void writeBox(const ANNorthRect &r) // write box |
|
276 { |
|
277 // unfilled box object |
|
278 ofile << "2 2 0 1 -1 7 0 0 -1 0.000 0 0 -1 0 0 5\n"; |
|
279 |
|
280 int p0_x = (int) TRANS_X(r.lo); // transform endpoints |
|
281 int p0_y = (int) TRANS_Y(r.lo); |
|
282 int p1_x = (int) TRANS_X(r.hi); |
|
283 int p1_y = (int) TRANS_Y(r.hi); |
|
284 ofile << "\t" |
|
285 << p0_x << " " << p0_y << " " // write vertices |
|
286 << p1_x << " " << p0_y << " " |
|
287 << p1_x << " " << p1_y << " " |
|
288 << p0_x << " " << p1_y << " " |
|
289 << p0_x << " " << p0_y << "\n"; |
|
290 } |
|
291 |
|
292 void writeLine(ANNpoint p0, ANNpoint p1) // write line |
|
293 { |
|
294 // unfilled line object |
|
295 ofile << "2 1 0 1 -1 7 0 0 -1 0.000 0 0 -1 0 0 2\n"; |
|
296 |
|
297 int p0_x = (int) TRANS_X(p0); // transform endpoints |
|
298 int p0_y = (int) TRANS_Y(p0); |
|
299 int p1_x = (int) TRANS_X(p1); |
|
300 int p1_y = (int) TRANS_Y(p1); |
|
301 ofile << "\t" |
|
302 << p0_x << " " << p0_y << " " // write vertices |
|
303 << p1_x << " " << p1_y << "\n"; |
|
304 } |
|
305 |
|
306 void writeCaption( // write caption text |
|
307 const ANNorthRect &bnd_box, // bounding box |
|
308 char *caption) // caption |
|
309 { |
|
310 if (!strcmp(caption, "\0")) return; // null string? |
|
311 int px = (int) TRANS_X(bnd_box.lo); // put .5 in. lower left |
|
312 int py = (int) (TRANS_Y(bnd_box.lo) + 0.50 * u_per_in); |
|
313 ofile << "4 0 -1 0 0 0 20 0.0000 4 255 2000 "; |
|
314 ofile << px << " " << py << " " << caption << "\\001\n"; |
|
315 } |
|
316 |
|
317 //---------------------------------------------------------------------- |
|
318 // overlap - test whether a box overlap slicing region |
|
319 // |
|
320 // The slicing region is a 2-dimensional plane in space |
|
321 // which contains points (x1, x2, ..., xn) satisfying the |
|
322 // n-2 linear equalities: |
|
323 // |
|
324 // xi == slice_val[i] for i != dim_x, dim_y |
|
325 // |
|
326 // This procedure returns true of the box defined by |
|
327 // corner points box.lo and box.hi overlap this plane. |
|
328 //---------------------------------------------------------------------- |
|
329 |
|
330 ANNbool overlap(const ANNorthRect &box) |
|
331 { |
|
332 for (int i = 0; i < dim; i++) { |
|
333 if (i != dim_x && i != dim_y && |
|
334 (box.lo[i] > slice_val[i] || box.hi[i] < slice_val[i])) |
|
335 return ANNfalse; |
|
336 } |
|
337 return ANNtrue; |
|
338 } |
|
339 |
|
340 //---------------------------------------------------------------------- |
|
341 // readTree, recReadTree - inputs tree and outputs figure |
|
342 // |
|
343 // readTree procedure initializes things and then calls recReadTree |
|
344 // which does all the work. |
|
345 // |
|
346 // recReadTree reads in a node of the tree, makes any recursive |
|
347 // calls as needed to input the children of this node (if internal) |
|
348 // and maintains the bounding box. Note that the bounding box |
|
349 // is modified within this procedure, but it is the responsibility |
|
350 // of the procedure that it be restored to its original value |
|
351 // on return. |
|
352 // |
|
353 // Recall that these are the formats. The tree is given in |
|
354 // preorder. |
|
355 // |
|
356 // Leaf node: |
|
357 // leaf <n_pts> <bkt[0]> <bkt[1]> ... <bkt[n-1]> |
|
358 // Splitting nodes: |
|
359 // split <cut_dim> <cut_val> <lo_bound> <hi_bound> |
|
360 // Shrinking nodes: |
|
361 // shrink <n_bnds> |
|
362 // <cut_dim> <cut_val> <side> |
|
363 // <cut_dim> <cut_val> <side> |
|
364 // ... (repeated n_bnds times) |
|
365 // |
|
366 // On reading a leaf we determine whether we should output the |
|
367 // cell's points (if dimension = 2 or this cell overlaps the |
|
368 // slicing region). For splitting nodes we check whether the |
|
369 // current cell overlaps the slicing plane and whether the |
|
370 // cutting dimension coincides with either the x or y drawing |
|
371 // dimensions. If so, we output the corresponding splitting |
|
372 // segment. |
|
373 //---------------------------------------------------------------------- |
|
374 |
|
375 void recReadTree(ANNorthRect &box) |
|
376 { |
|
377 char tag[STRING_LEN]; // tag (leaf, split, shrink) |
|
378 int n_pts; // number of points in leaf |
|
379 int idx; // point index |
|
380 int cd; // cut dimension |
|
381 ANNcoord cv; // cut value |
|
382 ANNcoord lb; // low bound |
|
383 ANNcoord hb; // high bound |
|
384 int n_bnds; // number of bounding sides |
|
385 int sd; // which side |
|
386 |
|
387 ifile >> tag; // input node tag |
|
388 if (strcmp(tag, "leaf") == 0) { // leaf node |
|
389 |
|
390 ifile >> n_pts; // input number of points |
|
391 // check for overlap |
|
392 if (dim == 2 || overlap(box)) { |
|
393 for (int i = 0; i < n_pts; i++) { // yes, write the points |
|
394 ifile >> idx; |
|
395 writePoint(pts[idx]); |
|
396 } |
|
397 } |
|
398 else { // input but ignore points |
|
399 for (int i = 0; i < n_pts; i++) { |
|
400 ifile >> idx; |
|
401 } |
|
402 } |
|
403 } |
|
404 else if (strcmp(tag, "split") == 0) { // splitting node |
|
405 |
|
406 ifile >> cd >> cv >> lb >> hb; |
|
407 if (lb != box.lo[cd] || hb != box.hi[cd]) { |
|
408 Error("Bounding box coordinates are fishy", ANNwarn); |
|
409 } |
|
410 |
|
411 ANNcoord lv = box.lo[cd]; // save bounds for cutting dim |
|
412 ANNcoord hv = box.hi[cd]; |
|
413 |
|
414 //-------------------------------------------------------------- |
|
415 // The following code is rather fragile so modify at your |
|
416 // own risk. We first decrease the high-end of the bounding |
|
417 // box down to the cutting plane and then read the left subtree. |
|
418 // Then we increase the low-end of the bounding box up to the |
|
419 // cutting plane (thus collapsing the bounding box to a d-1 |
|
420 // dimensional hyperrectangle). Then we draw the projection of |
|
421 // its diagonal if it crosses the slicing plane. This will have |
|
422 // the effect of drawing its intersection on the slicing plane. |
|
423 // Then we restore the high-end of the bounding box and read |
|
424 // the right subtree. Finally we restore the low-end of the |
|
425 // bounding box, before returning. |
|
426 //-------------------------------------------------------------- |
|
427 box.hi[cd] = cv; // decrease high bounds |
|
428 recReadTree(box); // read left subtree |
|
429 // check for overlap |
|
430 box.lo[cd] = cv; // increase low bounds |
|
431 if (dim == 2 || overlap(box)) { // check for overlap |
|
432 if (cd == dim_x || cd == dim_y) { // cut through slice plane |
|
433 writeLine(box.lo, box.hi); // draw cutting line |
|
434 } |
|
435 } |
|
436 box.hi[cd] = hv; // restore high bounds |
|
437 |
|
438 recReadTree(box); // read right subtree |
|
439 box.lo[cd] = lv; // restore low bounds |
|
440 } |
|
441 else if (strcmp(tag, "shrink") == 0) { // splitting node |
|
442 |
|
443 ANNorthRect inner(dim, box); // copy bounding box |
|
444 ifile >> n_bnds; // number of bounding sides |
|
445 for (int i = 0; i < n_bnds; i++) { |
|
446 ifile >> cd >> cv >> sd; // input bounding halfspace |
|
447 ANNorthHalfSpace hs(cd, cv, sd); // create orthogonal halfspace |
|
448 hs.project(inner.lo); // intersect by projecting |
|
449 hs.project(inner.hi); |
|
450 } |
|
451 if (dim == 2 || overlap(inner)) { |
|
452 writeBox(inner); // draw inner rectangle |
|
453 } |
|
454 recReadTree(inner); // read inner subtree |
|
455 recReadTree(box); // read outer subtree |
|
456 } |
|
457 else { |
|
458 Error("Illegal node type in dump file", ANNabort); |
|
459 } |
|
460 } |
|
461 |
|
462 void readTree(ANNorthRect &bnd_box) |
|
463 { |
|
464 writeHeader(); // output header |
|
465 writeBox(bnd_box); // draw bounding box |
|
466 writeCaption(bnd_box, caption); // write caption |
|
467 recReadTree(bnd_box); // do it |
|
468 } |
|
469 |
|
470 //---------------------------------------------------------------------- |
|
471 // readANN - read the ANN dump file |
|
472 // |
|
473 // This procedure reads in the dump file. See the format below. |
|
474 // It first reads the header line with version number. If the |
|
475 // points section is present it reads them (otherwise just leaves |
|
476 // points = NULL), and then it reads the tree section. It inputs |
|
477 // the bounding box and determines the parameters for transforming |
|
478 // the image to figure units. It then invokes the procedure |
|
479 // readTree to do all the real work. |
|
480 // |
|
481 // Dump File Format: <xxx> = coordinate value (ANNcoord) |
|
482 // |
|
483 // #ANN <version number> <comments> [END_OF_LINE] |
|
484 // points <dim> <n_pts> (point coordinates: this is optional) |
|
485 // 0 <xxx> <xxx> ... <xxx> (point indices and coordinates) |
|
486 // 1 <xxx> <xxx> ... <xxx> |
|
487 // ... |
|
488 // tree <dim> <n_pts> <bkt_size> |
|
489 // <xxx> <xxx> ... <xxx> (lower end of bounding box) |
|
490 // <xxx> <xxx> ... <xxx> (upper end of bounding box) |
|
491 // If the tree is null, then a single line "null" is |
|
492 // output. Otherwise the nodes of the tree are printed |
|
493 // one per line in preorder. Leaves and splitting nodes |
|
494 // have the following formats: |
|
495 // Leaf node: |
|
496 // leaf <n_pts> <bkt[0]> <bkt[1]> ... <bkt[n-1]> |
|
497 // Splitting nodes: |
|
498 // split <cut_dim> <cut_val> <lo_bound> <hi_bound> |
|
499 // Shrinking nodes: |
|
500 // shrink <n_bnds> |
|
501 // <cut_dim> <cut_val> <side> |
|
502 // <cut_dim> <cut_val> <side> |
|
503 // ... (repeated n_bnds times) |
|
504 // |
|
505 // Note: Infinite lo_ and hi_bounds are printed as the special |
|
506 // values "-INF" and "+INF", respectively. We do not |
|
507 // check for this, because the current version of ANN |
|
508 // starts with a finite bounding box if the tree is |
|
509 // nonempty. |
|
510 //---------------------------------------------------------------------- |
|
511 |
|
512 void readANN() |
|
513 { |
|
514 int j; |
|
515 char str[STRING_LEN]; // storage for string |
|
516 char version[STRING_LEN]; // storage for version |
|
517 int bkt_size; // bucket size |
|
518 |
|
519 ifile >> str; // input header |
|
520 if (strcmp(str, "#ANN") != 0) { // incorrect header |
|
521 Error("Incorrect header for dump file", ANNabort); |
|
522 } |
|
523 ifile.getline(version, STRING_LEN); // get version (ignore) |
|
524 ifile >> str; // get major heading |
|
525 if (strcmp(str, "points") == 0) { // points section |
|
526 ifile >> dim; // read dimension |
|
527 ifile >> n_pts; // number of points |
|
528 pts = annAllocPts(n_pts, dim); // allocate points |
|
529 for (int i = 0; i < n_pts; i++) { // input point coordinates |
|
530 int idx; // point index |
|
531 ifile >> idx; // input point index |
|
532 if (idx < 0 || idx >= n_pts) { |
|
533 Error("Point index is out of range", ANNabort); |
|
534 } |
|
535 for (j = 0; j < dim; j++) { |
|
536 ifile >> pts[idx][j]; // read point coordinates |
|
537 } |
|
538 } |
|
539 ifile >> str; // get next major heading |
|
540 } |
|
541 if (strcmp(str, "tree") == 0) { // tree section |
|
542 ifile >> dim; // read dimension |
|
543 if (dim_x > dim || dim_y > dim) { |
|
544 Error("Dimensions out of bounds", ANNabort); |
|
545 } |
|
546 ifile >> n_pts; // number of points |
|
547 ifile >> bkt_size; // bucket size (ignored) |
|
548 // read bounding box |
|
549 ANNorthRect bnd_box(dim); // create bounding box |
|
550 for (j = 0; j < dim; j++) { |
|
551 ifile >> bnd_box.lo[j]; // read box low coordinates |
|
552 } |
|
553 for (j = 0; j < dim; j++) { |
|
554 ifile >> bnd_box.hi[j]; // read box high coordinates |
|
555 } |
|
556 // compute scaling factors |
|
557 double box_len_x = bnd_box.hi[dim_x] - bnd_box.lo[dim_x]; |
|
558 double box_len_y = bnd_box.hi[dim_y] - bnd_box.lo[dim_y]; |
|
559 // longer side determines scale |
|
560 if (box_len_x > box_len_y) scale = u_size/box_len_x; |
|
561 else scale = u_size/box_len_y; |
|
562 // compute offsets |
|
563 offset_x = u_low_x - scale*bnd_box.lo[dim_x]; |
|
564 offset_y = u_low_y + scale*bnd_box.hi[dim_y]; |
|
565 readTree(bnd_box); // read the tree and process |
|
566 } |
|
567 else if (strcmp(str, "null") == 0) return; // empty tree |
|
568 else { |
|
569 cerr << "Input string: " << str << "\n"; |
|
570 Error("Illegal ann format. Expecting section heading", ANNabort); |
|
571 } |
|
572 } |
|
573 |
|
574 //---------------------------------------------------------------------- |
|
575 // Main program |
|
576 // |
|
577 // Gets the command-line arguments and invokes the main scanning |
|
578 // procedure. |
|
579 //---------------------------------------------------------------------- |
|
580 |
|
581 main(int argc, char **argv) |
|
582 { |
|
583 getArgs(argc, argv); // get input arguments |
|
584 readANN(); // read the dump file |
|
585 } |