/*!
* \return Interiority score for the test object.
* \ingroup WlzFeatures
* \brief Computes an interiority score for the test object with
* respect to the given distance object. See WlzInteriority().
* \param disObj Given distance object.
* \param tstObjs Array of test objects.
* \param dstErr Destination error pointer, may be NULL.
*/
static double WlzInteriorityPrv(
WlzObject *disObj,
WlzObject *tstObj,
WlzErrorNum *dstErr)
{
double score = 0.0;
WlzErrorNum errNum = WLZ_ERR_NONE;
if(tstObj->type != WLZ_EMPTY_OBJ)
{
WlzObject *isn = NULL;
isn = WlzAssignObject(
WlzIntersect2(disObj, tstObj, &errNum), NULL);
if((errNum == WLZ_ERR_NONE) &&
(isn != NULL) && (WlzIsEmpty(isn, NULL) == 0))
{
WlzPixelV bgd;
WlzObjectType gtt;
WlzObject *ist = NULL,
*isv = NULL;
bgd.v.inv = 0;
bgd.type = WLZ_GREY_INT;
gtt = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_INT, NULL);
isv = WlzNewObjectValues(isn, gtt, bgd, 0, bgd, &errNum);
if(errNum == WLZ_ERR_NONE)
{
ist = WlzAssignObject(
WlzGreyTransfer(isv, disObj, 0, &errNum), NULL);
}
(void )WlzFreeObj(isv);
if(errNum == WLZ_ERR_NONE)
{
(void )WlzGreyStats(ist, NULL, NULL, NULL, NULL, NULL, &score, NULL,
&errNum);
}
(void )WlzFreeObj(ist);
}
(void )WlzFreeObj(isn);
}
if(dstErr)
{
*dstErr = errNum;
}
return(score);
}
/*!
* \ingroup WlzValuesUtils
* \brief Transfer grey values from the source object to the
destination object. Currently it is assumed that the objects are
of the same type (2D/3D) and have the same grey-value type.
*
* \return Woolz object with transferred grey values
* \param obj destination object
* \param srcObj source object
* \param dstErr error return
* \par Source:
* WlzGreyTransfer.c
*/
WlzObject *WlzGreyTransfer(
WlzObject *obj,
WlzObject *srcObj,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *obj1, *obj2;
WlzValues values;
WlzIntervalWSpace iwsp1, iwsp2;
WlzGreyWSpace gwsp1, gwsp2;
int size;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check destination obj */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
} else if(WlzGreyTableIsTiled(obj->values.core->type)) {
errNum = WLZ_ERR_VALUES_TYPE;
}
else {
rtnObj = WlzCopyObject(obj, &errNum);
}
break;
case WLZ_3D_DOMAINOBJ:
return WlzGreyTransfer3d(obj, srcObj, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzGreyTransfer(obj->values.obj, srcObj,
&errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, obj->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check the source object */
if( errNum == WLZ_ERR_NONE ){
if( srcObj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( srcObj->type ){
case WLZ_2D_DOMAINOBJ:
break;
case WLZ_TRANS_OBJ:
srcObj = srcObj->values.obj;
break;
case WLZ_EMPTY_OBJ:
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* copy source obj values within the intersection */
if( errNum == WLZ_ERR_NONE ){
if((srcObj->type != WLZ_EMPTY_OBJ) ){
if( (obj1 = WlzIntersect2(srcObj, rtnObj, &errNum)) ){
obj1->values = WlzAssignValues(rtnObj->values, NULL);
obj2 = WlzMakeMain(obj1->type, obj1->domain, srcObj->values,
NULL, NULL, NULL);
errNum = WlzInitGreyScan(obj1, &iwsp1, &gwsp1);
errNum = WlzInitGreyScan(obj2, &iwsp2, &gwsp2);
switch( gwsp1.pixeltype ){
case WLZ_GREY_INT:
size = sizeof(int);
break;
case WLZ_GREY_SHORT:
size = sizeof(short);
break;
case WLZ_GREY_UBYTE:
size = sizeof(WlzUByte);
break;
case WLZ_GREY_FLOAT:
size = sizeof(float);
break;
case WLZ_GREY_DOUBLE:
size = sizeof(double);
break;
case WLZ_GREY_RGBA:
size = sizeof(WlzUInt);
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
while((errNum == WLZ_ERR_NONE) &&
(errNum = WlzNextGreyInterval(&iwsp1)) == WLZ_ERR_NONE){
(void) WlzNextGreyInterval(&iwsp2);
memcpy((void *) gwsp1.u_grintptr.inp,
(const void *) gwsp2.u_grintptr.inp,
size * iwsp1.colrmn);
}
if( errNum == WLZ_ERR_EOO ){
errNum = WLZ_ERR_NONE;
}
WlzFreeObj(obj2);
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \return New Woolz object.
* \ingroup WlzAllocation
* \brief Creates a new 2D spatial domain object by adding a
* rectangular buffer of values to the given current
* object (which may be NULL or empty).
* \param cObj Given current object.
* \param og Origin of rectangular buffer.
* \param sz Buffer size.
* \param gType Grey type which must be consistent
* with the current object and the
* buffer of values.
* \param bufSz Number of values in the buffer.
* \param bufP Given buffer of values.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzBuildObj2(WlzObject *cObj,
WlzIVertex2 og, WlzIVertex2 sz,
WlzGreyType gType, int bufSz, WlzGreyP bufP,
WlzErrorNum *dstErr)
{
WlzDomain bDom;
WlzValues bVal,
nVal;
WlzObject *bObj = NULL,
*nObj = NULL;
WlzPixelV bgdV;
WlzErrorNum errNum = WLZ_ERR_NONE;
bDom.core = NULL;
bVal.core = NULL;
nVal.core = NULL;
bgdV.type = WLZ_GREY_INT;
bgdV.v.inv = 0;
if(cObj)
{
WlzGreyType cGType = WLZ_GREY_ERROR;;
switch(cObj->type)
{
case WLZ_EMPTY_OBJ:
cObj = NULL;
break;
case WLZ_2D_DOMAINOBJ:
if(cObj->domain.core == NULL)
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if(cObj->values.core == NULL)
{
errNum = WLZ_ERR_VALUES_NULL;
}
else
{
cGType = WlzGreyTypeFromObj(cObj, &errNum);
bgdV = WlzGetBackground(cObj, &errNum);
}
if((errNum == WLZ_ERR_NONE) && (cGType != gType))
{
errNum = WLZ_ERR_GREY_TYPE;
}
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* Create new object with domain and values of given rectangular buffer. */
if(errNum == WLZ_ERR_NONE)
{
bDom.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_RECT,
og.vtY, og.vtY + sz.vtY - 1,
og.vtX, og.vtX + sz.vtX - 1,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
WlzObjectType gTT;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RECT, gType, NULL);
bVal.r = WlzMakeRectValueTb(gTT, bDom.i->line1, bDom.i->lastln,
bDom.i->kol1, sz.vtX, bgdV, bufP.inp, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
bObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, bDom, bVal, NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
if(cObj == NULL)
{
/* Just copy the buffer object. */
nObj = WlzCopyObject(bObj, &errNum);
}
else
{
/* Compute union of current and buffer objects. */
nObj = (cObj)? WlzUnion2(cObj, bObj, &errNum):
WlzMakeMain(WLZ_2D_DOMAINOBJ, bDom, nVal,
NULL, NULL, &errNum);
/* Create new value table. */
if(errNum == WLZ_ERR_NONE)
{
WlzObjectType gTT;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gType, NULL);
nVal.v = WlzNewValueTb(nObj, gTT, bgdV, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
nObj->values = WlzAssignValues(nVal, NULL);
}
if(errNum == WLZ_ERR_NONE)
{
WlzObject *tObj;
/* Copy existing values to new object. */
tObj = WlzGreyTransfer(nObj, cObj, &errNum);
(void )WlzFreeObj(nObj);
nObj = tObj;
/* Then copy buffer values to new object. */
if(errNum == WLZ_ERR_NONE)
{
tObj = WlzGreyTransfer(nObj, bObj, &errNum);
(void )WlzFreeObj(nObj);
nObj = tObj;
}
}
}
}
(void )WlzFreeObj(bObj);
if(dstErr)
{
*dstErr = errNum;
}
return(nObj);
}
/*!
* \ingroup WlzValuesUtils
* \brief static function to implement WlzGreyTransfer for 3D objects.
*
* \return woolz object
* \param obj destination object
* \param srcObj source object
* \param dstErr error return
* \par Source:
* WlzGreyTransfer.c
*/
static WlzObject *WlzGreyTransfer3d(
WlzObject *obj,
WlzObject *srcObj,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL;
WlzObject *obj1, *obj2, *tmpObj;
WlzDomain *domains;
WlzValues values, *valuess;
WlzPlaneDomain *pdom;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check the object - it is non-NULL and 3D but the
domain needs checking */
if( obj->domain.p == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else {
switch( obj->domain.p->type ){
case WLZ_2D_DOMAINOBJ:
/* check there is a valuetable */
if( obj->values.core == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
} else if(WlzGreyTableIsTiled(obj->values.core->type)) {
errNum = WLZ_ERR_VALUES_TYPE;
}
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
/* check the source object */
if( errNum == WLZ_ERR_NONE ){
if( srcObj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( srcObj->type ){
case WLZ_3D_DOMAINOBJ:
if( srcObj->domain.p ){
switch( srcObj->domain.p->type ){
case WLZ_2D_DOMAINOBJ:
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
else {
errNum = WLZ_ERR_DOMAIN_NULL;
}
break;
case WLZ_EMPTY_OBJ:
return WlzCopyObject(obj, dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
}
/* now we have a 3D obj and 3D srcObject so run through the source
and map values as required */
if( errNum == WLZ_ERR_NONE ){
WlzDomain *objDoms;
WlzValues *objVals;
/* attach a voxel table with empty values list */
values.vox = WlzMakeVoxelValueTb(obj->values.vox->type,
obj->domain.p->plane1,
obj->domain.p->lastpl,
obj->values.vox->bckgrnd,
NULL, NULL);
rtnObj = WlzMakeMain(obj->type, obj->domain, values, NULL, NULL, &errNum);
/* set some local variables */
pdom = rtnObj->domain.p;
domains = rtnObj->domain.p->domains;
valuess = rtnObj->values.vox->values;
objDoms = obj->domain.p->domains;
objVals = obj->values.vox->values;
/* calculate the new valuetables */
for(p=pdom->plane1; p <= pdom->lastpl;
p++, domains++, valuess++, objDoms++, objVals++){
if(((*domains).core)){
obj1 = WlzMakeMain(WLZ_2D_DOMAINOBJ, *objDoms, *objVals,
NULL, NULL, &errNum);
obj1 = WlzAssignObject(obj1, &errNum);
if((p >= srcObj->domain.p->plane1) &&
(p <= srcObj->domain.p->lastpl) &&
(srcObj->domain.p->domains[p-srcObj->domain.p->plane1].core)){
obj2 =
WlzMakeMain(WLZ_2D_DOMAINOBJ,
srcObj->domain.p->domains[p-srcObj->domain.p->plane1],
srcObj->values.vox->values[p-srcObj->domain.p->plane1],
NULL, NULL, &errNum);
}
else {
obj2 = WlzMakeEmpty(NULL);
}
obj2 = WlzAssignObject(obj2, &errNum);
tmpObj = WlzGreyTransfer(obj1, obj2, &errNum);
*valuess = WlzAssignValues(tmpObj->values, &errNum);
WlzFreeObj(obj1);
WlzFreeObj(obj2);
WlzFreeObj(tmpObj);
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
