home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast.iso / dv_x / dvix.zip / SHRINK.C < prev    next >
C/C++ Source or Header  |  1992-10-08  |  4KB  |  146 lines
  1. /* shrink.c: shrink a bitmap */
  2.  
  3. #include <stdio.h>
  4. #include "dvi.h"
  5. #include "pxl.h"
  6. #include "general.h"
  7. #include "local.h"
  8. #include "bitorder.h"
  9.  
  10. #ifdef MSBITFIRST
  11. #define bitMask(n) (1<<(BYTESIZE-1-(n)))
  12. #define bitMask2(n) (1<<(BYTESIZE*2-1-(n)))
  13. #define nextBitMask(bmask) ((bmask)>>1)
  14. #define catBits(b0,b1) (((b0)<<BYTESIZE)+(b1))
  15. #else
  16. #define bitMask(n) (1<<(n))
  17. #define bitMask2(n) (1<<(n))
  18. #define nextBitMask(bmask) ((bmask)<<1)
  19. #define catBits(b0,b1) (((b1)<<BYTESIZE)+(b0))
  20. #endif
  21.  
  22. int density_factor = 5;  /* personal prefernce (was 3) (GBP) */
  23.  
  24. sample(bitmap, x, y, w, h)
  25.     register struct bitmap *bitmap;
  26.     int x, y, w, h;
  27. {
  28.     register BYTE *ptr, *endp;
  29.     register unsigned long m, bits, b;
  30.     register int i, j, n;
  31.  
  32.     ptr = (BYTE*) (bitmap->bits
  33.             + (y * bitmap->bytes_wide)
  34.             + (x / BYTESIZE)*(BYTESIZE/BITS_PER_BYTE));
  35.     endp = (BYTE*) (bitmap->bits + (bitmap->h * bitmap->bytes_wide));
  36.     b = bitMask2(x % BYTESIZE);
  37.     n = 0;
  38.     for (i = 0;
  39.          i < h && ptr < endp;
  40.          i += 1, ptr += bitmap->bytes_wide/(BYTESIZE/BITS_PER_BYTE)) {
  41.         /* this should make up to s==BYTESIZE work ok */
  42.         bits = catBits(ptr[0], ptr[1]);
  43.         for (m = b, j = 0; j < w; j += 1, m = nextBitMask(m))
  44.             if (bits & m)
  45.                 n += 1;
  46.     }
  47.         return ((n>0) &&
  48.                 density_factor?(n >= (i * w) / density_factor):n); /* was 3 */
  49. }
  50.  
  51. shrink_graymap(bitmap, x_factor, y_factor)
  52.     register struct bitmap *bitmap;
  53.     int x_factor, y_factor;
  54. {
  55.     BYTE *shrunk_bits;
  56.     unsigned int shrunk_height, shrunk_width, shrunk_bytes_wide;
  57.     register BYTE *ptr;
  58.     BYTE *cp;
  59.     register unsigned int b, m;
  60.     register int x, y, sx, sy, xw, yw;
  61.     static int masks[4] = {0x80, 0x20, 0x08, 0x02};
  62.  
  63.     shrunk_height = ROUNDUP(bitmap->h, y_factor);
  64.     shrunk_width = ROUNDUP(bitmap->w*4, x_factor);
  65.     shrunk_bytes_wide = ROUNDUP(bitmap->w, x_factor);
  66.     ptr = shrunk_bits = (BYTE*) malloc(shrunk_height*shrunk_bytes_wide);
  67.     if (ptr == NULL)
  68.         error("Can't allocate shrunken graymap (%d by %d)",
  69.             shrunk_height, shrunk_width);
  70.     for (y = sy = 0; sy < shrunk_height*2; sy++, y += y_factor) {
  71.         b = 0;
  72.         cp = ptr;
  73.         yw = ((y+y_factor)>>1) - y>>1;
  74.         if (yw==0) yw=1;
  75.         for (x = 0; x < shrunk_width; x += (x_factor<<1)) {
  76.             m = masks[x&0x3];
  77.             if (sy&1) m >>= 1;
  78.             sx = (x>>2);
  79.             xw = ((x+x_factor)>>2) - sx;
  80.             if (xw==0) xw=1;
  81.             if (sample(bitmap, x>>2, y>>1, xw, yw))
  82.                 *ptr |= m;
  83.             else
  84.                 *ptr &= ~m;
  85.             b += 1;
  86.             m >>= 1;
  87.             if (b >= BYTESIZE) {
  88.                 b = 0;
  89.                 m = bitMask(0);
  90.                 ptr += 1;
  91.             }
  92.         }
  93.         ptr = cp + shrunk_bytes_wide;
  94.     }
  95.     free(bitmap->bits);
  96.     bitmap->bits = (char*) shrunk_bits;
  97.     bitmap->h = shrunk_height;
  98.     bitmap->w = shrunk_width*2;
  99.     bitmap->bytes_wide = shrunk_bytes_wide;
  100. }
  101.  
  102. shrink_bitmap(bitmap, x_factor, y_factor)
  103.     register struct bitmap *bitmap;
  104.     int x_factor, y_factor;
  105. {
  106.     BYTE *shrunk_bits;
  107.     unsigned int shrunk_height, shrunk_width, shrunk_bytes_wide;
  108.     register BYTE *ptr;
  109.     BYTE *cp;
  110.     register unsigned int b, m;
  111.     register int x, y;
  112.  
  113.     shrunk_height = ROUNDUP(bitmap->h, y_factor);
  114.     shrunk_width = ROUNDUP(bitmap->w, x_factor);
  115.     shrunk_bytes_wide = ROUNDUP(shrunk_width, BYTESIZE)
  116.                 *(BYTESIZE/BITS_PER_BYTE);
  117.     ptr = shrunk_bits = (BYTE*) malloc(shrunk_height*shrunk_bytes_wide);
  118.     if (ptr == NULL)
  119.         error("Can't allocate shrunken bitmap (%d by %d)",
  120.             shrunk_height, shrunk_width);
  121.     for (y = 0; y < bitmap->h; y += y_factor) {
  122.         b = 0;
  123.         m = bitMask(0);
  124.         cp = ptr;
  125.         for (x = 0; x < bitmap->w; x += x_factor) {
  126.             if (sample(bitmap, x, y, x_factor, y_factor))
  127.                 *ptr |= m;
  128.             else
  129.                 *ptr &= ~m;
  130.             b += 1;
  131.             m = nextBitMask(m);
  132.             if (b >= BYTESIZE) {
  133.                 b = 0;
  134.                 m = bitMask(0);
  135.                 ptr += 1;
  136.             }
  137.         }
  138.         ptr = cp + shrunk_bytes_wide/(BYTESIZE/BITS_PER_BYTE);
  139.     }
  140.     free(bitmap->bits);
  141.     bitmap->bits = (char*) shrunk_bits;
  142.     bitmap->h = shrunk_height;
  143.     bitmap->w = shrunk_width;
  144.     bitmap->bytes_wide = shrunk_bytes_wide;
  145. }
  146.