source: proiecte/pmake3d/make3d_original/Make3dSingleImageStanford_version0.1/third_party/vrippack-0.31/src/vrip/configure.cc @ 37

Last change on this file since 37 was 37, checked in by (none), 14 years ago

Added original make3d
File size: 16.2 KB
Line 
1/*
2
3Brian Curless
4
5Computer Graphics Laboratory
6Stanford University
7
8---------------------------------------------------------------------
9
10Copyright (1997) The Board of Trustees of the Leland Stanford Junior
11University. Except for commercial resale, lease, license or other
12commercial transactions, permission is hereby given to use, copy,
13modify this software for academic purposes only.  No part of this
14software or any derivatives thereof may be used in the production of
15computer models for resale or for use in a commercial
16product. STANFORD MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND
17CONCERNING THIS SOFTWARE.  No support is implied or provided.
18
19*/
20
21
22#include "vripGlobals.h"
23#include "configure.h"
24#include "linePersp.h"
25#include "perspective.h"
26
27OrthoShear *
28computeShear(vec3f dir)
29{
30    vec3f newDir;
31
32    OrthoShear *shear = new OrthoShear;
33
34    if (fabs(dir[0]) > fabs(dir[1])) {
35        if (fabs(dir[0]) > fabs(dir[2]))
36            shear->axis = X_AXIS;
37        else
38            shear->axis = Z_AXIS;
39    } 
40    else if (fabs(dir[1]) > fabs(dir[2]))
41        shear->axis = Y_AXIS;
42    else
43        shear->axis = Z_AXIS;
44
45
46    // Assumes a transpose operation
47
48    switch (shear->axis) {
49
50      case X_AXIS:
51        newDir[0] = dir[2];
52        newDir[1] = dir[1];
53        newDir[2] = dir[0];
54        break;
55
56     case Y_AXIS:
57        newDir[0] = dir[0];
58        newDir[1] = dir[2];
59        newDir[2] = dir[1];
60        break;
61
62      case Z_AXIS:
63        newDir[0] = dir[0];
64        newDir[1] = dir[1];
65        newDir[2] = dir[2];
66        break;
67    }
68
69    shear->flip = newDir[2] > 0;
70
71    shear->sx = newDir[0]/fabs(newDir[2]);
72    shear->sy = newDir[1]/fabs(newDir[2]);
73
74    if (Verbose)
75        printf("Shear: sx = %f  sy = %f  axis = %d  flip = %d\n", 
76               shear->sx, shear->sy, shear->axis, shear->flip);
77
78    return shear;
79}
80
81
82void
83configureGrid(OccGrid *grid, OrthoShear *shear)
84{
85    // Unflip the grid, if necessary
86    if (grid->flip) {
87        grid->flip = FALSE;
88        grid->origin[2] = -grid->origin[2];
89    }
90
91    // Transpose to the desired axis
92    if (shear->axis != grid->axis) {
93        if (grid->axis == X_AXIS)
94            grid->transposeXZ();
95        else if (grid->axis == Y_AXIS)
96            grid->transposeYZ();
97       
98        if (shear->axis == X_AXIS)
99            grid->transposeXZ();
100        else if (shear->axis == Y_AXIS)
101            grid->transposeYZ();
102
103        grid->axis = shear->axis;
104    }
105
106    // Flip the grid, if necessary
107    grid->flip = shear->flip;
108    grid->origin[2] = grid->flip ? -grid->origin[2] : grid->origin[2];
109
110    float zinc = grid->flip ? -grid->resolution : grid->resolution;
111    float z = grid->origin[2];
112    for (int i = 0; i < grid->zdim; i++, z+= zinc) {
113        grid->sliceOrigins[i][0] = grid->origin[0] + shear->sx * z;
114        grid->sliceOrigins[i][1] = grid->origin[1] + shear->sy * z;
115        grid->sliceOrigins[i][2] = z;
116    }
117}
118
119
120void
121configureGrid(OccGridRLE **pInGrid, OccGridRLE **pOutGrid, OrthoShear *shear)
122{
123    OccGridRLE *temp, *inGrid, *outGrid;
124
125    inGrid = *pInGrid;
126    outGrid = *pOutGrid;
127
128    // Unflip the grid, if necessary
129    if (inGrid->flip) {
130        inGrid->flip = FALSE;
131        inGrid->origin[2] = -inGrid->origin[2];
132    }
133
134    outGrid->copyParams(inGrid);
135
136    // Transpose to the desired axis
137    if (shear->axis != inGrid->axis) {
138        if (inGrid->axis == X_AXIS) {
139            inGrid->transposeXZ(outGrid);
140            SWAP(inGrid, outGrid, temp);
141        }
142        else if (inGrid->axis == Y_AXIS) {
143            inGrid->transposeYZ(outGrid);
144            SWAP(inGrid, outGrid, temp);
145        }
146       
147        if (shear->axis == X_AXIS) {
148            inGrid->transposeXZ(outGrid);
149        }
150        else if (shear->axis == Y_AXIS) {
151            inGrid->transposeYZ(outGrid);
152        }
153        else {
154            SWAP(inGrid, outGrid, temp);
155        }           
156
157        outGrid->axis = shear->axis;
158    }
159    else {
160        SWAP(inGrid, outGrid, temp);
161    }   
162
163    // Flip the grid, if necessary
164    outGrid->flip = shear->flip;
165    outGrid->origin[2] = outGrid->flip ? -outGrid->origin[2] : outGrid->origin[2];
166
167    float zinc = outGrid->flip ? -outGrid->resolution : outGrid->resolution;
168
169    float z = outGrid->origin[2];
170
171    for (int i = 0; i < outGrid->zdim; i++, z+= zinc) {
172        outGrid->sliceOrigins[i][0] = outGrid->origin[0] + shear->sx * z;
173        outGrid->sliceOrigins[i][1] = outGrid->origin[1] + shear->sy * z;
174        outGrid->sliceOrigins[i][2] = z;
175
176        inGrid->sliceOrigins[i][0] = inGrid->origin[0] + shear->sx * z;
177        inGrid->sliceOrigins[i][1] = inGrid->origin[1] + shear->sy * z;
178        inGrid->sliceOrigins[i][2] = z;
179    }
180
181    inGrid->copyParams(outGrid);
182
183    *pInGrid = inGrid;
184    *pOutGrid = outGrid;
185}
186
187
188void
189configureGrid(OccGridNormRLE **pInGrid, OccGridNormRLE **pOutGrid, 
190              OrthoShear *shear)
191{
192    OccGridNormRLE *temp, *inGrid, *outGrid;
193
194    inGrid = *pInGrid;
195    outGrid = *pOutGrid;
196
197    outGrid->copyParams(inGrid);
198
199    // Transpose to the desired axis
200    if (shear->axis != inGrid->axis) {
201        if (inGrid->axis == X_AXIS) {
202            inGrid->transposeXZ(outGrid);
203            SWAP(inGrid, outGrid, temp);
204        }
205        else if (inGrid->axis == Y_AXIS) {
206            inGrid->transposeYZ(outGrid);
207            SWAP(inGrid, outGrid, temp);
208        }
209       
210        if (shear->axis == X_AXIS) {
211            inGrid->transposeXZ(outGrid);
212        }
213        else if (shear->axis == Y_AXIS) {
214            inGrid->transposeYZ(outGrid);
215        }
216        else {
217            SWAP(inGrid, outGrid, temp);
218        }           
219
220        outGrid->axis = shear->axis;
221    }
222    else {
223        SWAP(inGrid, outGrid, temp);
224    }   
225
226    // Flip the grid, if necessary
227    outGrid->flip = shear->flip;
228    outGrid->origin[2] = outGrid->flip ? -outGrid->origin[2] : outGrid->origin[2];
229
230    float zinc = outGrid->flip ? -outGrid->resolution : outGrid->resolution;
231
232    float z = outGrid->origin[2];
233
234    for (int i = 0; i < outGrid->zdim; i++, z+= zinc) {
235        outGrid->sliceOrigins[i][0] = outGrid->origin[0] + shear->sx * z;
236        outGrid->sliceOrigins[i][1] = outGrid->origin[1] + shear->sy * z;
237        outGrid->sliceOrigins[i][2] = z;
238    }
239
240    inGrid->copyParams(outGrid);
241
242    *pInGrid = inGrid;
243    *pOutGrid = outGrid;
244}
245
246
247void
248configureGridLinePersp(OccGridRLE **pInGrid, OccGridRLE **pOutGrid, 
249                       OrthoShear *shear)
250{
251    OccGridRLE *temp, *inGrid, *outGrid;
252
253    inGrid = *pInGrid;
254    outGrid = *pOutGrid;
255
256    // Unflip the grid, if necessary
257    if (inGrid->flip) {
258        inGrid->flip = FALSE;
259        inGrid->origin[2] = -inGrid->origin[2];
260    }
261
262    outGrid->copyParams(inGrid);
263
264    // Transpose to the desired axis
265    if (shear->axis != inGrid->axis) {
266        if (inGrid->axis == X_AXIS) {
267            inGrid->transposeXZ(outGrid);
268            SWAP(inGrid, outGrid, temp);
269        }
270        else if (inGrid->axis == Y_AXIS) {
271            inGrid->transposeYZ(outGrid);
272            SWAP(inGrid, outGrid, temp);
273        }
274       
275        if (shear->axis == X_AXIS) {
276            inGrid->transposeXZ(outGrid);
277        }
278        else if (shear->axis == Y_AXIS) {
279            inGrid->transposeYZ(outGrid);
280        }
281        else {
282            SWAP(inGrid, outGrid, temp);
283        }           
284
285        outGrid->axis = shear->axis;
286    }
287    else {
288        SWAP(inGrid, outGrid, temp);
289    }   
290
291    // Flip the grid, if necessary
292    outGrid->flip = shear->flip;
293    outGrid->origin[2] = outGrid->flip ? 
294        -outGrid->origin[2] : outGrid->origin[2];
295
296    float zinc = outGrid->flip ? -outGrid->resolution : outGrid->resolution;
297    float z = outGrid->origin[2];
298    for (int i = 0; i < outGrid->zdim; i++, z+= zinc) {
299        outGrid->sliceOrigins[i][0] = outGrid->origin[0];
300        outGrid->sliceOrigins[i][1] = outGrid->origin[1];
301        outGrid->sliceOrigins[i][2] = z;
302    }
303
304    inGrid->copyParams(outGrid);
305
306    *pInGrid = inGrid;
307    *pOutGrid = outGrid;
308}
309
310
311void
312configureGridPersp(OccGridRLE **pInGrid, OccGridRLE **pOutGrid, 
313                   OrthoShear *shear)
314{
315    OccGridRLE *temp, *inGrid, *outGrid;
316
317    inGrid = *pInGrid;
318    outGrid = *pOutGrid;
319
320    // Unflip the grid, if necessary
321    if (inGrid->flip) {
322        inGrid->flip = FALSE;
323        inGrid->origin[2] = -inGrid->origin[2];
324    }
325
326    outGrid->copyParams(inGrid);
327
328    // Transpose to the desired axis
329    if (shear->axis != inGrid->axis) {
330        if (inGrid->axis == X_AXIS) {
331            inGrid->transposeXZ(outGrid);
332            SWAP(inGrid, outGrid, temp);
333        }
334        else if (inGrid->axis == Y_AXIS) {
335            inGrid->transposeYZ(outGrid);
336            SWAP(inGrid, outGrid, temp);
337        }
338       
339        if (shear->axis == X_AXIS) {
340            inGrid->transposeXZ(outGrid);
341        }
342        else if (shear->axis == Y_AXIS) {
343            inGrid->transposeYZ(outGrid);
344        }
345        else {
346            SWAP(inGrid, outGrid, temp);
347        }           
348
349        outGrid->axis = shear->axis;
350    }
351    else {
352        SWAP(inGrid, outGrid, temp);
353    }   
354
355    // Flip the grid, if necessary
356    outGrid->flip = shear->flip;
357    outGrid->origin[2] = outGrid->flip ? 
358        -outGrid->origin[2] : outGrid->origin[2];
359
360    float zinc = outGrid->flip ? -outGrid->resolution : outGrid->resolution;
361    float z = outGrid->origin[2];
362    for (int i = 0; i < outGrid->zdim; i++, z+= zinc) {
363        outGrid->sliceOrigins[i][0] = outGrid->origin[0];
364        outGrid->sliceOrigins[i][1] = outGrid->origin[1];
365        outGrid->sliceOrigins[i][2] = z;
366    }
367
368    inGrid->copyParams(outGrid);
369
370    *pInGrid = inGrid;
371    *pOutGrid = outGrid;
372}
373
374
375BBox3f *
376getBBox(OccGrid *grid) 
377{
378    float d1, d2, d3, d4, res;
379
380    BBox3f *bbox = new BBox3f;
381
382    res = grid->resolution;
383
384    d1 = grid->sliceOrigins[0][0];
385    d2 = grid->sliceOrigins[0][0] + grid->xdim*res;
386    d3 = grid->sliceOrigins[grid->zdim-1][0];
387    d4 = grid->sliceOrigins[grid->zdim-1][0] + grid->xdim*res;
388    bbox->fll.x = MIN(MIN(d1,d2),MIN(d3,d4));
389    bbox->nur.x = MAX(MAX(d1,d2),MAX(d3,d4));
390
391    d1 = grid->sliceOrigins[0][1];
392    d2 = grid->sliceOrigins[0][1] + grid->ydim*res;
393    d3 = grid->sliceOrigins[grid->zdim-1][1];
394    d4 = grid->sliceOrigins[grid->zdim-1][1] + grid->ydim*res;
395    bbox->fll.y = MIN(MIN(d1,d2),MIN(d3,d4));
396    bbox->nur.y = MAX(MAX(d1,d2),MAX(d3,d4));
397
398    d1 = grid->sliceOrigins[0][2];
399    d2 = grid->sliceOrigins[grid->zdim-1][2];
400    bbox->fll.z = MIN(d1,d2);
401    bbox->nur.z = MAX(d1,d2);
402
403    return bbox;
404}
405
406
407BBox3f *
408getBBox(OccGridRLE *grid) 
409{
410    float d1, d2, d3, d4, res;
411
412    BBox3f *bbox = new BBox3f;
413
414    res = grid->resolution;
415
416    d1 = grid->sliceOrigins[0][0];
417    d2 = grid->sliceOrigins[0][0] + grid->xdim*res;
418    d3 = grid->sliceOrigins[grid->zdim-1][0];
419    d4 = grid->sliceOrigins[grid->zdim-1][0] + grid->xdim*res;
420    bbox->fll.x = MIN(MIN(d1,d2),MIN(d3,d4));
421    bbox->nur.x = MAX(MAX(d1,d2),MAX(d3,d4));
422
423    d1 = grid->sliceOrigins[0][1];
424    d2 = grid->sliceOrigins[0][1] + grid->ydim*res;
425    d3 = grid->sliceOrigins[grid->zdim-1][1];
426    d4 = grid->sliceOrigins[grid->zdim-1][1] + grid->ydim*res;
427    bbox->fll.y = MIN(MIN(d1,d2),MIN(d3,d4));
428    bbox->nur.y = MAX(MAX(d1,d2),MAX(d3,d4));
429
430    d1 = grid->sliceOrigins[0][2];
431    d2 = grid->sliceOrigins[grid->zdim-1][2];
432    bbox->fll.z = MIN(d1,d2);
433    bbox->nur.z = MAX(d1,d2);
434
435    return bbox;
436}
437
438
439BBox3f *
440getBBox(OccGridNormRLE *grid) 
441{
442    float d1, d2, d3, d4, res;
443
444    BBox3f *bbox = new BBox3f;
445
446    res = grid->resolution;
447
448    d1 = grid->sliceOrigins[0][0];
449    d2 = grid->sliceOrigins[0][0] + grid->xdim*res;
450    d3 = grid->sliceOrigins[grid->zdim-1][0];
451    d4 = grid->sliceOrigins[grid->zdim-1][0] + grid->xdim*res;
452    bbox->fll.x = MIN(MIN(d1,d2),MIN(d3,d4));
453    bbox->nur.x = MAX(MAX(d1,d2),MAX(d3,d4));
454
455    d1 = grid->sliceOrigins[0][1];
456    d2 = grid->sliceOrigins[0][1] + grid->xdim*res;
457    d3 = grid->sliceOrigins[grid->zdim-1][1];
458    d4 = grid->sliceOrigins[grid->zdim-1][1] + grid->ydim*res;
459    bbox->fll.y = MIN(MIN(d1,d2),MIN(d3,d4));
460    bbox->nur.y = MAX(MAX(d1,d2),MAX(d3,d4));
461
462    d1 = grid->sliceOrigins[0][2];
463    d2 = grid->sliceOrigins[grid->zdim-1][2];
464    bbox->fll.z = MIN(d1,d2);
465    bbox->nur.z = MAX(d1,d2);
466
467    return bbox;
468}
469
470
471BBox3f *
472getBBoxLinePersp(OccGridRLE *grid, int *numLines) 
473{
474    Vec3f v, v1, v2, v3, v4, v5, v6, v7, v8;
475    float res, dely;
476
477    BBox3f *bbox = new BBox3f;
478
479    res = grid->resolution;
480
481    v.setValue(grid->sliceOrigins[0][0], 
482               grid->sliceOrigins[0][1], 
483               grid->sliceOrigins[0][2]);
484    applyLinePersp(v, v1);
485
486    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
487               grid->sliceOrigins[0][1], 
488               grid->sliceOrigins[0][2]);
489    applyLinePersp(v, v2);
490
491    dely = fabs(v1.y - v2.y);
492
493    v.setValue(grid->sliceOrigins[0][0], 
494               grid->sliceOrigins[0][1] + grid->ydim*res, 
495               grid->sliceOrigins[0][2]);
496    applyLinePersp(v, v3);
497
498    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
499               grid->sliceOrigins[0][1] + grid->ydim*res, 
500               grid->sliceOrigins[0][2]);
501    applyLinePersp(v, v4);
502
503    dely = MAX(dely, fabs(v3.y - v4.y));
504
505    v.setValue(grid->sliceOrigins[0][0], 
506               grid->sliceOrigins[0][1], 
507               grid->sliceOrigins[grid->zdim-1][2]);
508    applyLinePersp(v, v5);
509
510    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
511               grid->sliceOrigins[0][1], 
512               grid->sliceOrigins[grid->zdim-1][2]);
513    applyLinePersp(v, v6);
514
515    dely = MAX(dely, fabs(v5.y - v6.y));
516
517    v.setValue(grid->sliceOrigins[0][0], 
518               grid->sliceOrigins[0][1] + grid->ydim*res, 
519               grid->sliceOrigins[grid->zdim-1][2]);
520    applyLinePersp(v, v7);
521
522    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
523               grid->sliceOrigins[0][1] + grid->ydim*res, 
524               grid->sliceOrigins[grid->zdim-1][2]);
525    applyLinePersp(v, v8);
526
527    dely = MAX(dely, fabs(v7.y - v8.y));
528
529
530    bbox->fll.x = MIN(MIN(MIN(v1.x,v2.x),MIN(v3.x,v4.x)), 
531                      MIN(MIN(v5.x,v6.x),MIN(v7.x,v8.x)));
532    bbox->nur.x = MAX(MAX(MAX(v1.x,v2.x),MAX(v3.x,v4.x)), 
533                      MAX(MAX(v5.x,v6.x),MAX(v7.x,v8.x)));
534
535    bbox->fll.y = MIN(MIN(MIN(v1.y,v2.y),MIN(v3.y,v4.y)), 
536                      MIN(MIN(v5.y,v6.y),MIN(v7.y,v8.y)));
537    bbox->nur.y = MAX(MAX(MAX(v1.y,v2.y),MAX(v3.y,v4.y)), 
538                      MAX(MAX(v5.y,v6.y),MAX(v7.y,v8.y)));
539
540    bbox->fll.z = MIN(MIN(MIN(v1.z,v2.z),MIN(v3.z,v4.z)), 
541                      MIN(MIN(v5.z,v6.z),MIN(v7.z,v8.z)));
542    bbox->nur.z = MAX(MAX(MAX(v1.z,v2.z),MAX(v3.z,v4.z)), 
543                      MAX(MAX(v5.z,v6.z),MAX(v7.z,v8.z)));
544
545
546
547    *numLines = int(ceil(dely/res))+2;
548
549#if 0
550    // Shouldn't need to multiply by 2
551    *numLines = 2*int(ceil(dely/res))+2;
552    if (Warn)
553        printf("Using conservative line width in depth map.\n");
554#endif
555
556    if (Verbose) {
557        printf("BBox: (%f, %f, %f) -> (%f, %f, %f)\n", 
558               bbox->fll.x, bbox->fll.y, bbox->fll.z, 
559               bbox->nur.x, bbox->nur.y, bbox->nur.z);
560    }
561
562    return bbox;
563}
564
565
566BBox3f *
567getBBoxPersp(OccGridRLE *grid, int *numLines) 
568{
569    Vec3f v, v1, v2, v3, v4, v5, v6, v7, v8;
570    float res, dely;
571
572    BBox3f *bbox = new BBox3f;
573
574    res = grid->resolution;
575
576    v.setValue(grid->sliceOrigins[0][0], 
577               grid->sliceOrigins[0][1], 
578               grid->sliceOrigins[0][2]);
579    applyPersp(v, v1);
580
581    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
582               grid->sliceOrigins[0][1], 
583               grid->sliceOrigins[0][2]);
584    applyPersp(v, v2);
585
586    dely = fabs(v1.y - v2.y);
587
588    v.setValue(grid->sliceOrigins[0][0], 
589               grid->sliceOrigins[0][1] + grid->ydim*res, 
590               grid->sliceOrigins[0][2]);
591    applyPersp(v, v3);
592
593    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
594               grid->sliceOrigins[0][1] + grid->ydim*res, 
595               grid->sliceOrigins[0][2]);
596    applyPersp(v, v4);
597
598    dely = MAX(dely, fabs(v3.y - v4.y));
599
600    v.setValue(grid->sliceOrigins[0][0], 
601               grid->sliceOrigins[0][1], 
602               grid->sliceOrigins[grid->zdim-1][2]);
603    applyPersp(v, v5);
604
605    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
606               grid->sliceOrigins[0][1], 
607               grid->sliceOrigins[grid->zdim-1][2]);
608    applyPersp(v, v6);
609
610    dely = MAX(dely, fabs(v5.y - v6.y));
611
612    v.setValue(grid->sliceOrigins[0][0], 
613               grid->sliceOrigins[0][1] + grid->ydim*res, 
614               grid->sliceOrigins[grid->zdim-1][2]);
615    applyPersp(v, v7);
616
617    v.setValue(grid->sliceOrigins[0][0] + grid->xdim*res, 
618               grid->sliceOrigins[0][1] + grid->ydim*res, 
619               grid->sliceOrigins[grid->zdim-1][2]);
620    applyPersp(v, v8);
621
622    dely = MAX(dely, fabs(v7.y - v8.y));
623
624
625    bbox->fll.x = MIN(MIN(MIN(v1.x,v2.x),MIN(v3.x,v4.x)), 
626                      MIN(MIN(v5.x,v6.x),MIN(v7.x,v8.x)));
627    bbox->nur.x = MAX(MAX(MAX(v1.x,v2.x),MAX(v3.x,v4.x)), 
628                      MAX(MAX(v5.x,v6.x),MAX(v7.x,v8.x)));
629
630    bbox->fll.y = MIN(MIN(MIN(v1.y,v2.y),MIN(v3.y,v4.y)), 
631                      MIN(MIN(v5.y,v6.y),MIN(v7.y,v8.y)));
632    bbox->nur.y = MAX(MAX(MAX(v1.y,v2.y),MAX(v3.y,v4.y)), 
633                      MAX(MAX(v5.y,v6.y),MAX(v7.y,v8.y)));
634
635    bbox->fll.z = MIN(MIN(MIN(v1.z,v2.z),MIN(v3.z,v4.z)), 
636                      MIN(MIN(v5.z,v6.z),MIN(v7.z,v8.z)));
637    bbox->nur.z = MAX(MAX(MAX(v1.z,v2.z),MAX(v3.z,v4.z)), 
638                      MAX(MAX(v5.z,v6.z),MAX(v7.z,v8.z)));
639
640
641
642    *numLines = int(ceil(dely/res))+2;
643
644#if 0
645    // Shouldn't need to multiply by 2
646    *numLines = 2*int(ceil(dely/res))+2;
647    if (Warn)
648        printf("Using conservative line width in depth map.\n");
649#endif
650
651    if (Verbose) {
652        printf("BBox: (%f, %f, %f) -> (%f, %f, %f)\n", 
653               bbox->fll.x, bbox->fll.y, bbox->fll.z, 
654               bbox->nur.x, bbox->nur.y, bbox->nur.z);
655    }
656
657    return bbox;
658}
659
Note: See TracBrowser for help on using the repository browser.