home *** CD-ROM | disk | FTP | other *** search
/ Practical Algorithms for Image Analysis / Practical Algorithms for Image Analysis.iso / CH_2.2 / HISTEXX / HISTEXX.C next >
Encoding:
C/C++ Source or Header  |  1999-09-11  |  5.9 KB  |  189 lines
  1. /* 
  2.  * histexx.c
  3.  * 
  4.  * Practical Algorithms for Image Analysis
  5.  * 
  6.  * Copyright (c) 1997, 1998, 1999 MLMSoftwareGroup, LLC
  7.  */
  8.  
  9. /* HISTEXX:     program expands intensity range about a chosen input
  10.  *            intensity, X, and by a chosen level of expansion
  11.  *    usage:  histexx inimg outimg [-x X_CENTER] [-s SLOPE] [-t TAPERING_SLOPE] [-L]
  12.  *
  13.  *
  14.  */
  15.  
  16. #include <stdio.h>
  17. #include <math.h>
  18. #include <string.h>
  19. #include <stdlib.h>
  20. #include <tiffimage.h>          /* tiff info on images */
  21. #include <images.h>             /* contains image format information */
  22. extern void print_sos_lic ();
  23.  
  24. #define NBINS 256               /* no. of histogram bins */
  25. #define XMAX 255.0              /* maximum x-value */
  26. #define YMAX 255.0              /* maximum y-value */
  27.  
  28. #define XCENTER_DFLT 128        /* default center of transform */
  29. #define SLOPE_DFLT 2.0          /* default transform slope */
  30. #define SLOPE_TAPER_DFLT 0.2    /* default taper slope */
  31.  
  32. int input (int, char **, long *, double *, double *);
  33. int usage (short);
  34.  
  35. int argc;
  36. char *argv[];
  37. long *xCenter;                  /* intensity center of transformation */
  38. double *slope,                  /* slope of mapping transform */
  39.  *slopeTaper;                   /* slope of tapering transform */
  40.  
  41.  
  42. main (argc, argv)
  43.      int argc;
  44.      char *argv[];
  45.  
  46. {
  47.   register long x, y;           /* image coordinates */
  48.   Image *imgI;                  /* I/O image structures */
  49.   unsigned char **image,        /* input/output data array */
  50.     transform[NBINS];           /* transform array */
  51.   long nCol, nRow;              /* image dimensions */
  52.   long xCenter;                 /* intensity center of transformation */
  53.   double xC;                    /* (double) of xCenter */
  54.   double slope,                 /* slope of mapping transform */
  55.     slopeTaper;                 /* slope of tapering transform */
  56.   double y1, y2;                /* tapered y-bounds */
  57.   double a, b, c, temp;         /* intermediate variables */
  58.   double xD;                    /* (double) of x */
  59.  
  60. /* read user parameter values */
  61.   if ((input (argc, argv, &xCenter, &slope, &slopeTaper)) < 0)
  62.     return (-1);
  63.  
  64. /* open input file */
  65.   imgI = ImageIn (argv[1]);
  66.   if (imgI->bps == 8 && imgI->spp == 3) {
  67.     printf ("Got RGB image!!!\nInput image must be Grayscale or B&W!!\n");
  68.     exit (1);
  69.   }
  70.   image = imgI->img;
  71.   nRow = ImageGetHeight (imgI);
  72.   nCol = ImageGetWidth (imgI);
  73.   printf ("image size is %dx%d\n", nCol, nRow);
  74.  
  75. /* calculate transform */
  76.   xC = (double) xCenter;
  77.   a = (1.0 - slope) / (XMAX * XMAX - 3.0 * xC * XMAX + 3.0 * xC * xC);
  78.   b = -3.0 * a * xC;
  79.   c = slope + 3.0 * a * xC * xC;
  80.   for (x = 0; x < NBINS; x++) {
  81.     xD = (double) x;
  82.     temp = a * xD * xD * xD + b * xD * xD + c * xD;
  83.     y1 = slopeTaper * xD;
  84.     y2 = slopeTaper * xD + YMAX - slopeTaper * XMAX;
  85.     if (temp < y1)
  86.       temp = y1;
  87.     else if (temp > y2)
  88.       temp = y2;
  89.     transform[x] = (unsigned char) (temp + 0.5);
  90.   }
  91.  
  92. /* transform image intensities */
  93.   for (y = 0; y < nRow; y++)
  94.     for (x = 0; x < nCol; x++)
  95.       image[y][x] = transform[image[y][x]];
  96.  
  97. /* write output image */
  98.   ImageOut (argv[2], imgI);
  99.   return (0);
  100. }
  101.  
  102. /* USAGE:       function gives instructions on usage of program
  103.  *                    usage: usage (flag)
  104.  *              When flag is 1, the long message is given, 0 gives short.
  105.  */
  106.  
  107. int
  108. usage (flag)
  109.      short flag;                /* flag =1 for long message; =0 for short message */
  110. {
  111.  
  112. /* print short usage message or long */
  113.   printf ("USAGE: histexx inimg outimg [-x X_CENTER] [-s SLOPE] [-t TAPERING_SLOPE] [-L]\n");
  114.   if (flag == 0)
  115.     return (-1);
  116.  
  117.   printf ("\nhistexx expands intensity range about a chosen value.\n\n");
  118.   printf ("ARGUMENTS:\n");
  119.   printf ("    inimg: input image filename (TIF)\n");
  120.   printf ("   outimg: output image filename (TIF)\n\n");
  121.   printf ("OPTIONS:\n");
  122.   printf ("  -x X_CENTER: intensity value about which to increase contrast.\n");
  123.   printf ("               (default = %d)\n", XCENTER_DFLT);
  124.   printf ("     -s SLOPE: slope of enhancement transform. As the value is\n");
  125.   printf ("               set above 1, contrast becomes greater about X_CENTER,\n");
  126.   printf ("               but contrast is reduced at other intensities. If slope is\n");
  127.   printf ("               set below 1, contrast is reduced at X_CENTER and increased\n");
  128.   printf ("               at high and low intensities. If slope is 1, there is no\n");
  129.   printf ("               change in the intensities. (Default = %4.1f)\n", SLOPE_DFLT);
  130.   printf ("-t TAPERING_SLOPE: slope of bounds of transformation. Slope\n");
  131.   printf ("               values larger than zero produce more tapering.\n");
  132.   printf ("               (Default = %4.1f)\n", SLOPE_TAPER_DFLT);
  133.   printf ("           -L: print Software License for this module\n");
  134.  
  135.   return (-1);
  136. }
  137.  
  138.  
  139. /* INPUT:       function reads input parameters
  140.  *                  usage: input (argc, argv, &xCenter, &slope, &slopeTaper)
  141.  */
  142.  
  143. #define USAGE_EXIT(VALUE) {usage (VALUE); return (-1);}
  144.  
  145. input (argc, argv, xCenter, slope, slopeTaper)
  146.      int argc;
  147.      char *argv[];
  148.      long *xCenter;             /* intensity center of transformation */
  149.      double *slope,             /* slope of mapping transform */
  150.       *slopeTaper;              /* slope of tapering transform */
  151. {
  152.   long n;
  153.  
  154.   if (argc == 1)
  155.     USAGE_EXIT (1);
  156.   if (argc == 2)
  157.     USAGE_EXIT (2);
  158.  
  159.   *xCenter = XCENTER_DFLT;
  160.   *slope = SLOPE_DFLT;
  161.   *slopeTaper = SLOPE_TAPER_DFLT;
  162.  
  163.   for (n = 3; n < argc; n++) {
  164.     if (strcmp (argv[n], "-x") == 0) {
  165.       if (++n == argc)
  166.         USAGE_EXIT (0);
  167.       *xCenter = (long) atol (argv[n]);
  168.     }
  169.     else if (strcmp (argv[n], "-s") == 0) {
  170.       if (++n == argc)
  171.         USAGE_EXIT (0);
  172.       *slope = atof (argv[n]);
  173.     }
  174.     else if (strcmp (argv[n], "-t") == 0) {
  175.       if (++n == argc)
  176.         USAGE_EXIT (0);
  177.       *slopeTaper = atof (argv[n]);
  178.     }
  179.     else if (strcmp (argv[n], "-L") == 0) {
  180.       print_sos_lic ();
  181.       exit (0);
  182.     }
  183.     else
  184.       USAGE_EXIT (0);
  185.   }
  186.  
  187.   return (0);
  188. }
  189.