/*! * \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 New Woolz domain object with maximal domain and grey * values which encode the gradient's direction or NULL * on error. * \ingroup WlzFeatures * \brief Computes the maximal domain and gradient direction of * given Woolz 2D domain object. * \note All the objects domains are known to be the same. * \param grdM Gradient magnitude. * \param grdY Gradient (partial derivative) * through lines. * \param grdX Gradient (partial derivative) * through columns. * \param minThrV Minimum gradient value to * consider. * \param dstErr Destination error pointer, may * be null. */ static WlzObject *WlzNMSuppress2D(WlzObject *grdM, WlzObject *grdY, WlzObject *grdX, WlzPixelV minThrV, WlzErrorNum *dstErr) { int idN, inLen, outLen, inLnIdx = 0; WlzGreyType gType, bufType; WlzIVertex2 bufSz, inPos, outPos, orgPos; WlzValues tmpVal; WlzDomain dstDom, grdDom; WlzIntervalWSpace tmpIWSp = {0}, grdMIWSp = {0}, grdYIWSp = {0}, grdXIWSp = {0}; WlzGreyWSpace tmpGWSp, grdMGWSp, grdYGWSp, grdXGWSp; WlzPixelV zeroV; WlzGreyP grdMBufGP, grdYBufGP, grdXBufGP; WlzDynItvPool pool; WlzObject *dstObj = NULL, *tmpObj = NULL; void *grdYBuf = NULL, *grdXBuf = NULL; void **grdMBuf = NULL; WlzErrorNum errNum = WLZ_ERR_NONE; tmpVal.core = NULL; pool.itvBlock = NULL; dstDom.core = NULL; if((grdM->type != WLZ_2D_DOMAINOBJ) || (grdY->type != WLZ_2D_DOMAINOBJ) || (grdX->type != WLZ_2D_DOMAINOBJ)) { errNum = WLZ_ERR_OBJECT_NULL; } else if((grdM->domain.core == NULL) || (grdY->domain.core == NULL) || (grdX->domain.core == NULL)) { errNum = WLZ_ERR_DOMAIN_NULL; } else if((grdM->values.core == NULL) || (grdY->values.core == NULL) || (grdX->values.core == NULL)) { errNum = WLZ_ERR_VALUES_NULL; } else { /* Find required buffer type (WLZ_GREY_DOUBLE or WLZ_GREY_INT). */ bufType = WLZ_GREY_INT; gType = WlzGreyTableTypeToGreyType(grdM->values.core->type, &errNum); if(errNum == WLZ_ERR_NONE) { if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE)) { bufType = WLZ_GREY_DOUBLE; } else { gType = WlzGreyTableTypeToGreyType(grdY->values.core->type, &errNum); if(errNum == WLZ_ERR_NONE) { if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE)) { bufType = WLZ_GREY_DOUBLE; } else { gType = WlzGreyTableTypeToGreyType(grdX->values.core->type, &errNum); if(errNum == WLZ_ERR_NONE) { if((gType == WLZ_GREY_FLOAT) || (gType == WLZ_GREY_DOUBLE)) { bufType = WLZ_GREY_DOUBLE; } } } } } } } /* Convert minimum gradient threshold value. */ if(errNum == WLZ_ERR_NONE) { if(bufType == WLZ_GREY_INT) { errNum = WlzValueConvertPixel(&minThrV, minThrV, WLZ_GREY_INT); } else /* bufType == WLZ_GREY_DOUBLE */ { errNum = WlzValueConvertPixel(&minThrV, minThrV, WLZ_GREY_DOUBLE); } } if(errNum == WLZ_ERR_NONE) { grdDom = grdM->domain; /* Make destination object with WLZ_GREY_UBYTE greys. */ zeroV.type = WLZ_GREY_UBYTE; zeroV.v.inv = 0; tmpVal.v = WlzNewValueTb(grdM, WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_UBYTE, NULL), zeroV, &errNum); if(errNum == WLZ_ERR_NONE) { /* Use the input domain while calculating the new maximal domain. */ tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, grdM->domain, tmpVal, NULL, NULL, &errNum); } } /* Initialize the memory pool with some size of block. Any +ve number * greater than the maximum number of intervals in any destination line * would work but the fewer allocations then the more efficient the code, * hence this attempt to guess the required number of intervals in the * destination domain. */ if(errNum == WLZ_ERR_NONE) { pool.itvsInBlock = (((grdDom.i->lastkl - grdDom.i->kol1 + 1) * (grdDom.i->lastln - grdDom.i->line1 + 1)) / 64) + grdDom.i->lastkl - grdDom.i->kol1 + 1024; } /* Make gradient buffers. */ if(errNum == WLZ_ERR_NONE) { bufSz.vtY = 3; bufSz.vtX = grdDom.i->lastkl - grdDom.i->kol1 + 1; if(bufType == WLZ_GREY_INT) { if((AlcInt2Malloc((int ***)&grdMBuf, bufSz.vtY, bufSz.vtX) != ALC_ER_NONE) || ((grdYBuf = AlcMalloc(sizeof(int) * bufSz.vtX)) == NULL) || ((grdXBuf = AlcMalloc(sizeof(int) * bufSz.vtX)) == NULL)) { errNum = WLZ_ERR_MEM_ALLOC; } else { grdYBufGP.inp = (int *)grdYBuf; grdXBufGP.inp = (int *)grdXBuf; } } else /* bufType == WLZ_GREY_DOUBLE */ { if((AlcDouble2Malloc((double ***)&grdMBuf, bufSz.vtY, bufSz.vtX) != ALC_ER_NONE) || ((grdYBuf = AlcMalloc(sizeof(double) * bufSz.vtX)) == NULL) || ((grdXBuf = AlcMalloc(sizeof(double) * bufSz.vtX)) == NULL)) { errNum = WLZ_ERR_MEM_ALLOC; } else { grdYBufGP.dbp = (double *)grdYBuf; grdXBufGP.dbp = (double *)grdXBuf; } } } /* Make destination interval domain with interval lines but not intervals. */ if(errNum == WLZ_ERR_NONE) { dstDom.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_INTVL, grdDom.i->line1, grdDom.i->lastln, grdDom.i->kol1, grdDom.i->lastkl, &errNum); } if(errNum == WLZ_ERR_NONE) { /* Scan down through the gradient objects. */ if(((errNum = WlzInitGreyScan(tmpObj, &tmpIWSp, &tmpGWSp)) == WLZ_ERR_NONE) && ((errNum = WlzInitGreyScan(grdM, &grdMIWSp, &grdMGWSp)) == WLZ_ERR_NONE) && ((errNum = WlzInitGreyScan(grdY, &grdYIWSp, &grdYGWSp)) == WLZ_ERR_NONE) && ((errNum = WlzInitGreyScan(grdX, &grdXIWSp, &grdXGWSp)) == WLZ_ERR_NONE)) { orgPos.vtX = grdDom.i->kol1; orgPos.vtY = grdDom.i->line1; while((errNum == WLZ_ERR_NONE) && ((errNum = WlzNextGreyInterval(&grdMIWSp)) == WLZ_ERR_NONE)) { inLen = grdMIWSp.rgtpos - grdMIWSp.lftpos + 1; inPos.vtX = grdMIWSp.lftpos - orgPos.vtX; /* Process any lines between this and the last by clearing the * gradient magnitude buffer . */ if(grdMIWSp.nwlpos > 0) { idN = (grdMIWSp.nwlpos >= 3)? 3: grdMIWSp.nwlpos; while(--idN >= 0) { inPos.vtY = grdMIWSp.linpos - orgPos.vtY - idN; inLnIdx = (3 + inPos.vtY) % 3; if(bufType == WLZ_GREY_INT) { WlzValueSetInt(*((int **)grdMBuf + inLnIdx), 0, bufSz.vtX); } else /* bufType == WLZ_GREY_DOUBLE */ { WlzValueSetDouble(*((double **)grdMBuf + inLnIdx), 0, bufSz.vtX); } } } /* Copy intervals to values buffers. */ if(bufType == WLZ_GREY_INT) { grdMBufGP.inp = *((int **)grdMBuf + inLnIdx); } else /* bufType == WLZ_GREY_DOUBLE */ { grdMBufGP.dbp = *((double **)grdMBuf + inLnIdx); } WlzValueCopyGreyToGrey(grdMBufGP, inPos.vtX, bufType, grdMGWSp.u_grintptr, 0, grdMGWSp.pixeltype, inLen); if(grdMIWSp.intrmn == 0) { while((errNum == WLZ_ERR_NONE) && (tmpIWSp.linpos < grdMIWSp.linpos)) { outPos.vtY = tmpIWSp.linpos - orgPos.vtY; if(outPos.vtY >= 0) { outLen = tmpIWSp.rgtpos - tmpIWSp.lftpos + 1; outPos.vtX = tmpIWSp.lftpos - orgPos.vtX; WlzValueCopyGreyToGrey(grdYBufGP, 0, bufType, grdYGWSp.u_grintptr, 0, grdYGWSp.pixeltype, outLen); WlzValueCopyGreyToGrey(grdXBufGP, 0, bufType, grdXGWSp.u_grintptr, 0, grdXGWSp.pixeltype, outLen); if(bufType == WLZ_GREY_INT) { errNum = WlzNMSuppress2DBufI(dstDom.i, (int **)grdMBuf, (int *)grdYBuf, (int *)grdXBuf, &pool, tmpGWSp.u_grintptr.ubp, outLen, outPos, orgPos, minThrV.v.inv); } else /* bufType == WLZ_GREY_DOUBLE */ { errNum = WlzNMSuppress2DBufD(dstDom.i, (double **)grdMBuf, (double *)grdYBuf, (double *)grdXBuf, &pool, tmpGWSp.u_grintptr.ubp, outLen, outPos, orgPos, minThrV.v.dbv); } } if(errNum == WLZ_ERR_NONE) { errNum = WlzNextGreyInterval(&tmpIWSp); } if(errNum == WLZ_ERR_NONE) { errNum = WlzNextGreyInterval(&grdYIWSp); } if(errNum == WLZ_ERR_NONE) { errNum = WlzNextGreyInterval(&grdXIWSp); } } } } if(errNum == WLZ_ERR_EOO) { errNum = WLZ_ERR_NONE; } } if(tmpIWSp.gryptr == &tmpGWSp) { (void )WlzEndGreyScan(&tmpIWSp, &tmpGWSp); } if(grdMIWSp.gryptr == &grdMGWSp) { (void )WlzEndGreyScan(&grdMIWSp, &grdMGWSp); } if(grdYIWSp.gryptr == &grdYGWSp) { (void )WlzEndGreyScan(&grdYIWSp, &grdYGWSp); } if(grdXIWSp.gryptr == &grdXGWSp) { (void )WlzEndGreyScan(&grdXIWSp, &grdXGWSp); } } if(errNum == WLZ_ERR_NONE) { if((errNum = WlzStandardIntervalDomain(dstDom.i)) == WLZ_ERR_NONE) { dstObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, dstDom, tmpVal, NULL, NULL, &errNum); } } if(tmpObj) { WlzFreeObj(tmpObj); } if(errNum != WLZ_ERR_NONE) { if(tmpObj == NULL) { if(dstDom.core) { (void )WlzFreeDomain(dstDom); } if(tmpVal.core) { (void )WlzFreeValues(tmpVal); } } } if(grdMBuf) { Alc2Free(grdMBuf); } if(grdYBuf) { AlcFree(grdYBuf); } if(grdXBuf) { AlcFree(grdXBuf); } 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; }
/*! * \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; }