| blob | d9d8ca5cf63870534762cdaaea701fdf05763c17 |
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 * Filtering data
78 */
83 /*
84 * Falloff exponent
85 */
89 /*
90 * Third-camera error multiplier
91 */
94 /*
95 * Occupancy update iterations
96 */
99 /*
100 * Pairwise ambiguity
101 */
104 /*
105 * Pairwise comparisons
106 */
109 /*
110 * 3D Post-exclusion
111 */
115 /*
116 * Nearness threshold
117 */
120 /*
121 * Encounter threshold for defined pixels.
122 */
125 /*
126 * Flag for subspace traversal.
127 */
130 /*
131 * Structure to hold input frame information at levels of
132 * detail between full detail and full decimation.
133 */
141 /*
142 * Constructor
143 */
146 pt _pt;
166 }
167 }
169 /*
170 * Get the number of scales
171 */
174 }
176 /*
177 * Get an image.
178 */
183 }
187 }
189 /*
190 * Get a 'trilinear' color. We currently don't do interpolation
191 * between levels of detail; hence, it's discontinuous in tl_coord.
192 */
217 }
242 }
244 /*
245 * Get the transformation
246 */
251 }
253 /*
254 * Get the camera origin in world coordinates
255 */
258 }
260 /*
261 * Destructor
262 */
266 }
267 }
268 };
270 /*
271 * Structure to hold weight information for reference images.
272 */
276 pt transformation;
286 }
298 }
302 /*
303 * Explicit weight subtree
304 */
306 ale_real node_value;
315 }
321 }
322 };
324 /*
325 * Constructor
326 */
331 }
333 /*
334 * Check spatial bounds.
335 */
353 }
358 }
360 /*
361 * Increase resolution to the given level.
362 */
369 /*
370 * Check for the cases known to have no lower level of detail.
371 */
381 /*
382 * Load the lower-level image structure.
383 */
391 /*
392 * Check for the case where no lower level of detail is
393 * available.
394 */
399 /*
400 * Spread out the lower level of detail among (uninitialized)
401 * peer values.
402 */
411 }
413 /*
414 * Set the lower level of detail to point here.
415 */
418 }
420 /*
421 * Add weights to positive higher-resolution pixels where
422 * found when their current values match the given subtree
423 * values; set negative pixels to zero and return 0 if no
424 * positive higher-resolution pixels are found.
425 */
433 }
438 /*
439 * Check for positive values.
440 */
446 }
448 /*
449 * Handle the case where there are no higher levels of detail.
450 */
456 }
459 }
461 /*
462 * Handle the case where higher levels of detail are available.
463 */
478 }
490 }
495 }
497 /*
498 * Add weight.
499 */
507 // fprintf(stderr, "[aw tc=%d i=%d j=%d imax=%d jmax=%d]\n",
508 // tc, i, j, im->height(), im->width());
513 /*
514 * Increase resolution, if necessary
515 */
519 /*
520 * Attempt to add the weight at levels of detail
521 * where weight is defined.
522 */
527 /*
528 * If no weights are defined at any level of detail,
529 * then set the weight here.
530 */
533 }
545 }
560 /*
561 * Establish a reasonable (?) upper bound on resolution.
562 */
567 }
569 /*
570 * Initialize, if necessary.
571 */
581 }
583 /*
584 * Check resolution bounds
585 */
589 /*
590 * Generate additional levels of detail, if necessary.
591 */
594 tc_low--;
599 }
602 tc_high++;
607 }
610 }
612 /*
613 * Get weight
614 */
617 // fprintf(stderr, "[gw tc=%d i=%u j=%u tclow=%d tchigh=%d]\n",
618 // tc, i, j, tc_low, tc_high);
628 }
648 }
656 }
659 }
669 }
683 }
686 }
688 /*
689 * Check whether a subtree is simple.
690 */
702 }
704 /*
705 * Get a weight subtree.
706 */
709 /*
710 * tc > tc_high is handled recursively.
711 */
723 }
726 }
733 /*
734 * Rectangular images will, in general, have
735 * out-of-bounds tree sections. Handle this case.
736 */
743 /*
744 * -1 weights are handled recursively
745 */
758 }
761 }
763 /*
764 * Zero weights have NULL subtrees.
765 */
770 /*
771 * Handle the remaining case.
772 */
775 }
784 }
803 }
805 /*
806 * Destructor
807 */
811 }
812 }
813 };
815 /*
816 * Resolution check.
817 */
828 }
830 /*
831 * Structure to hold input frame information at all levels of detail.
832 */
835 /*
836 * All images.
837 */
845 }
852 }
857 }
862 }
868 }
873 }
877 }
878 };
880 /*
881 * All levels-of-detail
882 */
886 /*
887 * Data structure for storing best encountered subspace candidates.
888 */
895 /*
896 * Point p is in world coordinates.
897 */
900 // fprintf(stderr, "[gs iw=%f %f %f d=%f]\n",
901 // iw[0], iw[1], iw[2], diagonal);
908 }
913 /*
914 * Loop until resolutions of interest have been generated.
915 */
923 /*
924 * Generate any new desired spatial registers.
925 */
927 /*
928 * Inputs
929 */
933 /*
934 * Low resolution
935 */
941 }
943 /*
944 * High resolution.
945 */
951 }
952 }
954 /*
955 * Check for completion
956 */
961 /*
962 * Check precision before analyzing space further.
963 */
969 }
973 total_tsteps++;
976 total_tsteps++;
981 }
982 }
983 }
992 /*
993 * Is this necessary?
994 */
1002 }
1003 }
1005 /*
1006 * Point p is expected to be in local projective coordinates.
1007 */
1026 &(levels[tc - input_decimation_lower][i * swidth * pairwise_ambiguity + j * pairwise_ambiguity + k]);
1045 }
1046 }
1048 /*
1049 * Generate subspaces for candidates.
1050 */
1071 }
1076 // fprintf(stderr, "[gss l=%d i=%d j=%d d=%g]\n", l, i, j, pk->first);
1082 }
1083 }
1084 }
1085 };
1087 /*
1088 * List for calculating weighted median.
1089 */
1098 }
1103 }
1109 else
1121 }
1122 }
1130 }
1135 used++;
1136 }
1142 }
1146 }
1153 }
1157 }
1164 }
1170 }
1171 }
1175 }
1177 /*
1178 * Finds the median at half-weight, or between half-weight
1179 * and zero-weight, depending on the attenuation value.
1180 */
1196 // if (weight_sum == 0)
1197 // return undefined;
1207 }
1222 }
1223 }
1226 }
1230 // if (initial_size == 0) {
1231 // initial_size = (int) (d2::image_rw::count() * 1.5);
1232 // }
1242 }
1243 }
1245 /*
1246 * copy constructor. This is required to avoid undesired frees.
1247 */
1256 }
1260 }
1261 };
1263 /*
1264 * Class for information regarding spatial regions of interest.
1265 *
1266 * This class is configured for convenience in cases where sampling is
1267 * performed using an approximation of the fine:box:1,triangle:2 chain.
1268 * In this case, the *_1 variables would store the fine data and the
1269 * *_2 variables would store the coarse data. Other uses are also
1270 * possible.
1271 */
1274 /*
1275 * Map channel value --> weight.
1276 */
1280 /*
1281 * Current color.
1282 */
1285 /*
1286 * Map occupancy value --> weight.
1287 */
1288 wml occupancy_weights_1;
1289 wml occupancy_weights_2;
1291 /*
1292 * Current occupancy value.
1293 */
1294 ale_real occupancy;
1296 /*
1297 * pocc/socc density
1298 */
1303 /*
1304 * Insert a weight into a list.
1305 */
1308 }
1310 /*
1311 * Find the median of a weighted list. Uses NaN for undefined.
1312 */
1315 }
1318 /*
1319 * Constructor.
1320 */
1326 }
1328 /*
1329 * Accumulate color; primary data set.
1330 */
1334 }
1336 /*
1337 * Accumulate color; secondary data set.
1338 */
1342 }
1344 /*
1345 * Accumulate occupancy; primary data set.
1346 */
1349 }
1351 /*
1352 * Accumulate occupancy; secondary data set.
1353 */
1360 // fprintf(stderr, "%p updated socc with: %f %f\n", this, occupancy, weight);
1361 // occupancy_weights_2.print_info();
1362 }
1364 /*
1365 * Update color (and clear accumulation structures).
1366 */
1379 }
1380 }
1382 /*
1383 * Update occupancy (and clear accumulation structures).
1384 */
1400 }
1402 /*
1403 * Get current color.
1404 */
1407 }
1409 /*
1410 * Get current occupancy.
1411 */
1415 }
1417 /*
1418 * Get primary color density.
1419 */
1423 }
1427 }
1428 };
1430 /*
1431 * Map spatial regions of interest to spatial info structures. XXX:
1432 * This may get very poor cache behavior in comparison with, say, an
1433 * array. Unfortunately, there is no immediately obvious array
1434 * representation. If some kind of array representation were adopted,
1435 * it would probably cluster regions of similar depth from the
1436 * perspective of the typical camera. In particular, for a
1437 * stereoscopic view, depth ordering for two random points tends to be
1438 * similar between cameras, I think. Unfortunately, it is never
1439 * identical for all points (unless cameras are co-located). One
1440 * possible approach would be to order based on, say, camera 0's idea
1441 * of depth.
1442 */
1450 /*
1451 * Debugging variables.
1452 */
1459 /*
1460 * Member functions
1461 */
1465 }
1469 }
1473 }
1477 }
1481 }
1485 }
1489 }
1493 }
1497 }
1501 }
1503 /*
1504 * Initialize 3D scene from 2D scene, using 2D and 3D alignment
1505 * information.
1506 */
1509 /*
1510 * Rear clip value of 0 is converted to infinity.
1511 */
1519 }
1521 /*
1522 * Scale and translate clipping plane depths.
1523 */
1532 /*
1533 * Allocate image structures.
1534 */
1540 }
1541 }
1543 /*
1544 * Perform spatial_info updating on a given subspace, for given
1545 * parameters.
1546 */
1552 /*
1553 * Skip spaces with no color information.
1554 *
1555 * XXX: This could be more efficient, perhaps.
1556 */
1561 }
1563 /*
1564 * Get in-bounds centroid, if one exists.
1565 */
1572 }
1574 /*
1575 * Get information on the subspace.
1576 */
1582 /*
1583 * Store current weight so we can later check for
1584 * modification by higher-resolution subspaces.
1585 */
1589 /*
1590 * Check for higher resolution subspaces, and
1591 * update the space iterator.
1592 */
1597 /*
1598 * Cleave space for the higher-resolution pass,
1599 * skipping the current space, since we will
1600 * process that later.
1601 */
1611 }
1613 /*
1614 * Add new data on the subspace and update weights.
1615 */
1627 }
1629 /*
1630 * Determine the probability of encounter.
1631 */
1635 /*
1636 * Update weights
1637 */
1641 /*
1642 * Delete the subtree, if necessary.
1643 */
1647 /*
1648 * Check for cases in which the subspace should not be
1649 * updated.
1650 */
1655 /*
1656 * Update subspace.
1657 */
1670 }
1671 }
1673 /*
1674 * Run a single iteration of the spatial_info update cycle.
1675 */
1677 /*
1678 * Iterate through each frame.
1679 */
1682 /*
1683 * Open the frame and transformation.
1684 */
1689 /*
1690 * Allocate weights data structure for storing encounter
1691 * probabilities.
1692 */
1696 /*
1697 * Call subspace_info_update for the root space.
1698 */
1702 /*
1703 * Free weights.
1704 */
1708 /*
1709 * Close the frame and transformation.
1710 */
1714 }
1716 /*
1717 * Update all spatial_info structures.
1718 */
1719 for (spatial_info_map_t::iterator i = spatial_info_map.begin(); i != spatial_info_map.end(); i++) {
1723 // d2::pixel color = i->second.get_color();
1725 // fprintf(stderr, "space p=%p updated to c=[%f %f %f] o=%f\n",
1726 // i->first, color[0], color[1], color[2],
1727 // i->second.get_occupancy());
1728 }
1729 }
1731 /*
1732 * Support function for view() and depth().
1733 */
1735 static const void view_recurse(int type, d2::image *im, d2::image *weights, space::iterate si, pt _pt) {
1739 /*
1740 * XXX: This could be more efficient, perhaps.
1741 */
1746 }
1750 /*
1751 * Get information on the subspace.
1752 */
1755 // d2::pixel color = d2::pixel(1, 1, 1) * (double) (((unsigned int) (st.get_node()) / sizeof(space)) % 65535);
1758 /*
1759 * Determine the view-local bounding box for the
1760 * subspace.
1761 */
1770 /*
1771 * Data structure to check modification of weights by
1772 * higher-resolution subspaces.
1773 */
1777 /*
1778 * Check for higher resolution subspaces, and
1779 * update the space iterator.
1780 */
1785 /*
1786 * Store information about current weights,
1787 * so we will know which areas have been
1788 * covered by higher-resolution subspaces.
1789 */
1795 /*
1796 * Cleave space for the higher-resolution pass,
1797 * skipping the current space, since we will
1798 * process that afterward.
1799 */
1809 }
1812 /*
1813 * Iterate over pixels in the bounding box, finding
1814 * pixels that intersect the subspace. XXX: assume
1815 * for now that all pixels in the bounding box
1816 * intersect the subspace.
1817 */
1822 /*
1823 * Check for higher-resolution updates.
1824 */
1830 }
1832 }
1834 /*
1835 * Determine the probability of encounter.
1836 */
1840 /*
1841 * Update images.
1842 */
1846 /*
1847 * Color view
1848 */
1855 /*
1856 * Weighted (transparent) depth display
1857 */
1865 /*
1866 * Ambiguity (ambivalence) measure.
1867 */
1874 /*
1875 * Closeness measure.
1876 */
1886 }
1890 /*
1891 * Weighted (transparent) contribution display
1892 */
1903 /*
1904 * Weighted (transparent) occupancy display
1905 */
1913 /*
1914 * (Depth, xres, yres) triple
1915 */
1924 }
1928 /*
1929 * (xoff, yoff, 0) triple
1930 */
1938 }
1942 }
1943 }
1944 }
1946 /*
1947 * Generate an depth image from a specified view.
1948 */
1957 }
1970 /*
1971 * Use adaptive subspace data.
1972 */
1977 /*
1978 * Iterate through subspaces.
1979 */
1989 #if 1
1991 #else
1994 #endif
1996 /*
1997 * Normalize depths by weights
1998 */
2009 /*
2010 * Handle interpolation.
2011 */
2021 else
2025 }
2043 }
2044 }
2048 /*
2049 * Handle exclusions and encounter thresholds
2050 */
2058 }
2059 }
2066 }
2075 }
2077 /*
2078 * Generate an image from a specified view.
2079 */
2081 /*
2082 * Unfiltered function
2083 */
2093 }
2105 /*
2106 * Use adaptive subspace data.
2107 */
2112 /*
2113 * Iterate through subspaces.
2114 */
2128 }
2136 }
2138 /*
2139 * Filtered function.
2140 */
2143 /*
2144 * Comments on implementation:
2145 *
2146 * Consider that for each pixel in each view, there is a 'most
2147 * visible' (or at least one equally most visible) subspace,
2148 * the subspace that represents most of the weight of the
2149 * pixel. In determining whether this space is visible from
2150 * another frame, the correct approach is probably to compile a
2151 * list of such subspaces for each frame against which a given
2152 * most-visible subspace for a pixel of interest can be
2153 * compared. This determines visibility from a given frame.
2154 * Beyond this, the only requirement for mapping points
2155 * frame-to-frame in 2d (for using d2::ssfe, etc.) is to use
2156 * the estimated position and slope of the depth surface to map
2157 * four points from one frame to the other using the given 3D
2158 * transformation -- this defines a 2D projective
2159 * transformation. (Values for the aforementioned estimates
2160 * are provided below, using the d2::image functions
2161 * fcdiff_median() and medians().)
2162 */
2186 }
2189 }
2191 /*
2192 * Generic function.
2193 */
2202 }
2203 }
2207 }
2211 }
2215 }
2219 }
2224 }
2228 }
2232 }
2236 }
2240 }
2244 }
2248 }
2252 }
2264 }
2267 }
2276 }
2278 /*
2279 * Add specified control points to the model
2280 */
2282 }
2288 /*
2289 * Make pt list.
2290 */
2300 }
2301 }
2303 for (std::map<const char *, pt>::iterator i = d3_depth_pt->begin(); i != d3_depth_pt->end(); i++) {
2305 }
2307 for (std::map<const char *, pt>::iterator i = d3_output_pt->begin(); i != d3_output_pt->end(); i++) {
2309 }
2312 }
2314 /*
2315 * Get a trilinear coordinate for an anisotropic candidate cell.
2316 */
2326 /*
2327 * Determine the view-local extrema in 2 dimensions.
2328 */
2340 }
2341 }
2346 }
2348 /*
2349 * Check whether a cell is visible from a given viewpoint. This function
2350 * is guaranteed to return 1 when a cell is visible, but it is not guaranteed
2351 * to return 0 when a cell is invisible.
2352 */
2362 /*
2363 * Cycle through all vertices of the cell to check certain
2364 * properties.
2365 */
2402 }
2414 }
2416 /*
2417 * Check whether a cell is output-visible.
2418 */
2424 }
2426 /*
2427 * Check whether a cell is input-visible.
2428 */
2431 }
2433 /*
2434 * Return true if a cell fails an output resolution bound.
2435 */
2436 static int fails_output_resolution_bound(point min, point max, const std::vector<pt> &pt_outputs) {
2446 }
2449 }
2451 /*
2452 * Check lower-bound resolution constraints
2453 */
2470 }
2472 /*
2473 * Try the candidate nearest to the specified cell.
2474 */
2475 static void try_nearest_candidate(unsigned int f1, unsigned int f2, candidates *c, point min, point max) {
2480 // fprintf(stderr, "[tnc n=%f %f %f x=%f %f %f]\n", min[0], min[1], min[2], max[0], max[1], max[2]);
2482 /*
2483 * Reject clipping plane violations.
2484 */
2490 /*
2491 * Calculate projections.
2492 */
2501 // fprintf(stderr, ":");
2505 }
2512 tc++;
2513 stc++;
2514 }
2519 /*
2520 * Calculate score from color match. Assume for now
2521 * that the transformation can be approximated locally
2522 * with a translation.
2523 */
2536 }
2547 score += l1_multiplier
2550 }
2552 /*
2553 * Include third-camera contributions in the score.
2554 */
2574 score += tc_multiplier
2576 }
2579 }
2581 /*
2582 * Check for cells that are completely clipped.
2583 */
2587 }
2589 /*
2590 * Update extremum variables for cell points mapped to a particular view.
2591 */
2592 static void update_extrema(point min, point max, pt _pt, int *extreme_dim, ale_pos *extreme_ratio) {
2603 /*
2604 * Determine the view-local extrema in all dimensions, and
2605 * determine the vertex of closest z coordinate.
2606 */
2616 }
2620 }
2624 /*
2625 * Update extrema as necessary for each dimension.
2626 */
2637 ale_pos local_distance = (_pt.wp_unscaled(point(cell[p1[0]][0], cell[p1[1]][1], cell[p1[2]][2])).xy()
2643 }
2644 }
2645 }
2647 /*
2648 * Get the next split dimension.
2649 */
2650 static int get_next_split(int f1, int f2, point min, point max, const std::vector<pt> &pt_outputs) {
2663 }
2666 }
2668 /*
2669 * Find candidates for subspace creation.
2670 */
2671 static void find_candidates(unsigned int f1, unsigned int f2, candidates *c, point min, point max,
2684 }
2687 }
2693 }
2700 }
2706 }
2713 __LINE__);
2720 }
2724 if (!space::traverse::get_next_cells(get_next_split(f1, f2, min, max, pt_outputs), min, max, new_cells)) {
2728 }
2744 }
2748 }
2750 /*
2751 * Generate a map from scores to 3D points for various depths at point (i, j) in f1, at
2752 * lowest resolution.
2753 */
2754 static score_map p2f_score_map(unsigned int f1, unsigned int f2, unsigned int i, unsigned int j) {
2756 score_map result;
2764 /*
2765 * Get the pixel color in the primary frame
2766 */
2768 // d2::pixel color_primary = if1->get_pixel(i, j);
2770 /*
2771 * Map two depths to the secondary frame.
2772 */
2777 // fprintf(stderr, "%d->%d (%d, %d) point pair: (%d, %d, %d -> %f, %f), (%d, %d, %d -> %f, %f)\n",
2778 // f1, f2, i, j, i, j, 1000, p1[0], p1[1], i, j, -1000, p2[0], p2[1]);
2779 // _pt1.debug_output();
2780 // _pt2.debug_output();
2783 /*
2784 * For cases where the mapped points define a
2785 * line and where points on the line fall
2786 * within the defined area of the frame,
2787 * determine the starting point for inspection.
2788 * In other cases, continue to the next pixel.
2789 */
2800 }
2802 /*
2803 * Make absurdly large/small slopes either infinity, negative infinity, or zero.
2804 */
2814 }
2816 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2823 // fprintf(stderr, "slope == %f\n", slope);
2827 // fprintf(stderr, "case 0\n");
2831 // fprintf(stderr, "case 1\n");
2835 // fprintf(stderr, "case 2\n");
2839 // fprintf(stderr, "case 3\n");
2843 // fprintf(stderr, "case 4\n");
2844 // fprintf(stderr, "%d->%d (%d, %d) does not intersect the defined area\n",
2845 // f1, f2, i, j);
2847 }
2850 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2852 /*
2853 * Determine increment values for examining
2854 * point, ensuring that incr_i is always
2855 * positive.
2856 */
2869 }
2871 // fprintf(stderr, "%d->%d (%d, %d) increments are (%f, %f)\n",
2872 // f1, f2, i, j, incr_i, incr_j);
2874 /*
2875 * Examine regions near the projected line.
2876 */
2882 // fprintf(stderr, "%d->%d (%d, %d) checking (%f, %f)\n",
2883 // f1, f2, i, j, ii, jj);
2885 #if 0
2886 /*
2887 * Check for higher, lower, and nearby points.
2888 *
2889 * Red = 2^0
2890 * Green = 2^1
2891 * Blue = 2^2
2892 */
2909 }
2910 }
2912 /*
2913 * If this is not a region of interest,
2914 * then continue.
2915 */
2920 // if (((higher & lower) | nearby) != 0x7)
2921 // continue;
2922 #endif
2923 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2925 // fprintf(stderr, "%d->%d (%d, %d) accepted (%f, %f)\n",
2926 // f1, f2, i, j, ii, jj);
2928 /*
2929 * Create an orthonormal basis to
2930 * determine line intersection.
2931 */
2938 // fprintf(stderr, "(%d, %d, 0) transformed to world and back is: (%f, %f, %f)\n",
2939 // i, j, foo[0], foo[1], foo[2]);
2942 // fprintf(stderr, "(%d, %d, 10) transformed to world and back is: (%f, %f, %f)\n",
2943 // i, j, foo[0], foo[1], foo[2]);
2953 /*
2954 * Select a fourth point to define a second line.
2955 */
2959 /*
2960 * Representation in the new basis.
2961 */
2964 // d2::point nbp1 = d2::point(bp1.dproduct(b0), bp1.dproduct(b1));
2968 /*
2969 * Determine intersection of line
2970 * (nbp0, nbp1), which is parallel to
2971 * b0, with line (nbp2, np3).
2972 */
2974 /*
2975 * XXX: a stronger check would be
2976 * better here, e.g., involving the
2977 * ratio (np3[0] - nbp2[0]) / (np3[1] -
2978 * nbp2[1]). Also, acceptance of these
2979 * cases is probably better than
2980 * rejection.
2981 */
2984 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2990 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
2998 /*
2999 * Map the intersection back to the world
3000 * basis.
3001 */
3005 /*
3006 * Reject intersection points behind a
3007 * camera.
3008 */
3014 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3020 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3022 /*
3023 * Reject clipping plane violations.
3024 */
3027 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3034 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3036 /*
3037 * Score the point.
3038 */
3046 /*
3047 * Calculate score from color match. Assume for now
3048 * that the transformation can be approximated locally
3049 * with a translation.
3050 */
3061 }
3064 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3075 score += l1_multiplier
3078 }
3080 /*
3081 * Include third-camera contributions in the score.
3082 */
3099 score += tc_multiplier
3101 }
3106 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3108 /*
3109 * Reject points with undefined score.
3110 */
3113 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3119 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3121 #if 0
3122 /*
3123 * XXX: reject points not on the z=-27.882252 plane.
3124 */
3127 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3131 #endif
3134 // fprintf(stderr, "score map (%u, %u) line %u\n", i, j, __LINE__);
3136 /*
3137 * Add the point to the score map.
3138 */
3140 // d2::pixel c_ip = if1->in_bounds(ip.xy()) ? if1->get_bl(ip.xy())
3141 // : d2::pixel();
3142 // d2::pixel c_is = if2->in_bounds(is.xy()) ? if2->get_bl(is.xy())
3143 // : d2::pixel();
3145 // fprintf(stderr, "Candidate subspace: f1=%u f2=%u i=%u j=%u ii=%f jj=%f"
3146 // "cp=[%f %f %f] cs=[%f %f %f]\n",
3147 // f1, f2, i, j, ii, jj, c_ip[0], c_ip[1], c_ip[2],
3148 // c_is[0], c_is[1], c_is[2]);
3151 }
3153 // fprintf(stderr, "Iterating through the score map:\n");
3154 //
3155 // for (score_map::iterator smi = result.begin(); smi != result.end(); smi++) {
3156 // fprintf(stderr, "%f ", smi->first);
3157 // }
3158 //
3159 // fprintf(stderr, "\n");
3162 }
3165 /*
3166 * Attempt to refine space around a point, to high and low resolutions
3167 * resulting in two resolutions in total.
3168 */
3177 }
3181 /*
3182 * Loop until all resolutions of interest have been generated.
3183 */
3197 }
3199 /*
3200 * Generate any new desired spatial registers.
3201 */
3205 /*
3206 * Low resolution
3207 */
3213 }
3215 /*
3216 * High resolution.
3217 */
3222 }
3223 }
3225 /*
3226 * Check precision before analyzing space further.
3227 */
3233 }
3237 total_tsteps++;
3240 total_tsteps++;
3245 }
3246 }
3247 }
3249 /*
3250 * Calculate target dimension
3251 */
3264 }
3266 for (std::map<const char *, pt>::iterator i = d3_output_pt->begin(); i != d3_output_pt->end(); i++) {
3269 }
3271 for (std::map<const char *, pt>::iterator i = d3_depth_pt->begin(); i != d3_depth_pt->end(); i++) {
3274 }
3279 }
3281 /*
3282 * Calculate level of detail for a given viewpoint.
3283 */
3287 }
3289 /*
3290 * Calculate depth range for a given pair of viewpoints.
3291 */
3315 else
3317 }
3326 }
3328 /*
3329 * Calculate a refined point for a given set of parameters.
3330 */
3334 ale_pos depth_range) {
3353 }
3354 }
3357 }
3359 /*
3360 * Analyze space in a manner dependent on the score map.
3361 */
3382 // point is = smi->second.is;
3387 total_ambiguity++;
3404 }
3427 /*
3428 * Re-evaluate target dimension.
3429 */
3431 ale_pos target_dim_ =
3445 }
3447 /*
3448 * Attempt to refine space around the intersection point.
3449 */
3460 }
3462 }
3463 }
3466 /*
3467 * Initialize space and identify regions of interest for the adaptive
3468 * subspace model.
3469 */
3474 /*
3475 * Variable indicating whether low-resolution filler space
3476 * is desired to avoid aliased gaps in surfaces.
3477 */
3490 /*
3491 * Initialize root space.
3492 */
3496 /*
3497 * Special handling for experimental option 'subspace_traverse'.
3498 */
3501 /*
3502 * Subdivide space to resolve intensity matches between pairs
3503 * of frames.
3504 */
3535 }
3539 }
3547 }
3549 /*
3550 * Subdivide space to resolve intensity matches between pairs
3551 * of frames.
3552 */
3566 }
3568 /*
3569 * Iterate over all points in the primary frame.
3570 */
3575 total_pixels++;
3577 /*
3578 * Generate a map from scores to 3D points for
3579 * various depths in f1.
3580 */
3584 /*
3585 * Analyze space in a manner dependent on the score map.
3586 */
3591 }
3593 /*
3594 * This ordering may encourage image f1 to be cached.
3595 */
3600 }
3601 }
3604 }
3607 /*
3608 * Update spatial information structures.
3609 *
3610 * XXX: the name of this function is horribly misleading. There isn't
3611 * even a 'search depth' any longer, since there is no longer any
3612 * bounded DFS occurring.
3613 */
3617 /*
3618 * Subspace model
3619 */
3626 }
3628 #if 0
3629 /*
3630 * Describe a scene to a renderer
3631 */
3633 }
3634 #endif
3635 };
3637 #endif