home *** CD-ROM | disk | FTP | other *** search
/ vis-ftp.cs.umass.edu / vis-ftp.cs.umass.edu.tar / vis-ftp.cs.umass.edu / pub / Software / ASCENDER / ascendMar8.tar / UMass / BoldtNew / LLVS / g0_to_plane.c < prev    next >
C/C++ Source or Header  |  1996-01-31  |  6KB  |  208 lines
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <math.h>
  6. #include "llvs_per_plane.h"
  7.  
  8. #define HEADER_TYPE_LEN 16
  9. #define HEADER_INFO_LEN 120
  10. #define INT_STRING_LEN 10
  11. #define BYTESIZE 8
  12.  
  13. #define IU_TESTBED_TYPE "SRI TB01IMGHDR"
  14.  
  15. void copy_substring(char* dest, char* src, int begin, int end)
  16. {
  17.   strncpy(dest,&src[begin],end-begin);
  18.   dest[end-begin] = '\0';
  19.   return;
  20. }
  21.  
  22. int read_int_from_string(char* src, int begin, int end)
  23. {
  24.   char tmpstr[INT_STRING_LEN];  
  25.  
  26.   copy_substring(tmpstr,src,begin,end);
  27.   return((int)(atoi(tmpstr)));
  28. }
  29.  
  30. int string_equal(char* string, char* strptr)  /* string must end with '\0'  */
  31. {                                             /* but strptr doesn't have to */
  32.   return(!strncmp(string,strptr,strlen(string)));
  33. }
  34.  
  35. int ceiling(int a, int b)
  36. {
  37.   return((int)(ceil( ((float)a) / ((float)b) )));
  38. }
  39.  
  40.  
  41. void read_block(unsigned char *buffer, FILE *infile,
  42.         int numElements, int bytesPerElement)
  43. {
  44.   int numbytes;
  45.  
  46.   for (numbytes = numElements * bytesPerElement; numbytes > 0; numbytes--)
  47.     *buffer++ = getc(infile);
  48.   return;
  49. }
  50.  
  51.  
  52. void main(int argc, char *argv[])
  53. {
  54.  
  55.   char *infilename, *outfilename;
  56.   FILE *infile;
  57.   PLANE *outplane;
  58.   PLANE_INFO *outplane_info;
  59.   char headerString[HEADER_INFO_LEN+1];
  60.   char elementType[40-32+1];
  61.   unsigned char *block;
  62.   int imageXdim, imageYdim, elementSize, elementBytes, headerLen;
  63.   int blockXdim, blockYdim, blockSize, numXblocks, numYblocks;
  64.   int dx = 1, dy = -1;  /* llvs plane top-bottom scan order (specified by dy) */
  65.                         /* is opposite that of the RCDE */
  66.   int i, itmp, jtmp;
  67.   int bx, by, ix, iy, ixstart, iystart;
  68.   int level, backval = 0;
  69.   int pixval;
  70.  
  71.   if (!(argc == 3)) {
  72.     fprintf(stderr,"Usage: g0_to_plane.c inimage.g0 outimage.plane\n");
  73.     fprintf(stderr,"Converts RCDE format images to LLVS plane files\n");
  74.     return;
  75.   }
  76.  
  77.   infilename = argv[1];
  78.   outfilename = argv[2];
  79.  
  80.   if ((infile = fopen(infilename,"r")) == NULL) {
  81.     perror("error opening input file");
  82.     perror(infilename);
  83.     return;
  84.   }
  85.  
  86.   for (i=0 ; i < HEADER_TYPE_LEN; i++)
  87.     headerString[i] = getc(infile);
  88.   headerString[HEADER_TYPE_LEN] = '\0';
  89.  
  90.   if (!(string_equal(IU_TESTBED_TYPE,headerString))) {
  91.     fprintf(stderr,"***Error reading image file \"%s\".\n",infilename);
  92.     fprintf(stderr,"***This program only converts iu testbed images.\n");
  93.     fprintf(stderr,"***File header label should be \"%s\"\n",IU_TESTBED_TYPE);
  94.     fprintf(stderr,"***but was found to be \"%s\".\n",headerString);
  95.     fclose(infile);
  96.     return;
  97.  
  98.   }
  99.  
  100.   rewind(infile);
  101.  
  102.   for (i=0 ; i < HEADER_INFO_LEN; i++)
  103.     headerString[i] = getc(infile);
  104.   headerString[HEADER_INFO_LEN] = '\0';
  105.  
  106.   copy_substring(elementType,headerString,32,40);
  107.   elementSize = read_int_from_string(headerString,56,64);
  108.  
  109.   if (!((string_equal("UNSIGNED",elementType)) &&
  110.     ((elementSize == 8) || (elementSize == 16)))) {
  111.     fprintf(stderr,"***Error reading image file \"%s\"\n",infilename);
  112.     fprintf(stderr,"***Can only convert images of element type\n");
  113.     fprintf(stderr,"***   (\"UNSIGNED\" 8) or (\"UNSIGNED\" 16)\n");
  114.     fprintf(stderr,"***but the element type was found to be\n");
  115.     fprintf(stderr,"***   (\"%s\" %d)\n", elementType, elementSize);
  116.     fclose(infile);
  117.     return;
  118.   }
  119.  
  120.   elementBytes = (int)(elementSize / BYTESIZE);
  121.  
  122.   imageXdim = read_int_from_string(headerString,64,72);
  123.   imageYdim = read_int_from_string(headerString,72,80);
  124.  
  125.   /* testbed format gives the number of BYTES horizontally in block */
  126.   itmp = read_int_from_string(headerString,80,88);
  127.   blockXdim = (int) (itmp / elementBytes);
  128.   blockYdim = read_int_from_string(headerString,88,96);
  129.  
  130.   numXblocks = ceiling(imageXdim,blockXdim);
  131.   numYblocks = ceiling(imageYdim,blockYdim);
  132.  
  133.   itmp = read_int_from_string(headerString,112,120);
  134.   jtmp = blockXdim * blockYdim;
  135.   blockSize = ((itmp < jtmp) ? jtmp : itmp);
  136.  
  137.   /* scan order */
  138.   if (string_equal("RL",&headerString[24]))
  139.     dx = (- dx);
  140.   if (string_equal("TB",&headerString[26]))
  141.     dy = (- dy);
  142.  
  143.   headerLen = read_int_from_string(headerString,16,24);
  144.  
  145.   /* position to beginning of pixel data */
  146.   rewind(infile);
  147.   for (i=0 ; i < headerLen; i++) getc(infile);
  148.  
  149.  
  150.   /* allocate LLVS plane */
  151.   itmp = ((imageYdim > imageXdim) ? imageYdim : imageXdim);
  152.   level = (int)(ceil(log10((double)itmp) / log10(2.0)));
  153.   if (new_plane(&outplane,&outplane_info,
  154.         ((elementSize==8) ? LLVS_BYTE : LLVS_SHORT), /* data type */
  155.         level,       /* level */
  156.         imageYdim,   /* number of rows */     
  157.         imageXdim,   /* number of cols */
  158.         0,           /* starting row */
  159.         0,           /* starting col */
  160.         &backval     /* background value */
  161.         ) < 0) {
  162.     perror("g0_to_plane: new_plane");
  163.     fprintf(stderr,"error allocating LLVS plane\n");
  164.     fclose(infile);
  165.     return;
  166.   }
  167.  
  168.   block = (unsigned char *)malloc(blockSize*elementSize);
  169.   if (block == NULL) {
  170.     perror("Error allocating block array");
  171.     fclose(infile);
  172.     return;
  173.   }
  174.  
  175.   /* outer loop, read in blocks */
  176.   iystart = ((dy > 0) ? 0 : (imageYdim - 1));
  177.   for( itmp=0; itmp < numYblocks; itmp++) {
  178.     ixstart = ((dx > 0) ? 0 : (imageXdim - 1));
  179.     for( jtmp = 0; jtmp < numXblocks; jtmp++) {
  180.       read_block(block,infile,blockSize,elementBytes);
  181.       /* inner loop - copy block to image */
  182.       for( iy = iystart, by = 0; by < blockYdim; iy += dy, by++)
  183.     for( ix = ixstart, bx = 0; bx < blockXdim; ix += dx, bx++) {
  184.       /* if ((ix>=0)&&(ix<imageXdim)&&(iy>=0)&&(iy<imageYdim)) */
  185.       /* out of bounds checking is now done in set_pixel */
  186.       for(i=0,pixval=0; i < elementBytes; i++) {
  187.         pixval *= 256;
  188.         pixval += block[(by*blockXdim+bx)*elementBytes];
  189.       }
  190.       SET_PIXEL(pixval,outplane,iy,ix,(*outplane_info));
  191.     }
  192.       ixstart += dy * blockXdim;
  193.     }
  194.     iystart += dy * blockYdim;
  195.   }
  196.  
  197.  
  198.   /* write output LLVS plane file */
  199.   if (write_plane(outplane,outplane_info,"NIL",outfilename) < 0) {
  200.     perror("g0_to_plane: write_plane");
  201.     fprintf(stderr,"could not write plane file %s\n", outfilename);
  202.   }
  203.  
  204.   fclose(infile);
  205.   return;
  206. }
  207.  
  208.