home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / xloadimg.zip / xloadimage.4.1 / bright.c < prev    next >
C/C++ Source or Header  |  1993-10-28  |  6KB  |  292 lines
  1. /* bright.c
  2.  *
  3.  * miscellaneous colormap altering functions
  4.  *
  5.  * jim frost 10.10.89
  6.  *
  7.  * Copyright 1989, 1991 Jim Frost.
  8.  * See included file "copyright.h" for complete copyright information.
  9.  */
  10.  
  11. #include "copyright.h"
  12. #include "image.h"
  13.  
  14. /* alter an image's brightness by a given percentage
  15.  */
  16.  
  17. void brighten(image, percent, verbose)
  18.      Image        *image;
  19.      unsigned int  percent;
  20.      unsigned int  verbose;
  21. { int          a;
  22.   unsigned int newrgb;
  23.   float        fperc;
  24.   unsigned int size;
  25.   byte        *destptr;
  26.  
  27.   goodImage(image, "brighten");
  28.   if (BITMAPP(image)) /* we're AT&T */
  29.     return;
  30.  
  31.   if (verbose) {
  32.     printf("  Brightening colormap by %d%%...", percent);
  33.     fflush(stdout);
  34.   }
  35.  
  36.   fperc= (float)percent / 100.0;
  37.  
  38.   switch (image->type) {
  39.   case IRGB:
  40.     for (a= 0; a < image->rgb.used; a++) {
  41.       newrgb= *(image->rgb.red + a) * fperc;
  42.       if (newrgb > 65535)
  43.     newrgb= 65535;
  44.       *(image->rgb.red + a)= newrgb;
  45.       newrgb= *(image->rgb.green + a) * fperc;
  46.       if (newrgb > 65535)
  47.     newrgb= 65535;
  48.       *(image->rgb.green + a)= newrgb;
  49.       newrgb= *(image->rgb.blue + a) * fperc;
  50.       if (newrgb > 65535)
  51.     newrgb= 65535;
  52.       *(image->rgb.blue + a)= newrgb;
  53.     }
  54.     break;
  55.  
  56.   case ITRUE:
  57.     size= image->width * image->height * 3;
  58.     destptr= image->data;
  59.     for (a= 0; a < size; a++) {
  60.       newrgb= *destptr * fperc;
  61.       if (newrgb > 255)
  62.     newrgb= 255;
  63.       *(destptr++)= newrgb;
  64.     }
  65.     break;
  66.   }
  67.   if (verbose)
  68.     printf("done\n");
  69. }
  70.  
  71. void gammacorrect(image, disp_gam, verbose)
  72.      Image *image;
  73.      double disp_gam;
  74.      unsigned int verbose;
  75. { int          a;
  76.   int gammamap[256];
  77.   unsigned int size;
  78.   byte        *destptr;
  79.  
  80.   goodImage(image, "gammacorrect");
  81.   if (BITMAPP(image)) /* we're AT&T */
  82.     return;
  83.  
  84.   if (verbose) {
  85.     printf("  Adjusting colormap for display gamma of %4.2f...", disp_gam);
  86.     fflush(stdout);
  87.   }
  88.  
  89.   make_gamma(disp_gam,gammamap);
  90.  
  91.   switch (image->type) {
  92.   case IRGB:
  93.     for (a= 0; a < image->rgb.used; a++) {
  94.       *(image->rgb.red + a)= gammamap[(*(image->rgb.red + a))>>8]<<8;
  95.       *(image->rgb.green + a)= gammamap[(*(image->rgb.green + a))>>8]<<8;
  96.       *(image->rgb.blue + a)= gammamap[(*(image->rgb.blue + a))>>8]<<8;
  97.     }
  98.     break;
  99.  
  100.   case ITRUE:
  101.     size= image->width * image->height * 3;
  102.     destptr= image->data;
  103.     for (a= 0; a < size; a++) {
  104.       *destptr= gammamap[*destptr];
  105.       destptr++;
  106.     }
  107.     break;
  108.   }
  109.  
  110.   if (verbose)
  111.     printf("done\n");
  112. }
  113.  
  114. /* this initializes a lookup table for doing normalization
  115.  */
  116.  
  117. static void setupNormalizationArray(min, max, array, verbose)
  118.      unsigned int min, max;
  119.      byte *array;
  120.      unsigned int verbose;
  121. { int a;
  122.   unsigned int new;
  123.   float factor;
  124.  
  125.   if (verbose) {
  126.     printf("scaling %d:%d to 0:255...", min, max);
  127.     fflush(stdout);
  128.   }
  129.   factor= 256.0 / (max - min);
  130.   for (a= min; a <= max; a++) {
  131.     new= (float)(a - min) * factor;
  132.     array[a]= (new > 255 ? 255 : new);
  133.   }
  134. }
  135.  
  136. /* normalize an image.
  137.  */
  138.  
  139. Image *normalize(image, verbose)
  140.      Image        *image;
  141.      unsigned int  verbose;
  142. { unsigned int  a, x, y;
  143.   unsigned int  min, max;
  144.   Pixel         pixval;
  145.   Image        *newimage;
  146.   byte         *srcptr, *destptr;
  147.   byte          array[256];
  148.  
  149.   goodImage(image, "normalize");
  150.   if (BITMAPP(image))
  151.     return(image);
  152.  
  153.   if (verbose) {
  154.     printf("  Normalizing...");
  155.     fflush(stdout);
  156.   }
  157.   switch (image->type) {
  158.   case IRGB:
  159.     min= 256;
  160.     max = 0;
  161.     for (a= 0; a < image->rgb.used; a++) {
  162.       byte red, green, blue;
  163.  
  164.       red= image->rgb.red[a] >> 8;
  165.       green= image->rgb.green[a] >> 8;
  166.       blue= image->rgb.blue[a] >> 8;
  167.       if (red < min)
  168.     min= red;
  169.       if (red > max)
  170.     max= red;
  171.       if (green < min)
  172.     min= green;
  173.       if (green > max)
  174.     max= green;
  175.       if (blue < min)
  176.     min= blue;
  177.       if (blue > max)
  178.     max= blue;
  179.     }
  180.     setupNormalizationArray(min, max, array, verbose);
  181.  
  182.     newimage= newTrueImage(image->width, image->height);
  183.     if (image->title) {
  184.     newimage->title = (char *)lmalloc(strlen(image->title) + 14);
  185.     sprintf(newimage->title, "%s (normalized)", image->title);
  186.     }
  187.     srcptr= image->data;
  188.     destptr= newimage->data;
  189.     for (y= 0; y < image->height; y++)
  190.       for (x= 0; x < image->width; x++) {
  191.     pixval= memToVal(srcptr, image->pixlen);
  192.     *destptr= array[image->rgb.red[pixval] >> 8];
  193.     *destptr++;
  194.     *destptr= array[image->rgb.green[pixval] >> 8];
  195.     *destptr++;
  196.     *destptr= array[image->rgb.blue[pixval] >> 8];
  197.     *destptr++;
  198.     srcptr += image->pixlen;
  199.       }
  200.     break;
  201.  
  202.   case ITRUE:
  203.     srcptr= image->data;
  204.     min= 255;
  205.     max= 0;
  206.     for (y= 0; y < image->height; y++)
  207.       for (x= 0; x < image->width; x++) {
  208.     if (*srcptr < min)
  209.       min= *srcptr;
  210.     if (*srcptr > max)
  211.       max= *srcptr;
  212.     srcptr++;
  213.     if (*srcptr < min)
  214.       min= *srcptr;
  215.     if (*srcptr > max)
  216.       max= *srcptr;
  217.     srcptr++;
  218.     if (*srcptr < min)
  219.       min= *srcptr;
  220.     if (*srcptr > max)
  221.       max= *srcptr;
  222.     srcptr++;
  223.       }
  224.     setupNormalizationArray(min, max, array, verbose);
  225.  
  226.     srcptr= image->data;
  227.     for (y= 0; y < image->height; y++)
  228.       for (x= 0; x < image->width; x++) {
  229.     *srcptr= array[*srcptr];
  230.     srcptr++;
  231.     *srcptr= array[*srcptr];
  232.     srcptr++;
  233.     *srcptr= array[*srcptr];
  234.     srcptr++;
  235.       }
  236.     newimage= image;
  237.   }
  238.  
  239.   if (verbose)
  240.     printf("done\n");
  241.   return(newimage);
  242. }
  243.  
  244. /* convert to grayscale
  245.  */
  246.  
  247. void gray(image, verbose)
  248.      Image *image;
  249.      unsigned int verbose;
  250. { int a;
  251.   unsigned int size;
  252.   Intensity intensity, red, green, blue;
  253.   byte *destptr;
  254.  
  255.   goodImage(image, "gray");
  256.   if (BITMAPP(image))
  257.     return;
  258.  
  259.   if (verbose) {
  260.     printf("  Converting image to grayscale...");
  261.     fflush(stdout);
  262.   }
  263.   switch (image->type) {
  264.   case IRGB:
  265.     for (a= 0; a < image->rgb.used; a++) {
  266.       intensity= colorIntensity(image->rgb.red[a],
  267.                 image->rgb.green[a],
  268.                 image->rgb.blue[a]);
  269.       image->rgb.red[a]= intensity;
  270.       image->rgb.green[a]= intensity;
  271.       image->rgb.blue[a]= intensity;
  272.     }
  273.     break;
  274.  
  275.   case ITRUE:
  276.     size= image->width * image->height;
  277.     destptr= image->data;
  278.     for (a= 0; a < size; a++) {
  279.       red= *destptr << 8;
  280.       green= *(destptr + 1) << 8;
  281.       blue= *(destptr + 2) << 8;
  282.       intensity= colorIntensity(red, green, blue) >> 8;
  283.       *(destptr++)= intensity; /* red */
  284.       *(destptr++)= intensity; /* green */
  285.       *(destptr++)= intensity; /* blue */
  286.     }
  287.     break;
  288.   }
  289.   if (verbose)
  290.     printf("done\n");
  291. }
  292.