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 / partition.c < prev    next >
C/C++ Source or Header  |  1996-01-31  |  10KB  |  279 lines
  1. /* partition.c
  2.  *   break an image into (possibly overlapping) chunks
  3.  * ------------------------------------------------------------------
  4.  * was extractpieces.c - Program to extract 512x512 pieces from a huge image
  5.  * Created by Robert Heller on Wed Feb  5 08:51:16 1992
  6.  * ------------------------------------------------------------------
  7.  * Modification History:
  8.  *   Dec 29 1993 - Bob Collins - Make 266x266 pieces that overlap by 10 
  9.  *       pixels.  Renamed file to overlappingpieces.c
  10.  *   Nov 12 1994 - Bob Collins - added optional arguments to specify
  11.  *       minrow, mincol, maxrow, maxcol, width, and overlap.
  12.  *   Feb 17 1994 - Bob Collins - added optional arguments -RC, -XY
  13.  *       to specify type of coordinate system (if -XY, then bounding
  14.  *       box coordinates are interpreted as minx, miny, maxx, maxy.
  15.  *       Renamed file to partition.c
  16.  * ------------------------------------------------------------------
  17.  * Contents:
  18.  * ------------------------------------------------------------------
  19.  *  
  20.  * Copyright (c) 1992 by University of Massachusetts
  21.  *     All Rights Reserved
  22.  * 
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <errno.h>
  28. #include <string.h>
  29. #include "llvs_per_plane.h"
  30.  
  31.  
  32. extern void extract_plane();
  33.  
  34.  
  35. /*------------------------------------------------------------------*/
  36.  
  37. int usage_abort()   /***** ONLINE HELP *****/
  38. {
  39.   printf("partition - break a large image into (possibly overlapping) chunks\n\n");
  40.   printf("usage: partition planefile [-RC] [minrow mincol maxrow maxcol [width overlap]]\n");
  41.   printf("...or: partition planefile [-XY] [minx miny maxx maxy [width overlap]]\n");
  42.   printf("where\n");
  43.   printf("  planefile is an LLVS plane file\n");
  44.   printf("  -RC specifies a row-column coordinate system (default)\n");
  45.   printf("  -XY specifies an X-Y coordinate system\n");
  46.   printf("  minrow mincol maxrow maxcol specify a subimage for cropping\n");
  47.   printf("     (if -XY, these are interpreted as minx miny maxx maxy)\n");
  48.   printf("     The actual subimage boundaries will correspond to the\n");
  49.   printf("     intersection of this rectangle with the image boundaries.\n");
  50.   printf("  width is the pixel width/height of each chunk (default 256)\n");
  51.   printf("  overlap is the pixel overlap between chunks (default 0)\n");
  52.   exit(EINVAL);
  53. }
  54.  
  55. /*------------------------------------------------------------------*/
  56.  
  57. void main (int argc, char *argv[])
  58. {
  59.   static PLANE *inpl, *outpl, *blockpl;
  60.   static PLANE_INFO *inpl_info, *outpl_info, *blockpl_info;
  61.   static LIMITS limits;
  62.   static char *inassoc, outfile[256], basename[256], infile[256];
  63.   FILE *infofile;
  64.   register char *p;
  65.   int error;
  66.   int rowcol_coords = TRUE;           /* default is row-col coordinates */
  67.   register int row, col, drow, dcol, rowdim, coldim;
  68.   int firstrow, firstcol, lastrow, lastcol;   /* boundary of full image */
  69.   int minrow, mincol, maxrow, maxcol;           /* boundary of subimage */
  70.   int minx, miny, maxx, maxy;              /* for coversion of XY to RC */
  71.   int width = 256, overlap = 0, blockdim;
  72.   int argnum, wid, hei, newplane = FALSE;
  73.   int col_numblks, row_numblks, itmp, jtmp;
  74.  
  75.   argnum = 1;
  76.   if (argc > argnum)         /* PLANE FILENAME ARGUMENT */
  77.     strcpy(infile,argv[argnum++]);
  78.   else
  79.     usage_abort(); 
  80.  
  81.   if (argc > argnum) {       /* OPTIONAL COORDINATE SYSTEM SPECIFICATION */    
  82.     if ((!strcmp(argv[argnum],"-RC")) || (!strcmp(argv[argnum],"-rc"))) {
  83.       rowcol_coords = TRUE;
  84.       argnum++;
  85.     }
  86.     else if ((!strcmp(argv[argnum],"-XY")) || (!strcmp(argv[argnum],"-xy"))) {
  87.       rowcol_coords = FALSE;
  88.       argnum++;
  89.     }
  90.   }
  91.  
  92.   if (argc > argnum) {       /* OPTIONAL SUBIMAGE RECTANGLE */
  93.     minrow = atoi(argv[argnum++]);
  94.     mincol = atoi(argv[argnum++]);
  95.     maxrow = atoi(argv[argnum++]);
  96.     maxcol = atoi(argv[argnum++]);
  97.   }
  98.   else {
  99.     minrow = -999999;
  100.     maxrow =  999999;
  101.     mincol = -999999;
  102.     maxcol =  999999;
  103.   }
  104.  
  105.   if (argc > argnum) {      /* OPTIONAL BLOCKSIZE AND OVERLAP */
  106.     width = atoi(argv[argnum++]);
  107.     overlap = atoi(argv[argnum++]);
  108.   }
  109.  
  110.   if (argc > argnum) usage_abort();
  111.  
  112.   
  113.   p = strrchr(infile,'.');      /* READ IN PLANE FILE IMAGE */
  114.   if (p == NULL) strcat(infile,".plane");
  115.   else if (strchr(p,'/') != NULL) strcat(infile,".plane");
  116.   if (read_plane(&inpl,&inpl_info,&inassoc,infile) < 0) {
  117.     error = errno;
  118.     perror("partition: read_plane");
  119.     fprintf(stderr,"partition: read_plane: could not read in plane %s\n",
  120.         infile);
  121.     exit(error);
  122.   }
  123.   /* IMAGE BOUNDARIES */
  124.   firstcol = inpl_info->column_location;
  125.   lastcol  = inpl_info->column_location + inpl_info->column_dimension - 1;
  126.   firstrow = inpl_info->row_location;
  127.   lastrow  = inpl_info->row_location + inpl_info->row_dimension - 1;
  128.  
  129.  
  130.   if (!(rowcol_coords)) { 
  131.     /* INTERNAL PROCESSING USES ROW-COL COORDINATES */
  132.     /* CONVERT MINX MINY MAXX MAXY TO MINROW, MINCOL, MAXROW, MAXCOL */
  133.     minx = minrow;  miny = mincol;  maxx = maxrow;  maxy = maxcol;
  134.     minrow = lastrow - maxy;    mincol = minx;
  135.     maxrow = lastrow - miny;    maxcol = maxx;
  136.   }
  137.  
  138.   /* INTERSECT SUBIMAGE WITH ACTUAL IMAGE BOUNDARIES */
  139.   minrow = MAX(minrow,firstrow);
  140.   mincol = MAX(mincol,firstcol);
  141.   maxrow = MIN(maxrow,lastrow);
  142.   maxcol = MIN(maxcol,lastcol);
  143.  
  144.   /* COMPUTE BLOCK INFORMATION */
  145.   rowdim = maxrow - minrow + 1;
  146.   coldim = maxcol - mincol + 1;
  147.   blockdim = width - overlap;
  148.  
  149.   row_numblks = (int)(rowdim / blockdim);
  150.   if ((rowdim < blockdim) || ((rowdim % blockdim) > overlap))
  151.     row_numblks++;
  152.  
  153.   col_numblks = (int)(coldim / blockdim);
  154.   if ((coldim < blockdim) || ((coldim % blockdim) > overlap))
  155.     col_numblks++;
  156.  
  157.  
  158.   /* PREALLOCATE A PLANE FOR THE MAJORITY OF IMAGE BLOCKS */
  159.   if (new_plane(&blockpl,&blockpl_info,inpl_info->datatype,inpl_info->level,
  160.         (blockdim+overlap),(blockdim+overlap),0,0,
  161.         &inpl_info->background) < 0) {
  162.     error = errno;
  163.     perror("partition: new_plane");
  164.     fprintf(stderr,"partition: new_plane: could not allocate plane\n");
  165.     exit(error);
  166.   }
  167.  
  168.   strcpy(basename,infile);            /* INIT FILENAME STRING */
  169.   p = strrchr(basename,'.');
  170.   if (p != NULL) *p = '\0';
  171.  
  172.  
  173.   limits.level = inpl_info->level;    /* INIT PLANE LIMITS STRUCTURE */
  174.   limits.deltarow = 1;    
  175.   limits.deltacol = 1;    
  176.  
  177.   /* PRINT IMAGE STATS TO INFO FILE */
  178.   sprintf(outfile,"%s.info",basename);
  179.   if ((infofile = fopen(outfile,"w")) == NULL) {
  180.     error = errno;
  181.     perror("partition: fopen");
  182.     fprintf(stderr,"partition: error opening image info file\n");
  183.     fprintf(stderr,"partition: info filename was %s\n",outfile);
  184.     exit(error);
  185.   }
  186.   fprintf(infofile,"image: %s\n",basename);
  187.   fprintf(infofile,"image minrow: %d\n",firstrow);
  188.   fprintf(infofile,"image maxrow: %d\n",lastrow);
  189.   fprintf(infofile,"image mincol: %d\n",firstcol);
  190.   fprintf(infofile,"image maxcol: %d\n",lastcol);
  191.   fprintf(infofile,"image numrows: %d\n",lastrow-firstrow+1);
  192.   fprintf(infofile,"image numcols: %d\n",lastcol-firstcol+1);
  193.   fprintf(infofile,"crop minrow: %d\n",minrow);
  194.   fprintf(infofile,"crop maxrow: %d\n",maxrow);
  195.   fprintf(infofile,"crop mincol: %d\n",mincol);
  196.   fprintf(infofile,"crop maxcol: %d\n",maxcol);
  197.   fprintf(infofile,"crop numrows: %d\n",maxrow-minrow+1);
  198.   fprintf(infofile,"crop numcols: %d\n",maxcol-mincol+1);
  199.   fprintf(infofile,"block width: %d\n",width);
  200.   fprintf(infofile,"block overlap: %d\n",overlap);
  201.   fprintf(infofile,"row numblocks: %d\n",row_numblks);
  202.   fprintf(infofile,"col numblocks: %d\n",col_numblks);
  203.   fclose(infofile);
  204.  
  205.   /* MAIN LOOP - CUT UP THE PIECES AND WRITE THEM OUT */
  206.   row = (rowcol_coords ? minrow : (maxrow - blockdim - overlap + 1));
  207.   drow = (rowcol_coords ? blockdim : (- blockdim));
  208.  
  209.   for( itmp=0; itmp < row_numblks; itmp++, row+=drow) {
  210.     col = mincol; 
  211.     dcol = blockdim;
  212.  
  213.     for( jtmp=0; jtmp < col_numblks; jtmp++, col+=dcol) {
  214.       limits.startrow = MAX(minrow, row);
  215.       limits.startcol = MAX(mincol, col);
  216.       limits.endrow   = MIN(maxrow, (row + blockdim + overlap - 1));
  217.       limits.endcol   = MIN(maxcol,(col + blockdim + overlap - 1));
  218.  
  219.       hei = limits.endrow - limits.startrow + 1;
  220.       wid = limits.endcol - limits.startcol + 1;
  221.  
  222.       if ((hei == (blockdim + overlap)) & (wid == (blockdim + overlap))) {
  223.     outpl = blockpl;   /* USE PREALLOCATED BLOCK */
  224.     outpl_info = blockpl_info;
  225.     newplane = FALSE;
  226.       }
  227.       else {               /* CUSTOM-MAKE ONE OF THE RIGHT SIZE */
  228.     newplane = TRUE;
  229.     if (new_plane(&outpl,&outpl_info,inpl_info->datatype,inpl_info->level,
  230.               hei,wid,0,0,&inpl_info->background) < 0) {
  231.       error = errno;
  232.       perror("partition: new_plane");
  233.       fprintf(stderr,"partition: new_plane: could not allocate plane\n");
  234.       fprintf(stderr,"partition: size was %d  by %d\n", hei, wid);
  235.       exit(error);
  236.     }
  237.       }
  238.  
  239.       /* EXTRACT BLOCK FROM IMAGE */
  240.       outpl_info->row_location = limits.startrow;   
  241.       outpl_info->column_location = limits.startcol; 
  242.       memset(outpl,0,plane_size(outpl_info));
  243.       extract_plane(inpl,inpl_info,outpl,outpl_info,&limits);
  244.  
  245. /*
  246.       printf("Block %d,%d to %d,%d, (hei=%d,wid=%d)\n",
  247.          (int)limits.startrow, (int)limits.startcol,
  248.          (int)limits.endrow, (int)limits.endcol,
  249.          hei,wid);
  250. */
  251.  
  252.       /* TAG OUTPUT FILE NAME WITH BLOCK LOCATION */
  253.       if (rowcol_coords)
  254.     sprintf(outfile,"%sR%dC%d.plane",basename,
  255.         (int)limits.startrow, (int)limits.startcol);
  256.       else
  257.     sprintf(outfile,"%sX%dY%d.plane",basename,
  258.         (int)limits.startcol, (int)(lastrow - limits.endrow));
  259.  
  260.       /* WRITE OUT THE BLOCK SUBPLANE */
  261.       outpl_info->row_location = 0;     /* old hackery, not sure why */
  262.       outpl_info->column_location = 0;
  263.       if (write_plane(outpl,outpl_info,"NIL",outfile) < 0) {
  264.     error = errno;
  265.     perror("partition: write_plane");
  266.     fprintf(stderr,"partition: write_plane: could not ");
  267.     fprintf(stderr,"write plane file %s\n", outfile);
  268.     exit(error);
  269.       }
  270.       if (newplane) {
  271.     free(outpl);
  272.     free(outpl_info);
  273.       }
  274.     }
  275.   }
  276.   return;
  277. }
  278.  
  279.