home *** CD-ROM | disk | FTP | other *** search
/ vis-ftp.cs.umass.edu / vis-ftp.cs.umass.edu.tar / vis-ftp.cs.umass.edu / pub / Software / ASCENDER / ascendMar8.tar / UMass / Triangulate / fbip-build.c < prev    next >
C/C++ Source or Header  |  1995-04-13  |  6KB  |  234 lines
  1. /*
  2.  * HISTORY
  3.  *
  4.  * 30-Dec-94 Chris McGlone (jcm) at the Digital Mapping Laboratory,
  5.  * School of Computer Science at Carnegie-Mellon University.
  6.  * Installed. Originally supplied by Lynn Quam  (quam@ai.sri.com)
  7.  * for use with classified RADIUS imagery.
  8.  *
  9.  */
  10.  
  11.  
  12. #include "fbip.h"
  13. #include <stdio.h>
  14. #include "nrutil.h"
  15.  
  16. /*
  17.   originally in nolisp.c
  18. */
  19. COORDINATE *project_to_world(projection, view_pt, world_pt)
  20.   COORDINATE_PROJECTION projection;
  21.   COORDINATE view_pt[3];
  22.   COORDINATE world_pt[3];
  23. {
  24.   return(0);
  25. }
  26.  
  27. /*
  28.   calculates the inverse of the matrix
  29.  
  30.   1   Zl  Zl^2
  31.   1   Zm  Zm^2
  32.   1   Zh  Zh^2 
  33.  
  34.   as discussed in "documentation"
  35.  
  36. */
  37. void fbip_compute_height_interpolation_coeffs (fbip)
  38.   FBIP fbip;
  39. {
  40.   int i,j,n;
  41.   double z, zn;
  42.   double ** array;
  43.  
  44.   n = fbip->n_levels;
  45.   array = dmatrix(0,n-1,0,n-1);
  46.   
  47.   for (i = 0; i<n; i++){
  48.     z = fbip->z_levels[i] - fbip->zorg;
  49.     for (j = 0, zn=1.0; j<n; j++, zn=zn*z){
  50.       array[i][j] = zn;
  51.     }
  52.   }
  53.   
  54.   matrixinvert(array,n);
  55.   
  56.   for (i = 0 ; i < n; i++)
  57.     for (j = 0; j < n; j++)
  58.       fbip->height_interpolation_coeffs[i][j] = array[i][j];
  59.  
  60.   free_dmatrix(array,0,n-1,0,n-1);
  61. }
  62.  
  63.  
  64. void fbip_compute_block_coeffs_from_corner_coords (fbip, uv_vects, xy_vects,
  65.                           projective_coeffs)
  66.   FBIP fbip;
  67.   COORDINATE uv_vects[4][2];
  68.   COORDINATE xy_vects[][4][2];
  69.   double *projective_coeffs;
  70. {
  71.   int n_levels, n;
  72.   double **proj_mat, *proj_rhs;
  73.   int *indx, level, i, j, j2, i1, corner;
  74.   double d, u, v, x, y;
  75.   
  76.   n = 8;
  77.   proj_mat = dmatrix(0,n-1,0,n-1);
  78.   proj_rhs = dvector(0,n-1);
  79.   indx     = (int *)calloc(n, sizeof(int));
  80.   
  81.   n_levels = fbip->n_levels;
  82.   
  83.   for (level = 0, j=0; level<n_levels; level++, j+=8){
  84.     for (corner = 0, i=0; corner<4; corner++, i+=2){
  85.       
  86.       i1 = i+1;
  87.       u = uv_vects[corner][0];
  88.       v = uv_vects[corner][1];
  89.       x = xy_vects[level][corner][0] - fbip->xorg;
  90.       y = xy_vects[level][corner][1] - fbip->yorg;
  91.       
  92.       proj_rhs[i] = u;
  93.       
  94.       proj_mat[i][0] = x;
  95.       proj_mat[i][1] = y;
  96.       proj_mat[i][2] = 1.0;
  97.       proj_mat[i][3] = 0.0;
  98.       proj_mat[i][4] = 0.0;
  99.       proj_mat[i][5] = 0.0;
  100.       proj_mat[i][6] = - x*u;
  101.       proj_mat[i][7] = - y*u;
  102.       
  103.       proj_rhs[i1] = v;
  104.       
  105.       proj_mat[i1][0] = 0.0;
  106.       proj_mat[i1][1] = 0.0;
  107.       proj_mat[i1][2] = 0.0;
  108.       proj_mat[i1][3] = x;
  109.       proj_mat[i1][4] = y;
  110.       proj_mat[i1][5] = 1.0;
  111.       proj_mat[i1][6] = - x*v;
  112.       proj_mat[i1][7] = - y*v;
  113.     }
  114.     
  115.     ludcmp(proj_mat, n, indx, &d);
  116.     lubksb(proj_mat, n, indx, proj_rhs);
  117.     
  118.     for (i = 0, j2 = j; i < n; i++, j2++){
  119.       projective_coeffs[j2] = proj_rhs[i]; 
  120.     }
  121.   }
  122.  
  123.   cfree(indx);
  124.   free_dvector(proj_rhs,0,n-1);
  125.   free_dmatrix(proj_mat,0,n-1,0,n-1);
  126. }
  127.  
  128. void fbip_generate_corners_array (fbip, projection, corners_array)
  129.   FBIP fbip;
  130.   COORDINATE_PROJECTION projection;
  131.   double ***corners_array;
  132. {
  133.   int ui, vi, level, k;
  134.   double u,v,z;
  135.   COORDINATE *view_vector, *world_vector;
  136.   
  137.   for (ui=0, u = fbip->umin; ui<=fbip->blocks_wide; ui++, u+=fbip->du)
  138.   {view_vector[0] = u;
  139.    for (vi=0, v =fbip->vmin; vi<=fbip->blocks_hi; vi++, v+=fbip->dv)
  140.    {corners_array[ui][vi][0] = u;
  141.     corners_array[ui][vi][1] = v;
  142.     view_vector[1] = v;
  143.     for (level = 0, k=2; level<fbip->n_levels; level++, k+=2)
  144.     {z = fbip->z_levels[level];
  145.      view_vector[2]= z;
  146.      project_to_world(projection, view_vector, world_vector); 
  147.      corners_array[ui][vi][k  ] = world_vector[0]; 
  148.      corners_array[ui][vi][k+1] = world_vector[1]; 
  149.    }}}}
  150.  
  151.  
  152. typedef double CORNER_COORDS[4][2];
  153.  
  154. void fill_fbip (fbip, corners_array)
  155.   FBIP fbip;
  156.   double ***corners_array;
  157. {
  158.   double uv_vects[4][2];
  159.   /* double *xy_vects[4][2]; */
  160.   CORNER_COORDS *xy_vects;
  161.   
  162.   int level, n_levels, ui, vi, ui2, vi2, corner, k;
  163.   n_levels = fbip->n_levels;
  164.   
  165. /*  debprintf("fill_fbip ...");*/
  166.   xy_vects = (CORNER_COORDS *) malloc(n_levels*8*sizeof(double));
  167. /*  debprintf("allocated xy_vects ... ");*/
  168.   
  169.   for (ui = 0; ui<fbip->blocks_wide; ui++)
  170.   {for (vi=0; vi<fbip->blocks_hi; vi++)
  171.    {for (corner = 0; corner<4; corner++)
  172.     {switch (corner)
  173.      {case 0: ui2 = ui;  vi2=vi; break;
  174.      case 1: ui2 = ui+1; vi2=vi; break;
  175.      case 2: ui2 = ui;   vi2=vi+1; break;
  176.      case 3: ui2 = ui+1; vi2=vi+1;break;
  177.      }
  178.      
  179.      uv_vects[corner][0]= corners_array[ui2][vi2][0];
  180.      uv_vects[corner][1]= corners_array[ui2][vi2][1];
  181.      
  182.      for (level = 0, k = 0; level<n_levels; level++, k+=2)
  183.      {xy_vects[level][corner][0] = corners_array[ui2][vi2][k+2];
  184.       xy_vects[level][corner][1] = corners_array[ui2][vi2][k+3];
  185.     }
  186.    }
  187.     fbip_compute_block_coeffs_from_corner_coords
  188.       (fbip,
  189.        uv_vects,
  190.        xy_vects,
  191.        fbip->block_projective_coeffs_array[ui][vi]);
  192.     
  193.   }}
  194. /*  debprintf("done\n");*/
  195.   
  196.   free(xy_vects);
  197. }
  198.  
  199.  
  200. double *** allocate_corners_array(blocks_wide, blocks_hi,  n_levels)
  201.   int blocks_wide;
  202.   int blocks_hi;
  203.   int n_levels;
  204. {
  205.   double ***corners_array;
  206.   int ui, vi, rec_size;
  207.   rec_size = (2+2*n_levels)*sizeof(double);
  208.   
  209.   corners_array = (double ***) malloc((blocks_wide+1)*sizeof (double **));
  210.   for (ui=0; ui<=blocks_wide; ui++)
  211.   {corners_array[ui]= (double **) malloc((blocks_hi+1)*sizeof(double *));
  212.    for (vi=0; vi<=blocks_hi; vi++)
  213.      corners_array[ui][vi]= (double *) malloc(rec_size);
  214.  }
  215.   return(corners_array);
  216. }
  217.  
  218. void deallocate_corners_array(corners_array, blocks_wide, blocks_hi)
  219.   double ***corners_array;
  220.   int blocks_wide; 
  221.   int blocks_hi;
  222. {
  223.   int ui, vi;
  224.   
  225.   for (ui=0; ui<=blocks_wide; ui++)
  226.   {for (vi=0; vi<=blocks_hi; vi++)
  227.      free(corners_array[ui][vi]);
  228.    free(corners_array[ui]);
  229.  }
  230.   free(corners_array);
  231. } 
  232.  
  233.  
  234.