home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume19 / fbm / part05 / fledge.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-08  |  8.2 KB  |  357 lines
  1. /*****************************************************************
  2.  * fledge.c: FBM Library 0.9 (Beta test) 07-Mar-89  Michael Mauldin
  3.  *
  4.  * Copyright (C) 1989 by Gary Sherwin & Michael Mauldin.
  5.  * Permission is granted to use this file in whole or in part provided
  6.  * that you do not sell it for profit and that this copyright notice
  7.  * is retained unchanged.
  8.  *
  9.  * fledge.c:
  10.  *
  11.  * CONTENTS
  12.  *    findedge_fbm (&image, beta)
  13.  *
  14.  * EDITLOG
  15.  *    LastEditDate = Tue Mar  7 19:56:54 1989 - Michael Mauldin
  16.  *    LastFileName = /usr2/mlm/src/misc/fbm/fledge.c
  17.  *
  18.  * HISTORY
  19.  * 07-Mar-89  Michael Mauldin (mlm) at Carnegie Mellon University
  20.  *    Beta release (version 0.9) mlm@cs.cmu.edu
  21.  *
  22.  * 21-Aug-88  Michael Mauldin (mlm) at Carnegie-Mellon University
  23.  *    Created.
  24.  *****************************************************************/
  25.  
  26. # include <stdio.h>
  27. # include <math.h>
  28. # include <ctype.h>
  29. # include "fbm.h"
  30.  
  31. /****************************************************************
  32.  * findedge_fbm: determine whether image is in color, and call the
  33.  *            appropriate edge detection routine.
  34.  ****************************************************************/
  35.  
  36. #ifndef lint
  37. static char *fbmid =
  38.     "$FBM fledge.c <0.9> 07-Mar-89  (C) 1989 by Michael Mauldin$";
  39. #endif
  40.  
  41. findedge_fbm (input, output, beta)
  42. FBM *input, *output;
  43. int beta;
  44. {
  45.   if (input->hdr.planes == 1)
  46.   { return (findedge_bw (input, output, beta)); }
  47.   else
  48.   { return (findedge_bw (input, output, beta)); }
  49. }
  50.  
  51. /****************************************************************
  52.  * findedge_bw: use a digital Laplacian filter to edge detect a BW image
  53.  ****************************************************************/
  54.  
  55. findedge_bw (input, output, beta)
  56. FBM *input, *output;
  57. int beta;
  58. { register unsigned char *bmp, *obm;
  59.   register int i, j, rowlen, w, h;
  60.   int new, sum;
  61.   int bf, wf, tf; /* white and black pixel counters */
  62.  
  63. /* Filter Chip
  64. *
  65. *
  66. * UL, UC, UR
  67. * CL, CC, CR
  68. * BL, BC, BR
  69. *
  70. */
  71.  
  72.   if (input->hdr.planes != 1)
  73.   { fprintf (stderr, "findedge_bw: can't process color images\n");
  74.     return (0);
  75.   }
  76.  
  77.   fprintf (stderr, "Edge detect BW, beta %d\n", beta);
  78.  
  79.   /* Allocate output */
  80.   output->hdr = input->hdr;
  81.   alloc_fbm (output);
  82.  
  83.   w = input->hdr.cols;
  84.   h = input->hdr.rows;
  85.   rowlen = input->hdr.rowlen;
  86.  
  87.   /* Set pixel counters for image statistics */
  88.   bf = wf = tf = 0;
  89.  
  90.   /* Compute outer border of pixels */
  91.     /* Compute Top Line U of Pixels */
  92.       /* Compute ULPixel */
  93.    
  94.   j=0;
  95.   { bmp = &(input->bm[j*rowlen]);
  96.     obm = &(output->bm[j*rowlen]);
  97.     
  98.     i=0;
  99.     { sum = 0;
  100.       sum = sum + (bmp[i]*(-3)     + bmp[i+1]       );
  101.       sum = sum + (bmp[i+rowlen]   + bmp[i+rowlen+1]);
  102.       sum = (sum * 8) / 3;
  103.  
  104.       if (sum > beta) { new = BLACK; bf++; }
  105.       else { new = WHITE; wf++; }
  106.  
  107.       tf++;
  108.  
  109.       obm[i] = new;
  110.  
  111.     }
  112.  
  113.     /* Compute URPixel */
  114.    
  115.     i=w;
  116.     { sum = 0;
  117.       sum = sum + (bmp[i-1]*(-3)     + bmp[i]         ) ;
  118.       sum = sum + (bmp[i+rowlen-1]   + bmp[i+rowlen]  ) ;
  119.       sum = (sum * 8) / 3;
  120.  
  121.       if (sum > beta) { new = BLACK; bf++; }
  122.       else { new = WHITE; wf++; }
  123.  
  124.       tf++;
  125.  
  126.       obm[i] = new;
  127.  
  128.     }
  129.  
  130.    /* Compute Rest of U1 Line */
  131.   
  132.     for (i=1; i < w-1; i++)
  133.     { sum = 0;
  134.       sum = sum + (bmp[i-1]*(-5)   + bmp[i]        + bmp[i+1]       ) ;
  135.       sum = sum + (bmp[i+rowlen-1] + bmp[i+rowlen] + bmp[i+rowlen+1]) ;
  136.       sum = (sum * 8) / 5;
  137.  
  138.       if (sum > beta) { new = BLACK; bf++; }
  139.         else { new = WHITE; wf++; }
  140.  
  141.       tf++;
  142.  
  143.       obm[i] = new;
  144.  
  145.     }
  146.   }
  147.  
  148.   /* Compute Left and Right borders */
  149.   
  150.   for (j=1; j < h-1; j++)
  151.   { bmp = &(input->bm[j*rowlen]);
  152.     obm = &(output->bm[j*rowlen]);
  153.  
  154.     /* Compute L Pixel */   
  155.     i=0;
  156.     { sum = 0;
  157.       sum = sum + (bmp[i-rowlen]   + bmp[i-rowlen+1]) ;
  158.       sum = sum + (bmp[i]*(-5)     + bmp[i+1]       ) ;
  159.       sum = sum + (bmp[i+rowlen]   + bmp[i+rowlen+1]) ;
  160.       sum = (sum * 8) / 5;
  161.  
  162.       if (sum > beta) { new = BLACK; bf++; }
  163.       else { new = WHITE; wf++; }
  164.  
  165.       tf++;
  166.  
  167.       obm[i] = new;
  168.  
  169.     }
  170.  
  171.  
  172.     /* Compute R1Pixel */
  173.     i=w;
  174.     { sum = 0;
  175.       sum = sum + (bmp[i-rowlen-1]   + bmp[i-rowlen]  ) ;
  176.       sum = sum + (bmp[i-1]          + bmp[i]*(-5)    ) ;
  177.       sum = sum + (bmp[i+rowlen-1]   + bmp[i+rowlen]  ) ;
  178.       sum = (sum * 8) / 5;
  179.  
  180.       if (sum > beta) { new = BLACK; bf++; }
  181.       else { new = WHITE; wf++; }
  182.  
  183.       tf++;
  184.  
  185.       obm[i] = new;
  186.  
  187.     }
  188.   }
  189.  
  190.     /* Compute Bottom Line B of Pixels */
  191.     /* Compute BL Pixel */ 
  192.   j=h;
  193.   { bmp = &(input->bm[j*rowlen]);
  194.     obm = &(output->bm[j*rowlen]);
  195.     
  196.     i=0;
  197.     { sum = 0;
  198.       sum = sum + (bmp[i-rowlen]   + bmp[i-rowlen+1]) ;
  199.       sum = sum + (bmp[i]*(-3)     + bmp[i+1]       ) ;
  200.       sum = (sum * 8) / 3;
  201.  
  202.       if (sum > beta) { new = BLACK; bf++; }
  203.       else { new = WHITE; wf++; }
  204.  
  205.       tf++;
  206.  
  207.       obm[i] = new;
  208.  
  209.     }
  210.  
  211.        /* Compute BR Pixel */
  212.  
  213.     i=w;
  214.     { sum = 0;
  215.       sum = sum + (bmp[i-rowlen-1]   + bmp[i-rowlen]  ) ;
  216.       sum = sum + (bmp[i-1]          + bmp[i]*(-3)    ) ;
  217.       sum = (sum * 8) / 3;
  218.  
  219.       if (sum > beta) { new = BLACK; bf++; }
  220.       else { new = WHITE; wf++; }
  221.  
  222.       tf++;
  223.  
  224.       obm[i] = new;
  225.  
  226.     }
  227.  
  228.       /* Compute Rest of B1 Line */
  229.  
  230.     for (i=1; i < w-1; i++)
  231.     { sum = 0;
  232.       sum = sum + (bmp[i-rowlen-1]   + bmp[i-rowlen]   + bmp[i-rowlen+1]) ;
  233.       sum = sum + (bmp[i-1]          + bmp[i]*(-5)     + bmp[i+1]       ) ;
  234.       sum = (sum * 8) / 5;
  235.  
  236.       if (sum > beta) { new = BLACK; bf++; }
  237.       else { new = WHITE; wf++; }
  238.  
  239.       tf++;
  240.  
  241.       obm[i] = new;
  242.  
  243.     }
  244.   }
  245.  
  246.   /* Compute Main Image Body */
  247.  
  248.   for (j=1; j < h-1; j++)
  249.   { bmp = &(input->bm[j*rowlen]);
  250.     obm = &(output->bm[j*rowlen]);
  251.     
  252.     for (i=1; i < w-1; i++)
  253.     { sum = 0;
  254.       sum = sum + (bmp[i-rowlen-1]   + bmp[i-rowlen]   + bmp[i-rowlen+1]) ;
  255.       sum = sum + (bmp[i-1]          + bmp[i]*(-8)     + bmp[i+1]       ) ;
  256.       sum = sum + (bmp[i+rowlen-1]   + bmp[i+rowlen]   + bmp[i+rowlen+1]) ;
  257.  
  258.       if (sum > beta) { new = BLACK; bf++; }
  259.       else { new = WHITE; wf++; }
  260.  
  261.       tf++;
  262.  
  263.       obm[i] = new;
  264.  
  265.     }
  266.   }
  267.  
  268.   fprintf (stderr, "Edge detection complete for slope of %2d for %d pixels.\n", beta, tf);
  269.   fprintf (stderr, "Detected %d white pixels and %d black pixels.\n", bf, wf);
  270.  
  271.   return (1);
  272. }
  273.  
  274. /****************************************************************
  275.  * findedge_clr: use a digital Laplacian filter to edge detect a CLR image
  276.  ****************************************************************/
  277.  
  278. findedge_clr (input, output, beta)
  279. FBM *input, *output;
  280. double beta;
  281. { register unsigned char *bmp, *obm, *avg;
  282.   register int i, j, k, rowlen, plnlen, w, h, p, sum;
  283.   int new, delta, beta100 = beta * 100;
  284.   unsigned char *gray;
  285.  
  286.   fprintf (stderr, "Sharpen color, beta %lg\n", beta);
  287.  
  288.   /* Allocate output */
  289.   output->hdr = input->hdr;
  290.   alloc_fbm (output);
  291.  
  292.   w = input->hdr.cols;
  293.   h = input->hdr.rows;
  294.   p = input->hdr.planes;
  295.   rowlen = input->hdr.rowlen;
  296.   plnlen = input->hdr.plnlen;
  297.   
  298.   /* Calculate the intensity plane */
  299.   gray = (unsigned char *) malloc (plnlen);
  300.  
  301.   for (j=0; j<h; j++)  
  302.   { bmp = &(input->bm[j*rowlen]);
  303.     avg = &(gray[j*rowlen]);    
  304.  
  305.     for (i=0; i<w; i++)
  306.     { sum = 0;
  307.       for (k=0; k<p; k++)
  308.       { sum += bmp[i+k*plnlen]; }
  309.       avg[i] = sum/p;
  310.     }
  311.   }
  312.   
  313.   /* Copy edges directly */
  314.   for (k=0; k<p; k++)
  315.   {  for (j=0; j<h; j++)
  316.     { output->bm[k*plnlen + j*rowlen] =
  317.     input->bm[k*plnlen + j*rowlen];
  318.       output->bm[k*plnlen + j*rowlen + w-1] =
  319.     input->bm[k*plnlen + j*rowlen + w-1];
  320.     }
  321.   
  322.     for (i=0; i<w; i++)
  323.     { output->bm[k*plnlen + i] =
  324.     input->bm[k*plnlen + i];
  325.       output->bm[k*plnlen + (h-1)*rowlen + i] =
  326.     input->bm[k*plnlen + (h-1)*rowlen + i];
  327.     }
  328.   }
  329.  
  330.   for (j=1; j < h-1; j++)
  331.   { avg = &(gray[j*rowlen]);
  332.     
  333.     for (i=1; i < w-1; i++)
  334.     { sum = avg[i-rowlen-1] +     avg[i-rowlen] + avg[i-rowlen+1] +
  335.         avg[i-1]        - 8 * avg[i]        + avg[i+1]        +
  336.         avg[i+rowlen-1] +     avg[i+rowlen] + avg[i+rowlen+1];
  337.  
  338.       for (k=0; k<p; k++)
  339.       { bmp =  &(input->bm[k*plnlen + j*rowlen + i]);
  340.         obm = &(output->bm[k*plnlen + j*rowlen + i]);
  341.         
  342.     if (sum < 0)
  343.     { delta = - (beta100 * *bmp * -sum / (8*100)); }
  344.     else
  345.     { delta = beta100 * *bmp * sum / (8*100); }
  346.   
  347.     new = *bmp - delta;
  348.   
  349.     if (new < BLACK) new = BLACK;
  350.     else if (new > WHITE) new = WHITE;
  351.     
  352.     *obm = new;
  353.       }
  354.     }
  355.   }
  356. }
  357.