/*! * \ingroup WlzBinaryOps * \brief Segment a domain into connected parts. Connectivity is defined by the connect parameter and can be 4- or 8-connected for 2D objects and 6-, 18- or 26-connected for 3D objects. Note this version requires that there is sufficient space in the objects array defined by maxNumObjs and this is not extended. This should be changed in future so that the array is extended as required. * * \return Error number. * \param obj input object to be segmented * \param mm number of objects return * \param dstArrayObjs object array return, allocated in the procedure. * \param maxNumObjs maximum number of object to return (determines the size of the array) * \param ignlns ignore objects with num lines <= ignlns * \param connect connectivity to determine connected regions * \par Source: * WlzLabel.c */ WlzErrorNum WlzLabel( WlzObject *obj, int *mm, WlzObject ***dstArrayObjs, int maxNumObjs, int ignlns, WlzConnectType connect) { WlzIntervalDomain *jdp; WlzRagRValues *jvp; WlzIntervalWSpace iwsp; WlzInterval *itvl; WlzInterval *jtvl; WlzLAllocBuf *crntal, *altemp; WlzLAllocBuf *al, *crntst, *crlast; WlzLAllocBuf *precal, *precst, *prlast; int nints, mkl; int maxinline,nob,line,ended,lend,chainlistsize; WlzLLink *freechain, *alprec, *alloc, *link1, *link2; int lftcrn, lftprc, rtcrn, rtprec; int jrtcrn, mxkl, jl, jr; int oll, ofl, jjj; WlzDomain domain; WlzValues values; int jdqt; WlzErrorNum errNum=WLZ_ERR_NONE; WlzObject **objlist; /* see HISTORY for comments from the FORTRAN version */ /* now we allocate space for the objects */ if( (objlist = (WlzObject **)AlcMalloc(sizeof(WlzObject *) * maxNumObjs)) == NULL ){ errNum = WLZ_ERR_MEM_ALLOC; } else { *dstArrayObjs = objlist; } /* check object note *mm is always set to zero on error return because the "Too many objects" error can return nobj valid objects therefore if *mm != 0 there are valid objects in objlist which must be freed */ if( obj == NULL ){ *mm = 0; return WLZ_ERR_OBJECT_NULL; } /* check types */ switch( obj->type ){ case WLZ_2D_DOMAINOBJ: if( obj->domain.core == NULL ){ *mm = 0; return WLZ_ERR_DOMAIN_NULL; } switch( obj->domain.core->type ){ case WLZ_INTERVALDOMAIN_INTVL: break; case WLZ_INTERVALDOMAIN_RECT: if( (obj->domain.i->lastln - obj->domain.i->line1) < ignlns ){ *mm = 0; return( WLZ_ERR_NONE ); } if( maxNumObjs < 1 ){ *mm = 0; return( WLZ_ERR_INT_DATA ); } objlist[0] = WlzAssignObject( WlzMakeMain(obj->type, obj->domain, obj->values, NULL, NULL, &errNum), NULL); *mm = 1; return WLZ_ERR_NONE; default: *mm = 0; return WLZ_ERR_DOMAIN_TYPE; } break; case WLZ_3D_DOMAINOBJ: if( obj->domain.core == NULL ){ *mm = 0; return WLZ_ERR_DOMAIN_NULL; } return WlzLabel3d(obj, mm, objlist, maxNumObjs, ignlns, connect); case WLZ_EMPTY_OBJ: *mm = 0; return WLZ_ERR_NONE; case WLZ_TRANS_OBJ: /* should be able to do this quite easily */ default: *mm = 0; return WLZ_ERR_OBJECT_TYPE; } /* check connectivity parameter */ switch( connect ){ default: return WLZ_ERR_INT_DATA; case WLZ_8_CONNECTED: jdqt = 0; break; case WLZ_4_CONNECTED: jdqt = 1; break; } /* * Allocate and initialise the working spaces. * * The chain store size is not easily predictable. * Here we use ((twice the number of lines) plus (one third the * number of intervals)), very much smaller than the * previous allocation, but apparently adequate to * segment both metaphase spreads and single connected objects. * In any case, this version of label can if necessary allocate * more space when the original chain store fills up. */ chainlistsize = mintcount(obj->domain.i, &maxinline) / 3; chainlistsize += (1 + obj->domain.i->lastln - obj->domain.i->line1)*2; if( (freechain = chainalloc(0,chainlistsize)) == NULL ){ *mm = 0; return WLZ_ERR_MEM_ALLOC; } buckle(freechain, freechain, chainlistsize); /* * The allocation list size is determined as twice * (1 + maximum number of intervals in a line of input object). */ if( (al = (WlzLAllocBuf *) AlcCalloc(2 * (maxinline+1), sizeof(WlzLAllocBuf))) == NULL ){ chainFree(); *mm = 0; return WLZ_ERR_MEM_ALLOC; } jvp = obj->values.v; /* initialise interval scanning */ WlzInitRasterScan (obj, &iwsp, WLZ_RASTERDIR_ILIC); line = iwsp.linpos; ended = 0 ; lend = 0 ; WlzNextInterval(&iwsp); crntst = al + 1 + maxinline; nob = 0 ; prlast = al ; precst = al + 1 ; /* commence new line */ while (!ended) { crntal = crntst-1 ; line++; if (lend) { ended = 1 ; lend = 0 ; } else { /* read the intervals into the allocation buffer */ while (iwsp.linpos <= line) { crntal++; crntal->a_int.ileft = iwsp.lftpos; crntal->a_int.iright = iwsp.rgtpos; if (WlzNextInterval(&iwsp) != 0) { lend = 1 ; break ; } } } crlast = crntal ; crntal = crntst ; precal = precst ; alloc = NULL ; /* test whether last interval in current line dealt with */ while (crntal <= crlast) { lftcrn = crntal->a_int.ileft ; jrtcrn = crntal->a_int.iright ; rtcrn = jrtcrn+2 ; alprec = precal->a_link; lftprc = precal->a_int.ileft ; rtprec = precal->a_int.iright +2 ; /* test whether last interval in preceeding line dealt with */ if (precal > prlast || rtcrn <= lftprc + jdqt) { /* is interval in current line already allocated */ if (!alloc) { /* start a new object and allocate this interval to it */ /* interval list */ link1 = newchain2(freechain,lftcrn,jrtcrn); /* line-of-intervals list */ link2 = newchain1(freechain, (unsigned long) link1); /* "object" -- first line, last line, line-of-intervals pointer */ crntal->a_link = newchain1(freechain,line) ; crntal->a_link = addlink1 (freechain, crntal->a_link, (unsigned long)line); crntal->a_link = addlink1 (freechain, crntal->a_link, (unsigned long) link2); } /* move on to next interval in current line */ crntal++ ; alloc = NULL; } else { if (rtprec > lftcrn+ (int )jdqt) { /* case of overlapping intervals: */ /* is intvl in current line already allocated ? */ if (!alloc) { /* allocate this interval and add to object list */ alloc = alprec ; link1 = alloc->l_link ; crntal->a_link = alloc ; /* test whether this line has already been started for this object */ if (link1->l_u.line != line) { /* update last line */ link1->l_u.line = line; /* add a link to the line list for this line */ link1 = newchain2(freechain,lftcrn,jrtcrn); alloc->l_u.u_link = addlink1 (freechain, alloc->l_u.u_link, (unsigned long) link1); } else { /* add interval to interval list for last line */ link1 = alloc->l_u.u_link; link1->l_u.u_link = addlink2 (freechain, link1->l_u.u_link, lftcrn, jrtcrn); } } else { /* merge lists and reallocate intervals */ /* test whether both already allocated to same object */ if (alprec != alloc) { merge (&alprec, &alloc, freechain); /* reallocate intervals in preceding line */ for (altemp = precst; altemp <= prlast; altemp++) { if (altemp->a_link == alloc) { altemp->a_link = alprec ; } } /* reallocate intervals in current line */ for (altemp = crntst; altemp <= crntal; altemp++) { if (altemp->a_link == alloc) { altemp->a_link = alprec ; } } alloc = alprec ; } } if (rtcrn < rtprec) { /* move to next interval in this line */ crntal++; alloc = NULL ; continue; /* the outer while loop */ } } /* move on to next interval in preceding line */ precal++ ; } } /* all intervals in current line dealt with: */ /* find and construct any finished objects */ if (precst <= prlast) { for (precal = precst; precal <= prlast; precal++) { alprec = precal->a_link ; /* has the object to which this interval was allocated been dealt with */ if (alprec) { /* remove any later intervals allocated to the same object */ for (altemp = precal; altemp <= prlast; altemp++) { if (altemp->a_link == alprec) { altemp->a_link = NULL ; } } /* test if this object has intervals in the current line */ /* and if so skip to end of outer loop */ if (crntst <= crlast) { for (altemp = crntst; altemp <= crlast; altemp++) { if (altemp->a_link == alprec) goto loopend; } } /* construct object - first find line and column bounds */ link1 = alprec->l_link; oll = (int) link1->l_u.line; link1 = link1->l_link; ofl = (int) link1->l_u.line; link1 = alprec->l_u.u_link; mkl = 0; /* Just to keep lint happy. */ mxkl = 0; /* Just to keep lint happy. */ nints = 0; for (jjj=ofl; jjj<=oll; jjj++) { link1 = link1->l_link; link2 = link1->l_u.u_link; do { link2 = link2->l_link; jl = link2->l_u.intv.ileft; jr = link2->l_u.intv.iright; if (nints == 0 || jl < mkl) mkl = jl ; if (nints == 0 || jr > mxkl) mxkl = jr ; nints++; /* test for end of line */ } while (link2 != link1->l_u.u_link); } /* test whether object large enough, if not ignore it */ /* test for height or width less than threshold */ if (oll-ofl < ignlns || mxkl-mkl < ignlns) { for (jjj = ofl; jjj <= oll; jjj++) { link1 = link1->l_link; link2 = link1->l_u.u_link; /* recover chain space */ join (freechain, link2) ; } } else { /* test for object array overflow */ if (nob >= maxNumObjs) { AlcFree((void *) al); chainFree(); *mm = nob; return(WLZ_ERR_INT_DATA); } link1 = alprec->l_u.u_link; /* set up domain and object, and update counts need to test successful space allocation here */ jdp = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, ofl,oll,mkl,mxkl, &errNum); domain.i = jdp; values.v = jvp; *objlist = WlzAssignObject( WlzMakeMain(WLZ_2D_DOMAINOBJ, domain,values,NULL,obj,&errNum), NULL); objlist++; nob++; /* get the size correct here !!! */ itvl = (WlzInterval *) AlcMalloc (nints * sizeof(WlzInterval)); jdp->freeptr = AlcFreeStackPush(jdp->freeptr, (void *)itvl, NULL); /* write intervals and interval pointers lists */ for (jjj=ofl; jjj<=oll; jjj++) { jtvl = itvl; nints = 0; link1 = link1->l_link; link2 = link1->l_u.u_link; do { /* * the following increment since the interval * list is circular, monotone increasing, * but link2 originally points at the * rightmost interval (see comment at top). */ link2 = link2->l_link; itvl->ileft = link2->l_u.intv.ileft - mkl; itvl->iright = link2->l_u.intv.iright - mkl; itvl++; nints++; /* test for end of line */ } while (link2 != link1->l_u.u_link); WlzMakeInterval(jjj,jdp,nints,jtvl); join (freechain, link2) ; } } /* return line list etc to free-list store */ join (freechain, alprec->l_u.u_link); join (freechain, alprec) ; } loopend: ; } } /* update pointers - swap the two halves of the allocation list */ /* before getting the intervals in the next line */ altemp = crntst ; crntst = precst ; precst = altemp ; prlast = crlast ; } *mm = nob ; AlcFree((void *) al); chainFree(); return WLZ_ERR_NONE; }
/*! * \return Woolz object read from jpeg image. * \ingroup WlzExtFF * \brief Reads a jpeg image frm the given file stream and returns a * Woolz object. * \param fP Given file stream. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzEffReadObjJpeg( FILE *fP, WlzErrorNum *dstErr) { WlzObject *rtnObj=NULL; struct jpeg_decompress_struct cinfo; struct my_error_mgr jerr; JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ int width, height; /* int depth; */ int wlzDepth; WlzGreyType newpixtype; WlzPixelV bckgrnd; int i, rOff; WlzGreyP wlzData; WlzErrorNum errNum=WLZ_ERR_NONE; /* check input */ if( fP == NULL ){ errNum = WLZ_ERR_PARAM_NULL; } /* We set up the normal JPEG error routines, then override error_exit. */ if( errNum == WLZ_ERR_NONE ){ cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp(jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress(&cinfo); if( rtnObj ){ WlzFreeObj(rtnObj); rtnObj = NULL; } errNum = WLZ_ERR_READ_INCOMPLETE; } } if( errNum == WLZ_ERR_NONE ){ /* initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* specify data source (eg, a file) */ jpeg_stdio_src(&cinfo, fP); /* read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* default set parameters for decompression */ (void) jpeg_start_decompress(&cinfo); /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; /* Make a one-row-high sample array that will go away when done with image */ buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); /* create the appropriate woolz object, read scanlines and copy data */ switch( cinfo.jpeg_color_space ){ default: case JCS_UNKNOWN: errNum = WLZ_ERR_READ_INCOMPLETE; break; case JCS_GRAYSCALE: bckgrnd.type = WLZ_GREY_UBYTE; #if BITS_IN_JSAMPLE == 8 if( cinfo.data_precision != 8 ){ errNum = WLZ_ERR_FILE_FORMAT; } else { wlzDepth = sizeof(char); newpixtype = WLZ_GREY_UBYTE; /* depth = cinfo.num_components * 8; */ bckgrnd.v.ubv = 0; } #endif /* BITS_IN_SAMPLE == 8 */ #if BITS_IN_JSAMPLE == 12 if( cinfo.data_precision != 12 ){ errNum = WLZ_ERR_FILE_FORMAT; } else { wlzDepth = sizeof(short); newpixtype = WLZ_GREY_SHORT; /* depth = cinfo.num_components * 12; */ bckgrnd.v.shv = 0; } #endif /* BITS_IN_SAMPLE == 12 */ break; case JCS_YCbCr: case JCS_CMYK: case JCS_YCCK: case JCS_RGB: bckgrnd.type = WLZ_GREY_RGBA; cinfo.out_color_space = JCS_RGB; #if BITS_IN_JSAMPLE == 8 if( cinfo.data_precision != 8 ){ errNum = WLZ_ERR_FILE_FORMAT; } else { wlzDepth = sizeof(int); newpixtype = WLZ_GREY_RGBA; /* depth = cinfo.num_components * 8; */ bckgrnd.v.inv = 0; } #endif /* BITS_IN_SAMPLE == 8 */ #if BITS_IN_JSAMPLE == 12 errNum = WLZ_ERR_UNIMPLEMENTED; #endif /* BITS_IN_SAMPLE == 8 */ break; } if( errNum == WLZ_ERR_NONE ){ /* make the woolz object */ width = cinfo.image_width; height = cinfo.image_height; if((wlzData.ubp = (WlzUByte *)AlcCalloc(width*height, wlzDepth)) != NULL){ if((rtnObj = WlzMakeRect(0, height-1, 0, width-1, newpixtype, wlzData.inp, bckgrnd, NULL, NULL, &errNum)) != NULL){ AlcErrno errAlcNum; rtnObj->values.r->freeptr = AlcFreeStackPush(rtnObj->values.r->freeptr, (void *) wlzData.ubp, &errAlcNum); if( errAlcNum != ALC_ER_NONE ){ errNum = WLZ_ERR_MEM_ALLOC; } } else{ AlcFree((void *) wlzData.ubp); } } else { errNum = WLZ_ERR_MEM_ALLOC; } } } /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. * scan object copying in scanline values */ if( errNum == WLZ_ERR_NONE ){ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ (void) jpeg_read_scanlines(&cinfo, buffer, 1); /* copy to the woolz object buffer */ switch( newpixtype ){ case WLZ_GREY_UBYTE: memcpy((void *) wlzData.ubp, (const void *) buffer[0], sizeof(char) * width); wlzData.ubp += width; break; case WLZ_GREY_SHORT: memcpy((void *) wlzData.shp, (const void *) buffer[0], sizeof(short) * width); wlzData.shp += width; break; case WLZ_GREY_RGBA: /* this we need to decode */ rOff = 0; for(i=0; i < width; i++, wlzData.rgbp++, rOff += 3){ WLZ_RGBA_RGBA_SET(*wlzData.rgbp, buffer[0][rOff], buffer[0][rOff+1], buffer[0][rOff+2], 255); } break; default: break; } } /* Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* Release JPEG decompression object */ jpeg_destroy_decompress(&cinfo); } if( dstErr ){ *dstErr = errNum; } return rtnObj; }
/*! * \ingroup WlzAllocation * \brief Make in interval values table to match the input object The table will have linkcount set to zero. * * \return New interval values table. * \param type Required table type. * \param obj Input object. * \param bckgrnd Values table background value. * \param dstErr Error return. * \par Constraints The woolz object type must resolve to WLZ_GREY_TAB_INTL using WlzGreyTableTypeToTableType()or an error will be reported and NULL returned. For historical reasons the type encodes the table type as well as the grey-value type. * \par Source: * WlzMakeIntervalValues.c */ WlzIntervalValues * WlzMakeIntervalValues(WlzObjectType type, WlzObject *obj, WlzPixelV bckgrnd, WlzErrorNum *dstErr) { WlzValues v; WlzValueIntervalLine *vil; WlzValueLine *val; WlzGreyP g; WlzIntervalWSpace iwsp; WlzIntervalDomain *idom; WlzErrorNum errNum=WLZ_ERR_NONE; /* check the values table type */ v.i = NULL; (void) WlzGreyTableTypeToTableType(type, &errNum); if( errNum == WLZ_ERR_NONE ){ (void) WlzGreyTableTypeToGreyType(type, &errNum); } /* check the object */ if( (errNum == WLZ_ERR_NONE) && (obj == NULL) ){ errNum = WLZ_ERR_OBJECT_NULL; } if( errNum == WLZ_ERR_NONE ){ switch( obj->type ){ case WLZ_2D_DOMAINOBJ: if( obj->domain.core == NULL ){ errNum = WLZ_ERR_DOMAIN_NULL; break; } idom = obj->domain.i; break; case WLZ_EMPTY_OBJ: default: errNum = WLZ_ERR_DOMAIN_TYPE; break; } } /* * allocate space for basic, per line and per interval structures */ if((errNum == WLZ_ERR_NONE) && ((v.i = (WlzIntervalValues *) AlcCalloc(sizeof(WlzIntervalValues) + (idom->lastln - idom->line1 + 1) * sizeof(WlzValueIntervalLine) + WlzIntervalCount(idom, NULL) * sizeof(WlzValueLine), 1)) == NULL) ){ errNum = WLZ_ERR_MEM_ALLOC; } if( errNum == WLZ_ERR_NONE ){ vil = (WlzValueIntervalLine *) (v.i + 1); val = (WlzValueLine *) (vil + idom->lastln - idom->line1 + 1); v.i->bckgrnd = bckgrnd; switch( WlzGreyTableTypeToGreyType(type, NULL) ){ case WLZ_GREY_INT: g.inp = (int *) AlcCalloc(WlzArea(obj, NULL), sizeof(int)); break; case WLZ_GREY_SHORT: g.shp = (short *) AlcCalloc(WlzArea(obj, NULL), sizeof(short)); break; case WLZ_GREY_UBYTE: g.ubp = (WlzUByte *) AlcCalloc(WlzArea(obj, NULL), sizeof(WlzUByte)); break; case WLZ_GREY_FLOAT: g.flp = (float *) AlcCalloc(WlzArea(obj, NULL), sizeof(float)); break; case WLZ_GREY_DOUBLE: g.dbp = (double *) AlcCalloc(WlzArea(obj, NULL), sizeof(double)); break; case WLZ_GREY_RGBA: g.rgbp = (WlzUInt *) AlcCalloc(WlzArea(obj, NULL), sizeof(WlzUInt)); break; default: WlzFreeValues( v ); v.i = NULL; errNum = WLZ_ERR_GREY_TYPE; break; } } if( (errNum == WLZ_ERR_NONE) && (g.inp == NULL) ){ WlzFreeValues( v ); v.i = NULL; errNum = WLZ_ERR_MEM_ALLOC; } /* * fill in structure values and initialise scanning */ if( errNum == WLZ_ERR_NONE ){ v.i->type = type; v.i->freeptr = AlcFreeStackPush(v.i->freeptr, (void *)g.inp, NULL); v.i->line1 = idom->line1; v.i->lastln = idom->lastln; v.i->kol1 = idom->kol1; v.i->width = idom->lastkl - idom->kol1 + 1; v.i->vil = vil; v.i->linkcount = 0; v.i->original_table.core = NULL; vil--; if((errNum = WlzInitRasterScan(obj, &iwsp, WLZ_RASTERDIR_ILIC)) != WLZ_ERR_NONE ){ WlzFreeValues( v ); v.i = NULL; } } /* * fill in the line and interval structures, note grey-type already checked. */ if( errNum == WLZ_ERR_NONE ){ while((errNum == WLZ_ERR_NONE) && (errNum = WlzNextInterval(&iwsp)) == WLZ_ERR_NONE){ if (iwsp.nwlpos != 0) { vil += iwsp.nwlpos; vil->vtbint = val; } vil->nintvs++; val->vkol1 = iwsp.lftpos - v.i->kol1; val->vlastkl = iwsp.rgtpos - v.i->kol1; switch( WlzGreyTableTypeToGreyType(type, NULL) ){ case WLZ_GREY_INT: val->values.inp = g.inp; g.inp += iwsp.colrmn; break; case WLZ_GREY_SHORT: val->values.shp = g.shp; g.shp += iwsp.colrmn; break; case WLZ_GREY_UBYTE: val->values.ubp = g.ubp; g.ubp += iwsp.colrmn; break; case WLZ_GREY_FLOAT: val->values.flp = g.flp; g.flp += iwsp.colrmn; break; case WLZ_GREY_DOUBLE: val->values.dbp = g.dbp; g.dbp += iwsp.colrmn; break; case WLZ_GREY_RGBA: val->values.rgbp = g.rgbp; g.rgbp += iwsp.colrmn; break; default: errNum = WLZ_ERR_GREY_TYPE; break; } val++; } switch( errNum ){ case WLZ_ERR_NONE: case WLZ_ERR_EOO: errNum = WLZ_ERR_NONE; break; default: WlzFreeValues( v ); v.i = NULL; break; } } if( dstErr ){ *dstErr = errNum; } return(v.i); }
/*! * \return Rescaled object. * \ingroup WlzTransform * \brief Rescales the given 2D domain object using an integer scale. * \param obj Given object. * \param scale Integer scale factor. * \param expand If zero use \f$\frac{1}{scale}\f$. * \param dstErr Destination error pointer, may be NULL. */ static WlzObject *WlzIntRescaleObj2D( WlzObject *obj, int scale, int expand, WlzErrorNum *dstErr) { WlzObject *rtnObj=NULL; WlzDomain domain; WlzValues values; WlzInterval *intvls; int k1, kl, l1, ll, l, num_intvls; WlzErrorNum errNum=WLZ_ERR_NONE; /* check expand or contract */ if( expand ) { k1 = obj->domain.i->kol1 * scale; kl = obj->domain.i->lastkl * scale + scale - 1; l1 = obj->domain.i->line1 * scale; ll = obj->domain.i->lastln * scale + scale - 1; } else { k1 = obj->domain.i->kol1 / scale; kl = obj->domain.i->lastkl / scale; l1 = obj->domain.i->line1 / scale; ll = obj->domain.i->lastln / scale; } /* create a new object */ if((domain.i = WlzMakeIntervalDomain(obj->domain.i->type, l1, ll, k1, kl, &errNum)) != NULL){ values.core = NULL; rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values, NULL, NULL, NULL); } /* fill in the intervals */ if( errNum == WLZ_ERR_NONE){ if( domain.i->type == WLZ_INTERVALDOMAIN_INTVL ) { int intvline_offset, max_offset; WlzIntervalLine *intvline; num_intvls = WlzIntervalCount(obj->domain.i, NULL); num_intvls = expand ? num_intvls * scale : num_intvls; intvls = (WlzInterval *)AlcMalloc(sizeof(WlzInterval) * num_intvls); domain.i->freeptr = AlcFreeStackPush(domain.i->freeptr, (void *)intvls, NULL); max_offset = obj->domain.i->lastln - obj->domain.i->line1; for(l=l1; l <= ll; l++) { int i; intvline_offset = (expand?l/scale:l*scale) - obj->domain.i->line1; intvline_offset = WLZ_MAX(intvline_offset, 0); intvline_offset = WLZ_MIN(intvline_offset, max_offset); intvline = obj->domain.i->intvlines + intvline_offset; for(i=0; i < intvline->nintvs; i++) { intvls[i].ileft = (intvline->intvs + i)->ileft; intvls[i].iright = (intvline->intvs + i)->iright; if( expand ) { intvls[i].ileft *= scale; intvls[i].iright *= scale; intvls[i].iright += scale - 1; } else { intvls[i].ileft /= scale; intvls[i].iright /= scale; } } i = check_intvs(intvls, i); WlzMakeInterval(l, domain.i, i, intvls); intvls += i; } (void) WlzStandardIntervalDomain( domain.i ); } } /* create the valuetable */ if( (errNum == WLZ_ERR_NONE) && obj->values.core ) { WlzIntervalWSpace iwsp; WlzGreyWSpace gwsp; WlzPixelV backgrnd; WlzGreyValueWSpace *gVWSp = NULL; WlzGreyType gtype; backgrnd = WlzGetBackground(obj, NULL); if((values.v = WlzNewValueTb(rtnObj, obj->values.v->type, backgrnd, &errNum)) != NULL){ rtnObj->values = WlzAssignValues(values, NULL); /* fill in the grey-values */ errNum = WlzInitGreyScan(rtnObj, &iwsp, &gwsp); if(errNum == WLZ_ERR_NONE) { gVWSp = WlzGreyValueMakeWSp(obj, &errNum); if(errNum == WLZ_ERR_NONE) { gtype = WlzGreyTableTypeToGreyType(obj->values.v->type, NULL); } while((errNum == WLZ_ERR_NONE) && (errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE) { int k; int lp = expand ? iwsp.linpos/scale : iwsp.linpos*scale; for( k=0; k <= (iwsp.rgtpos - iwsp.lftpos); k++ ) { int kp = expand ? (k+iwsp.lftpos)/scale : (k+iwsp.lftpos)*scale; WlzGreyValueGet(gVWSp, 0, (double) lp, (double) kp); switch(gtype) { case WLZ_GREY_INT: gwsp.u_grintptr.inp[k] = (*(gVWSp->gVal)).inv; break; case WLZ_GREY_SHORT: gwsp.u_grintptr.shp[k] = (*(gVWSp->gVal)).shv; break; case WLZ_GREY_UBYTE: gwsp.u_grintptr.ubp[k] = (*(gVWSp->gVal)).ubv; break; case WLZ_GREY_FLOAT: gwsp.u_grintptr.flp[k] = (*(gVWSp->gVal)).flv; break; case WLZ_GREY_DOUBLE: gwsp.u_grintptr.dbp[k] = (*(gVWSp->gVal)).dbv; break; case WLZ_GREY_RGBA: gwsp.u_grintptr.rgbp[k] = (*(gVWSp->gVal)).rgbv; break; default: errNum = WLZ_ERR_GREY_TYPE; break; } } } if( errNum == WLZ_ERR_EOO ){ errNum = WLZ_ERR_NONE; } WlzGreyValueFreeWSp(gVWSp); (void )WlzEndGreyScan(&iwsp, &gwsp); } } } if( dstErr ){ *dstErr = errNum; } return rtnObj; }
/*! * \return Transformed object. * \ingroup WlzTransform * \brief Transform an object using the given view-transform. * Typically this is for mapping section data back into * the 3D space of the reference image/reconstruction. * \param srcObj Given source object. * \param viewStr Given view transform. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *Wlz3DViewTransformObj( WlzObject *srcObj, WlzThreeDViewStruct *viewStr, WlzErrorNum *dstErr) { WlzErrorNum errNum=WLZ_ERR_NONE; AlcErrno alcErr = ALC_ER_NONE; WlzObject *dstObj=NULL; int area; int i, k, p, xp, yp, line; int plane1, lastpl, line1, lastln, kol1, lastkl; WlzIVertex3 *vertices; int numVtxs, vtxIdx; WlzIntervalWSpace iwsp; WlzGreyWSpace gwsp; WlzDomain domain, tmpDomain; WlzValues values; int numInts, itvlFlg; WlzInterval *itvl; /* check the object */ if( srcObj == NULL ) { errNum = WLZ_ERR_OBJECT_NULL; } else { switch( srcObj->type ) { case WLZ_2D_DOMAINOBJ: if( srcObj->domain.core == NULL ) { errNum = WLZ_ERR_DOMAIN_NULL; } area = WlzArea(srcObj, &errNum); if( area == 0 ) { dstObj = WlzMakeEmpty(&errNum); } break; case WLZ_2D_POLYGON: /* to be done at some time to 3D polyline */ case WLZ_BOUNDLIST: /* convert to 3D polylines */ case WLZ_TRANS_OBJ: errNum = WLZ_ERR_OBJECT_TYPE; break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* create the voxel list */ if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) { numVtxs = sizeof(WlzIVertex3) * (area+4); vertices = AlcMalloc(sizeof(WlzIVertex3) * (area+4)); numVtxs = 0; if( vertices ) { errNum = WlzInitRasterScan(srcObj, &iwsp, WLZ_RASTERDIR_ILIC); } else { errNum = WLZ_ERR_MEM_ALLOC; } if( errNum == WLZ_ERR_NONE ) { while( (errNum = WlzNextInterval(&iwsp)) == WLZ_ERR_NONE ) { float x, y, z; if((iwsp.linpos < (int) viewStr->minvals.vtY) || (iwsp.linpos > (int) viewStr->maxvals.vtY)) { continue; } yp = iwsp.linpos - (int) viewStr->minvals.vtY; for(k=iwsp.lftpos; k <= iwsp.rgtpos; k++) { if((k < (int) viewStr->minvals.vtX) || (k > (int) viewStr->maxvals.vtX)) { continue; } xp = k - (int) viewStr->minvals.vtX; x = (float )(viewStr->xp_to_x[xp] + viewStr->yp_to_x[yp]); y = (float )(viewStr->xp_to_y[xp] + viewStr->yp_to_y[yp]); z = (float )(viewStr->xp_to_z[xp] + viewStr->yp_to_z[yp]); vertices[numVtxs].vtX = WLZ_NINT(x); vertices[numVtxs].vtY = WLZ_NINT(y); vertices[numVtxs].vtZ = WLZ_NINT(z); numVtxs++; } } if(errNum == WLZ_ERR_EOO) /* Reset error from end of object */ { errNum = WLZ_ERR_NONE; } } } /* sort wrt planes, lines, kols */ if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) { qsort((void *) vertices, (size_t) numVtxs, sizeof(WlzIVertex3), compareVtxVal); /* create planedomain */ plane1 = vertices[0].vtZ; lastpl = vertices[numVtxs - 1].vtZ; line1 = vertices[0].vtY; lastln = line1; kol1 = vertices[0].vtX; lastkl = kol1; for(i=1; i < numVtxs; i++) { if( kol1 > vertices[i].vtX ) { kol1 = vertices[i].vtX; } if( lastkl < vertices[i].vtX ) { lastkl = vertices[i].vtX; } if( line1 > vertices[i].vtY ) { line1 = vertices[i].vtY; } if( lastln < vertices[i].vtY ) { lastln = vertices[i].vtY; } } if( (domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, plane1, lastpl, line1, lastln, kol1, lastkl, &errNum)) == NULL ) { AlcFree((void *) vertices); } } /* for each plane count intervals and make domain */ if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) { vtxIdx = 0; for(p=plane1; p <= lastpl; p++) { /* increment vertex index to current plane */ while( vertices[vtxIdx].vtZ < p ) { vtxIdx++; } /* check for empty domain */ if( vertices[vtxIdx].vtZ > p ) { domain.p->domains[p - plane1].i = NULL; continue; } /* estimate intervals - foreach pixel add one, foreach adjacent pixel on the same line subtract one */ numInts = 1; kol1 = vertices[vtxIdx].vtX; lastkl = kol1; for(i=vtxIdx+1; i < numVtxs; i++) { if( vertices[i].vtZ > p ) { break; } numInts++; if((vertices[i].vtY == vertices[i-1].vtY) && ((vertices[i].vtX == (vertices[i-1].vtX)) || (vertices[i].vtX == (vertices[i-1].vtX + 1)) )) { numInts--; } if(kol1 > vertices[i].vtX) { kol1 = vertices[i].vtX; } if(lastkl < vertices[i].vtX) { lastkl = vertices[i].vtX; } } line1 = vertices[vtxIdx].vtY; lastln = vertices[i-1].vtY; /* make the domain and add the intervals pointer */ tmpDomain.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, line1, lastln, kol1, lastkl, &errNum); itvl = (WlzInterval *) AlcMalloc(sizeof(WlzInterval)*numInts); tmpDomain.i->freeptr = AlcFreeStackPush(tmpDomain.i->freeptr, (void *) itvl, &alcErr); if(alcErr != ALC_ER_NONE) { errNum = WLZ_ERR_MEM_ALLOC; } /* one more loop to add the intervals */ itvl->ileft = vertices[vtxIdx].vtX - kol1; line = vertices[vtxIdx].vtY; itvlFlg = 1; /* interval started */ numInts = 1; for(i=vtxIdx+1; i < numVtxs; i++) { /* new plane -> interval finished if started */ if( vertices[i].vtZ > p ) { if( itvlFlg ) { itvl[numInts-1].iright = vertices[i-1].vtX - kol1; WlzMakeInterval(line, tmpDomain.i, numInts, itvl); itvl += numInts; itvlFlg = 0; /* interval finished */ numInts = 0; } break; } /* check if new interval */ if( !itvlFlg ) { itvl->ileft = vertices[i].vtX - kol1; line = vertices[i].vtY; itvlFlg = 1; numInts = 1; continue; /* no further tests */ } /* check for gap - increment interval count */ if((vertices[i].vtY == line) && ((vertices[i].vtX - vertices[i-1].vtX) > 1)) { itvl[numInts-1].iright = vertices[i-1].vtX - kol1; numInts++; itvl[numInts-1].ileft = vertices[i].vtX - kol1; itvlFlg = 1; } /* check for new-line */ if( line < vertices[i].vtY ) { itvl[numInts-1].iright = vertices[i-1].vtX - kol1; WlzMakeInterval(line, tmpDomain.i, numInts, itvl); itvl += numInts; itvl->ileft = vertices[i].vtX - kol1; line = vertices[i].vtY; itvlFlg = 1; numInts = 1; } } /* complete the last interval */ if( itvlFlg ) { itvl[numInts-1].iright = vertices[i-1].vtX - kol1; WlzMakeInterval(line, tmpDomain.i, numInts, itvl); itvl += numInts; } /* add the domain to the planedomain */ domain.p->domains[p - plane1] = WlzAssignDomain(tmpDomain, &errNum); (void) WlzIntervalCount(tmpDomain.i, 0); } } /* create the new object */ if( (errNum == WLZ_ERR_NONE) && (dstObj == NULL) ) { values.core = NULL; dstObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } /* check for grey-level data */ if((errNum == WLZ_ERR_NONE) && dstObj && (dstObj->type != WLZ_EMPTY_OBJ) && srcObj->values.core ) { WlzPixelV bckgrnd; WlzObject *tmpObj; WlzValues tmpValues; WlzDVertex3 vtx; WlzGreyValueWSpace *gVWSp = NULL; WlzObjectType valueTbType; /* explicit intialisation to satisfy strict ANSI on SGI */ bckgrnd = WlzGetBackground(srcObj, &errNum); valueTbType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, bckgrnd.type, NULL); /* make a voxel table */ values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, plane1, lastpl, bckgrnd, NULL, &errNum); dstObj->values = WlzAssignValues(values, &errNum); /* set up grey-value random access to original and loop through planes setting values */ gVWSp = WlzGreyValueMakeWSp(srcObj, NULL); for(p=plane1; p <= lastpl; p++) { /* check for empty domain */ if( domain.p->domains[p-plane1].core == NULL ) { continue; } /* make a value table */ tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain.p->domains[p-plane1], values.vox->values[p-plane1], NULL, NULL, &errNum); tmpValues.v = WlzNewValueTb(tmpObj, valueTbType, bckgrnd, &errNum); values.vox->values[p-plane1] = WlzAssignValues(tmpValues, &errNum); tmpObj->values = WlzAssignValues(tmpValues, &errNum); /* transfer values */ errNum = WlzInitGreyScan(tmpObj, &iwsp, &gwsp); while((errNum == WLZ_ERR_NONE) && ((errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE)) { for(i=0; i<iwsp.colrmn; i++) { vtx.vtX = iwsp.colpos + i; vtx.vtY = iwsp.linpos; vtx.vtZ = p; Wlz3DSectionTransformVtx(&vtx, viewStr); WlzGreyValueGet(gVWSp, 0.0, WLZ_NINT(vtx.vtY), WLZ_NINT(vtx.vtX)); switch( gwsp.pixeltype ) { case WLZ_GREY_LONG: *(gwsp.u_grintptr.lnp+i) = gVWSp->gVal[0].lnv; break; case WLZ_GREY_INT: *(gwsp.u_grintptr.inp+i) = gVWSp->gVal[0].inv; break; case WLZ_GREY_SHORT: *(gwsp.u_grintptr.shp+i) = gVWSp->gVal[0].shv; break; case WLZ_GREY_UBYTE: *(gwsp.u_grintptr.ubp+i) = gVWSp->gVal[0].ubv; break; case WLZ_GREY_FLOAT: *(gwsp.u_grintptr.flp+i) = gVWSp->gVal[0].flv; break; case WLZ_GREY_DOUBLE: *(gwsp.u_grintptr.dbp+i) = gVWSp->gVal[0].dbv; break; case WLZ_GREY_RGBA: *(gwsp.u_grintptr.rgbp+i) = gVWSp->gVal[0].rgbv; break; case WLZ_GREY_BIT: /* not sure what to do with these */ default: break; } } } if(errNum == WLZ_ERR_EOO) /* Reset error from end of object */ { errNum = WLZ_ERR_NONE; } WlzFreeObj(tmpObj); } WlzGreyValueFreeWSp(gVWSp); } /* clean temp allocation */ if( vertices ) { AlcFree((void *) vertices); } if( dstErr ) { *dstErr = errNum; } return dstObj; }
/*! * \return Object with domain equal to the set difference between the * first and second object, with valuetable from the first * object. * \ingroup WlzDomainOps * \brief Calculates the domain difference between two objects. * \param obj1 First object. * \param obj2 Second object. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzDiffDomain( WlzObject *obj1, WlzObject *obj2, WlzErrorNum *dstErr) { WlzIntervalWSpace iwsp2, iwsp1; WlzInterval *intp; WlzInterval *jntp; WlzDomain diffdom; WlzValues values; WlzIntervalDomain *idom1; int k1, dfinished, intervalcount; WlzObject *diff=NULL; WlzErrorNum errNum=WLZ_ERR_NONE; diffdom.core = NULL; /* check object 1 */ if( obj1 == NULL ){ errNum = WLZ_ERR_OBJECT_NULL; } if( errNum == WLZ_ERR_NONE ){ switch( obj1->type ){ case WLZ_2D_DOMAINOBJ: case WLZ_3D_DOMAINOBJ: if( obj1->domain.core == NULL ){ errNum = WLZ_ERR_DOMAIN_NULL; } break; case WLZ_EMPTY_OBJ: diffdom.i = NULL; values.v = NULL; return WlzMakeMain(WLZ_EMPTY_OBJ, diffdom, values, NULL, NULL, dstErr); default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* check object 2 - obj2 == NULL is now an error */ if( (errNum == WLZ_ERR_NONE) && (obj2 == NULL) ){ errNum = WLZ_ERR_OBJECT_NULL; } if( errNum == WLZ_ERR_NONE ){ switch( obj2->type ){ case WLZ_2D_DOMAINOBJ: case WLZ_3D_DOMAINOBJ: if( obj2->type != obj1->type ){ errNum = WLZ_ERR_OBJECT_TYPE; break; } if( obj2->domain.core == NULL ){ errNum = WLZ_ERR_OBJECT_NULL; break; } break; case WLZ_EMPTY_OBJ: return WlzMakeMain(obj1->type, obj1->domain, obj1->values, NULL, NULL, dstErr); default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* switch for 3D objects */ if( (errNum == WLZ_ERR_NONE) && (obj1->type == WLZ_3D_DOMAINOBJ) ){ return WlzDiffDomain3d( obj1, obj2, dstErr ); } /* * make a new interval table that is big enough */ if( errNum == WLZ_ERR_NONE ){ idom1 = obj1->domain.i; k1 = idom1->kol1; if( (intp = (WlzInterval *) AlcCalloc(WlzIntervalCount(idom1, NULL) + WlzIntervalCount(obj2->domain.i, NULL), sizeof(WlzInterval))) == NULL ){ errNum = WLZ_ERR_MEM_ALLOC; } jntp = intp; } if( errNum == WLZ_ERR_NONE ){ if( (diffdom.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, idom1->line1, idom1->lastln, k1, idom1->lastkl, &errNum)) == NULL ){ AlcFree((void *) intp); } else { diffdom.i->freeptr = AlcFreeStackPush(diffdom.i->freeptr, (void *)intp, NULL); } } if( errNum == WLZ_ERR_NONE ){ if( (diff = WlzMakeMain(WLZ_2D_DOMAINOBJ, diffdom, obj1->values, NULL, NULL, &errNum)) == NULL ){ WlzFreeIntervalDomain(diffdom.i); } } /* * initialise interval scanning */ if( errNum == WLZ_ERR_NONE ){ errNum = WlzInitRasterScan(obj1, &iwsp1, WLZ_RASTERDIR_ILIC); } if( errNum == WLZ_ERR_NONE ){ errNum = WlzInitRasterScan(obj2, &iwsp2, WLZ_RASTERDIR_ILIC); dfinished = 0; intervalcount = 0; } /* * scan object constructing intervals after subtraction of obj2 */ if( (errNum == WLZ_ERR_NONE) && ((errNum = WlzNextInterval(&iwsp2)) == WLZ_ERR_NONE) ){ while( (errNum = WlzNextInterval(&iwsp1)) == WLZ_ERR_NONE ){ /* * case 1 - interval in obj1 succedes interval in obj2 - * get next interval of obj2 */ while( (errNum == WLZ_ERR_NONE) && (dfinished == 0) && (iwsp1.linpos > iwsp2.linpos || (iwsp1.linpos == iwsp2.linpos && iwsp1.lftpos > iwsp2.rgtpos))){ switch( errNum = WlzNextInterval(&iwsp2) ){ case WLZ_ERR_NONE: dfinished = 0; break; case WLZ_ERR_EOO: errNum = WLZ_ERR_NONE; dfinished = 1; break; default: break; } } if( errNum != WLZ_ERR_NONE ){ break; } /* * case 2 - interval in obj1 precedes interval in obj2 * or obj2 finished - just copy interval */ if( (dfinished != 0) || (iwsp1.linpos < iwsp2.linpos || ((iwsp1.linpos == iwsp2.linpos) && (iwsp1.rgtpos < iwsp2.lftpos)) ) ){ jntp->ileft = iwsp1.lftpos - k1; jntp->iright = iwsp1.rgtpos - k1; intervalcount++; jntp++; } /* * case 3 - intervals overlap. * there may be more than one obj2 interval. */ else { /* * test left end of obj1 interval < left * end of obj2 interval, when complete * interval can be constructed immediately */ if (iwsp2.lftpos > iwsp1.lftpos) { jntp->ileft = iwsp1.lftpos - k1; jntp->iright = iwsp2.lftpos -1 - k1; intervalcount++; jntp++; } do { /* * if right end of obj2 interval < * right end of obj1 interval can * plant left end of new interval */ if (iwsp2.rgtpos < iwsp1.rgtpos) { jntp->ileft = iwsp2.rgtpos +1 - k1; switch( errNum = WlzNextInterval(&iwsp2) ){ case WLZ_ERR_NONE: dfinished = 0; break; case WLZ_ERR_EOO: errNum = WLZ_ERR_NONE; dfinished = 1; break; default: break; } if( errNum != WLZ_ERR_NONE ){ break; } /* * check if next obj2 interval * still overlaps this obj1 interval */ if( (dfinished == 0) && (iwsp1.linpos == iwsp2.linpos) && (iwsp1.rgtpos >= iwsp2.lftpos)) jntp->iright = iwsp2.lftpos -1 -k1; else jntp->iright = iwsp1.rgtpos - k1; intervalcount++; jntp++; } } while( (dfinished == 0) && (iwsp1.linpos == iwsp2.linpos) && (iwsp1.rgtpos > iwsp2.rgtpos) ); } if( errNum != WLZ_ERR_NONE ){ break; } /* * is this obj1 interval the last in the line ? * if so, load up the new intervals into the * diff domain. */ if (iwsp1.intrmn == 0) { errNum = WlzMakeInterval(iwsp1.linpos, diffdom.i, intervalcount, intp); intervalcount = 0; intp = jntp; } if( errNum != WLZ_ERR_NONE ){ break; } } } if(errNum == WLZ_ERR_EOO) /* Reset error from end of intervals */ { errNum = WLZ_ERR_NONE; } /* this checks the area and returns NULL if zero in principle it should return an "empty object" */ if(errNum == WLZ_ERR_NONE) { if(WlzIntervalCount(diffdom.i, NULL) == 0){ WlzFreeObj(diff); diffdom.i = NULL; values.v = NULL; diff = WlzMakeEmpty(&errNum); } else { WlzStandardIntervalDomain(diff->domain.i); } } else { WlzFreeObj(diff); diff = NULL; } if( dstErr ){ *dstErr = errNum; } return diff; }
/*! * \return New Woolz interval domain or NULL on error. * \ingroup WlzTransform * \brief Creates a new 2D Woolz interval domain with a single line * which is the profile from the given start position to the * given end position for the given spatial domain object. * \param gObj Given Woolz object. * \param sPos Start position. * \param ePos End position. * \param dstErr Destination error pointer, may be NULL. */ WlzIntervalDomain *WlzProfileLineIDom( WlzObject *gObj, WlzIVertex3 sPos, WlzIVertex3 ePos, WlzErrorNum *dstErr) { WlzIntervalDomain *iDom = NULL; WlzErrorNum errNum = WLZ_ERR_NONE; /* Check given object. */ if(gObj == NULL) { errNum = WLZ_ERR_OBJECT_NULL; } else { switch(gObj->type) { case WLZ_2D_DOMAINOBJ: case WLZ_3D_DOMAINOBJ: if(gObj->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } if(errNum == WLZ_ERR_NONE) { int len; WlzIVertex3 dPos; WlzProfileWalkWSp pWSp = {0}; WlzInterval *rItv = NULL; WLZ_VTX_3_SUB(dPos, ePos, sPos); len = (int )ceil(WLZ_VTX_3_LENGTH(dPos)); /* Create return object. */ iDom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, 0, 0, 0, len - 1, &errNum); if(errNum == WLZ_ERR_NONE) { if((rItv = (WlzInterval *) AlcCalloc((len / 2) + 1, sizeof(WlzInterval))) == NULL) { errNum = WLZ_ERR_MEM_ALLOC; (void )WlzFreeIntervalDomain(iDom); iDom = NULL; } } if(errNum == WLZ_ERR_NONE) { WlzIntervalLine *itvLn; iDom->freeptr = AlcFreeStackPush(iDom->freeptr, (void *)rItv, NULL); pWSp.start = sPos; pWSp.end = ePos; pWSp.domain.i = iDom; itvLn = pWSp.domain.i->intvlines + 0; itvLn->intvs = rItv; itvLn->nintvs = 0; errNum = WlzProfileWalk(gObj, WlzProfileSetIDom, &pWSp); } } if(errNum != WLZ_ERR_NONE) { iDom = NULL; } if(dstErr) { *dstErr = errNum; } return(iDom); }
/*! * \ingroup WlzBinaryOps * \brief Calculate the set union of an array of domain objects. Domians only unless uvt non-zero in which case make an average grey table. Note background values are used in the averaging process. All objects must be domain objects of the same type (2D or 3D) unless WLZ_EMPTY_OBJ, NULL input objects are an error. This function may modify the order of the objects in the array it is passed if the array contains empty objects. * * \return Union of the array of object. * \param n number of input objects * \param objs input object array * \param uvt grey-table copy flag, copy if non-zero. * \param dstErr error return. * \par Source: * WlzUnionN.c */ WlzObject *WlzUnionN( int n, WlzObject **objs, int uvt, WlzErrorNum *dstErr) { WlzObject *obj=NULL; WlzDomain domain; WlzValues values; WlzIntervalDomain *idom; WlzInterval *itvl, *jtvl; WlzIntervalWSpace *iwsp; WlzIntervalWSpace *biwsp, *tiwsp, niwsp; WlzGreyWSpace *gwsp, ngwsp; WlzObjectType type; int i, j, k, l; int inttot, numactive, change, lwas, nints, noverlap; WlzPixelV backg; int line1, lastln; int kol1,lastkl; WlzGreyV gv; WlzGreyP greyptr; int **locbuff; int *locbuffs; int span; WlzErrorNum errNum=WLZ_ERR_NONE; /* preliminary stuff - count of non-NULL objects, note WLZ_EMPTY_OBJs are ignored but NULL objects are an error */ if( n < 1 ){ errNum = WLZ_ERR_PARAM_DATA; } else { for (i=0; i<n ; i++ ){ if ( objs[i] == NULL ){ errNum = WLZ_ERR_OBJECT_NULL; break; } if( objs[i]->type == WLZ_EMPTY_OBJ ){ obj = objs[i]; for ( j=i; j<n-1 ; j++ ){ objs[j] = objs[j+1]; } objs[n-1] = obj; n--; i--; } } } /* n has been checked therefore no objects implies all empty */ if( (errNum == WLZ_ERR_NONE) && (n < 1) ){ return WlzMakeEmpty(dstErr); } /* now check they are all of the same type */ if( errNum == WLZ_ERR_NONE ){ for(i=1; i < n; i++){ if( objs[i]->type != objs[0]->type ){ errNum = WLZ_ERR_OBJECT_TYPE; break; } } } /* now test the type note empty objects have been discarded */ if( errNum == WLZ_ERR_NONE ){ switch( objs[0]->type ){ case WLZ_2D_DOMAINOBJ: break; case WLZ_3D_DOMAINOBJ: return WlzUnion3d(n, objs, uvt, dstErr); case WLZ_TRANS_OBJ: default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* now discard empty objects */ if( errNum == WLZ_ERR_NONE ){ for (i=0; i<n ; i++ ){ if( WlzIsEmpty(objs[i], NULL) ){ obj = objs[i]; for ( j=i; j<n-1 ; j++ ){ objs[j] = objs[j+1]; } objs[n-1] = obj; n--; i--; } } } obj = NULL; /* recheck number of objects */ if( (errNum == WLZ_ERR_NONE) && (n < 1) ){ return WlzMakeEmpty(dstErr); } if( (errNum == WLZ_ERR_NONE) && (n == 1) ){ return WlzMakeMain(objs[0]->type, objs[0]->domain, objs[0]->values, NULL, NULL, dstErr); } /* check if grey-value merge is possible */ if( errNum == WLZ_ERR_NONE ){ for (i=0; i<n ; i++ ){ if( objs[i]->values.core == NULL ){ uvt = 0; break; } } } /* * find the line and column bounds of the union. */ if( errNum == WLZ_ERR_NONE ){ line1 = objs[0]->domain.i->line1; lastln = objs[0]->domain.i->lastln; kol1 = objs[0]->domain.i->kol1; lastkl = objs[0]->domain.i->lastkl; for (i=1; i<n; i++) { idom = objs[i]->domain.i; if (line1 > idom->line1) line1 = idom->line1; if (lastln < idom->lastln) lastln = idom->lastln; if (kol1 > idom->kol1) kol1 = idom->kol1; if (lastkl < idom->lastkl) lastkl = idom->lastkl; } span = lastkl - kol1 +1 ; if( (locbuff = (int **) AlcMalloc((n+1)*sizeof(int *))) == NULL ){ errNum = WLZ_ERR_MEM_ALLOC; } } /* space must be allocated for the largest variety of grey-value */ if( errNum == WLZ_ERR_NONE ){ if( (locbuffs = (int *) AlcMalloc(sizeof(double)*span*(n+1))) == NULL ){ AlcFree((void *) locbuff); errNum = WLZ_ERR_MEM_ALLOC; } else { for(i=0; i <= n; i++){ locbuff[i] = locbuffs + i*span; } } } /* * count the individual intervals so that sufficient space * for the union may be allocated. */ if( errNum == WLZ_ERR_NONE ){ inttot=0; for(i=0; i < n; i++){ inttot += WlzIntervalCount(objs[i]->domain.i, &errNum); } } /* * set up domain, value table structures, and object. */ if( errNum == WLZ_ERR_NONE ){ if( (idom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, line1,lastln,kol1,lastkl, &errNum)) == NULL ){ AlcFree((void *) locbuffs); AlcFree((void *) locbuff); } else if( (itvl = (WlzInterval *) AlcMalloc(inttot * sizeof(WlzInterval))) == NULL){ AlcFree((void *) locbuffs); AlcFree((void *) locbuff); WlzFreeIntervalDomain(idom); errNum = WLZ_ERR_MEM_ALLOC; } else { idom->freeptr = AlcFreeStackPush(idom->freeptr, (void *)itvl, NULL); lwas = line1; jtvl = itvl; nints = 0; domain.i = idom; values.v = NULL; if( (obj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values, NULL, NULL, &errNum)) == NULL ){ WlzFreeIntervalDomain( idom ); AlcFree((void *) locbuffs); AlcFree((void *) locbuff); return(NULL); } } } /* * allocate space for workspaces */ if( errNum == WLZ_ERR_NONE ){ if( (iwsp = (WlzIntervalWSpace *) AlcMalloc (n * sizeof (WlzIntervalWSpace))) == NULL ){ WlzFreeObj( obj ); AlcFree((void *) locbuffs); AlcFree((void *) locbuff); errNum = WLZ_ERR_MEM_ALLOC; obj = NULL; } else { biwsp = iwsp; tiwsp = iwsp + n; } } /* * Construct the union object's table of intervals. * Initialise scanning on each object/workspace combination. * Scan synchronously, setting up the union of adjacent and * overlapping intervals. Needs a clear head !! */ if( errNum == WLZ_ERR_NONE ){ for (i=0; i<n; i++) { WlzInitRasterScan(objs[i], iwsp, WLZ_RASTERDIR_ILIC); WlzNextInterval(iwsp++); } numactive = n; /* * find next line and left hand end of next interval of union */ while (numactive > 0) { /* * find first remaining active object */ iwsp = biwsp; while( iwsp->linrmn < 0 ){ iwsp++; } /* * find minimum line number of remaining active intervals */ l = iwsp->linpos; kol1 = iwsp->lftpos; lastkl = iwsp->rgtpos; for (iwsp++; iwsp<tiwsp; iwsp++) if (iwsp->linrmn >= 0 && iwsp->linpos < l) { l = iwsp->linpos; kol1 = iwsp->lftpos; lastkl = iwsp->rgtpos; } /* * find left-most interval in this line */ for (iwsp=biwsp; iwsp<tiwsp; iwsp++) if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos < kol1) { kol1 = iwsp->lftpos; lastkl = iwsp->rgtpos; } /* * construct maximal interval with current left end-point */ do { change = 0; for (iwsp=biwsp; iwsp<tiwsp; iwsp++) { while( iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= lastkl+1 ){ if (iwsp->rgtpos > lastkl) { lastkl = iwsp->rgtpos; change = 1; } if (WlzNextInterval(iwsp) != WLZ_ERR_NONE) { numactive--; } } } } while (change == 1); itvl->ileft = kol1 - idom->kol1; itvl->iright = lastkl - idom->kol1; if (l == lwas) nints++; else { (void) WlzMakeInterval(lwas,idom,nints,jtvl); for (j = lwas+1; j<l; j++) { (void) WlzMakeInterval(j,idom,0,NULL); } lwas = l; nints = 1; jtvl = itvl; } itvl++; } (void) WlzMakeInterval(lwas,idom,nints,jtvl); for (j = lwas+1; j<=lastln; j++) { (void) WlzMakeInterval(j,idom,0,NULL); } } /* now deal with the grey-values if required */ if( (errNum == WLZ_ERR_NONE) && (uvt != 0) ){ WlzGreyType grey_type; if( (gwsp = (WlzGreyWSpace *) AlcMalloc (n * sizeof (WlzGreyWSpace))) == NULL){ WlzFreeObj( obj ); AlcFree((void *) locbuffs); AlcFree((void *) locbuff); AlcFree((void *) biwsp); errNum = WLZ_ERR_MEM_ALLOC; obj = NULL; } /* construct an empty "ragged-rectangle" greytable with appropriate grey-type */ if( errNum == WLZ_ERR_NONE ){ backg = WlzGetBackground(objs[0], NULL); grey_type = WlzGreyTableTypeToGreyType(objs[0]->values.core->type, NULL); type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, grey_type, NULL); if( (values.v = WlzNewValueTb(obj, type, backg, &errNum)) == NULL ){ WlzFreeObj( obj ); AlcFree((void *) locbuffs); AlcFree((void *) locbuff); AlcFree((void *) biwsp); obj = NULL; } else { obj->values = WlzAssignValues(values, NULL); } } /* fill the grey table. Where more than one input objects overlap, take mean of grey values. */ if( errNum == WLZ_ERR_NONE ){ WlzInitGreyScan(obj, &niwsp, &ngwsp); iwsp = biwsp; for (i=0; i<n; i++) { WlzInitGreyScan(objs[i], iwsp, &gwsp[i]); WlzNextGreyInterval(iwsp++); if( gwsp[i].pixeltype != grey_type ){ AlcFree((void *) gwsp); AlcFree((void *) locbuffs); AlcFree((void *) locbuff); AlcFree((void *) biwsp); WlzFreeObj( obj ); obj = NULL; errNum = WLZ_ERR_GREY_TYPE; } } } if( errNum == WLZ_ERR_NONE ){ while (WlzNextGreyInterval(&niwsp) == WLZ_ERR_NONE) { l = niwsp.linpos; greyptr = ngwsp.u_grintptr; switch( ngwsp.pixeltype ){ case WLZ_GREY_INT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.inv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.inv += *(gwsp[i].u_grintptr.inp + k - iwsp->lftpos); } } *greyptr.inp = gv.inv / noverlap; greyptr.inp++; } break; case WLZ_GREY_SHORT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.shv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.shv += *(gwsp[i].u_grintptr.shp + k - iwsp->lftpos); } } *greyptr.shp = (short )(gv.shv / noverlap); greyptr.shp++; } break; case WLZ_GREY_UBYTE: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.inv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.inv += *(gwsp[i].u_grintptr.ubp + k - iwsp->lftpos); } } *greyptr.ubp = (WlzUByte )(gv.inv / noverlap); greyptr.ubp++; } break; case WLZ_GREY_FLOAT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.flv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.flv += *(gwsp[i].u_grintptr.flp + k - iwsp->lftpos); } } *greyptr.flp = gv.flv / noverlap; greyptr.flp++; } break; case WLZ_GREY_DOUBLE: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.dbv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.dbv += *(gwsp[i].u_grintptr.dbp + k - iwsp->lftpos); } } *greyptr.dbp = gv.dbv / noverlap; greyptr.dbp++; } break; case WLZ_GREY_RGBA: /* RGBA to be done - do properly RAB */ for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { noverlap = 0; gv.rgbv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while (iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ WlzNextGreyInterval(iwsp); } if (iwsp->linrmn >= 0 && iwsp->linpos == l && iwsp->lftpos <= k) { noverlap++; gv.rgbv += *(gwsp[i].u_grintptr.rgbp + k - iwsp->lftpos); } } *greyptr.rgbp = gv.rgbv / noverlap; greyptr.rgbp++; } break; default: break; } } } AlcFree((void *) gwsp); } if( errNum == WLZ_ERR_NONE ){ AlcFree( (void *) biwsp); AlcFree( (void *)locbuff ); AlcFree( (void *)locbuffs ); } if( dstErr ){ *dstErr = errNum; } return( obj ); }
WlzObject *WlzCbThreshold( WlzObject *obj, WlzThreshCbFn threshCb, void *clientData, WlzErrorNum *dstErr) { WlzObject *nobj=NULL; WlzIntervalDomain *idom = NULL; WlzGreyP g; WlzThreshCbStr callData; int colno, nints; int over; int nl1,nll,nk1,nkl; WlzIntervalWSpace iwsp; WlzGreyWSpace gwsp; WlzInterval *itvl = NULL, *jtvl = NULL; WlzDomain domain; WlzValues values; WlzErrorNum errNum=WLZ_ERR_NONE; /* check the object */ if( obj == NULL ){ errNum = WLZ_ERR_OBJECT_NULL; } else { switch( obj->type ){ case WLZ_2D_DOMAINOBJ: /* check object 2D domain and valuetable */ if( obj->domain.core == NULL ){ errNum = WLZ_ERR_DOMAIN_NULL; break; } if( obj->values.core == NULL ){ errNum = WLZ_ERR_VALUES_NULL; break; } break; case WLZ_3D_DOMAINOBJ: return WlzCbThreshold3d(obj, threshCb, clientData, dstErr); case WLZ_TRANS_OBJ: if((nobj = WlzCbThreshold(obj->values.obj, threshCb, clientData, &errNum)) != NULL){ values.obj = nobj; return WlzMakeMain(obj->type, obj->domain, values, NULL, obj, dstErr); } break; case WLZ_EMPTY_OBJ: return WlzMakeEmpty(dstErr); default: errNum = WLZ_ERR_OBJECT_TYPE; } } /* * first pass - find line and column bounds of thresholded * object and number of intervals. */ if( errNum == WLZ_ERR_NONE ){ idom = obj->domain.i; nl1 = idom->lastln; nll = idom->line1; nk1 = idom->lastkl; nkl = idom->kol1; callData.pix.type = gwsp.pixeltype; (void) WlzInitGreyScan(obj, &iwsp, &gwsp); } if( errNum == WLZ_ERR_NONE ){ nints = 0; while( (errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE ){ callData.pos.vtY = iwsp.linpos; g = gwsp.u_grintptr; over = 0; for (colno = iwsp.lftpos; colno <= iwsp.rgtpos; colno++) { callData.pix.p = g; callData.pos.vtX = colno; if((*threshCb)(obj, clientData, &callData) ){ if (over == 0) { over = 1; if (iwsp.linpos < nl1) nl1 = iwsp.linpos; if (iwsp.linpos > nll) nll = iwsp.linpos; if (colno < nk1) nk1 = colno; } } else { if (over == 1) { if (colno > nkl) nkl = colno; over = 0; nints++; } } switch( gwsp.pixeltype ){ case WLZ_GREY_INT: g.inp++; break; case WLZ_GREY_SHORT: g.shp++; break; case WLZ_GREY_UBYTE: g.ubp++; break; case WLZ_GREY_FLOAT: g.flp++; break; case WLZ_GREY_DOUBLE: g.dbp++; break; case WLZ_GREY_RGBA: g.rgbp++; break; default: break; } } if (over == 1) { if (colno > nkl) nkl = colno; over = 0; nints++; } } nkl--; /* since we have looked at points beyond interval ends */ (void )WlzEndGreyScan(&iwsp, &gwsp); if( errNum == WLZ_ERR_EOO ){ errNum = WLZ_ERR_NONE; } } /* domain structure */ if( errNum == WLZ_ERR_NONE ){ if( nints > 0 ){ if((idom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, nl1, nll, nk1, nkl, &errNum)) != NULL){ if( (itvl = (WlzInterval *) AlcMalloc(nints * sizeof(WlzInterval))) == NULL ){ errNum = WLZ_ERR_MEM_ALLOC; WlzFreeIntervalDomain(idom); } else { idom->freeptr = AlcFreeStackPush(idom->freeptr, (void *)itvl, NULL); } } /* * second pass - construct intervals */ if( errNum == WLZ_ERR_NONE ){ errNum = WlzInitGreyScan(obj, &iwsp, &gwsp); callData.pix.type = gwsp.pixeltype; nints = 0; jtvl = itvl; } /* find thresholded endpoints */ if( errNum == WLZ_ERR_NONE ){ while( (errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE ){ if( iwsp.linpos < nl1 || iwsp.linpos > nll ){ continue; } callData.pos.vtY = iwsp.linpos; g = gwsp.u_grintptr; over = 0; for (colno = iwsp.lftpos; colno <= iwsp.rgtpos; colno++) { callData.pix.p = g; callData.pos.vtX = colno; if((*threshCb)(obj, clientData, &callData) ){ if (over == 0) { over = 1; itvl->ileft = colno - nk1; } } else { if (over == 1) { over = 0; itvl->iright = colno - nk1 - 1; nints++; itvl++; } } switch( gwsp.pixeltype ){ case WLZ_GREY_INT: g.inp++; break; case WLZ_GREY_SHORT: g.shp++; break; case WLZ_GREY_UBYTE: g.ubp++; break; case WLZ_GREY_FLOAT: g.flp++; break; case WLZ_GREY_DOUBLE: g.dbp++; break; case WLZ_GREY_RGBA: g.rgbp++; break; default: break; } } if (over == 1) { over = 0; itvl->iright = colno - nk1 - 1; nints++; itvl++; } /* * end of line ? */ if (iwsp.intrmn == 0) { WlzMakeInterval(iwsp.linpos, idom, nints, jtvl); jtvl = itvl; nints = 0; } } if( errNum == WLZ_ERR_EOO ){ errNum = WLZ_ERR_NONE; } } } else { /* no thresholded points - make a dummy domain anyway */ return WlzMakeEmpty(dstErr); } } /* main object */ if( errNum == WLZ_ERR_NONE ){ domain.i = idom; nobj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, obj->values, obj->plist, obj, &errNum); } if( dstErr ){ *dstErr = errNum; } return(nobj); }
/*! * \ingroup WlzBinaryOps * \brief Calculate the intersection of a set of objects. If uvt=0 calculate domain only, uvt=1 calculate the mmean grey-value at each point. Input objects must be all non-NULL and domain objects of the same type i.e. either 2D or 3D otherwise an error is returned. * * \return Intersection object with grey-table as required, if the intersection is empty returns WLZ_EMPTY_OBJ, NULL on error. * \param n number of input objects * \param objs input object array * \param uvt grey-table copy flag (1 - copy, 0 - no copy) * \param dstErr error return. * \par Source: * WlzIntersectN.c */ WlzObject *WlzIntersectN( int n, WlzObject **objs, int uvt, WlzErrorNum *dstErr) { WlzObject *obj = NULL; WlzIntervalDomain *idom; WlzInterval *itvl, *jtvl; WlzIntervalWSpace *iwsp; WlzIntervalWSpace *biwsp,*tiwsp,niwsp; WlzGreyWSpace *gwsp,ngwsp; WlzDomain domain; WlzValues values; WlzObjectType type; WlzPixelV backg; WlzGreyP greyptr; WlzGreyV gv; int i, j, k, l, inttot, change, lwas, nints; int line1, lastln; int kol1, lastkl; WlzErrorNum errNum = WLZ_ERR_NONE; /* * check pointers */ /* intersecction of no objects is an empty domain */ domain.i = NULL; values.v = NULL; if( n < 1 ) { return WlzMakeEmpty(dstErr); } /* array pointer == NULL or any object pointer == NULL is an error */ if(objs == NULL){ errNum = WLZ_ERR_OBJECT_NULL; } else { for(i=0; i<n; i++){ if(objs[i] == NULL){ errNum = WLZ_ERR_OBJECT_NULL; } } } if(errNum != WLZ_ERR_NONE) { obj = NULL; if(dstErr) { *dstErr = errNum; } return(obj); } /* check type of first object */ switch( objs[0]->type ){ case WLZ_2D_DOMAINOBJ: break; case WLZ_3D_DOMAINOBJ: return WlzIntersect3d(objs, n, uvt, &errNum); case WLZ_EMPTY_OBJ: return WlzMakeEmpty(dstErr); default: errNum = WLZ_ERR_OBJECT_TYPE; if(dstErr) { *dstErr = errNum; } return NULL; } /* check number */ if (n == 1){ obj = WlzMakeMain(objs[0]->type, objs[0]->domain, objs[0]->values, NULL, NULL, &errNum); if(dstErr) { *dstErr = errNum; } return(obj); } /* check all objects are non-empty and have the same type Note an empty object is not an error */ for (i=0; i<n; i++){ if( objs[i]->type != objs[0]->type ){ if( objs[i]->type == WLZ_EMPTY_OBJ ){ return WlzMakeEmpty(dstErr); } else { errNum = WLZ_ERR_OBJECT_TYPE; if(dstErr) { *dstErr = errNum; } return NULL; } } /* check for size */ if( WlzIsEmpty(objs[i], &errNum) ){ return WlzMakeEmpty(dstErr); } else { if( errNum != WLZ_ERR_NONE ){ if(dstErr) { *dstErr = errNum; } return NULL; } } } /* * Find the line and column bounds of the intersection. */ line1 = objs[0]->domain.i->line1; lastln = objs[0]->domain.i->lastln; kol1 = objs[0]->domain.i->kol1; lastkl = objs[0]->domain.i->lastkl; for (i=1; i<n; i++) { idom = objs[i]->domain.i; if (line1 < idom->line1) { line1 = idom->line1; } if (lastln > idom->lastln) { lastln = idom->lastln; } if (kol1 < idom->kol1) { kol1 = idom->kol1; } if (lastkl > idom->lastkl) { lastkl = idom->lastkl; } } if( lastkl < kol1 || lastln < line1 ){ return WlzMakeEmpty(dstErr); } /* * Count the individual intervals so that sufficient space * for the intersection may be allocated. */ inttot=0; for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) { inttot += WlzIntervalCount(objs[i]->domain.i, &errNum); } if(errNum != WLZ_ERR_NONE) { if(dstErr) { *dstErr = errNum; } return NULL; } /* * Set up domain, value table structures, and object. */ if( (idom = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, line1, lastln, 0, lastkl-kol1, &errNum)) == NULL ){ if(dstErr) { *dstErr = errNum; } return NULL; } if( (itvl = (WlzInterval *) AlcMalloc (inttot * sizeof(WlzInterval))) == NULL ){ WlzFreeIntervalDomain(idom); errNum = WLZ_ERR_MEM_ALLOC; if(dstErr) { *dstErr = errNum; } return NULL; } idom->freeptr = AlcFreeStackPush(idom->freeptr, (void *)itvl, NULL); lwas = line1; jtvl = itvl; nints = 0; domain.i = idom; values.v = NULL; if( (obj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values, NULL, NULL, &errNum)) == NULL ){ WlzFreeIntervalDomain(idom); if(dstErr) { *dstErr = errNum; } return NULL; } /* * allocate space for workspaces */ if( (iwsp = (WlzIntervalWSpace *) AlcMalloc(n * sizeof(WlzIntervalWSpace))) == NULL ){ WlzFreeObj( obj ); errNum = WLZ_ERR_MEM_ALLOC; if(dstErr) { *dstErr = errNum; } return NULL; } biwsp = iwsp; tiwsp = biwsp + n; /* * Construct the intersection object's table of intervals. * Initialise scanning on each object/workspace combination. * Scan synchronously, setting up the intersection of * overlapping intervals. Needs a clear head !! */ for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) { errNum = WlzInitRasterScan(objs[i],iwsp,WLZ_RASTERDIR_ILIC); if(errNum == WLZ_ERR_NONE) { errNum = WlzNextInterval(iwsp++); } } if(errNum != WLZ_ERR_NONE) { WlzFreeObj( obj ); if(dstErr) { *dstErr = errNum; } return NULL; } l = lwas; for (;;) { /* * find next line of intersection */ do { change = 0; for (iwsp=biwsp; iwsp<tiwsp; iwsp++) { if (iwsp->linpos > l) { l = iwsp->linpos; } } for (iwsp=biwsp; iwsp<tiwsp; iwsp++) { while (iwsp->linpos < l) { if ((errNum = WlzNextInterval(iwsp)) != WLZ_ERR_NONE) { if(errNum == WLZ_ERR_EOO) { errNum = WLZ_ERR_NONE; } goto firstfinished; } if (iwsp->linpos > l) { change = 1; } } } } while (change != 0); /* * find next interval of intersection */ kol1 = biwsp->lftpos; lastkl = biwsp->rgtpos; while(errNum == WLZ_ERR_NONE) { do { change = 0; for (iwsp=biwsp; iwsp<tiwsp; iwsp++) if (iwsp->lftpos > lastkl) { kol1 = iwsp->lftpos; lastkl = iwsp->rgtpos; } else if (iwsp->lftpos > kol1) kol1 = iwsp->lftpos; for (iwsp=biwsp; iwsp<tiwsp; iwsp++) { while (iwsp->rgtpos < kol1) { if ((errNum = WlzNextInterval(iwsp)) != WLZ_ERR_NONE) { if(errNum == WLZ_ERR_EOO) { errNum = WLZ_ERR_NONE; } goto firstfinished; } if (iwsp->linpos != l) { l = iwsp->linpos; goto jumpline; } if (iwsp->lftpos > kol1) change = 1; } } } while ((change != 0) && (errNum == WLZ_ERR_NONE)); if(errNum == WLZ_ERR_NONE) { for (iwsp=biwsp; iwsp < tiwsp; iwsp++) { if (iwsp->rgtpos <= lastkl) { lastkl = iwsp->rgtpos; } } if (lastkl >= kol1) { itvl->ileft = kol1 - idom->kol1; itvl->iright = lastkl - idom->kol1; if (l == lwas) { nints++; } else { errNum = WlzMakeInterval(lwas,idom,nints,jtvl); for (j = lwas+1; (j < l) && (errNum == WLZ_ERR_NONE); j++) { errNum = WlzMakeInterval(j,idom,0,NULL); } if(errNum == WLZ_ERR_NONE) { lwas = l; nints = 1; jtvl = itvl; } } itvl++; } kol1 = lastkl+1; } } jumpline: ; } firstfinished: if(errNum != WLZ_ERR_NONE) { WlzFreeObj(obj); if(dstErr) { *dstErr = errNum; } return NULL; } errNum = WlzMakeInterval(lwas,idom,nints,jtvl); for (j = lwas+1; (j <= lastln) && (errNum == WLZ_ERR_NONE); j++) { errNum = WlzMakeInterval(j,idom,0,NULL); } if(errNum != WLZ_ERR_NONE) { WlzFreeObj(obj); AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return NULL; } /* * standardise the interval list (remove leading and trailing * empty lines, set kol1 so that at least one interval commences * at zero, set lastkl correctly) */ (void )WlzStandardIntervalDomain(idom); /* check for error or empty */ nints = WlzIntervalCount(idom, &errNum); if( nints < 0 ){ /* error */ WlzFreeObj(obj); AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return NULL; } else if( nints == 0 ){ /* empty object */ WlzFreeObj(obj); AlcFree((void *) biwsp); return WlzMakeEmpty(dstErr); } if (uvt != 0) { WlzGreyType grey_type; if( (gwsp = (WlzGreyWSpace *) AlcMalloc (n * sizeof (WlzGreyWSpace))) == NULL ){ WlzFreeObj(obj); AlcFree((void *) biwsp); errNum = WLZ_ERR_MEM_ALLOC; if(dstErr) { *dstErr = errNum; } return NULL; } /* construct an empty "ragged-rectangle" (type 1 or 2) greytable choosing the grey-value type from the first object in the list */ backg = WlzGetBackground(objs[0], &errNum); if(errNum == WLZ_ERR_NONE) { grey_type = WlzGreyTableTypeToGreyType(objs[0]->values.core->type, &errNum); } if(errNum == WLZ_ERR_NONE) { type = WlzGreyTableType(WLZ_GREY_TAB_RAGR, grey_type, &errNum); } if((errNum != WLZ_ERR_NONE) || (values.v = WlzNewValueTb(obj, type, backg, &errNum)) == NULL ){ WlzFreeObj( obj ); AlcFree((void *) gwsp); AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return NULL; } obj->values = WlzAssignValues(values, &errNum); if(errNum != WLZ_ERR_NONE) { WlzFreeObj( obj ); AlcFree((void *) gwsp); AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return NULL; } /* * fill the grey table with mean of grey values. */ /* initialise the work-spaces and check pixel type */ errNum = WlzInitGreyScan(obj, &niwsp, &ngwsp); iwsp = biwsp; for (i=0; (i < n) && (errNum == WLZ_ERR_NONE); i++) { errNum = WlzInitGreyScan(objs[i], iwsp, &gwsp[i]); if(errNum == WLZ_ERR_NONE) { errNum = WlzNextGreyInterval(iwsp++); } if( gwsp[i].pixeltype != grey_type ){ errNum = WLZ_ERR_GREY_TYPE; } } if(errNum != WLZ_ERR_NONE) { WlzFreeObj( obj ); AlcFree((void *) gwsp); AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return NULL; } while (WlzNextGreyInterval(&niwsp) == WLZ_ERR_NONE) { l = niwsp.linpos; greyptr = ngwsp.u_grintptr; switch( ngwsp.pixeltype ){ case WLZ_GREY_INT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.inv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.inv += *(gwsp[i].u_grintptr.inp + k - iwsp->lftpos); } *greyptr.inp = gv.inv / n; greyptr.inp++; } break; case WLZ_GREY_SHORT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.shv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.shv += *(gwsp[i].u_grintptr.shp + k - iwsp->lftpos); } *greyptr.shp = (short )(gv.shv / n); greyptr.shp++; } break; case WLZ_GREY_UBYTE: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.ubv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.ubv += *(gwsp[i].u_grintptr.ubp + k - iwsp->lftpos); } *greyptr.ubp = (WlzUByte )(gv.ubv / n); greyptr.ubp++; } break; case WLZ_GREY_FLOAT: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.flv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.flv += *(gwsp[i].u_grintptr.flp + k - iwsp->lftpos); } *greyptr.flp = gv.flv / n; greyptr.flp++; } break; case WLZ_GREY_DOUBLE: for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.dbv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.dbv += *(gwsp[i].u_grintptr.dbp + k - iwsp->lftpos); } *greyptr.dbp = gv.dbv / n; greyptr.dbp++; } break; case WLZ_GREY_RGBA: /* RGBA to be done again RAB */ for (k = niwsp.lftpos; k <= niwsp.rgtpos; k++) { gv.rgbv = 0; for (iwsp=biwsp,i=0; iwsp<tiwsp; iwsp++,i++) { while(iwsp->linrmn >= 0 && (iwsp->linpos < l || (iwsp->linpos == l && iwsp->rgtpos < k))){ (void )WlzNextGreyInterval(iwsp); } gv.rgbv += *(gwsp[i].u_grintptr.rgbp + k - iwsp->lftpos); } *greyptr.rgbp = gv.rgbv / n; greyptr.rgbp++; } break; default: errNum = WLZ_ERR_GREY_TYPE; break; } } if(errNum == WLZ_ERR_EOO) { errNum = WLZ_ERR_NONE; } AlcFree((void *) gwsp); } AlcFree((void *) biwsp); if(dstErr) { *dstErr = errNum; } return obj; }