home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Science / Science.zip / fblnk224.zip / imageacc.c < prev    next >
C/C++ Source or Header  |  1999-01-28  |  4KB  |  188 lines
  1. /*  imageacc.c  for Fitsblink 1.2  */
  2. /*  Functions for access and modification of image elements  */
  3. #include <stdio.h>
  4. #include <math.h>
  5. #include <stdlib.h>
  6. #include <forms.h>
  7. #include "formblink.h"
  8. #include "functs.h"
  9.  
  10. extern FITS_IMAGE count_options;
  11.  
  12. /*   Set basic image parameters */
  13. void
  14. set_image_parameters(FITS_IMAGE *slika, int xmax, int ymax, PIXEL *image)
  15.      
  16. {
  17.   int i;
  18.  
  19.   slika->width = xmax;
  20.   slika->height = ymax;
  21.   slika->x1 = 1;
  22.   slika->y1 = 1;
  23.   slika->x2 = slika->width - 2;
  24.   slika->y2 = slika->height - 2;
  25.   slika->image = image;
  26.   slika->pi = (PIXEL **) myalloc(ymax * sizeof(PIXEL *), 
  27.                  "set_image_parameters", "pi");
  28.   /*  Set array of pointers to rows */
  29.   for (i = 0; i < ymax; i++) {
  30.     slika->pi[i] = image + i * xmax;
  31.   }    
  32.   slika->maxsize = DEFAULT_MAXSIZE;
  33.   slika->sg_num = DEFAULT_SGNUM;
  34.   slika->minbright = DEFAULT_MINBRIGHT;
  35.   slika->minstar = DEFAULT_MINSTAR;
  36.   slika->border = DEFAULT_BORDER;
  37.   if (count_options.maxsize != -999) {
  38.     slika->maxsize = count_options.maxsize;
  39.   }
  40.   if (count_options.sg_num != -999) {
  41.     slika->sg_num = count_options.sg_num;
  42.   }
  43.   if (count_options.minstar != -999) {
  44.     slika->minstar = count_options.minstar;
  45.   }
  46.   if (count_options.minbright != -999) {
  47.     slika->minbright = count_options.minbright;
  48.   }
  49.   if (count_options.fitmeasure != -999) {
  50.     slika->fitmeasure = count_options.fitmeasure;
  51.   }
  52.   if (count_options.border != -999) {
  53.     slika->border = count_options.border;
  54.   }
  55.   if (count_options.inner != -999) {
  56.     slika->inner = count_options.inner;
  57.   }
  58.   if (count_options.outer != -999) {
  59.     slika->outer = count_options.outer;
  60.   }
  61. }
  62.  
  63.  
  64. /*   Return value of pixel at coordinates (x, y)   */
  65. PIXEL
  66.   video_point(FITS_IMAGE *slika, int x, int y)
  67.     
  68. {
  69.   if (x >= 0 && x < slika->width &&
  70.       y >= 0 && y < slika->height)
  71.     return *(slika->pi[y] + x);
  72.   else return 0;
  73. }
  74.  
  75.  
  76. /*   Set pixel with coordinates x, y to value  v  */
  77. void
  78.   set_point(FITS_IMAGE *slika, int x, int y, PIXEL v)
  79. {
  80.   PIXEL *p;
  81.   p = slika->pi[y] + x;
  82.   *p = v;
  83. }
  84.  
  85. void
  86.   xor_point(FITS_IMAGE *slika, int x, int y)
  87. {
  88.   PIXEL *p;
  89.   p = slika->pi[y] + x;
  90.   *p ^= 65535;
  91. }
  92.  
  93.  
  94.  
  95.  
  96. /*  Make a convolution in point (x, y) with a function, defined in structure g  */
  97. float
  98. convolve(GAUSSF *g, FITS_IMAGE *sl, int x, int y)
  99.  
  100. {
  101.   int i, j, i1, j1;
  102.   int f2n = g->n / 2;
  103.   float s = 0;
  104.   int v, vall = 0;
  105.  
  106.   for (i1 = 0, i = x - f2n; i1 < g->n; i1++, i++) {
  107.     if (i > sl->x1 && i < sl->x2) {
  108.       for (j1 = 0, j = y - f2n; j1 < g->n; j1++, j++) {
  109.     if (j > sl->y1 && j < sl->y2) {
  110.       v = video_point(sl, i, j);
  111.       s += g->g[i1][j1] * v;
  112.       vall += v;
  113.     }
  114.       }
  115.     }
  116.   }
  117.   return s / vall;
  118. }
  119.  
  120. /*  Make a simple filtering of the image  */
  121. void
  122. blur(FITS_IMAGE *sl) 
  123.  
  124. {
  125.   int x, y;
  126.   PIXEL *row, *row1;
  127.  
  128.   row = myalloc(sizeof(PIXEL) * sl->width, "blur", "row");
  129.   row1 = myalloc(sizeof(PIXEL) * sl->width, "blur", "row1");
  130.   /*  Copy the first row */
  131.   for (x = 0; x < sl->width; x++) row[x] = video_point(sl, x, 0);
  132.   for (y = 1; y < sl->height - 1; y++) {
  133.     row1[0] = video_point(sl, 0, y);
  134.     for (x = 1; x < sl->width - 1; x++) {
  135.       row1[x] = video_point(sl, x, y);
  136.       set_point(sl, x, y, (video_point(sl, x - 1, y) + video_point(sl, x + 1, y) +
  137.                video_point(sl, x, y - 1) + video_point(sl, x - 1, y + 1)) / 4);
  138.     }
  139.     row1[0] = video_point(sl, sl->width - 1, y);
  140.     for (x = 0; x < sl->width; x++) row[x] = row1[x];
  141.   }
  142.   free(row1);
  143.   free(row);
  144. }
  145.  
  146.  
  147.  
  148.  
  149.  
  150. /*  Calculate the coefficients of the Gaussian filter  */
  151. void
  152. set_gaussian_filter(GAUSSF *f, float sigma, float r)
  153.  
  154. {
  155.   float x, y, x2, y2, r2, s2;
  156.   int i, j;
  157.   int fn2;
  158.  
  159.   f->n = 2 * (r + 1) + 1;  /*  Array size  */
  160.   f->r = r;              /*  Radius inside which the coefficients are valid */
  161.   f->sigma = sigma;      /*  Half-width of the Gaussian  */
  162.   /*  Reserve space for the coefficient array  */
  163.   f->g = myalloc(sizeof(float *) * f->n, "set_gaussian_filter", "f->g");
  164.   for (i = 0; i < f->n; i++) {
  165.     f->g[i] = myalloc(sizeof(float) * f->n, "set_gaussian_filter", "f->g[i]");
  166.   }
  167.   fn2 = f->n / 2;
  168.   r2 = r * r;
  169.   s2 = sigma * sigma;
  170.   for (i = 0; i < f->n; i++) {
  171.     x = (i - fn2);
  172.     x2 = x * x;
  173.     for (j = 0; j < f->n; j++) {
  174.       y = (j - fn2);
  175.       y2 = y * y;
  176.       if (x2 + y2 <= r2) {
  177.     /*  Laplace of the gaussian  */
  178.     f->g[i][j] = (x2 + y2 - 2 * s2) / (s2 * s2) * exp(-(x2 + y2) / (2 * s2));
  179.       }
  180.       else {
  181.     f->g[i][j] = 0;
  182.       }
  183.     }
  184.   }
  185. }
  186.  
  187.  
  188.