home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v941.tgz / icon.v941src.tar / icon.v941src / ipl / cfuncs / ppm.c < prev    next >
C/C++ Source or Header  |  2000-07-29  |  16KB  |  582 lines
  1. /*
  2. ############################################################################
  3. #
  4. #    File:     ppm.c
  5. #
  6. #    Subject:  Functions to manipulate PPM files in memory
  7. #
  8. #    Author:   Gregg M. Townsend
  9. #
  10. #    Date:     November 17, 1997
  11. #
  12. ############################################################################
  13. #
  14. #   This file is in the public domain.
  15. #
  16. ############################################################################
  17. #
  18. #  These functions manipulate raw (P6) PPM image files in memory.
  19. #  The images must not contain comment strings.
  20. # 
  21. #  ppmwidth(s) -- return width of PPM image.
  22. #  ppmheight(s) -- return height of PPM image.
  23. #  ppmmax(s) -- return maximum value in PPM header.
  24. #  ppmdata(s) -- return data portion of PPM image.
  25. # 
  26. #  ppmimage(s,p,f) -- quantify image s using palette p, with flags f.
  27. #     Returns an Icon image string.  Flag "o" selects ordered dithering.
  28. #     Defaults:  p="c6",  f="o"
  29. # 
  30. #  ppmstretch(s,lo,hi,max) -- apply contrast stretch operation
  31. #     Returns a PPM string image that results from setting all
  32. #     values <= lo to zero, all values >= hi to max, with values
  33. #     between scaling linearly.  If hi = lo + 1, this becomes a 
  34. #     simple threshold operation.  If lo=0 and hi=ppmmax(s), this
  35. #     simply scales an image to a new maximum.
  36. # 
  37. #     Requirements: 0 <= lo < hi <= ppmmax(s), 1 <= max <= 255.
  38. #     Defaults:      lo=0, hi=ppmmax(s), max=255.
  39. # 
  40. #  ppm3x3(s,a,b,c,d,e,f,g,h,i) -- apply 3x3 convolution to PPM image.
  41. #     The matrix of real numbers [[a,b,c],[d,e,f],[g,h,i]] is used
  42. #     as a transformation matrix applied independently to the three
  43. #     color components of the image.
  44. #
  45. ############################################################################
  46. #
  47. #  Requires:  Dynamic loading
  48. #
  49. ############################################################################
  50. */
  51.  
  52.  
  53.  
  54. #include "icall.h"
  55. #include <ctype.h>
  56. #include <string.h>
  57. #include <stdlib.h>
  58.  
  59. int palnum(descriptor *d);
  60. char *rgbkey(int p, double r, double g, double b);
  61.  
  62.  
  63.  
  64. typedef struct {    /* ppminfo: struct describing a ppm image */
  65.    int w, h;        /* width and height */
  66.    int max;        /* maximum value */
  67.    long npixels;    /* total number of pixels */
  68.    long nbytes;        /* total number of pixels */
  69.    char *data;        /* pointer to start of raw data; null indicates error */
  70. } ppminfo;
  71.  
  72. static ppminfo ppmcrack(descriptor d);
  73. static descriptor ppmalc(int w, int h, int max);
  74. static char *rowextend(char *dst, char *src, int w, int nbr);
  75. static int ppmrows(ppminfo hdr, int nbr, int (*func) (), long arg);
  76. static int sharpenrow(char *a[], int w, int i, long max);
  77. static int convrow(char *a[], int w, int i, long max);
  78.  
  79. static char *out;    /* general purpose global output pointer */
  80.  
  81.  
  82.  
  83. /* macros */
  84.  
  85. /* ArgPPM(int n, ppminfo hdr) -- validate arg n, init hdr */
  86. #define ArgPPM(n,hdr) do {\
  87.    ArgString(n); \
  88.    hdr = ppmcrack(argv[n]); \
  89.    if (!hdr.data) Fail; \
  90. } while(0)
  91.  
  92. /* AlcResult(int w, h, max, ppminfo hdr) -- alc result string, init hdr */
  93. /* WARNING -- can move other strings; refresh addresses from descriptors. */
  94. #define AlcResult(w, h, max, hdr) do {\
  95.    descriptor d = ppmalc(w, h, max); \
  96.    if (d.vword == 0) Error(306); \
  97.    hdr = ppmcrack(argv[0] = d); \
  98. } while(0)
  99.  
  100.  
  101.  
  102. /* ppm info functions */
  103.  
  104. int ppmwidth(int argc, descriptor *argv)    /*: extract width of PPM string */
  105.    {
  106.    ppminfo hdr;
  107.  
  108.    ArgPPM(1, hdr);
  109.    RetInteger(hdr.w);
  110.    }
  111.  
  112. int ppmheight(int argc, descriptor *argv)    /*: extract height of PPM string */
  113.    {
  114.    ppminfo hdr;
  115.  
  116.    ArgPPM(1, hdr);
  117.    RetInteger(hdr.h);
  118.    }
  119.  
  120. int ppmmax(int argc, descriptor *argv)        /*: extract max of PPM string */
  121.    {
  122.    ppminfo hdr;
  123.  
  124.    ArgPPM(1, hdr);
  125.    RetInteger(hdr.max);
  126.    }
  127.  
  128. int ppmdata(int argc, descriptor *argv)        /*: extract data from PPM string */
  129.    {
  130.    ppminfo hdr;
  131.  
  132.    ArgPPM(1, hdr);
  133.    RetAlcString(hdr.data, hdr.nbytes);
  134.    }
  135.  
  136.  
  137.  
  138. /* ppmstretch(s,lo,hi) -- apply contrast stretch operation */
  139.  
  140. int ppmstretch(int argc, descriptor *argv) /*: stretch contrast of PPM string */
  141.    {
  142.    ppminfo src, dst;
  143.    int lo, hi, max, i, v;
  144.    float m;
  145.    char *d, *s;
  146.  
  147.    ArgPPM(1, src);
  148.  
  149.    if (argc < 2 || IconType(argv[2]) == 'n')
  150.       lo = 0;
  151.    else {
  152.       ArgInteger(2);
  153.       lo = IntegerVal(argv[2]);
  154.       if (lo < 0 || lo >= src.max)
  155.          ArgError(2, 205);
  156.       }
  157.  
  158.    if (argc < 3 || IconType(argv[3]) == 'n')
  159.       hi = src.max;
  160.    else {
  161.       ArgInteger(3);
  162.       hi = IntegerVal(argv[3]);
  163.       if (hi <= lo || hi > src.max)
  164.          ArgError(3, 205);
  165.       }
  166.  
  167.    if (argc < 4 || IconType(argv[4]) == 'n')
  168.       max = 255;
  169.    else {
  170.       ArgInteger(4);
  171.       max = IntegerVal(argv[4]);
  172.       if (max < 1 || max > 255)
  173.          ArgError(4, 205);
  174.       }
  175.  
  176.    m = (float)(max + 1) / (hi - lo);
  177.  
  178.    AlcResult(src.w, src.h, max, dst);
  179.    src = ppmcrack(argv[1]);            /* may have moved */
  180.    d = dst.data;
  181.    s = src.data;
  182.    for (i = 0; i < dst.nbytes; i++) {
  183.       v = m * ((*s++ & 0xFF) - lo);
  184.       if (v < 0) v = 0;
  185.       else if (v > dst.max) v = dst.max;
  186.       *d++ = v;
  187.       }
  188.    Return;
  189.    }
  190.  
  191.  
  192.  
  193. /* ppmsharpen(s) -- apply fixed sharpening convolution  */
  194.  
  195. int ppmsharpen(int argc, descriptor *argv)    /*: sharpen a PPM string */
  196.    {
  197.    int rv;
  198.    ppminfo src, dst;
  199.  
  200.    ArgPPM(1, src);
  201.    AlcResult(src.w, src.h, src.max, dst);
  202.    src = ppmcrack(argv[1]);            /* may have moved */
  203.  
  204.    out = dst.data;
  205.    rv = ppmrows(src, 1, sharpenrow, src.max);
  206.    if (rv == 0)
  207.       Return;
  208.    argv[0] = nulldesc;
  209.    return rv;
  210.    }
  211.  
  212. static int sharpenrow(char *a[], int w, int i, long max)
  213.    {
  214.    unsigned char *prev, *curr, *next;
  215.    int v;
  216.  
  217.    prev = (unsigned char *) a[-1];
  218.    curr = (unsigned char *) a[0];
  219.    next = (unsigned char *) a[1];
  220.    w *= 3;
  221.    while (w--) {
  222.       v = 2.0 * curr[0]
  223.     - .10 * (prev[-3] + prev[3] + next[-3] + next[3])
  224.     - .15 * (prev[0] + curr[-3] + curr[3] + next[0]);
  225.       if (v < 0)
  226.      v = 0;
  227.       else if (v > max)
  228.      v = max;
  229.       *out++ = v;
  230.       prev++;
  231.       curr++;
  232.       next++;
  233.       }
  234.    return 0;
  235.    }
  236.  
  237.  
  238.  
  239. /* ppm3x3(s,a,b,c,d,e,f,g,h,i) -- apply 3x3 convolution matrix */
  240.  
  241. static float cells[9];
  242.  
  243. int ppm3x3(int argc, descriptor *argv)        /*: convolve PPM with matrix */
  244.    {
  245.    int rv, i;
  246.    ppminfo src, dst;
  247.  
  248.    ArgPPM(1, src);
  249.    for (i = 0; i < 9; i++) {
  250.       ArgReal(i + 2);
  251.       cells[i] = RealVal(argv[i + 2]);
  252.       }
  253.  
  254.    AlcResult(src.w, src.h, src.max, dst);
  255.    src = ppmcrack(argv[1]);            /* may have moved */
  256.  
  257.    out = dst.data;
  258.    rv = ppmrows(src, 1, convrow, src.max);
  259.    if (rv == 0)
  260.       Return;
  261.    argv[0] = nulldesc;
  262.    return rv;
  263.    }
  264.  
  265. static int convrow(char *a[], int w, int i, long max)
  266.    {
  267.    unsigned char *prev, *curr, *next;
  268.    int v;
  269.  
  270.    prev = (unsigned char *) a[-1];
  271.    curr = (unsigned char *) a[0];
  272.    next = (unsigned char *) a[1];
  273.    w *= 3;
  274.    while (w--) {
  275.       v = cells[0] * prev[-3] + cells[1] * prev[0] + cells[2] * prev[3]
  276.         + cells[3] * curr[-3] + cells[4] * curr[0] + cells[5] * curr[3]
  277.         + cells[6] * next[-3] + cells[7] * next[0] + cells[8] * next[3];
  278.       if (v < 0)
  279.      v = 0;
  280.       else if (v > max)
  281.      v = max;
  282.       *out++ = v;
  283.       prev++;
  284.       curr++;
  285.       next++;
  286.       }
  287.    return 0;
  288.    }
  289.  
  290.  
  291.  
  292. /* ppmimage(s,p,f) -- quantify image s using palette p, returning Icon image. */
  293.  
  294. #define MDIM 16            /* dither matrix dimension */
  295. #define MSIZE (MDIM * MDIM)    /* total size */
  296.  
  297. int ppmimage(int argc, descriptor *argv)    /*: dither PPM to Icon image */
  298.    {
  299.    int i, p, row, col, ir, ig, ib;
  300.    double m, gd, r, g, b, dither[MSIZE], *dp, d;
  301.    char *pname, *flags, *s, *t, *rv;
  302.    ppminfo hdr;
  303.    static double dmults[7] = {0., 1./3., 1./1., 1./2., 1./3., 1./4., 1./5.};
  304.    static double gmults[7] = {0., 3./6., 1./2., 1./3., 1./4., 1./5., 1./6.};
  305.    static unsigned char dfactor[MSIZE] = {
  306.         0,128, 32,160,  8,136, 40,168,  2,130, 34,162, 10,138, 42,170,
  307.       192, 64,224, 96,200, 72,232,104,194, 66,226, 98,202, 74,234,106,
  308.        48,176, 16,144, 56,184, 24,152, 50,178, 18,146, 58,186, 26,154,
  309.       240,112,208, 80,248,120,216, 88,242,114,210, 82,250,122,218, 90,
  310.        12,140, 44,172,  4,132, 36,164, 14,142, 46,174,  6,134, 38,166,
  311.       204, 76,236,108,196, 68,228,100,206, 78,238,110,198, 70,230,102,
  312.        60,188, 28,156, 52,180, 20,148, 62,190, 30,158, 54,182, 22,150,
  313.       252,124,220, 92,244,116,212, 84,254,126,222, 94,246,118,214, 86,
  314.         3,131, 35,163, 11,139, 43,171,  1,129, 33,161,  9,137, 41,169,
  315.       195, 67,227, 99,203, 75,235,107,193, 65,225, 97,201, 73,233,105,
  316.        51,179, 19,147, 59,187, 27,155, 49,177, 17,145, 57,185, 25,153,
  317.       243,115,211, 83,251,123,219, 91,241,113,209, 81,249,121,217, 89,
  318.        15,143, 47,175,  7,135, 39,167, 13,141, 45,173,  5,133, 37,165,
  319.       207, 79,239,111,199, 71,231,103,205, 77,237,109,197, 69,229,101,
  320.        63,191, 31,159, 55,183, 23,151, 61,189, 29,157, 53,181, 21,149,
  321.       255,127,223, 95,247,119,215, 87,253,125,221, 93,245,117,213, 85,
  322. };
  323.  
  324.    ArgString(1);
  325.  
  326.    if (argc < 2 || IconType(argv[2]) == 'n') {
  327.       p = 6;
  328.       pname = "c6";
  329.       }
  330.    else {
  331.       ArgString(2);
  332.       p = palnum(&argv[2]);
  333.       if (p == 0)  Fail;
  334.       if (p == -1) ArgError(1, 103);
  335.       pname = StringVal(argv[2]);
  336.       }
  337.  
  338.    if (argc < 3 || IconType(argv[3]) == 'n')
  339.       flags = "o";
  340.    else {
  341.       ArgString(3);
  342.       flags = StringVal(argv[3]);
  343.       }
  344.  
  345.    hdr = ppmcrack(argv[1]);
  346.    if (!hdr.data)
  347.       Fail;                /* PPM format error */
  348.  
  349.    if (!strchr(flags, 'o'))
  350.       m = gd = 0.0;            /* no dithering */
  351.    else if (p > 0) {
  352.       m = dmults[p] - .0001;        /* color dithering magnitude */
  353.       gd = gmults[p];            /* correction factor if gray input */
  354.       }
  355.    else {
  356.       m = 1.0 / (-p - .9999);        /* grayscale dithering magnitude */
  357.       gd = 1.0;                /* no correction needed */        
  358.       }
  359.  
  360.    for (i = 0; i < MSIZE; i++)        /* build dithering table */
  361.       dither[i] = m * (dfactor[i] / (double)(MSIZE)- 0.5);
  362.  
  363.    rv = alcstr(NULL, 10 + hdr.npixels);    /* allocate room for output string */
  364.    if (!rv)
  365.       Error(306);
  366.    hdr = ppmcrack(argv[1]);        /* get addr again -- may have moved */
  367.    sprintf(rv, "%d,%s,", hdr.w, pname);
  368.    t = rv + strlen(rv);
  369.  
  370.    m = 1.0 / hdr.max;
  371.    s = hdr.data;
  372.    for (row = hdr.h; row > 0; row--) {
  373.       dp = &dither[MDIM * (row & (MDIM - 1))];
  374.       for (col = hdr.w; col > 0; col--) {
  375.      d = dp[col & (MDIM - 1)];
  376.          ir = *s++ & 0xFF;
  377.          ig = *s++ & 0xFF;
  378.          ib = *s++ & 0xFF;
  379.      if (ir == ig && ig == ib) {
  380.         g = m * ig + gd * d;
  381.             if (g < 0) g = 0; else if (g > 1) g = 1;
  382.         r = b = g;
  383.         }
  384.      else {
  385.             r = m * ir + d;  if (r < 0) r = 0;  else if (r > 1) r = 1;
  386.             g = m * ig + d;  if (g < 0) g = 0;  else if (g > 1) g = 1;
  387.             b = m * ib + d;  if (b < 0) b = 0;  else if (b > 1) b = 1;
  388.         }
  389.          *t++ = *(rgbkey(p, r, g, b));
  390.          }
  391.       }
  392.  
  393.    RetAlcString(rv, t - rv);
  394.    }
  395.  
  396.  
  397.  
  398. /*************************  internal functions  *************************/
  399.  
  400.  
  401.  
  402. /*
  403.  *  ppmalc(w, h, max) -- allocate new ppm image and initialize header
  404.  *
  405.  *  If allocation fails, the address in the returned descriptor is NULL.
  406.  */
  407. static descriptor ppmalc(int w, int h, int max)
  408.    {
  409.    char buf[32];
  410.    descriptor d;
  411.  
  412.    sprintf(buf, "P6\n%d %d\n%d\n", w, h, max);
  413.    d.dword = strlen(buf) + 3 * w * h;
  414.    d.vword = (word)alcstr(NULL, d.dword);
  415.    if (d.vword != 0)
  416.       strcpy((void *)d.vword, buf);
  417.    return d;
  418.    }
  419.  
  420.  
  421.  
  422. /*  ppmcrack(d) -- crack PPM header, setting max=0 on error  */
  423.  
  424. static ppminfo ppmcrack(descriptor d)
  425.    {
  426.    int n;
  427.    char *s;
  428.    ppminfo info;
  429.    static ppminfo zeroes;
  430.  
  431.    s = StringAddr(d);
  432.    if (sscanf(s, "P6 %d %d %n", &info.w, &info.h, &n) < 2)
  433.       return zeroes;            /* not a raw PPM file */
  434.  
  435.    /* can't scanf for "max" because it consumes too much trailing whitespace */
  436.    info.max = 0;
  437.    for (s += n; isspace(*s); s++)
  438.       ;
  439.    while (isdigit(*s))
  440.       info.max = 10 * info.max + *s++ - '0';
  441.    if (info.max == 0 || info.max > 255)
  442.       return zeroes;            /* illegal max value for raw PPM */
  443.  
  444.    /* now consume exactly one more whitespace character */
  445.    if (isspace(*s))
  446.       s++;
  447.  
  448.    info.npixels = (long)info.w * (long)info.h;
  449.    info.nbytes =  3 * info.npixels;
  450.    if (s + info.nbytes > StringAddr(d) + StringLen(d))
  451.       return zeroes;            /* file was truncated */
  452.  
  453.    info.data = s;
  454.    return info;
  455.    }
  456.  
  457.  
  458.  
  459. /*
  460.  *  ppmrows(hdr, nbr, func, arg) -- extend rows and call driver function  
  461.  *
  462.  *  Calls func(a, w, i, arg) for each row of the PPM image identified by hdr,
  463.  *  where
  464.  *    a is a pointer to a pointer to the first byte of the row (see below)
  465.  *    w is the width of a row, in pixels
  466.  *    i is the row number
  467.  *    arg is passed along from the call to ppmrows
  468.  *
  469.  *  When nbr > 0, this indicates that func() needs to read up to nbr pixels
  470.  *  above, below, left, and/or right of each source pixel; ppmrows copies
  471.  *  and extends the rows to make this easy.  The argument "a" passed to func
  472.  *  is a pointer to the center of an array of row pointers that extends by
  473.  *  nbr rows in each direction.  That is, a[0] points to the current row;
  474.  *  a[-1] points to the previous row, a[1] to the next row, and so on.
  475.  *
  476.  *  Each row is extended by nbr additional pixels in each direction by the
  477.  *  duplication of the first and last pixels.  The pointers in the array "a"
  478.  *  skip past the initial duplicates.  Thus a[0][0] is the first byte
  479.  *  (the red byte) of the first pixel, a[0][-3] is its duplicate, and
  480.  *  a[0][3] is the first byte of the second pixel of the row.
  481.  *
  482.  *  The idea behind all this complication is to make it easy to perform
  483.  *  neighborhood operations.  See any caller of ppmrows for an example.
  484.  *
  485.  *  If ppmrows cannot allocate memory, it returns error code 305.
  486.  *  If func returns nonzero, ppmrows returns that value immediately.
  487.  *  Otherwise, ppmrows returns zero.
  488.  */
  489.  
  490. static int ppmrows(ppminfo hdr, int nbr, int (*func) (), long arg)
  491.    {
  492.    char **a, *s;
  493.    void *buf;
  494.    int i, rv, np, row, rowlen;
  495.  
  496.    /* process nbr=0 without any copying */
  497.    if (nbr <= 0) {
  498.       s = hdr.data;
  499.       for (row = 0; row < hdr.h; row++) {
  500.      rv = func(&s, hdr.w, row, arg);
  501.      if (rv != 0)
  502.         return rv;
  503.      s += 3 * hdr.w;
  504.      }
  505.       return 0;
  506.       }
  507.  
  508.    /* allocate memory for pointers and data */
  509.    np = 2 * nbr + 1;            /* number of pointers */
  510.    rowlen = 3 * (nbr + hdr.w + nbr);    /* length of one extended row */
  511.    a = buf = malloc(np * sizeof(char *) + np * rowlen);
  512.    if (buf == NULL)
  513.       return 305;
  514.  
  515.    /* set pointers to row buffers */
  516.    s = (char *)buf + np * sizeof(char *) + 3 * nbr;
  517.    for (i = 0; i < np; i++) {
  518.       *a++ = s;
  519.       s += rowlen;
  520.       }
  521.    a -= nbr + 1;            /* point to center row */
  522.  
  523.    /* initialize buffers */
  524.    for (i = -nbr; i < 0; i++)        /* duplicates of first row */
  525.       rowextend(a[i], hdr.data, hdr.w, nbr);
  526.    for (i = 0; i <= nbr; i++)        /* first nbr+1 rows */
  527.       rowextend(a[i], hdr.data + 3 * i * hdr.w, hdr.w, nbr);
  528.  
  529.    /* iterate through rows */
  530.    for (row = 0; row < hdr.h; row++) {
  531.  
  532.       /* call function for this row */
  533.       rv = func(a, hdr.w, row, arg);
  534.       if (rv != 0) {
  535.      free(buf);
  536.      return rv;
  537.      }
  538.  
  539.       /* rotate row pointers */
  540.       s = a[-nbr];
  541.       for (i = -nbr; i < nbr; i++)
  542.      a[i] = a[i+1];
  543.       a[nbr] = s;
  544.  
  545.       /* replace oldest with new row */
  546.       if (row + nbr < hdr.h)
  547.      rowextend(s, hdr.data + 3 * (row + nbr) * hdr.w, hdr.w, nbr);
  548.       else
  549.      rowextend(s, hdr.data + 3 * (hdr.h - 1) * hdr.w, hdr.w, nbr);
  550.  
  551.       }
  552.  
  553.    free(buf);
  554.    return 0;
  555.    }
  556.  
  557.  
  558.  
  559. /*
  560.  *  rowextend(dst, src, w, nbr) -- extend row on both ends
  561.  *
  562.  *  Copy w bytes from src to dst, extending both ends by nbr copies of
  563.  *  the first/last 3-byte pixel.  w is the row width in pixels.
  564.  *  Returns unextended dst pointer.
  565.  */
  566. static char *rowextend(char *dst, char *src, int w, int nbr)
  567.    {
  568.    char *s1, *s2, *d1, *d2;
  569.  
  570.    memcpy(dst, src, 3 * w);
  571.    d1 = dst;
  572.    d2 = dst + 3 * w;
  573.    s1 = d1 + 3;
  574.    s2 = d2 - 3;
  575.    nbr *= 3;
  576.    while (nbr--) {
  577.       *--d1 = *--s1;
  578.       *d2++ = *s2++;
  579.       }
  580.    return dst;
  581.    }
  582.