home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / utilities / utilsm / netpbmsca / ppm / c / ppmnorm < prev    next >
Encoding:
Text File  |  1993-10-08  |  5.6 KB  |  214 lines
  1. /* ppmnorm.c - read a portable pixmap and normalize the contrast
  2. **
  3. ** by Wilson H. Bent, Jr. (whb@usc.edu)
  4. ** Extensively hacked from pgmnorm.c, which carries the following note:
  5. **
  6. ** Copyright (C) 1989, 1991 by Jef Poskanzer.
  7. **
  8. ** Permission to use, copy, modify, and distribute this software and its
  9. ** documentation for any purpose and without fee is hereby granted, provided
  10. ** that the above copyright notice appear in all copies and that both that
  11. ** copyright notice and this permission notice appear in supporting
  12. ** documentation.  This software is provided "as is" without express or
  13. ** implied warranty.
  14. **
  15. ** (End of note from pgmnorm.c)
  16. */
  17.  
  18. #include "ppm.h"
  19.  
  20. #include "lum.h"
  21.  
  22. #define MAXMAXVAL 1023
  23.  
  24. int
  25. main( argc, argv )
  26. int argc;
  27. char *argv[];
  28.     {
  29.     FILE *ifp;
  30.     pixel **pixels, *pixelrow;
  31.     register pixel *pP;
  32.     pixval maxval;
  33.     int argn, rows, cols, format, row;
  34.     int i, size, cutoff, count, val;
  35.     int hist[MAXMAXVAL+1];
  36.  
  37.     float bpercent, wpercent;
  38.     int range, bvalue, wvalue;
  39.     int specbpercent, specbvalue, specwpercent, specwvalue;
  40.     register int col;
  41.     char *usage = "[-bpercent N | -bvalue N] [-wpercent N | -wvalue N] [ppmfile]";
  42.  
  43.     ppm_init( &argc, argv );
  44.  
  45.     argn = 1;
  46.     bpercent = 2.0;
  47.     wpercent = 1.0;
  48.     specbpercent = specbvalue = specwpercent = specwvalue = 0;
  49.  
  50.     while ( argn + 1 < argc && argv[argn][0] == '-' )
  51.     {
  52.     if ( pm_keymatch( argv[argn], "-bpercent", 3 ) )
  53.         {
  54.         if ( specbvalue )
  55.         pm_error( "only one of -bpercent and -bvalue may be specified",
  56.             0,0,0,0,0 );
  57.         ++argn;
  58.         if ( argn == argc || sscanf( argv[argn], "%f", &bpercent ) != 1 )
  59.         pm_usage( usage );
  60.         if ( bpercent < 0.0  || bpercent > 100.0 )
  61.         pm_error( "black percentage must between 0 and 100",
  62.             0,0,0,0,0 );
  63.         specbpercent = 1;
  64.         }
  65.     else if ( pm_keymatch( argv[argn], "-bvalue", 3 ) )
  66.         {
  67.         if ( specbpercent )
  68.         pm_error( "only one of -bpercent and -bvalue may be specified",
  69.             0,0,0,0,0 );
  70.         ++argn;
  71.         if ( argn == argc || sscanf( argv[argn], "%d", &bvalue ) != 1 )
  72.         pm_usage( usage );
  73.         if ( bvalue < 0 )
  74.         pm_error( "black value must be >= 0", 0,0,0,0,0 );
  75.         specbvalue = 1;
  76.         }
  77.     else if ( pm_keymatch( argv[argn], "-wpercent", 3 ) )
  78.         {
  79.         if ( specbvalue )
  80.         pm_error( "only one of -wpercent and -wvalue may be specified",
  81.             0,0,0,0,0 );
  82.         ++argn;
  83.         if ( argn == argc || sscanf( argv[argn], "%f", &wpercent ) != 1 )
  84.         pm_usage( usage );
  85.         if ( wpercent < 0.0  || wpercent > 100.0 )
  86.         pm_error( "white percentage must between 0 and 100",
  87.             0,0,0,0,0 );
  88.         specwpercent = 1;
  89.         }
  90.     else if ( pm_keymatch( argv[argn], "-wvalue", 3 ) )
  91.         {
  92.         if ( specwpercent )
  93.         pm_error( "only one of -wpercent and -wvalue may be specified",
  94.             0,0,0,0,0 );
  95.         ++argn;
  96.         if ( argn == argc || sscanf( argv[argn], "%d", &wvalue ) != 1 )
  97.         pm_usage( usage );
  98.         if ( wvalue < 0 )
  99.         pm_error( "white value must be >= 0", 0,0,0,0,0 );
  100.         specwvalue = 1;
  101.         }
  102.     else
  103.         pm_usage( usage );
  104.     ++argn;
  105.     }
  106.  
  107.     if ( argn < argc )
  108.     {
  109.     ifp = pm_openr( argv[argn] );
  110.     ++argn;
  111.     }
  112.     else
  113.     ifp = stdin;
  114.  
  115.     if ( argn != argc )
  116.     pm_usage( usage );
  117.  
  118.     if ( specbvalue && specwvalue )
  119.     {
  120.     /* Rescale so that bvalue maps to 0, wvalue maps to maxval. */
  121.     ppm_readppminit( ifp, &cols, &rows, &maxval, &format );
  122.     pixelrow = ppm_allocrow( cols );
  123.     ppm_writeppminit( stdout, cols, rows, maxval, 0 );
  124.     for ( i = 0; i <= bvalue; ++i )
  125.        hist[i] = 0;
  126.     for ( i = wvalue; i <= maxval; ++i )
  127.         hist[i] = maxval;
  128.     range = wvalue - bvalue;
  129.     for ( i = bvalue+1, val = maxval; i < wvalue; ++i, val += maxval )
  130.         hist[i] = val / range;
  131.     for ( row = 0; row < rows; row++ )
  132.         {
  133.         ppm_readppmrow( ifp, pixelrow, cols, maxval, format );
  134.         for ( col = 0, pP = pixelrow; col < cols; col++, pP++ )
  135.         {
  136.         pP->r = hist[pP->r];
  137.         pP->g = hist[pP->g];
  138.         pP->b = hist[pP->b];
  139.         }
  140.         ppm_writeppmrow( stdout, pixelrow, cols, maxval, 0 );
  141.         }
  142.     pm_close( ifp );
  143.     }
  144.     else
  145.     {
  146.     pixels = ppm_readppm( ifp, &cols, &rows, &maxval );
  147.     pm_close( ifp );
  148.  
  149.     /* Build histogram. */
  150.     for ( i = 0; i <= maxval; i++ )
  151.         hist[i] = 0;
  152.     for ( row = 0; row < rows; row++ )
  153.         for ( col = 0, pP = pixels[row]; col < cols; col++, pP++ )
  154.         {
  155. #ifdef MAX_METHOD
  156. #define max(a,b) ((a) > (b) ? (a) : (b))
  157.         i = max (pP->r, max (pP->g, pP->b));
  158. #else
  159.         i = ( ( times77 [PPM_GETR ( *pP )] +
  160.             times150[PPM_GETG ( *pP )] +
  161.             times29 [PPM_GETB ( *pP )]) >> 8);
  162. #endif
  163.         ++hist[i];
  164.         }
  165.     size = rows * cols;
  166.     if ( ! specbvalue )
  167.         { /* Compute bvalue from bpercent. */
  168.         cutoff = size * bpercent / 100.0;
  169.         count = 0;
  170.         for ( bvalue = 0; bvalue <= maxval; bvalue++ )
  171.         {
  172.         count += hist[bvalue];
  173.         if ( count > cutoff )
  174.         break;
  175.         }
  176.         }
  177.     if ( ! specwvalue )
  178.         { /* Compute wvalue from wpercent. */
  179.         cutoff = size * wpercent / 100.0;
  180.         count = 0;
  181.         for ( wvalue = maxval; wvalue >= 0; wvalue-- )
  182.         {
  183.         count += hist[wvalue];
  184.         if ( count > cutoff )
  185.             break;
  186.         }
  187.         }
  188.  
  189.     /* Now rescale so that bvalue maps to 0, wvalue maps to maxval. */
  190.     pm_message(
  191.         "remapping %d..%d to %d..%d", bvalue, wvalue, 0, maxval, 0 );
  192.     ppm_writeppminit( stdout, cols, rows, maxval, 0 );
  193.     for ( i = 0; i <= bvalue; i++ )
  194.         hist[i] = 0;
  195.     for ( i = wvalue; i <= maxval; ++i )
  196.         hist[i] = maxval;
  197.     range = wvalue - bvalue;
  198.     for ( i = bvalue+1, val = maxval; i < wvalue; ++i, val += maxval )
  199.         hist[i] = val / range;
  200.     for ( row = 0; row < rows; row++ )
  201.         {
  202.         for ( col = 0, pP = pixels[row]; col < cols; col++, pP++ )
  203.         {
  204.         pP->r = hist[pP->r];
  205.         pP->g = hist[pP->g];
  206.         pP->b = hist[pP->b];
  207.         }
  208.         ppm_writeppmrow( stdout, pixels[row], cols, maxval, 0 );
  209.         }
  210.     }
  211.  
  212.     exit( 0 );
  213.     }
  214.