home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 580a.lha / hdf_utilities / src.LZH / src / r24hdf8.c < prev   
Encoding:
C/C++ Source or Header  |  1991-11-11  |  10.4 KB  |  421 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10r3
  4. *                Dec 6, 1990
  5. *
  6. * NCSA HDF Version 3.10r3 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 1.1 $";
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/r24hdf8.c,v 1.1 90/07/06 10:26:01 mfolk beta $
  27.  
  28. $Log:    r24hdf8.c,v $
  29.  * Revision 1.1  90/07/06  10:26:01  mfolk
  30.  * Initial revision
  31.  * 
  32. */
  33. /*
  34.   r24hdf8    Quantizes a raw RGB 24 bit "pixel" image into a 8 bit image
  35.         with RGB palette and stores it as a HDF 8-bit raster image
  36.         file.
  37.  
  38.   usage:    r24hdf8 x_dim y_dim r24_file hdf8_file
  39.  
  40.         On Input:
  41.         --------
  42.  
  43.         x_dim        - X dimension of image (horizontal size).
  44.         y_dim        - Y dimension of image (vertical size).
  45.         r24_file    - File containing the raw RGB 24
  46.                   bit image. The order of pixels is left to
  47.                   right and top to bottom. Each pixel is
  48.                   three contiguous bytes: red byte, green byte,
  49.                   and blue byte. Use filter ptox to convert
  50.                   from "planar" to "pixel" where planar means
  51.                   all red bytes for the whole image, followed 
  52.                   by all green bytes for the whole image, 
  53.                   followed by all blue bytes for the whole
  54.                   image.
  55.  
  56.         On Output:
  57.         ---------
  58.  
  59.         hdf8_file    - HDF file with one 8-bit raster image set,
  60.                   i.e. 8-bit image, dimensions, and 
  61.                   RGB palette.
  62.  
  63.   by:        NCSA
  64.   date(s):    May 89, Jun 89, Aug 89
  65.  
  66. ******************************************************************************
  67. * 
  68. * The following source code is in the public domain.
  69. * Specifically, we give to the public domain all rights for future licensing
  70. * of the source code, all resale rights, and all publishing rights.
  71. * 
  72. * We ask, but do not require, that the following message be included in all
  73. * derived works:
  74. * 
  75. * Portions developed at the National Center for Supercomputing Applications at
  76. * the University of Illinois at Urbana-Champaign.
  77. * 
  78. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  79. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  80. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  81. * 
  82. ******************************************************************************
  83. */
  84.  
  85. typedef    unsigned char    UCHAR;
  86. typedef unsigned int    UINT;
  87.  
  88. #define        NCOLORS        256
  89. #define        PALSIZE        3 * NCOLORS
  90. #define        COMPRESSION    0        /* no compression */
  91.  
  92. #include <stdio.h>
  93.  
  94. #ifdef UNIX
  95. #include <sys/file.h>
  96. #endif
  97. #ifdef MAC
  98. #include <FCntl.h>
  99. #include <StdLib.h>
  100. #endif
  101.  
  102. #include <hdf/df.h>
  103.  
  104. #define USAGE    fprintf (stderr, "usage: r24hdf8 x_dim y_dim r24_file hdf8_file\n")
  105.  
  106. main (argc, argv)
  107. int argc;
  108. char *argv[];
  109. {
  110.     int i, nc;
  111.     int fdr24;
  112.     int x_dim, y_dim, size;
  113.     char c;
  114.     char *ptr;
  115.     UCHAR *r24, *r8, *pal;
  116.     UCHAR hdfpal[PALSIZE], *p;
  117. #ifdef UNIX
  118.     char *malloc ();
  119. #endif
  120.  
  121.     if (argc != 5)
  122.     {
  123.         USAGE;
  124.         exit (1);
  125.     }
  126.  
  127.     x_dim = strtol (argv[1], &ptr, 10);
  128.     if (*ptr != NULL || x_dim <= 0) 
  129.     {
  130.         fprintf (stderr, "error: x dimension = %s is bad\n", argv[1]);
  131.         exit (-1);
  132.     }
  133.     y_dim = strtol (argv[2], &ptr, 10);
  134.     if (*ptr != NULL || y_dim <= 0) 
  135.     {
  136.         fprintf (stderr, "error: y dimension = %s is bad\n", argv[2]);
  137.         exit (-1);
  138.     }
  139.     size = x_dim * y_dim;
  140.  
  141.     if ((r24 = (UCHAR *) malloc (size * 3)) == NULL)
  142.     {
  143.         fprintf (stderr, "error: malloc to hold r24 image failed\n");
  144.         exit (-1);
  145.     }
  146.     if ((fdr24 = open (argv[3], "r")) == -1)
  147.     {
  148.         fprintf (stderr, "error: cannot open file %s to read\n", argv[3]);
  149.         exit (-1);
  150.     }
  151.  
  152.     if ((nc = read (fdr24, (char *) r24, size * 3)) != size * 3)
  153.     {
  154.         fprintf (stderr, "error: only %d bytes read from file %s - should be %d\n", nc, argv[3], size * 3);
  155.         exit (-1);
  156.     }
  157.         /* check for end of file */
  158.     if ((nc = read (fdr24, &c, 1)) != 0)
  159.     {
  160.         fprintf (stderr, "error: more bytes in file %s then dimensions indicate\n", argv[3]);
  161.         exit (-1);
  162.     }
  163.  
  164.     if ((r8 = (UCHAR *) malloc (size)) == NULL)
  165.     {
  166.         fprintf (stderr, "error: malloc to hold r8 image failed\n");
  167.         exit (-1);
  168.     }
  169.     if ((pal = (UCHAR *) malloc (PALSIZE)) == NULL)
  170.     {
  171.         fprintf (stderr, "error: malloc to hold palette failed\n");
  172.         exit (-1);
  173.     }
  174.  
  175.     if (r24r8 (x_dim, y_dim, r24, r8, NCOLORS, pal) == -1)
  176.     {
  177.         fprintf (stderr, "error: quantization failed\n");
  178.         exit (-1);
  179.     }
  180.  
  181.         /* rearrange palette to conform to HDF requirements */
  182.     p = hdfpal;
  183.     for (i = 0; i < NCOLORS; i++)
  184.     {
  185.         *p++ = pal[i];
  186.         *p++ = pal[i + NCOLORS];
  187.         *p++ = pal[i + NCOLORS * 2];
  188.     }
  189.     if (DFR8setpalette (hdfpal) == -1)
  190.     {
  191.         fprintf (stderr, "error: HDF set palette failed - error code = %d\n", DFerror);
  192.         exit (-1);
  193.     }
  194.     if (DFR8putimage (argv[4], r8, x_dim, y_dim, COMPRESSION) == -1)
  195.     {
  196.         fprintf (stderr, "error: HDF put image failed - error code = %d\n", DFerror);
  197.         exit (-1);
  198.     }
  199.     close (fdr24);
  200.  
  201.     free ((char *) r24);
  202.     free ((char *) r8);
  203.     free ((char *) pal);
  204.  
  205.     return 0;
  206. }
  207.  
  208. r24r8 (xres, yres, dat24, dat8, cres, cdat)
  209. int      xres;        /* x dimension - horizontal size */
  210. int      yres;        /* y dimension - vertical size */
  211. UCHAR   *dat24;        /* pointer to 24 bit image in "pixel" format */
  212. UCHAR   *dat8;        /* pointer to 8 bit image */
  213. int      cres;        /* number of colors in the palette - use 256 */
  214. UCHAR   *cdat;        /* pointer to palette - should be 3 * 256 bytes long */
  215. {
  216. /* 
  217.   by:        NCSA
  218.   date(s):    May 89, Jun 89
  219.  
  220. ******************************************************************************
  221. * 
  222. * The following source code is in the public domain.
  223. * Specifically, we give to the public domain all rights for future licensing
  224. * of the source code, all resale rights, and all publishing rights.
  225. * 
  226. * We ask, but do not require, that the following message be included in all
  227. * derived works:
  228. * 
  229. * Portions developed at the National Center for Supercomputing Applications at
  230. * the University of Illinois at Urbana-Champaign.
  231. * 
  232. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  233. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  234. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  235. * 
  236. ******************************************************************************
  237. */
  238.     int      ct,xct,yct;
  239.     int      rres,rd,rr,rn,rct;
  240.     int      gres,gd,gr,gn,gct;
  241.     int      bres,bd,br,bn,bct;
  242.     int      coff;
  243.     UINT    *idat[2];
  244.     UINT    *cp,*np;
  245.     UCHAR   *dip,*dop,*rp,*gp,*bp;
  246. #ifdef UNIX
  247.     char    *malloc();
  248. #endif
  249.  
  250.     if ((idat[0] = (UINT *)malloc(6*xres*sizeof(UINT))) == NULL)
  251.     {   fprintf(stderr,"error: Memory allocation fault\n");
  252.     return -1;
  253.     }
  254.     idat[1] = idat[0] + (3 * xres);
  255.  
  256.     rres = 6;
  257.     gres = 7;
  258.     bres = 6;
  259.     coff = 2;
  260.  
  261.     rr = gr = br = 255;
  262.     rn = rres - 1;
  263.     gn = gres - 1;
  264.     bn = bres - 1;
  265.  
  266.     rp = cdat + coff;
  267.     gp = rp + cres;
  268.     bp = gp + cres;
  269.  
  270.     for (rct=0; rct<rres; rct++)
  271.     {   for (gct=0; gct<gres; gct++)
  272.     {   for (bct=0; bct<bres; bct++)
  273.         {   *rp++ = (UCHAR)(rr * rct / rn);
  274.         *gp++ = (UCHAR)(gr * gct / gn);
  275.         *bp++ = (UCHAR)(br * bct / bn);
  276.         }
  277.     }
  278.     }
  279.  
  280.     rp = cdat;
  281.     gp = rp + cres;
  282.     bp = gp + cres;
  283.     cp = idat[0];
  284.     np = idat[1];
  285.     dip = dat24;
  286.     dop = dat8;
  287.  
  288.     for (xct=3*xres; --xct>=0; )
  289.     *cp++ = *dip++;
  290.  
  291.     for (yct=0; yct<(yres-1); yct++)
  292.     {
  293.     np = idat[(yct+1)%2];
  294.     for (xct=3*xres; --xct>=0; )
  295.         *np++ = *dip++;
  296.  
  297.     cp = idat[yct%2];
  298.     np = idat[(yct+1)%2];
  299.  
  300.     if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  301.     if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  302.     if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  303.  
  304.     *dop++ = ct = (rct * gres + gct) * bres + bct + coff;
  305.  
  306.     rd = cp[0] - rp[ct];
  307.     gd = cp[1] - gp[ct];
  308.     bd = cp[2] - bp[ct];
  309.  
  310.     cp += 3;
  311.     np += 3;
  312.  
  313.     cp[0]  += rd * 7 / 16;
  314.     cp[1]  += gd * 7 / 16;
  315.     cp[2]  += bd * 7 / 16;
  316.     np[-3] += rd * 5 / 16;
  317.     np[-2] += gd * 5 / 16;
  318.     np[-1] += bd * 5 / 16;
  319.     np[0]  += rd / 16;
  320.     np[1]  += gd / 16;
  321.     np[2]  += bd / 16;
  322.  
  323.     for (xct=2; xct<xres; xct++)
  324.     {
  325.         if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  326.         if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  327.         if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  328.  
  329.         *dop++ = ct = (rct * gres + gct) * bres + bct + coff;
  330.  
  331.         rd = cp[0] - rp[ct];
  332.         gd = cp[1] - gp[ct];
  333.         bd = cp[2] - bp[ct];
  334.  
  335.         cp += 3;
  336.         np += 3;
  337.  
  338.         cp[0]  += rd * 7 / 16;
  339.         cp[1]  += gd * 7 / 16;
  340.         cp[2]  += bd * 7 / 16;
  341.         np[-6] += rd * 3 / 16;
  342.         np[-5] += gd * 3 / 16;
  343.         np[-4] += bd * 3 / 16;
  344.         np[-3] += rd * 5 / 16;
  345.         np[-2] += gd * 5 / 16;
  346.         np[-1] += bd * 5 / 16;
  347.         np[0]  += rd / 16;
  348.         np[1]  += gd / 16;
  349.         np[2]  += bd / 16;
  350.  
  351.     }
  352.  
  353.     if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  354.     if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  355.     if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  356.  
  357.     *dop++ = ct = (rct * gres + gct) * bres + bct + coff;
  358.  
  359.     rd = cp[0] - rp[ct];
  360.     gd = cp[1] - gp[ct];
  361.     bd = cp[2] - bp[ct];
  362.  
  363.     cp += 3;
  364.     np += 3;
  365.  
  366.     np[-6] += rd * 3 / 16;
  367.     np[-5] += gd * 3 / 16;
  368.     np[-4] += bd * 3 / 16;
  369.     np[-3] += rd * 5 / 16;
  370.     np[-2] += gd * 5 / 16;
  371.     np[-1] += bd * 5 / 16;
  372.     }
  373.  
  374.     cp = idat[yct%2];
  375.  
  376.     if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  377.     if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  378.     if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  379.  
  380.     *dop++ = ct = (rct * gres + gct) * bres + bct + coff;
  381.  
  382.     rd = cp[0] - rp[ct];
  383.     gd = cp[1] - gp[ct];
  384.     bd = cp[2] - bp[ct];
  385.  
  386.     cp += 3;
  387.  
  388.     cp[0]  += rd * 7 / 16;
  389.     cp[1]  += gd * 7 / 16;
  390.     cp[2]  += bd * 7 / 16;
  391.  
  392.     for (xct=2; xct<xres; xct++)
  393.     {
  394.     if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  395.     if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  396.     if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  397.  
  398.     *dop++ = ct = (rct * gres + gct) * bres + bct + coff;
  399.  
  400.     rd = cp[0] - rp[ct];
  401.     gd = cp[1] - gp[ct];
  402.     bd = cp[2] - bp[ct];
  403.  
  404.     cp += 3;
  405.  
  406.     cp[0]  += rd * 7 / 16;
  407.     cp[1]  += gd * 7 / 16;
  408.     cp[2]  += bd * 7 / 16;
  409.     }
  410.  
  411.     if ((rct = (cp[0] * rn / rr)) > rn) rct = rn;
  412.     if ((gct = (cp[1] * gn / gr)) > gn) gct = gn;
  413.     if ((bct = (cp[2] * bn / br)) > bn) bct = bn;
  414.  
  415.     *dop++ = (rct * gres + gct) * bres + bct + coff;
  416.  
  417.     free(idat[0]);
  418.     return 0;
  419. }
  420.  
  421.