/*# proc: build_blobls - allocates and initializes a list of blobs.# proc:# proc: alloc_blobls - allocates a list of blobs.# proc:# proc: free_blobls - deallocates a list of blobs including image data if not NULL.# proc:# proc: realloc_blobls - reallocates a list of blobs that has overflowed.# proc:# proc: append_blobls - adds a blob to the end of a blob list.# proc:# proc: merge_with_blobls - merges two blobs contained in a blob list and frees# proc:                 up the location of the source blob.# proc: merge_among_blobls - merges two blobs, each in a separate blob list, and frees# proc:                 up the location of the source blob.# proc: merge_blobs - composites two blobs back together according to their cut# proc:               corrdinates from their parent image.# proc: remove_blobls - removes a blob from its blob list at a specified location by# proc:                 sliding (collapsing) the contents of the list down in memory.# proc: init_blobls - sets up global blob list attributes.# proc:# proc: build_blob - allocates and initializes a blob given image data and attributes.# proc:# proc: dup_blob - returns a duplicate copy of the blob passed.# proc:# proc: update_blobls_stats - recomputes blob attributes specified by the flag passed# proc:                       across all the blobs in the list.# proc: compute_blob_stats - computes blob attributes specified by the flag passed.# proc:# proc: alloc_blob - allocates a blob structure without any allocation for image data.# proc:# proc: free_blob - deallocates a blob structure and its image data if not NULL.# proc:# proc: char2bin_blobls - converts all the blobs in a list containing binary char image# proc:                   data to one bit per pixel data.# proc: find_first_max_blob_memb - used in coordination with the blob_offsetof() macro,# proc:           this routine will find the maximum value for a specific blob attribute.# proc: compute_avr_blob_memb - used in coordination with the blob_offsetof() macro,# proc:           this routine computes the average value for a specific blob attribute.# proc: prct_blobls_memb - selects the specified percentile from the list of blob# proc:             attributes.# proc: median_blob_memb - finds median from the list of blob attributes.# proc:# proc: sort_blobls_on_memb - used in coordination with the blob_offsetof() macro,# proc:             this routine sorts a list of blobs on a specific blob attribute.# proc: is_blob_above - determines if one blob is above another.# proc:# proc: find_blob_nbrs - given a list of blobs sorted left-to-right, returns blobs to the# proc:                  left and right of a given blob.# proc: find_blob_ind_blob_nbrs - given a list of blobs and a sorted rank of the list,# proc:                  returns blobs to the left and right of a given blob.# proc: find_first_blob_inside - determines if a blob is inside one of the blobs# proc:                          contained in a list.# proc: blob_hori_overlaps - given a blob and a list of blobs, finds all those blobs# proc:                 that horizontally overlap the first blob and measures and stores# proc:                 the distance of the overlaps.*/#include <stdio.h>#include <blobls.h>#include <multsort.h>#include <defs.h>/*******************************************************************/build_blobls(blobls, blob_alloc, flags, bpp, b_g)BLOBLS **blobls;int blob_alloc, flags, bpp, b_g;{   alloc_blobls(blobls, blob_alloc);   init_blobls((*blobls), flags, bpp, b_g);}/*******************************************************************/alloc_blobls(blobls, blob_alloc)BLOBLS **blobls;int blob_alloc;{   if(((*blobls) = (BLOBLS *)malloc(sizeof(BLOBLS))) == NULL)      syserr("alloc_blobls", "malloc", "blobls");   if(blob_alloc == 0)      (*blobls)->blobs = (BLOB **)NULL;   else      if(((*blobls)->blobs = (BLOB **)malloc(blob_alloc * sizeof(BLOB *))) == NULL)         syserr("alloc_blobls", "malloc", "blobs");   (*blobls)->num = 0;   (*blobls)->alloc = blob_alloc;}/*******************************************************************/free_blobls(blobls)BLOBLS *blobls;{   int i;   if(blobls->blobs != (BLOB **)NULL){      for(i = 0; i < blobls->num; i++){        free_blob(blobls->blobs[i]);      }      free(blobls->blobs);   }   free(blobls);}/*******************************************************************/realloc_blobls(blobls)BLOBLS *blobls;{   blobls->alloc += BLOB_CHUNKS;   if((blobls->blobs = (BLOB **)realloc(blobls->blobs,                               blobls->alloc * sizeof(BLOB *))) == NULL)      syserr("realloc_blobls", "realloc", "blob list");}/*******************************************************************/append_blobls(blobls, blob)BLOBLS *blobls;BLOB *blob;{   if(blobls->num >= blobls->alloc)      /* realloc first */      realloc_blobls(blobls);   blobls->blobs[blobls->num] = blob;   (blobls->num)++;}/************************************************************/merge_within_blobls(blobls, src, dst)BLOBLS *blobls;int src, dst;{   BLOB *nblob, *sptr, *dptr;   if((src < 0) || (src >= blobls->num))      fatalerr("merge_within_blobs", "src blob index not within blob list", NULL);   if((dst < 0) || (dst >= blobls->num))      fatalerr("merge_within_blobls", "dst blob index not within blob list", NULL);   sptr = blobls->blobs[src];   dptr = blobls->blobs[dst];   merge_blobs(&nblob, sptr, dptr, blobls->flags);   free(dptr->data);   free(dptr);   blobls->blobs[dst] = nblob;   free(sptr->data);   free(sptr);   remove_blobls(blobls, src);}/*******************************************************************/merge_among_blobls(sblobls, src, dblobls, dst)BLOBLS *sblobls, *dblobls;int src, dst;{   BLOB *nblob, *sptr, *dptr;   if((src < 0) || (src >= sblobls->num))      fatalerr("merge_among_blobs", "src blob index not within blob list", NULL);   if((dst < 0) || (dst >= dblobls->num))      fatalerr("merge_among_blobls", "dst blob index not within blob list", NULL);   sptr = sblobls->blobs[src];   dptr = dblobls->blobs[dst];   merge_blobs(&nblob, sptr, dptr, dblobls->flags);   free(dptr->data);   free(dptr);   dblobls->blobs[dst] = nblob;   /* remove dot blob from list */   free(sptr->data);   free(sptr);   remove_blobls(sblobls, src);}/*******************************************************************/merge_blobs(nblob, blob1, blob2, flags)BLOB **nblob, *blob1, *blob2;int flags;{   unsigned char *allocate_image();   int lx, rx, ty, by, tflags;   alloc_blob(nblob);   lx = min(blob1->x1, blob2->x1);   rx = max(blob1->x1 + blob1->w,            blob2->x1 + blob2->w);   ty = min(blob1->y1, blob2->y1);   by = max(blob1->y1 + blob1->h,            blob2->y1 + blob2->h);   (*nblob)->x1 = lx;   (*nblob)->y1 = ty;   (*nblob)->w = rx - lx;   (*nblob)->h = by - ty;   (*nblob)->data = allocate_image((*nblob)->w, (*nblob)->h, 8);   /* copy first blob */   subimage_copy(blob1->data, blob1->w, blob1->h,                 (*nblob)->data, (*nblob)->w, (*nblob)->h, 0, 0, blob1->w, blob1->h,                 blob1->x1 - lx, blob1->y1 - ty);   /* OR second blob */   subimage_or(blob2->data, blob2->w, blob2->h,               (*nblob)->data, (*nblob)->w, (*nblob)->h, 0, 0, blob2->w, blob2->h,               blob2->x1 - lx, blob2->y1 - ty);   /* compute new pixcnt without rescanning image */   if(flags & BLOB_PIXCNTS){      (*nblob)->pixcnt = blob1->pixcnt + blob2->pixcnt;      /* don't recount pixels, already taken care of */      tflags = flags & ~BLOB_PIXCNTS;   }   else      tflags = flags;   /* compute other blob statistics according to flags set */   compute_blob_stats((*nblob), tflags);}/*******************************************************************/remove_blobls(blobls, bi)BLOBLS *blobls;int bi;{   if((bi < 0) || (bi >= blobls->num))      fatalerr("remove_blobls", "blob index out of range of current list", NULL);   (blobls->num)--;   /* shift memory if blob not at end of list */   if(bi != blobls->num)      memcpy(&(blobls->blobs[bi]), &(blobls->blobs[bi+1]),             (blobls->num - bi) * sizeof(BLOB *));}/*******************************************************************/init_blobls(blobls, flags, bpp, b_g)BLOBLS *blobls;int flags, bpp, b_g;{   blobls->flags = flags;   blobls->bpp = bpp;   blobls->b_g = b_g;}/*******************************************************************/build_blob(blob, flags, bdata, bx, by, bw, bh)BLOB **blob;int flags;unsigned char *bdata;int bx, by, bw, bh;{   alloc_blob(blob);   (*blob)->data = bdata;   (*blob)->x1 = bx;   (*blob)->y1 = by;   (*blob)->w = bw;   (*blob)->h = bh;   compute_blob_stats((*blob), flags);}/*******************************************************************/BLOB *dup_blob(blob, bpp)BLOB *blob;int bpp;{   BLOB *oblob;   unsigned char *imagedup();   alloc_blob(&oblob);   memcpy(oblob, blob, sizeof(BLOB));   /* allocate and copy separate image space */   oblob->data = imagedup(blob->data, blob->w, blob->h, bpp);   return(oblob);}/*******************************************************************/update_blobls_stats(blobls, flags)BLOBLS *blobls;int flags;{   int i;   int do_xy2s, do_cxys, do_as, do_pixcnt;/*   if(!(blobls->flags & BLOB_XY1S) || !(blobls->flags & BLOB_WHS))      fatalerr("update_blobls_stats",               "must have at least (x1, y1) and (w, h) already in blob structures",               NULL);*/   /* set up tests for flags */   do_xy2s = (flags & BLOB_XY2S)?1:0;   do_cxys = (flags & BLOB_CXYS)?1:0;   do_as = (flags & BLOB_AS)?1:0;   do_pixcnt = (flags & BLOB_PIXCNTS)?1:0;   /* update blob stats accordingly */   for(i = 0; i < blobls->num; i++){