home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / netpbma.zip / ppm / ppmtoxpm.c < prev    next >
C/C++ Source or Header  |  1994-01-31  |  15KB  |  489 lines
  1. /* ppmtoxpm.c - read a portable pixmap and produce a (version 3) X11 pixmap
  2. **
  3. ** Copyright (C) 1990 by Mark W. Snitily
  4. **
  5. ** Permission to use, copy, modify, and distribute this software and its
  6. ** documentation for any purpose and without fee is hereby granted, provided
  7. ** that the above copyright notice appear in all copies and that both that
  8. ** copyright notice and this permission notice appear in supporting
  9. ** documentation.  This software is provided "as is" without express or
  10. ** implied warranty.
  11. **
  12. ** This tool was developed for Schlumberger Technologies, ATE Division, and
  13. ** with their permission is being made available to the public with the above
  14. ** copyright notice and permission notice.
  15. **
  16. ** Upgraded to XPM2 by
  17. **   Paul Breslaw, Mecasoft SA, Zurich, Switzerland (paul@mecazh.uu.ch)
  18. **   Thu Nov  8 16:01:17 1990
  19. **
  20. ** Upgraded to XPM version 3 by
  21. **   Arnaud Le Hors (lehors@mirsa.inria.fr)
  22. **   Tue Apr 9 1991
  23. **
  24. ** Rainer Sinkwitz sinkwitz@ifi.unizh.ch - 21 Nov 91:
  25. **  - Bug fix, should should malloc space for rgbn[j].name+1 in line 441
  26. **    caused segmentation faults
  27. **    
  28. **  - lowercase conversion of RGB names def'ed out,
  29. **    considered harmful.
  30. */
  31.  
  32. #include "ppm.h"
  33. #include "ppmcmap.h"
  34.  
  35.  
  36. /* Max number of colors allowed in ppm input. */
  37. #define MAXCOLORS    256
  38.  
  39. /* Max number of rgb mnemonics allowed in rgb text file. */
  40. #define MAX_RGBNAMES 1024
  41.  
  42. /* Lower bound and upper bound of character-pixels printed in XPM output.
  43.    Be careful, don't want the character '"' in this range. */
  44. /*#define LOW_CHAR  '#'  <-- minimum ascii character allowed */
  45. /*#define HIGH_CHAR '~'  <-- maximum ascii character allowed */
  46. #define LOW_CHAR  '`'
  47. #define HIGH_CHAR 'z'
  48.  
  49. #define max(a,b) ((a) > (b) ? (a) : (b))
  50.  
  51.  
  52. typedef struct {            /* rgb values and ascii names (from
  53.                      * rgb text file) */
  54.     int r, g, b;            /* rgb values, range of 0 -> 65535 */
  55.     char *name;                /* color mnemonic of rgb value */
  56. }      rgb_names;
  57.  
  58. typedef struct {            /* character-pixel mapping */
  59.     char *cixel;            /* character string printed for
  60.                      * pixel */
  61.     char *rgbname;            /* ascii rgb color, either color
  62.                      * mnemonic or #rgb value */
  63. }      cixel_map;
  64.  
  65.  
  66. /* prototypes/forward reference */
  67. static void   read_rgb_names ARGS((char *, rgb_names *, int *));
  68. static char * gen_numstr ARGS((int, int, int));
  69. static void   gen_cmap ARGS((colorhist_vector, int, pixval, int, rgb_names *, int, cixel_map *, int *));
  70.  
  71.  
  72. pixel **pixels;
  73.  
  74.  
  75. int
  76. main(argc, argv)
  77.     int argc;
  78.     char *argv[];
  79.  
  80. {
  81.     FILE *ifd;
  82.     register pixel *pP;
  83.     int argn, rows, cols, ncolors, row, col, i;
  84.     pixval maxval;            /* pixval == unsigned char or
  85.                      * unsigned short */
  86.     colorhash_table cht;
  87.     colorhist_vector chv;
  88.  
  89.     /* Used for rgb value -> rgb mnemonic mapping */
  90.     int map_rgb_names = 0;
  91.     rgb_names *rgbn;    /* rgb_names rgbn[MAX_RGBNAMES]; */
  92.     int rgbn_max;
  93.  
  94.     /* Used for rgb value -> character-pixel string mapping */
  95.     cixel_map *cmap;    /* cixel_map cmap[MAXCOLORS]; */
  96.     int charspp;            /* chars per pixel */
  97.  
  98.     char out_name[100], rgb_fname[100], *cp;
  99.     char *usage = "[-name <xpm-name>] [-rgb <rgb-textfile>] [ppmfile]";
  100.  
  101.     ppm_init(&argc, argv);
  102.     out_name[0] = rgb_fname[0] = '\0';
  103.  
  104.     argn = 1;
  105.  
  106.     /* Check for command line options. */
  107.     while (argn < argc && argv[argn][0] == '-') {
  108.  
  109.     /* Case "-", use stdin for input. */
  110.     if (argv[argn][1] == '\0')
  111.         break;
  112.  
  113.     /* Case "-name <xpm-filename>", get output filename. */
  114.     if (strncmp(argv[argn], "-name", max(strlen(argv[argn]), 2)) == 0) {
  115.         argn++;
  116.         if (argn == argc || sscanf(argv[argn], "%s", out_name) != 1)
  117.         pm_usage(usage);
  118.     }
  119.     /* Case "-rgb <rgb-filename>", get rgb mnemonics filename. */
  120.     else if (strncmp(argv[argn], "-rgb", max(strlen(argv[argn]), 2)) == 0) {
  121.         argn++;
  122.         if (argn == argc || sscanf(argv[argn], "%s", rgb_fname) != 1)
  123.         pm_usage(usage);
  124.         map_rgb_names = 1;
  125.     }
  126.     /* Nothing else allowed... */
  127.     else
  128.         pm_usage(usage);
  129.  
  130.     argn++;
  131.     }
  132.  
  133.     /* Input file specified, open it and set output filename if necessary. */
  134.     if (argn < argc) {
  135.  
  136.     /* Open the input file. */
  137.     ifd = pm_openr(argv[argn]);
  138.  
  139.     /* If output filename not specified, use input filename as default. */
  140.     if (out_name[0] == '\0') {
  141.         strcpy(out_name, argv[argn]);
  142.         if (cp = index(out_name, '.'))
  143.         *cp = '\0';        /* remove extension */
  144.     }
  145.  
  146.     /*
  147.      * If (1) input file was specified as "-" we're using stdin, or (2)
  148.      * output filename was specified as "-", set output filename to the
  149.      * default. 
  150.      */
  151.     if (!strcmp(out_name, "-"))
  152.         strcpy(out_name, "noname");
  153.  
  154.     argn++;
  155.     }
  156.     /* No input file specified.  Using stdin so set default output filename. */
  157.     else {
  158.     ifd = stdin;
  159.     if (out_name[0] == '\0')
  160.         strcpy(out_name, "noname");
  161.     }
  162.  
  163.     /* Only 0 or 1 input files allowed. */
  164.     if (argn != argc)
  165.     pm_usage(usage);
  166.  
  167.     /*
  168.      * "maxval" is the largest value that can be be found in the ppm file.
  169.      * All pixel components are relative to this value. 
  170.      */
  171.     pixels = ppm_readppm(ifd, &cols, &rows, &maxval);
  172.     pm_close(ifd);
  173.  
  174.     /* Figure out the colormap. */
  175.     fprintf(stderr, "(Computing colormap...");
  176.     fflush(stderr);
  177.     chv = ppm_computecolorhist(pixels, cols, rows, MAXCOLORS, &ncolors);
  178.     if (chv == (colorhist_vector) 0)
  179.     pm_error(
  180.      "too many colors - try running the pixmap through 'ppmquant 256'",
  181.          0, 0, 0, 0, 0);
  182.     fprintf(stderr, "  Done.  %d colors found.)\n", ncolors);
  183.  
  184.     /* Make a hash table for fast color lookup. */
  185.     cht = ppm_colorhisttocolorhash(chv, ncolors);
  186.  
  187.     /*
  188.      * If a rgb text file was specified, read in the rgb mnemonics. Does not
  189.      * return if fatal error occurs. 
  190.      */
  191.     rgbn = (rgb_names *) malloc(MAX_RGBNAMES * sizeof(rgb_names));
  192.     if (rgbn == (rgb_names *) NULL)
  193.     pm_error("out of memory");
  194.  
  195.     if (map_rgb_names)
  196.     read_rgb_names(rgb_fname, rgbn, &rgbn_max);
  197.  
  198.     cmap = (cixel_map *)malloc(ncolors * sizeof(cixel_map));
  199.     if (cmap == (cixel_map *) NULL)
  200.     pm_error("out of memory");
  201.  
  202.     /* Now generate the character-pixel colormap table. */
  203.     gen_cmap(chv, ncolors, maxval, map_rgb_names, rgbn, rgbn_max,
  204.          cmap, &charspp);
  205.  
  206.     /* Write out the XPM file. */
  207.  
  208.     printf("/* XPM */\n");
  209.     printf("static char *%s[] = {\n", out_name);
  210.     printf("/* width height ncolors chars_per_pixel */\n");
  211.     printf("\"%d %d %d %d\",\n", cols, rows, ncolors, charspp);
  212.     printf("/* colors */\n");
  213.     for (i = 0; i < ncolors; i++) {
  214.     printf("\"%s c %s\",\n", cmap[i].cixel, cmap[i].rgbname);
  215.     }
  216.     printf("/* pixels */\n");
  217.     for (row = 0; row < rows; row++) {
  218.     printf("\"");
  219.     for (col = 0, pP = pixels[row]; col < cols; col++, pP++) {
  220.         printf("%s", cmap[ppm_lookupcolor(cht, pP)].cixel);
  221.     }
  222.     printf("\"%s\n", (row == (rows - 1) ? "" : ","));
  223.     }
  224.     printf("};\n");
  225.  
  226.     exit(0);
  227.  
  228. }                    /* main */
  229.  
  230. /*---------------------------------------------------------------------------*/
  231. /* This routine reads a rgb text file.  It stores the rgb values (0->65535)
  232.    and the rgb mnemonics (malloc'ed) into the "rgbn" array.  Returns the
  233.    number of entries stored in "rgbn_max". */
  234. static
  235. void
  236. read_rgb_names(rgb_fname, rgbn, rgbn_max)
  237.     char *rgb_fname;
  238.     rgb_names *rgbn;
  239.     int *rgbn_max;
  240. {
  241.     FILE *rgbf;
  242.     int i, items, red, green, blue;
  243.     char line[512], name[512], *rgbname, *n, *m;
  244.  
  245.     /* Open the rgb text file.  Abort if error. */
  246.     if ((rgbf = fopen(rgb_fname, "r")) == NULL)
  247.     pm_error("error opening rgb text file \"%s\"", rgb_fname, 0, 0, 0, 0);
  248.  
  249.     /* Loop reading each line in the file. */
  250.     for (i = 0; fgets(line, sizeof(line), rgbf); i++) {
  251.  
  252.     /* Quit if rgb text file is too large. */
  253.     if (i == MAX_RGBNAMES) {
  254.         fprintf(stderr,
  255.         "Too many entries in rgb text file, truncated to %d entries.\n",
  256.             MAX_RGBNAMES);
  257.         fflush(stderr);
  258.         break;
  259.     }
  260.     /* Read the line.  Skip if bad. */
  261.     items = sscanf(line, "%d %d %d %[^\n]\n", &red, &green, &blue, name);
  262.     if (items != 4) {
  263.         fprintf(stderr, "rgb text file syntax error on line %d\n", i + 1);
  264.         fflush(stderr);
  265.         i--;
  266.         continue;
  267.     }
  268.     /* Make sure rgb values are within 0->255 range.  Skip if bad. */
  269.     if (red < 0 || red > 0xFF ||
  270.         green < 0 || green > 0xFF ||
  271.         blue < 0 || blue > 0xFF) {
  272.         fprintf(stderr, "rgb value for \"%s\" out of range, ignoring it\n",
  273.             name);
  274.         fflush(stderr);
  275.         i--;
  276.         continue;
  277.     }
  278.     /* Allocate memory for ascii name.  Abort if error. */
  279.     if (!(rgbname = (char *) malloc(strlen(name) + 1)))
  280.         pm_error("out of memory allocating rgb name", 0, 0, 0, 0, 0);
  281.         
  282. #ifdef NAMESLOWCASE
  283.     /* Copy string to ascii name and lowercase it. */
  284.     for (n = name, m = rgbname; *n; n++)
  285.         *m++ = isupper(*n) ? tolower(*n) : *n;
  286.     *m = '\0';
  287. #else
  288.     strcpy(rgbname, name);
  289. #endif
  290.  
  291.     /* Save the rgb values and ascii name in the array. */
  292.     rgbn[i].r = red << 8;
  293.     rgbn[i].g = green << 8;
  294.     rgbn[i].b = blue << 8;
  295.     rgbn[i].name = rgbname;
  296.     }
  297.  
  298.     /* Return the max number of rgb names. */
  299.     *rgbn_max = i - 1;
  300.  
  301.     fclose(rgbf);
  302.  
  303. }                    /* read_rgb_names */
  304.  
  305. /*---------------------------------------------------------------------------*/
  306. /* Given a number and a base, (base == HIGH_CHAR-LOW_CHAR+1), this routine
  307.    prints the number into a malloc'ed string and returns it.  The length of
  308.    the string is specified by "digits".  The ascii characters of the printed
  309.    number range from LOW_CHAR to HIGH_CHAR.  The string is LOW_CHAR filled,
  310.    (e.g. if LOW_CHAR==0, HIGH_CHAR==1, digits==5, i=3, routine would return
  311.    the malloc'ed string "00011"). */
  312. static
  313. char *
  314. gen_numstr(i, base, digits)
  315.     int i, base, digits;
  316. {
  317.     char *str, *p;
  318.     int d;
  319.  
  320.     /* Allocate memory for printed number.  Abort if error. */
  321.     if (!(str = (char *) malloc(digits + 1)))
  322.     pm_error("out of memory", 0, 0, 0, 0, 0);
  323.  
  324.     /* Generate characters starting with least significant digit. */
  325.     p = str + digits;
  326.     *p-- = '\0';            /* nul terminate string */
  327.     while (p >= str) {
  328.     d = i % base;
  329.     i /= base;
  330.     *p-- = (char) ((int) LOW_CHAR + d);
  331.     }
  332.  
  333.     return str;
  334.  
  335. }                    /* gen_numstr */
  336.  
  337. /*---------------------------------------------------------------------------*/
  338. /* This routine generates the character-pixel colormap table. */
  339. static
  340. void
  341. gen_cmap(chv, ncolors, maxval, map_rgb_names, rgbn, rgbn_max,
  342.      cmap, charspp)
  343. /* input: */
  344.     colorhist_vector chv;        /* contains rgb values for colormap */
  345.     int ncolors;            /* number of entries in colormap */
  346.     pixval maxval;            /* largest color value, all rgb
  347.                      * values relative to this, (pixval
  348.                      * == unsigned short) */
  349.     int map_rgb_names;            /* == 1 if mapping rgb values to rgb
  350.                      * mnemonics */
  351.     rgb_names *rgbn;                    /* rgb mnemonics from rgb text file */
  352. int rgbn_max;                /* number of rgb mnemonics in table */
  353.  
  354. /* output: */
  355. cixel_map *cmap;                        /* pixel strings and ascii rgb
  356.                      * colors */
  357. int *charspp;                /* characters per pixel */
  358.  
  359. {
  360.     int i, j, base, cpp, mval, red, green, blue, r, g, b, matched;
  361.     char *str;
  362.  
  363.     /*
  364.      * Figure out how many characters per pixel we'll be using.  Don't want
  365.      * to be forced to link with libm.a, so using a division loop rather
  366.      * than a log function. 
  367.      */
  368.     base = (int) HIGH_CHAR - (int) LOW_CHAR + 1;
  369.     for (cpp = 0, j = ncolors; j; cpp++)
  370.     j /= base;
  371.     *charspp = cpp;
  372.  
  373.     /*
  374.      * Determine how many hex digits we'll be normalizing to if the rgb
  375.      * value doesn't match a color mnemonic. 
  376.      */
  377.     mval = (int) maxval;
  378.     if (mval <= 0x000F)
  379.     mval = 0x000F;
  380.     else if (mval <= 0x00FF)
  381.     mval = 0x00FF;
  382.     else if (mval <= 0x0FFF)
  383.     mval = 0x0FFF;
  384.     else
  385.     mval = 0xFFFF;
  386.  
  387.     /*
  388.      * Generate the character-pixel string and the rgb name for each
  389.      * colormap entry. 
  390.      */
  391.     for (i = 0; i < ncolors; i++) {
  392.  
  393.     /*
  394.      * The character-pixel string is simply a printed number in base
  395.      * "base" where the digits of the number range from LOW_CHAR to
  396.      * HIGH_CHAR and the printed length of the number is "cpp". 
  397.      */
  398.     cmap[i].cixel = gen_numstr(i, base, cpp);
  399.  
  400.     /* Fetch the rgb value of the current colormap entry. */
  401.     red = PPM_GETR(chv[i].color);
  402.     green = PPM_GETG(chv[i].color);
  403.     blue = PPM_GETB(chv[i].color);
  404.  
  405.     /*
  406.      * If the ppm color components are not relative to 15, 255, 4095,
  407.      * 65535, normalize the color components here. 
  408.      */
  409.     if (mval != (int) maxval) {
  410.         red = (red * mval) / (int) maxval;
  411.         green = (green * mval) / (int) maxval;
  412.         blue = (blue * mval) / (int) maxval;
  413.     }
  414.  
  415.     /*
  416.      * If the "-rgb <rgbfile>" option was specified, attempt to map the
  417.      * rgb value to a color mnemonic. 
  418.      */
  419.     if (map_rgb_names) {
  420.  
  421.         /*
  422.          * The rgb values of the color mnemonics are normalized relative
  423.          * to 255 << 8, (i.e. 0xFF00).  [That's how the original MIT
  424.          * code did it, really should have been "v * 65535 / 255"
  425.          * instead of "v << 8", but have to use the same scheme here or
  426.          * else colors won't match...]  So, if our rgb values aren't
  427.          * already 16-bit values, need to shift left. 
  428.          */
  429.         if (mval == 0x000F) {
  430.         r = red << 12;
  431.         g = green << 12;
  432.         b = blue << 12;
  433.         /* Special case hack for "white". */
  434.         if (0xF000 == r && r == g && g == b)
  435.             r = g = b = 0xFF00;
  436.         } else if (mval == 0x00FF) {
  437.         r = red << 8;
  438.         g = green << 8;
  439.         b = blue << 8;
  440.         } else if (mval == 0x0FFF) {
  441.         r = red << 4;
  442.         g = green << 4;
  443.         b = blue << 4;
  444.         } else {
  445.         r = red;
  446.         g = green;
  447.         b = blue;
  448.         }
  449.  
  450.         /*
  451.          * Just perform a dumb linear search over the rgb values of the
  452.          * color mnemonics.  One could speed things up by sorting the
  453.          * rgb values and using a binary search, or building a hash
  454.          * table, etc... 
  455.          */
  456.         for (matched = 0, j = 0; j <= rgbn_max; j++)
  457.         if (r == rgbn[j].r && g == rgbn[j].g && b == rgbn[j].b) {
  458.  
  459.             /* Matched.  Allocate string, copy mnemonic, and exit. */
  460.             if (!(str = (char *) malloc(strlen(rgbn[j].name) + 1)))
  461.             pm_error("out of memory", 0, 0, 0, 0, 0);
  462.             strcpy(str, rgbn[j].name);
  463.             cmap[i].rgbname = str;
  464.             matched = 1;
  465.             break;
  466.         }
  467.         if (matched)
  468.         continue;
  469.     }
  470.  
  471.     /*
  472.      * Either not mapping to color mnemonics, or didn't find a match.
  473.      * Generate an absolute #RGB value string instead. 
  474.      */
  475.     if (!(str = (char *) malloc(mval == 0x000F ? 5 :
  476.                     mval == 0x00FF ? 8 :
  477.                     mval == 0x0FFF ? 11 :
  478.                     14)))
  479.         pm_error("out of memory", 0, 0, 0, 0, 0);
  480.  
  481.     sprintf(str, mval == 0x000F ? "#%X%X%X" :
  482.         mval == 0x00FF ? "#%02X%02X%02X" :
  483.         mval == 0x0FFF ? "#%03X%03X%03X" :
  484.         "#%04X%04X%04X", red, green, blue);
  485.     cmap[i].rgbname = str;
  486.     }
  487.  
  488. }                    /* gen_cmap */
  489.