#ifdef DYNAMIC_BITMAPS /* * rotatebitmap.c * Routines to rotate bitmaps * * */ #include #include #include #ifndef NO_X_HEADERS #include #include #include #include #include #else #define NO_READ_BITMAPFILE /* with that out of the way, all tht we need is XImage to be defined */ /* * WARNING:Also, make sure whatever calls RotateBitmap() uses the SAME * * XImage typedef, or else RotateBitmap() will be very confused about * just * what its arguments */ /* * an abbreviated XImage struct, useful only for this code. * some X stuff * might understand it, though */ typedef struct _XImage { int width, height; int xoffset; int format; unsigned char *data; int byte_order; int bitmap_unit; int bitmap_bit_order; int bitmap_pad; int depth; int bytes_per_line; } XImage; #define XYBitmap 0 #define LSBFirst 0 #endif /* * define NO_READ_BITMAPFILE and this code file will #ifdef out all the * * routines and code related to the reading and writing of * the bitmap * file[s], and thus be useful as utilities for manipulating * bitmap files * in other programs * * * #define NO_READ_BITMAPFILE */ #ifndef NO_READ_BITMAPFILE /* * 'global' variables for the bitmap file reading code swiped from the * * 'bitmap' program code */ static int raster_length; /* how many chars in the raster[] array */ static unsigned char *stripped_name = "bitmap"; /* file name without directory path or extension */ #endif /* NO_READ_BITMAPFILE */ /* used primarily when reading from the .xbm files */ #ifndef OUTTA_RANGE #define OUTTA_RANGE -1 #endif int x_hot_spot = OUTTA_RANGE; int y_hot_spot = OUTTA_RANGE; #define PI 3.14152136 #ifndef NO_READ_BITMAPFILE static XImage image = { 0, 0, /* (int) width, (int) height */ 0, XYBitmap, NULL, /* (int) xoffset, (int) format, (char *) data */ LSBFirst, 8, /* (int) byte_order, (int) bitmap-unit */ LSBFirst, 8, 1, /* (int) bitmap_bit_order, bitmap_pad, depth */ 0 /* (int) bytes_per_line */ }; #endif /* useful utility: number of 8 bit bytes to form a line in xbm format */ #define BYTEWIDTH(width) (int) ((width) % 8 ? ((width)/8 + 1) : ((width)/8)) /* * basically, an extra byte is needed for the remaining bits if it's not * * divisible by 8. */ /* maximum size bitmaps that these routines can handle... */ #ifndef MAXHEIGHT #define MAXHEIGHT 100 #endif #ifndef MAXWIDTH #define MAXWIDTH 100 #endif #define TEMPSIZE MAXHEIGHT * BYTEWIDTH(MAXWIDTH) unsigned char rotatedarray[TEMPSIZE]; /* really, I ought to make this * dynamic... */ static XImage rotatedimage = { 0, 0, /* width, height */ 0, XYBitmap, rotatedarray, /* xoffset, format, data */ LSBFirst, 8, /* byte_order, bitmap_unit */ LSBFirst, 8, 1, /* bitmap_bit_order, bitmap_pad, depth */ 0 /* bytes_per_line */ }; /* establish the functions used in this code */ XImage *RotateBitmap( /* XImage bitmap,int rotation, int filtering */ ); int pixel( /* int x,int y, char * data, int width,int height */ ); void set_pixel( /* int rot_x,int rot_y, char * data, int width,int height */ ); #ifndef NO_READ_BITMAPFILE int ReadBitmapFile( /* char * filename */ ); void WriteXImageFile( /* char * filename, XImage imagedata */ ); void usage(); #endif /* * #define NETREK if this is going to be used as part of netrek code, * in * which there are arrays (double) Sin[256] and (double) Cos[256] * this way * this function doesn't need to call its own Sin and Cos * functinos. */ #ifdef NETREK extern double Sin[]; extern double Cos[]; #else double Sin(int angle); double Cos(int angle); #endif #ifndef NO_READ_BITMAPFILE /* * the wrapper for the standalone rotation utility. * see the usage() routine * for usage instructions... */ int main(int argc , char **argv) { char string[80]; int angle; int filtering = 5; XImage *imagedata = NULL; if (argc < 3) { usage(); exit(1); } argv++; argc--; /* skip argv[0] */ /* -f [##] option-- filtering level. 4-9 defualt 5 */ if (**argv == '-' && (*argv)[1] == 'f') { argc--; argv++; if (argc <= 0) usage(); filtering = atoi(*argv); printf("Filtering level: %d(%s)\n", filtering, *argv); argc--; argv++; if (argc <= 0) usage(); } angle = atoi(*argv); /* put angle in range */ while (angle < 0) angle += 256; angle = angle % 256; argc--; argv++; printf("Rotation angle: %d\n", angle); #ifdef DEBUG fprintf(stderr, "rotation angle %d\n", angle); #endif /* loop over all arguments */ while (--argc >= 0) { #ifdef DEBUG fprintf(stderr, "parsing argument: %s\n", *argv); #endif ReadBitmapFile(*argv); imagedata = RotateBitmap(image, angle, filtering); /* fix name to format oldfilename.rotation */ sprintf(string, "%s.%d", *argv, angle); WriteXImageFile(string, *imagedata); argv++; } return (0); } #endif /* NO_READ_BITMAPFILE */ /* * RotateBitmap() : Rotates X image structure, * returns pointer to rotated * XImage, NULL on error * args: standard XImage structure, rotation(0-255), * * filtering to use in non-right angle rotations (see below for explanation) * * Rotation is in units such that 256 equals full circle * * * for non-right angle rotations, 'filtering' is used. * rotate alg is * improved from version 1 in that we map each pixel from * rotated map onto * the non-rotated one. * furthermore, we check points to either side of the * center of the * rotated map's pixels. if enough of them (set by filtering) * are in a pixel, the * corresponding rotated pixel is mapped that color. */ /* maximum bitmap size handled. */ XImage * RotateBitmap(bitmap, angle, filtering) XImage bitmap; int angle; int filtering; { int i, j; int x, y; int width = bitmap.width; int height = bitmap.height; double cent_x = x_hot_spot; double cent_y = y_hot_spot; int maxbytes = 0; int bytesperline = 0; double increment = .30; double x_test, y_test; static unsigned char bitfield[MAXWIDTH][MAXHEIGHT] = {0}; /* this really should be dynamically * allocated */ char *rotatedata = rotatedimage.data; double sinval, cosval; #ifndef NETREK sinval = Sin(-angle); cosval = Cos(-angle); #else /* * oddly, the netrek Sin[] and Cos[] are rotated oddly from normal * math * functions. We must compensate for this` */ if (angle >= 0 && angle < 256) { sinval = Cos[256 - angle]; cosval = -Sin[256 - angle]; } else { /* deal with illegal range angles by just assuming 0 rotation */ sinval = 0; cosval = 1; } #endif width = bitmap.width; height = bitmap.height; if (cent_x == OUTTA_RANGE || cent_y == OUTTA_RANGE) { cent_x = (((double) width) - 1) / 2; cent_y = (((double) height) - 1) / 2; } rotatedimage.width = width; rotatedimage.height = height; rotatedimage.bytes_per_line = bytesperline = BYTEWIDTH(width); #ifndef DEBUG /* handle simple cases */ if (angle == 0) { for (i = 0; i < bytesperline * height; i++) rotatedimage.data[i] = bitmap.data[i]; return (&rotatedimage); }; #endif if ((sinval * sinval) <= 0.0001 || (sinval * sinval) >= 0.9999) { /* * don't have to do fancy increment stuff for right angle * rotations */ increment = 0; filtering = 1; #ifdef DEBUG printf("Performing Right angle rotation!\n"); #endif } #ifdef DEBUG printf("Sin(), Cos() of the angle are %f, %f\n", sinval, cosval); #endif /* calculate number of bytes needed */ maxbytes = height * bytesperline; /* clear bitmap space */ for (i = 0; i < maxbytes; i++) *(rotatedata + i) = 0; for (i = 0; i < height; i++) { /* row number */ for (j = 0; j < width; j++) { /* column number */ /* * note for case where increment==0, following loops should get * * executed only _once_ */ bitfield[i][j] = 0; for (x_test = i - increment; x_test <= i + increment; x_test += increment) { for (y_test = j - increment; y_test <= j + increment; y_test += increment) { x = (int) (cosval * (x_test - cent_x) + sinval * (y_test - cent_y) + cent_x + .5); y = (int) (-sinval * (x_test - cent_x) + cosval * (y_test - cent_y) + cent_x + .5); bitfield[i][j] += pixel(x, y, bitmap.data, width, height); if (x_test == i && y_test == j) bitfield[i][j] += pixel(x, y, bitmap.data, width, height); /* double weight of pixels exactly on */ if (increment == 0) y_test++; /* prevent infinite loop! */ } if (increment == 0) x_test++; /* prevent infinite loop! */ } } } for (i = 0; i < height; i++) { /* row number */ for (j = 0; j < width; j++) { /* column number */ if (bitfield[i][j] >= filtering) { set_pixel(i, j, rotatedata, width, height); } } } return (&rotatedimage); } /* * returns 1 if pixel corresponding to x,y in bitmap array data is set * * returns 0 in other cases */ int pixel(x, y, data, width, height) int x, y; char *data; int width, height; { int bytepos; int bitmask; #ifdef MASSIVEDEBUG int j; #endif if (x < 0 || x >= width) return (0); if (y < 0 || y >= height) return (0); bytepos = x * BYTEWIDTH(width) + (y / 8); bitmask = 1 << (y % 8); #ifdef MASSIVEDEBUG for (j = 0; j < BYTEWIDTH(width) * height; j++) { fprintf(stderr, "/%d", *(data + j)); } fprintf(stderr, "\n"); fprintf(stderr, "Checking pixel at %d, %d, (byte %d, mask %d)", x, y, bytepos, bitmask); #endif if (*(data + bytepos) & bitmask) { #ifdef BIGDEBUG fprintf(stderr, "-\n"); #endif return (1); } else { #ifdef BIGDEBUG fprintf(stderr, "#\n"); #endif return (0); } } /* * sets a pixel in the width/height data bitmap array, at * rot_x, rot_y */ void set_pixel(rot_x, rot_y, data, width, height) int rot_x, rot_y; char *data; int width, height; { int bytepos; int bitmask; if (rot_x < 0 || rot_x >= width) return; if (rot_y < 0 || rot_y >= height) return; bytepos = rot_x * BYTEWIDTH(width) + rot_y / 8; bitmask = 1 << (rot_y % 8); *(data + bytepos) |= bitmask; return; } #ifndef NO_READ_BITMAPFILE /* * Shamelessy grabbed from the source code to 'bitmap' from the * mit X * standard Distribution... */ int ReadBitmapFile(filename) char *filename; { unsigned int width, height; int x_hot, y_hot; unsigned char *data; int status; status = XmuReadBitmapDataFromFile(filename, &width, &height, &data, &x_hot, &y_hot); if (status != BitmapSuccess) return status; image.width = width; image.height = height; image.data = (char *) data; image.bytes_per_line = (image.width + 7) / 8; raster_length = image.bytes_per_line * image.height; x_hot_spot = x_hot; y_hot_spot = y_hot; return BitmapSuccess; } void WriteXImageFile(char *filename, XImage image) { FILE *file; register int i; int num_bytes = 0; file = fopen(filename, "w"); if (file == NULL) { fprintf(stderr, "Ack! Couldn't save %s!\n", filename); } #ifdef DEBUG fprintf(stderr, "Writing to file %s (%d)\n", filename, file); #endif fprintf(file, "#define %s_width %d\n", stripped_name, rotatedimage.width); fprintf(file, "#define %s_height %d\n", stripped_name, rotatedimage.height); if (x_hot_spot != OUTTA_RANGE) fprintf(file, "#define %s_x_hot %d\n", stripped_name, x_hot_spot); if (y_hot_spot != OUTTA_RANGE) fprintf(file, "#define %s_y_hot %d\n", stripped_name, y_hot_spot); fprintf(file, "static char %s_bits[] = {\n 0x%02x", stripped_name, (unsigned char) rotatedimage.data[0]); num_bytes = BYTEWIDTH(rotatedimage.width) * rotatedimage.height; #ifdef DEBUG fprintf(stderr, "number of bytes: %d\n", num_bytes); #endif for (i = 1; i < num_bytes; i++) { fprintf(file, ","); fprintf(file, (i % 12) ? " " : "\n "); fprintf(file, "0x%02x", (unsigned char) rotatedimage.data[i]); } fprintf(file, "};\n"); } double Sin(int angle) { return (sin((float) angle * PI / 128)); } double Cos(int angle) { return (cos((float) angle * PI / 128)); } void usage() { fprintf(stderr, "Usage: rotatebitmap [-f filterlevel] angle bitmaplist\n"); fprintf(stderr, "This program takes the bitmap files given to it, and\n"); fprintf(stderr, "rotates them, outputting them as [name].angle \n"); fprintf(stderr, "NOTE: angle is in units such that 0-255 describes a full circle \n"); exit(1); } #endif /* NO_READ_BITMAPFILE */ #endif