| blob | af9ed3584f4a2c263e39462a85ce56d63ededc7d |
1 // Copyright 2003, 2004, 2005 David Hilvert <dhilvert@auricle.dyndns.org>,
2 // <dhilvert@ugcs.caltech.edu>
4 /* This file is part of the Anti-Lamenessing Engine.
6 The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with the Anti-Lamenessing Engine; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
21 /*
22 * d3/scene.h: Representation of a 3D scene.
23 */
25 #ifndef __scene_h__
26 #define __scene_h__
30 /*
31 * View angle multiplier.
32 *
33 * Setting this to a value larger than one can be useful for debugging.
34 */
36 #define VIEW_ANGLE_MULTIPLIER 1
40 /*
41 * Clipping planes
42 */
46 /*
47 * Decimation exponents for geometry
48 */
53 /*
54 * Output clipping
55 */
58 /*
59 * Model files
60 */
64 /*
65 * Occupancy attenuation
66 */
70 /*
71 * Normalization of output by weight
72 */
76 /*
77 * Falloff exponent
78 */
82 /*
83 * Third-camera error multiplier
84 */
87 /*
88 * Occupancy update iterations
89 */
92 /*
93 * Pairwise ambiguity
94 */
97 /*
98 * Pairwise comparisons
99 */
102 /*
103 * 3D Post-exclusion
104 */
108 /*
109 * Nearness threshold
110 */
113 /*
114 * Encounter threshold for defined pixels.
115 */
118 /*
119 * Flag for subspace traversal.
120 */
123 /*
124 * Structure to hold input frame information at levels of
125 * detail between full detail and full decimation.
126 */
134 /*
135 * Constructor
136 */
139 pt _pt;
159 }
160 }
162 /*
163 * Get the number of scales
164 */
167 }
169 /*
170 * Get an image.
171 */
176 }
180 }
182 /*
183 * Get a 'trilinear' color. We currently don't do interpolation
184 * between levels of detail; hence, it's discontinuous in tl_coord.
185 */
210 }
235 }
237 /*
238 * Get the transformation
239 */
244 }
246 /*
247 * Get the camera origin in world coordinates
248 */
251 }
253 /*
254 * Destructor
255 */
259 }
260 }
261 };
263 /*
264 * Structure to hold weight information for reference images.
265 */
269 pt transformation;
279 }
291 }
295 /*
296 * Explicit weight subtree
297 */
299 ale_real node_value;
308 }
314 }
315 };
317 /*
318 * Constructor
319 */
324 }
326 /*
327 * Check spatial bounds.
328 */
346 }
351 }
353 /*
354 * Increase resolution to the given level.
355 */
362 /*
363 * Check for the cases known to have no lower level of detail.
364 */
374 /*
375 * Load the lower-level image structure.
376 */
384 /*
385 * Check for the case where no lower level of detail is
386 * available.
387 */
392 /*
393 * Spread out the lower level of detail among (uninitialized)
394 * peer values.
395 */
404 }
406 /*
407 * Set the lower level of detail to point here.
408 */
411 }
413 /*
414 * Add weights to positive higher-resolution pixels where
415 * found when their current values match the given subtree
416 * values; set negative pixels to zero and return 0 if no
417 * positive higher-resolution pixels are found.
418 */
426 }
431 /*
432 * Check for positive values.
433 */
439 }
441 /*
442 * Handle the case where there are no higher levels of detail.
443 */
449 }
452 }
454 /*
455 * Handle the case where higher levels of detail are available.
456 */
471 }
483 }
488 }
490 /*
491 * Add weight.
492 */
500 // fprintf(stderr, "[aw tc=%d i=%d j=%d imax=%d jmax=%d]\n",
501 // tc, i, j, im->height(), im->width());
506 /*
507 * Increase resolution, if necessary
508 */
512 /*
513 * Attempt to add the weight at levels of detail
514 * where weight is defined.
515 */
520 /*
521 * If no weights are defined at any level of detail,
522 * then set the weight here.
523 */
526 }
538 }
553 /*
554 * Establish a reasonable (?) upper bound on resolution.
555 */
560 }
562 /*
563 * Initialize, if necessary.
564 */
574 }
576 /*
577 * Check resolution bounds
578 */
582 /*
583 * Generate additional levels of detail, if necessary.
584 */
587 tc_low--;
592 }
595 tc_high++;
600 }
603 }
605 /*
606 * Get weight
607 */
610 // fprintf(stderr, "[gw tc=%d i=%u j=%u tclow=%d tchigh=%d]\n",
611 // tc, i, j, tc_low, tc_high);
621 }
641 }
649 }
652 }
662 }
676 }
679 }
681 /*
682 * Check whether a subtree is simple.
683 */
695 }
697 /*
698 * Get a weight subtree.
699 */
702 /*
703 * tc > tc_high is handled recursively.
704 */
716 }
719 }
726 /*
727 * Rectangular images will, in general, have
728 * out-of-bounds tree sections. Handle this case.
729 */
736 /*
737 * -1 weights are handled recursively
738 */
751 }
754 }
756 /*
757 * Zero weights have NULL subtrees.
758 */
763 /*
764 * Handle the remaining case.
765 */
768 }
777 }
796 }
798 /*
799 * Destructor
800 */
804 }
805 }
806 };
808 /*
809 * Resolution check.
810 */
821 }
823 /*
824 * Structure to hold input frame information at all levels of detail.
825 */
828 /*
829 * All images.
830 */
838 }
845 }
850 }
855 }
861 }
866 }
870 }
871 };
873 /*
874 * All levels-of-detail
875 */
879 /*
880 * Data structure for storing best encountered subspace candidates.
881 */
888 /*
889 * Point p is in world coordinates.
890 */
893 // fprintf(stderr, "[gs iw=%f %f %f d=%f]\n",
894 // iw[0], iw[1], iw[2], diagonal);
901 }
906 /*
907 * Loop until resolutions of interest have been generated.
908 */
916 /*
917 * Generate any new desired spatial registers.
918 */
920 /*
921 * Inputs
922 */
926 /*
927 * Low resolution
928 */
934 }
936 /*
937 * High resolution.
938 */
944 }
945 }
947 /*
948 * Check for completion
949 */
954 /*
955 * Check precision before analyzing space further.
956 */
962 }
966 total_tsteps++;
969 total_tsteps++;
974 }
975 }
976 }
985 /*
986 * Is this necessary?
987 */
995 }
996 }
998 /*
999 * Point p is expected to be in local projective coordinates.
1000 */
1019 &(levels[tc - input_decimation_lower][i * swidth * pairwise_ambiguity + j * pairwise_ambiguity + k]);
1038 }
1039 }
1041 /*
1042 * Generate subspaces for candidates.
1043 */
1064 }
1069 // fprintf(stderr, "[gss l=%d i=%d j=%d d=%g]\n", l, i, j, pk->first);
1075 }
1076 }
1077 }
1078 };
1080 /*
1081 * List for calculating weighted median.
1082 */
1091 }
1096 }
1102 else
1114 }
1115 }
1123 }
1128 used++;
1129 }
1135 }
1139 }
1146 }
1150 }
1157 }
1163 }
1164 }
1168 }
1170 /*
1171 * Finds the median at half-weight, or between half-weight
1172 * and zero-weight, depending on the attenuation value.
1173 */
1189 // if (weight_sum == 0)
1190 // return undefined;
1200 }
1215 }
1216 }
1219 }
1223 // if (initial_size == 0) {
1224 // initial_size = (int) (d2::image_rw::count() * 1.5);
1225 // }
1235 }
1236 }
1238 /*
1239 * copy constructor. This is required to avoid undesired frees.
1240 */
1249 }
1253 }
1254 };
1256 /*
1257 * Class for information regarding spatial regions of interest.
1258 *
1259 * This class is configured for convenience in cases where sampling is
1260 * performed using an approximation of the fine:box:1,triangle:2 chain.
1261 * In this case, the *_1 variables would store the fine data and the
1262 * *_2 variables would store the coarse data. Other uses are also
1263 * possible.
1264 */
1267 /*
1268 * Map channel value --> weight.
1269 */
1273 /*
1274 * Current color.
1275 */
1278 /*
1279 * Map occupancy value --> weight.
1280 */
1281 wml occupancy_weights_1;
1282 wml occupancy_weights_2;
1284 /*
1285 * Current occupancy value.
1286 */
1287 ale_real occupancy;
1289 /*
1290 * pocc/socc density
1291 */
1296 /*
1297 * Insert a weight into a list.
1298 */
1301 }
1303 /*
1304 * Find the median of a weighted list. Uses NaN for undefined.
1305 */
1308 }
1311 /*
1312 * Constructor.
1313 */
1319 }
1321 /*
1322 * Accumulate color; primary data set.
1323 */
1327 }
1329 /*
1330 * Accumulate color; secondary data set.
1331 */
1335 }
1337 /*
1338 * Accumulate occupancy; primary data set.
1339 */
1342 }
1344 /*
1345 * Accumulate occupancy; secondary data set.
1346 */
1353 // fprintf(stderr, "%p updated socc with: %f %f\n", this, occupancy, weight);
1354 // occupancy_weights_2.print_info();
1355 }
1357 /*
1358 * Update color (and clear accumulation structures).
1359 */
1372 }
1373 }
1375 /*
1376 * Update occupancy (and clear accumulation structures).
1377 */
1393 }
1395 /*
1396 * Get current color.
1397 */
1400 }
1402 /*
1403 * Get current occupancy.
1404 */
1408 }
1410 /*
1411 * Get primary color density.
1412 */
1416 }
1420 }
1421 };
1423 /*
1424 * Map spatial regions of interest to spatial info structures. XXX:
1425 * This may get very poor cache behavior in comparison with, say, an
1426 * array. Unfortunately, there is no immediately obvious array
1427 * representation. If some kind of array representation were adopted,
1428 * it would probably cluster regions of similar depth from the
1429 * perspective of the typical camera. In particular, for a
1430 * stereoscopic view, depth ordering for two random points tends to be
1431 * similar between cameras, I think. Unfortunately, it is never
1432 * identical for all points (unless cameras are co-located). One
1433 * possible approach would be to order based on, say, camera 0's idea
1434 * of depth.
1435 */
1443 /*
1444 * Debugging variables.
1445 */
1452 /*
1453 * Member functions
1454 */
1458 }
1462 }
1466 }
1470 }
1474 }
1478 }
1482 }
1486 }
1490 }
1494 }
1496 /*
1497 * Initialize 3D scene from 2D scene, using 2D and 3D alignment
1498 * information.
1499 */
1502 /*
1503 * Rear clip value of 0 is converted to infinity.
1504 */
1512 }
1514 /*
1515 * Scale and translate clipping plane depths.
1516 */
1525 /*
1526 * Allocate image structures.
1527 */
1533 }
1534 }
1536 /*
1537 * Perform spatial_info updating on a given subspace, for given
1538 * parameters.
1539 */
1545 /*
1546 * Skip spaces with no color information.
1547 *
1548 * XXX: This could be more efficient, perhaps.
1549 */
1554 }
1556 /*
1557 * Get in-bounds centroid, if one exists.
1558 */
1565 }
1567 /*
1568 * Get information on the subspace.
1569 */
1575 /*
1576 * Store current weight so we can later check for
1577 * modification by higher-resolution subspaces.
1578 */
1582 /*
1583 * Check for higher resolution subspaces, and
1584 * update the space iterator.
1585 */
1590 /*
1591 * Cleave space for the higher-resolution pass,
1592 * skipping the current space, since we will
1593 * process that later.
1594 */
1604 }
1606 /*
1607 * Add new data on the subspace and update weights.
1608 */
1620 }
1622 /*
1623 * Determine the probability of encounter.
1624 */
1628 /*
1629 * Update weights
1630 */
1634 /*
1635 * Delete the subtree, if necessary.
1636 */
1640 /*
1641 * Check for cases in which the subspace should not be
1642 * updated.
1643 */
1645 #if 0
1648 #endif
1650 /*
1651 * Update subspace.
1652 */
1665 }
1666 }
1668 /*
1669 * Run a single iteration of the spatial_info update cycle.
1670 */
1672 /*
1673 * Iterate through each frame.
1674 */
1677 /*
1678 * Open the frame and transformation.
1679 */
1684 /*
1685 * Allocate weights data structure for storing encounter
1686 * probabilities.
1687 */
1691 /*
1692 * Call subspace_info_update for the root space.
1693 */
1697 /*
1698 * Free weights.
1699 */
1703 /*
1704 * Close the frame and transformation.
1705 */
1709 }
1711 /*
1712 * Update all spatial_info structures.
1713 */
1714 for (spatial_info_map_t::iterator i = spatial_info_map.begin(); i != spatial_info_map.end(); i++) {
1718 // d2::pixel color = i->second.get_color();
1720 // fprintf(stderr, "space p=%p updated to c=[%f %f %f] o=%f\n",
1721 // i->first, color[0], color[1], color[2],
1722 // i->second.get_occupancy());
1723 }
1724 }
1726 /*
1727 * Support function for view() and depth().
1728 */
1730 static const void view_recurse(int type, d2::image *im, d2::image *weights, space::iterate si, pt _pt) {
1734 /*
1735 * XXX: This could be more efficient, perhaps.
1736 */
1741 }
1745 /*
1746 * Get information on the subspace.
1747 */
1750 // d2::pixel color = d2::pixel(1, 1, 1) * (double) (((unsigned int) (st.get_node()) / sizeof(space)) % 65535);
1753 /*
1754 * Determine the view-local bounding box for the
1755 * subspace.
1756 */
1765 /*
1766 * Data structure to check modification of weights by
1767 * higher-resolution subspaces.
1768 */
1772 /*
1773 * Check for higher resolution subspaces, and
1774 * update the space iterator.
1775 */
1780 /*
1781 * Store information about current weights,
1782 * so we will know which areas have been
1783 * covered by higher-resolution subspaces.
1784 */
1790 /*
1791 * Cleave space for the higher-resolution pass,
1792 * skipping the current space, since we will
1793 * process that afterward.
1794 */
1804 }
1807 /*
1808 * Iterate over pixels in the bounding box, finding
1809 * pixels that intersect the subspace. XXX: assume
1810 * for now that all pixels in the bounding box
1811 * intersect the subspace.
1812 */
1817 /*
1818 * Check for higher-resolution updates.
1819 */
1825 }
1827 }
1829 /*
1830 * Determine the probability of encounter.
1831 */
1835 /*
1836 * Update images.
1837 */
1841 /*
1842 * Color view
1843 */
1850 /*
1851 * Weighted (transparent) depth display
1852 */
1860 /*
1861 * Ambiguity (ambivalence) measure.
1862 */
1869 /*
1870 * Closeness measure.
1871 */
1881 }
1885 /*
1886 * Weighted (transparent) contribution display
1887 */
1898 /*
1899 * Weighted (transparent) occupancy display
1900 */
1908 /*
1909 * (Depth, xres, yres) triple
1910 */
1919 }
1923 /*
1924 * (xoff, yoff, 0) triple
1925 */
1933 }
1937 }
1938 }
1939 }
1941 /*
1942 * Generate an depth image from a specified view.
1943 */
1952 }
1965 /*
1966 * Use adaptive subspace data.
1967 */
1972 /*
1973 * Iterate through subspaces.
1974 */
1984 #if 1
1986 #else
1989 #endif
1991 /*
1992 * Normalize depths by weights
1993 */
2004 /*
2005 * Handle interpolation.
2006 */
2016 else
2020 }
2038 }
2039 }
2043 /*
2044 * Handle exclusions and encounter thresholds
2045 */
2053 }
2054 }
2061 }
2070 }
2072 /*
2073 * Generate an image from a specified view.
2074 */
2083 }
2095 /*
2096 * Use adaptive subspace data.
2097 */
2102 /*
2103 * Iterate through subspaces.
2104 */
2118 }
2126 }
2130 }
2134 }
2138 }
2142 }
2147 }
2151 }
2155 }
2159 }
2163 }
2175 }
2178 }
2187 }
2189 /*
2190 * Add specified control points to the model
2191 */
2193 }
2199 /*
2200 * Make pt list.
2201 */
2211 }
2212 }
2214 for (std::map<const char *, pt>::iterator i = d3_depth_pt->begin(); i != d3_depth_pt->end(); i++) {
2216 }
2218 for (std::map<const char *, pt>::iterator i = d3_output_pt->begin(); i != d3_output_pt->end(); i++) {
2220 }
2223 }
2225 /*
2226 * Get a trilinear coordinate for an anisotropic candidate cell.
2227 */
2237 /*
2238 * Determine the view-local extrema in 2 dimensions.
2239 */
2251 }
2252 }
2257 }
2259 /*
2260 * Check whether a cell is visible from a given viewpoint. This function
2261 * is guaranteed to return 1 when a cell is visible, but it is not guaranteed
2262 * to return 0 when a cell is invisible.
2263 */
2273 /*
2274 * Cycle through all vertices of the cell to check certain
2275 * properties.
2276 */
2313 }
2325 }
2327 /*
2328 * Check whether a cell is output-visible.
2329 */
2335 }
2337 /*
2338 * Check whether a cell is input-visible.
2339 */
2342 }
2344 /*
2345 * Return true if a cell fails an output resolution bound.
2346 */
2347 static int fails_output_resolution_bound(point min, point max, const std::vector<pt> &pt_outputs) {
2357 }
2360 }
2362 /*
2363 * Check lower-bound resolution constraints
2364 */
2381 }
2383 /*
2384 * Try the candidate nearest to the specified cell.
2385 */
2386 static void try_nearest_candidate(unsigned int f1, unsigned int f2, candidates *c, point min, point max) {
2391 // fprintf(stderr, "[tnc n=%f %f %f x=%f %f %f]\n", min[0], min[1], min[2], max[0], max[1], max[2]);
2393 /*
2394 * Reject clipping plane violations.
2395 */
2401 /*
2402 * Calculate projections.
2403 */
2412 // fprintf(stderr, ":");
2416 }
2423 tc++;
2424 stc++;
2425 }
2430 /*
2431 * Calculate score from color match. Assume for now
2432 * that the transformation can be approximated locally
2433 * with a translation.
2434 */
2447 }
2458 score += l1_multiplier
2461 }
2463 /*
2464 * Include third-camera contributions in the score.
2465 */
2485 score += tc_multiplier
2487 }
2490 }
2492 /*
2493 * Check for cells that are completely clipped.
2494 */
2498 }
2500 /*
2501 * Update extremum variables for cell points mapped to a particular view.
2502 */
2503 static void update_extrema(point min, point max, pt _pt, int *extreme_dim, ale_pos *extreme_ratio) {
2514 /*
2515 * Determine the view-local extrema in all dimensions, and
2516 * determine the vertex of closest z coordinate.
2517 */
2527 }
2531 }
2535 /*
2536 * Update extrema as necessary for each dimension.
2537 */
2548 ale_pos local_distance = (_pt.wp_unscaled(point(cell[p1[0]][0], cell[p1[1]][1], cell[p1[2]][2])).xy()
2554 }
2555 }
2556 }
2558 /*
2559 * Get the next split dimension.
2560 */
2561 static int get_next_split(int f1, int f2, point min, point max, const std::vector<pt> &pt_outputs) {
2574 }
2577 }
2579 /*
2580 * Find candidates for subspace creation.
2581 */
2582 static void find_candidates(unsigned int f1, unsigned int f2, candidates *c, point min, point max,
2595 }
2598 }
2604 }
2611 }
2617 }
2624 __LINE__);
2631 }
2635 if (!space::traverse::get_next_cells(get_next_split(f1, f2, min, max, pt_outputs), min, max, new_cells)) {
2639 }
2655 }
2659 }
2661 /*
2662 * Generate a map from scores to 3D points for various depths at point (i, j) in f1, at
2663 * lowest resolution.
2664 */
2665 static score_map p2f_score_map(unsigned int f1, unsigned int f2, unsigned int i, unsigned int j) {
2667 score_map result;
2675 /*
2676 * Get the pixel color in the primary frame
2677 */
2679 // d2::pixel color_primary = if1->get_pixel(i, j);
2681 /*
2682 * Map two depths to the secondary frame.
2683 */
2688 // fprintf(stderr, "%d->%d (%d, %d) point pair: (%d, %d, %d -> %f, %f), (%d, %d, %d -> %f, %f)\n",
2689 // f1, f2, i, j, i, j, 1000, p1[0], p1[1], i, j, -1000, p2[0], p2[1]);
2690 // _pt1.debug_output();
2691 // _pt2.debug_output();
2694 /*
2695 * For cases where the mapped points define a
2696 * line and where points on the line fall
2697 * within the defined area of the frame,
2698 * determine the starting point for inspection.
2699 * In other cases, continue to the next pixel.
2700 */
2711 }
2713 /*
2714 * Make absurdly large/small slopes either infinity, negative infinity, or zero.
2715 */
2725 }
2727 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2734 // fprintf(stderr, "slope == %f\n", slope);
2738 // fprintf(stderr, "case 0\n");
2742 // fprintf(stderr, "case 1\n");
2746 // fprintf(stderr, "case 2\n");
2750 // fprintf(stderr, "case 3\n");
2754 // fprintf(stderr, "case 4\n");
2755 // fprintf(stderr, "%d->%d (%d, %d) does not intersect the defined area\n",
2756 // f1, f2, i, j);
2758 }
2761 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2763 /*
2764 * Determine increment values for examining
2765 * point, ensuring that incr_i is always
2766 * positive.
2767 */
2780 }
2782 // fprintf(stderr, "%d->%d (%d, %d) increments are (%f, %f)\n",
2783 // f1, f2, i, j, incr_i, incr_j);
2785 /*
2786 * Examine regions near the projected line.
2787 */
2793 // fprintf(stderr, "%d->%d (%d, %d) checking (%f, %f)\n",
2794 // f1, f2, i, j, ii, jj);
2796 #if 0
2797 /*
2798 * Check for higher, lower, and nearby points.
2799 *
2800 * Red = 2^0
2801 * Green = 2^1
2802 * Blue = 2^2
2803 */
2820 }
2821 }
2823 /*
2824 * If this is not a region of interest,
2825 * then continue.
2826 */
2831 // if (((higher & lower) | nearby) != 0x7)
2832 // continue;
2833 #endif
2834 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2836 // fprintf(stderr, "%d->%d (%d, %d) accepted (%f, %f)\n",
2837 // f1, f2, i, j, ii, jj);
2839 /*
2840 * Create an orthonormal basis to
2841 * determine line intersection.
2842 */
2849 // fprintf(stderr, "(%d, %d, 0) transformed to world and back is: (%f, %f, %f)\n",
2850 // i, j, foo[0], foo[1], foo[2]);
2853 // fprintf(stderr, "(%d, %d, 10) transformed to world and back is: (%f, %f, %f)\n",
2854 // i, j, foo[0], foo[1], foo[2]);
2864 /*
2865 * Select a fourth point to define a second line.
2866 */
2870 /*
2871 * Representation in the new basis.
2872 */
2875 // d2::point nbp1 = d2::point(bp1.dproduct(b0), bp1.dproduct(b1));
2879 /*
2880 * Determine intersection of line
2881 * (nbp0, nbp1), which is parallel to
2882 * b0, with line (nbp2, np3).
2883 */
2885 /*
2886 * XXX: a stronger check would be
2887 * better here, e.g., involving the
2888 * ratio (np3[0] - nbp2[0]) / (np3[1] -
2889 * nbp2[1]). Also, acceptance of these
2890 * cases is probably better than
2891 * rejection.
2892 */
2895 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2901 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2909 /*
2910 * Map the intersection back to the world
2911 * basis.
2912 */
2916 /*
2917 * Reject intersection points behind a
2918 * camera.
2919 */
2925 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2931 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2933 /*
2934 * Reject clipping plane violations.
2935 */
2938 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2945 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2947 /*
2948 * Score the point.
2949 */
2957 /*
2958 * Calculate score from color match. Assume for now
2959 * that the transformation can be approximated locally
2960 * with a translation.
2961 */
2972 }
2975 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2986 score += l1_multiplier
2989 }
2991 /*
2992 * Include third-camera contributions in the score.
2993 */
3010 score += tc_multiplier
3012 }
3017 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3019 /*
3020 * Reject points with undefined score.
3021 */
3024 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3030 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3032 #if 0
3033 /*
3034 * XXX: reject points not on the z=-27.882252 plane.
3035 */
3038 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3042 #endif
3045 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3047 /*
3048 * Add the point to the score map.
3049 */
3051 // d2::pixel c_ip = if1->in_bounds(ip.xy()) ? if1->get_bl(ip.xy())
3052 // : d2::pixel();
3053 // d2::pixel c_is = if2->in_bounds(is.xy()) ? if2->get_bl(is.xy())
3054 // : d2::pixel();
3056 // fprintf(stderr, "Candidate subspace: f1=%u f2=%u i=%u j=%u ii=%f jj=%f"
3057 // "cp=[%f %f %f] cs=[%f %f %f]\n",
3058 // f1, f2, i, j, ii, jj, c_ip[0], c_ip[1], c_ip[2],
3059 // c_is[0], c_is[1], c_is[2]);
3062 }
3064 // fprintf(stderr, "Iterating through the score map:\n");
3065 //
3066 // for (score_map::iterator smi = result.begin(); smi != result.end(); smi++) {
3067 // fprintf(stderr, "%f ", smi->first);
3068 // }
3069 //
3070 // fprintf(stderr, "\n");
3073 }
3076 /*
3077 * Attempt to refine space around a point, to high and low resolutions
3078 * resulting in two resolutions in total.
3079 */
3088 }
3092 /*
3093 * Loop until all resolutions of interest have been generated.
3094 */
3106 }
3108 /*
3109 * Generate any new desired spatial registers.
3110 */
3114 /*
3115 * Low resolution
3116 */
3122 }
3124 /*
3125 * High resolution.
3126 */
3131 }
3132 }
3134 /*
3135 * Check precision before analyzing space further.
3136 */
3142 }
3146 total_tsteps++;
3149 total_tsteps++;
3154 }
3155 }
3156 }
3158 /*
3159 * Calculate target dimension
3160 */
3173 }
3175 for (std::map<const char *, pt>::iterator i = d3_output_pt->begin(); i != d3_output_pt->end(); i++) {
3178 }
3180 for (std::map<const char *, pt>::iterator i = d3_depth_pt->begin(); i != d3_depth_pt->end(); i++) {
3183 }
3188 }
3190 /*
3191 * Calculate level of detail for a given viewpoint.
3192 */
3196 }
3198 /*
3199 * Calculate depth range for a given pair of viewpoints.
3200 */
3223 else
3225 }
3236 }
3238 /*
3239 * Calculate a refined point for a given set of parameters.
3240 */
3244 ale_pos depth_range) {
3263 }
3264 }
3267 }
3269 /*
3270 * Analyze space in a manner dependent on the score map.
3271 */
3292 // point is = smi->second.is;
3297 total_ambiguity++;
3314 }
3337 /*
3338 * Attempt to refine space around the intersection point.
3339 */
3343 }
3345 }
3346 }
3349 /*
3350 * Initialize space and identify regions of interest for the adaptive
3351 * subspace model.
3352 */
3357 /*
3358 * Variable indicating whether low-resolution filler space
3359 * is desired to avoid aliased gaps in surfaces.
3360 */
3373 /*
3374 * Initialize root space.
3375 */
3379 /*
3380 * Special handling for experimental option 'subspace_traverse'.
3381 */
3384 /*
3385 * Subdivide space to resolve intensity matches between pairs
3386 * of frames.
3387 */
3418 }
3422 }
3430 }
3432 /*
3433 * Subdivide space to resolve intensity matches between pairs
3434 * of frames.
3435 */
3449 }
3451 /*
3452 * Iterate over all points in the primary frame.
3453 */
3458 total_pixels++;
3460 /*
3461 * Generate a map from scores to 3D points for
3462 * various depths in f1.
3463 */
3467 /*
3468 * Analyze space in a manner dependent on the score map.
3469 */
3474 }
3476 /*
3477 * This ordering may encourage image f1 to be cached.
3478 */
3483 }
3484 }
3487 }
3490 /*
3491 * Update spatial information structures.
3492 *
3493 * XXX: the name of this function is horribly misleading. There isn't
3494 * even a 'search depth' any longer, since there is no longer any
3495 * bounded DFS occurring.
3496 */
3500 /*
3501 * Subspace model
3502 */
3509 }
3511 #if 0
3512 /*
3513 * Describe a scene to a renderer
3514 */
3516 }
3517 #endif
3518 };
3520 #endif