/*!
* \ingroup WlzAllocation
* \brief Free a voxel value table
*
* \return Error number, values: WLZ_ERR_NONE,
WLZ_ERR_VOXELVALUES_TYPE and from WlzFreeValues().
* \param voxtab
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFreeVoxelValueTb(WlzVoxelValues *voxtab)
{
WlzValues *values;
int nplanes;
WlzErrorNum errNum = WLZ_ERR_NONE;
/* check the object pointer and linkcount */
if (voxtab == NULL){
return( WLZ_ERR_NONE );
}
/* check the type */
if( voxtab->type != WLZ_VOXELVALUETABLE_GREY ){
return WLZ_ERR_VOXELVALUES_TYPE;
}
if( WlzUnlink(&(voxtab->linkcount), &errNum) ){
nplanes = voxtab->lastpl - voxtab->plane1 + 1;
values = voxtab->values;
while( nplanes-- ){
errNum |= WlzFreeValues(*values);
values++;
}
WlzFreeVoxelValueTb(voxtab->original_table.vox);
AlcFreeStackFree(voxtab->freeptr);
AlcFree((char *) voxtab);
}
return( errNum );
}
/*!
* \return New convex hull values.
* \ingroup WlzConvexHull
* \brief Fill in parameters of the convex hull into the values table.
* \param cvh Given convex hull.
* \param obj Given object.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzConvHullValues *WlzMakeConvexHullValues3d(
WlzObject *cvh,
WlzObject *obj,
WlzErrorNum *dstErr)
{
WlzValues rtnvalues, *valuess, values;
WlzObject *obj1, *obj2;
WlzDomain *domains1, *domains2;
WlzPixelV bckgrnd;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* this is only called after a successful call to WlzObjToConvexPolygon
therefore the given convex hull object and object have been checked
and match */
rtnvalues.c = NULL;
bckgrnd.type = WLZ_GREY_UBYTE;
bckgrnd.v.ubv = 0;
/* make a voxeltable and calculate the convex hull values for each plane */
if((rtnvalues.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_CONV_HULL,
cvh->domain.p->plane1,
cvh->domain.p->lastpl,
bckgrnd, NULL, &errNum)) != NULL){
domains1 = cvh->domain.p->domains;
domains2 = obj->domain.p->domains;
valuess = rtnvalues.vox->values;
for(p=cvh->domain.p->plane1; p <= cvh->domain.p->lastpl;
p++, domains1++, domains2++, valuess++){
if( (*domains1).core != NULL ){
values.core = NULL;
obj1 = WlzMakeMain(WLZ_2D_POLYGON, *domains1, values,
NULL, NULL, NULL);
obj2 = WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains2, values,
NULL, NULL, NULL);
if((values.c = WlzMakeConvexHullValues(obj1, obj2, &errNum)) != NULL){
*valuess = WlzAssignValues(values, NULL);
}
else {
WlzFreeObj(obj2);
WlzFreeObj(obj1);
WlzFreeVoxelValueTb(rtnvalues.vox);
rtnvalues.vox = NULL;
break;
}
WlzFreeObj(obj2);
WlzFreeObj(obj1);
}
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnvalues.c;
}
/*!
* \return New grey value domain object with incrementing values.
* \ingroup WlzValuesUtils
* \brief Creates a new 3D domain object with integer values that
* increment throughout the object in scan order. Object
* values are set by incrementing the given value in place.
* \param in Input domain object.
* \param val Pointer to current value, this is
* incremented in place.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzGreyNewIncValues3D(WlzObject *in, int *val,
WlzErrorNum *dstErr)
{
WlzObjectType gTT;
WlzObject *out = NULL;
WlzPixelV bgd;
WlzValues values;
WlzErrorNum errNum = WLZ_ERR_NONE;
bgd.type = WLZ_GREY_INT;
bgd.v.inv = 0;
values.core = NULL;
gTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, WLZ_GREY_INT, &errNum);
values.vox = WlzNewValuesVox(in, gTT, bgd, &errNum);
if(errNum == WLZ_ERR_NONE)
{
out = WlzMakeMain(in->type, in->domain, values, in->plist, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzGreySetIncValuesItr(out, val);
}
if(errNum != WLZ_ERR_NONE)
{
if(out)
{
(void )WlzFreeObj(out);
out = NULL;
}
else if(values.core != NULL)
{
(void )WlzFreeVoxelValueTb(values.vox);
}
}
if(dstErr != NULL)
{
*dstErr = errNum;
}
return(out);
}
/*!
* \return Rescaled object.
* \ingroup WlzTransform
* \brief Rescales the given 3D domain object using an integer scale.
* \param gObj 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.
*/
WlzObject *WlzIntRescaleObj3D(WlzObject *gObj, int scale, int expand,
WlzErrorNum *dstErr)
{
int gPIdx,
nPIdx;
WlzDomain gDom,
nDom;
WlzValues gVal,
nVal,
dumVal;
WlzObject *gTObj = NULL,
*nTObj = NULL,
*rObj = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
WlzIBox3 nBox;
nDom.core = NULL;
nVal.core = NULL;
dumVal.core = NULL;
gDom = gObj->domain;
gVal = gObj->values;
if(expand)
{
nBox.xMin = gDom.p->kol1 * scale;
nBox.xMax = ((gDom.p->lastkl + 1) * scale) - 1;
nBox.yMin = gDom.p->line1 * scale;
nBox.yMax = ((gDom.p->lastln + 1) * scale) - 1;
nBox.zMin = gDom.p->plane1 * scale;
nBox.zMax = ((gDom.p->lastpl + 1) * scale) - 1;
}
else
{
nBox.xMin = gDom.p->kol1 / scale;
nBox.xMax = gDom.p->lastkl / scale;
nBox.yMin = gDom.p->line1 / scale;
nBox.yMax = gDom.p->lastln / scale;
nBox.zMin = gDom.p->plane1 / scale;
nBox.zMax = gDom.p->lastpl / scale;
}
nDom.p = WlzMakePlaneDomain(gDom.p->type, nBox.zMin, nBox.zMax,
nBox.yMin, nBox.yMax, nBox.xMin, nBox.xMax,
&errNum);
if(errNum == WLZ_ERR_NONE)
{
if(gVal.core && (gVal.core->type != WLZ_EMPTY_OBJ))
{
if(WlzGreyTableIsTiled(gVal.core->type))
{
errNum = WLZ_ERR_VALUES_TYPE;
}
else
{
nVal.vox = WlzMakeVoxelValueTb(gVal.vox->type, nBox.zMin, nBox.zMax,
WlzGetBackground(gObj, NULL),
NULL, &errNum);
}
}
}
if(errNum == WLZ_ERR_NONE)
{
nPIdx = nBox.zMin;
while((errNum == WLZ_ERR_NONE) && (nPIdx <= nBox.zMax))
{
gPIdx = (expand)? nPIdx / scale: nPIdx * scale;
if(nVal.vox)
{
gTObj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
*(gDom.p->domains + gPIdx),
*(gVal.vox->values + gPIdx),
NULL, NULL, &errNum);
}
else
{
gTObj = WlzMakeMain(WLZ_2D_DOMAINOBJ,
*(gDom.p->domains + gPIdx),
dumVal,
NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
nTObj = WlzIntRescaleObj2D(gTObj, scale, expand, &errNum);
}
(void )WlzFreeObj(gTObj);
gTObj = NULL;
if(errNum == WLZ_ERR_NONE)
{
*(nDom.p->domains + nPIdx) = WlzAssignDomain(nTObj->domain, NULL);
if(nVal.vox)
{
*(nVal.vox->values + nPIdx) = WlzAssignValues(nTObj->values, NULL);
}
}
(void )WlzFreeObj(nTObj);
nTObj = NULL;
++nPIdx;
}
}
if(errNum == WLZ_ERR_NONE)
{
rObj = WlzMakeMain(gObj->type, nDom, nVal, NULL, NULL, &errNum);
}
else
{
(void )WlzFreePlaneDomain(nDom.p);
(void )WlzFreeVoxelValueTb(nVal.vox);
}
if(dstErr)
{
*dstErr = errNum;
}
return(rObj);
}
/*!
* \return New woolz object or NULL on error.
* \ingroup WlzArithmetic
* \brief Scales the values of the given 3D Woolz object so that
* \f$v_{new} = m v_{given} + a.\f$ The input object is known
* to be a valid 3D domain object with grey values.
* \param iObj Given object.
* \param m Value to multiply object values by.
* \param a Value to add to product.
* \param rGType Required grey type for returned object.
* \param dstErr Destination error pointer, may be NULL.
*/
static WlzObject *WlzScalarMulAdd3D(WlzObject *iObj, WlzPixelV m, WlzPixelV a,
WlzGreyType rGType, WlzErrorNum *dstErr)
{
WlzValues rValues;
WlzObjectType rVType;
WlzPixelV bgdV;
WlzObject *rObj = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
rValues.core = NULL;
bgdV = WlzGetBackground(iObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
rVType = WlzGreyTableType(WLZ_GREY_TAB_RAGR, rGType, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
rValues.vox = WlzNewValuesVox(iObj, rVType, bgdV, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
int idP,
plMin,
plMax;
WlzPlaneDomain *iPDom;
WlzVoxelValues *iVox,
*rVox;
iPDom = iObj->domain.p;
iVox = iObj->values.vox;
rVox = rValues.vox;
plMin = iPDom->plane1;
plMax = iPDom->lastpl;
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(idP = plMin; idP <= plMax; ++idP)
{
WlzErrorNum errNum2D = WLZ_ERR_NONE;
if(errNum == WLZ_ERR_NONE)
{
int idO;
WlzDomain *iDom2D;
WlzValues *iVal2D,
*rVal2D;
idO = idP - iPDom->plane1;
iDom2D = iPDom->domains + idO;
iVal2D = iVox->values + idO;
rVal2D = rVox->values + idO;
if(((*iDom2D).core != NULL) && ((*iVal2D).core != NULL) &&
((*rVal2D).core != NULL))
{
WlzObject *iObj2D = NULL,
*rObj2D = NULL;
if((iObj2D = WlzMakeMain(WLZ_2D_DOMAINOBJ, *iDom2D, *iVal2D,
NULL, NULL, &errNum2D)) != NULL)
{
rObj2D = WlzScalarMulAdd2D(iObj2D, m, a, rGType, &errNum2D);
}
if(errNum2D == WLZ_ERR_NONE)
{
*rVal2D = WlzAssignValues(rObj2D->values, NULL);
}
(void )WlzFreeObj(iObj2D);
(void )WlzFreeObj(rObj2D);
}
}
if(errNum2D != WLZ_ERR_NONE)
{
#ifdef _OPENMP
#pragma omp critical
{
#endif
if(errNum == WLZ_ERR_NONE)
{
errNum = errNum2D;
}
#ifdef _OPENMP
}
#endif
}
}
}
if(errNum == WLZ_ERR_NONE)
{
rObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, iObj->domain, rValues,
iObj->plist, iObj->assoc, &errNum);
}
if(errNum != WLZ_ERR_NONE)
{
if(rObj == NULL)
{
(void )WlzFreeVoxelValueTb(rValues.vox);
}
else
{
(void )WlzFreeObj(rObj);
rObj = NULL;
}
}
if(dstErr != NULL)
{
*dstErr = errNum;
}
return(rObj);
}
/*!
* \ingroup WlzAllocation
* \brief Free space allocated to a woolz object.
*
* \return Error number, values: WLZ_ERR_NONE, WLZ_ERR_MEM_FREE
* \param obj Object to be freed.
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFreeObj(WlzObject *obj)
{
int i;
WlzCompoundArray *ca = (WlzCompoundArray *) obj;
WlzErrorNum errNum = WLZ_ERR_NONE;
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_FN|WLZ_DBG_LVL_1),
("WlzFreeObj FE %p\n",
obj));
/* check the object pointer and linkcount */
if (obj == NULL){
return( WLZ_ERR_NONE );
}
if( WlzUnlink(&(obj->linkcount), &errNum) ){ /* Check linkcount */
switch( obj->type ){
case WLZ_2D_DOMAINOBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_2D_DOMAINOBJ "
"%p %d %p %d %p\n",
obj, (obj->domain.i),
(obj->domain.i?obj->domain.i->linkcount: 0),
(obj->values.core),
((obj->values.core)? obj->values.core->linkcount: 0),
(obj->plist)));
errNum = WlzFreeDomain(obj->domain);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL)) {
if(WlzGreyTableIsTiled(obj->values.core->type) == WLZ_GREY_TAB_TILED) {
errNum = WlzFreeTiledValues(obj->values.t);
}
else {
errNum = WlzFreeValueTb(obj->values.v);
}
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreePropertyList(obj->plist);
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_3D_DOMAINOBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_3D_DOMAINOBJ %p, "
"%d %p %d %p\n",
obj, obj->domain.i,
(obj->domain.p? obj->domain.p->linkcount: 0),
obj->values.core,
(obj->values.core? obj->values.core->linkcount: 0),
obj->plist));
errNum = WlzFreePlaneDomain(obj->domain.p);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL)){
if(WlzGreyTableIsTiled(obj->values.core->type) == WLZ_GREY_TAB_TILED) {
errNum = WlzFreeTiledValues(obj->values.t);
}
else {
errNum = WlzFreeVoxelValueTb(obj->values.vox);
}
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreePropertyList(obj->plist);
}
if(errNum == WLZ_ERR_NONE) {
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_TRANS_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_TRANS_OBJ %p, "
"%d %p %d %p\n",
obj, obj->domain.t,
((obj->domain.t)?(obj->domain.t)->linkcount: 0),
obj->values.obj,
((obj->values.obj)?(obj->values.obj)->linkcount: 0),
obj->plist));
if( WlzFreeAffineTransform(obj->domain.t) ||
WlzFreeObj(obj->values.obj) ||
WlzFreePropertyList(obj->plist) ||
WlzFreeObj(obj->assoc) ){
errNum = WLZ_ERR_MEM_FREE;
}
break;
case WLZ_2D_POLYGON:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_2D_POLYGON %p\n",
obj, obj->domain.poly));
errNum = WlzFreePolyDmn(obj->domain.poly);
break;
case WLZ_BOUNDLIST:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_BOUNDLIST %p\n",
obj, obj->domain.b));
errNum = WlzFreeBoundList(obj->domain.b);
break;
case WLZ_CONTOUR:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONTOUR %p\n",
obj, obj->domain.ctr));
errNum = WlzFreeContour(obj->domain.ctr);
break;
case WLZ_CONV_HULL:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONV_HULL %p %p\n",
obj, obj->domain.core, obj->values.core));
if(obj->domain.core) {
switch(obj->domain.core->type) {
case WLZ_CONVHULL_DOMAIN_2D:
errNum = WlzFreeConvexHullDomain2(obj->domain.cvh2);
break;
case WLZ_CONVHULL_DOMAIN_3D:
errNum = WlzFreeConvexHullDomain3(obj->domain.cvh3);
break;
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
break;
case WLZ_CMESH_2D:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_2D %p, "
"%d %p %d %p\n",
obj, obj->domain.cm2,
((obj->domain.cm2)? (obj->domain.cm2)->linkcount: 0),
obj->values.x,
((obj->values.x)? (obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree2D(obj->domain.cm2);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_CMESH_2D5:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_2D5 %p, "
"%d %p %d %p\n",
obj, obj->domain.cm2d5,
((obj->domain.cm2d5)? (obj->domain.cm2d5)->linkcount: 0),
obj->values.x,
((obj->values.x)? (obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree2D5(obj->domain.cm2d5);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_CMESH_3D:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CMESH_3D %p, "
"%d %p %d %p\n",
obj, obj->domain.cm3,
((obj->domain.cm3)?(obj->domain.cm3)->linkcount: 0),
obj->values.x,
((obj->values.x)?(obj->values.x)->linkcount: 0),
obj->plist));
errNum = WlzCMeshFree3D(obj->domain.cm3);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreeIndexedValues(obj->values.x);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_POINTS:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_POINTS %p\n",
obj, obj->domain.pts));
errNum = WlzFreeDomain(obj->domain);
if((errNum == WLZ_ERR_NONE) && (obj->values.core != NULL))
{
errNum = WlzFreePointValues(obj->values.pts);
}
if((errNum == WLZ_ERR_NONE) && (obj->plist != NULL))
{
errNum = WlzFreePropertyList(obj->plist);
}
if((errNum == WLZ_ERR_NONE) && (obj->assoc != NULL))
{
errNum = WlzFreeObj(obj->assoc);
}
break;
case WLZ_HISTOGRAM:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_CONV_HULL %p\n",
obj, obj->domain.hist));
errNum = WlzFreeDomain(obj->domain);
break;
case WLZ_RECTANGLE:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_RECTANGLE %p\n",
obj, obj->domain.r));
errNum = WlzFreeDomain(obj->domain);
break;
case WLZ_AFFINE_TRANS:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_AFFINE_TRANS\n",
obj));
errNum = WlzFreeAffineTransform(obj->domain.t);
break;
case WLZ_LUT:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_LUT\n",
obj));
errNum = WlzFreeDomain(obj->domain);
if(errNum == WLZ_ERR_NONE)
{
errNum = WlzFreeLUTValues(obj->values);
}
break;
case WLZ_COMPOUND_ARR_1:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_COMPOUND_ARR_1\n",
ca));
for (i=0; i<ca->n; i++){
if( WlzFreeObj(ca->o[i]) != WLZ_ERR_NONE ){
errNum = WLZ_ERR_MEM_FREE;
}
}
break;
case WLZ_COMPOUND_ARR_2:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_COMPOUND_ARR_2\n",
ca));
for (i=0; i<ca->n; i++){
if( WlzFreeObj(ca->o[i]) != WLZ_ERR_NONE ){
errNum = WLZ_ERR_MEM_FREE;
}
}
break;
case WLZ_PROPERTY_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_PROPERTY_OBJ\n",
obj));
errNum = WlzFreePropertyList(obj->plist);
break;
case WLZ_EMPTY_OBJ:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p WLZ_EMPTY_OBJ\n",
obj));
break;
default:
WLZ_DBG((WLZ_DBG_ALLOC|WLZ_DBG_LVL_1),
("WlzFreeObj %p %d\n",
obj, (int )(obj->type)));
errNum = WLZ_ERR_OBJECT_TYPE;
break;
} /* End of switch */
AlcFree((void *) obj);
}
return( errNum );
}
static WlzObject *WlzIndexToRGBA3D(
WlzObject *obj,
unsigned char colormap[3][256],
WlzErrorNum *dstErr)
{
WlzObject *obj1, *temp;
WlzPlaneDomain *pdom, *npdom;
WlzVoxelValues *voxtab, *nvoxtab;
WlzDomain *domains, *ndomains, domain;
WlzValues *values, *nvalues, vals;
int i, nplanes;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* no need to check the object pointer or type because this procedure
can only be accessed via WlzIndexToRGBA. The domain and valuetable
must be checked however */
obj1 = NULL;
if( obj->domain.p == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->values.vox == NULL ){
errNum = WLZ_ERR_VALUES_NULL;
}
/* check types */
if( errNum == WLZ_ERR_NONE ){
switch( obj->domain.p->type ){
case WLZ_PLANEDOMAIN_DOMAIN:
break;
default:
errNum = WLZ_ERR_PLANEDOMAIN_TYPE;
break;
}
}
if( errNum == WLZ_ERR_NONE ){
switch( obj->values.vox->type ){
case WLZ_VOXELVALUETABLE_GREY:
break;
default:
errNum = WLZ_ERR_VOXELVALUES_TYPE;
break;
}
}
/* make new planedomain and voxelvaluetable */
if( errNum == WLZ_ERR_NONE ){
pdom = obj->domain.p;
voxtab = obj->values.vox;
npdom = WlzMakePlaneDomain(pdom->type,
pdom->plane1, pdom->lastpl,
pdom->line1, pdom->lastln,
pdom->kol1, pdom->lastkl, &errNum);
}
if((errNum == WLZ_ERR_NONE) &&
((nvoxtab = WlzMakeVoxelValueTb(voxtab->type, voxtab->plane1,
voxtab->lastpl, voxtab->bckgrnd,
NULL, &errNum)) == NULL) ){
WlzFreePlaneDomain(npdom);
}
if( errNum == WLZ_ERR_NONE ){
/* set up variables */
domains = pdom->domains;
ndomains = npdom->domains;
values = voxtab->values;
nvalues = nvoxtab->values;
nplanes = pdom->lastpl - pdom->plane1 + 1;
/* copy voxel_sizes */
for(i=0; i < 3; i++){
npdom->voxel_size[i] = pdom->voxel_size[i];
}
}
/* convert each plane */
while( (errNum == WLZ_ERR_NONE) && nplanes-- ){
if(((*domains).core == NULL) || ((*values).core == NULL)){
(*ndomains).core = NULL;
(*nvalues).core = NULL;
}
else if((temp = WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, *values,
NULL, NULL, &errNum)) != NULL){
if( temp->domain.i != NULL ){
if((obj1 = WlzIndexToRGBA(temp, colormap, &errNum)) != NULL){
if( obj1->type == WLZ_2D_DOMAINOBJ ){
*ndomains = WlzAssignDomain(obj1->domain, NULL);
*nvalues = WlzAssignValues(obj1->values, NULL);
}
else {
(*ndomains).core = NULL;
(*nvalues).core = NULL;
}
WlzFreeObj(obj1);
}
} else {
(*ndomains).core = NULL;
(*nvalues).core = NULL;
}
}
else {
WlzFreePlaneDomain(npdom);
WlzFreeVoxelValueTb( nvoxtab );
break;
}
domains++;
ndomains++;
values++;
nvalues++;
}
/* return a new object */
if( errNum == WLZ_ERR_NONE ){
domain.p = npdom;
vals.vox = nvoxtab;
if((obj1 = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, vals,
NULL, obj, &errNum)) != NULL){
/* nvoxtab->original = obj1; */
nvoxtab->original_table = WlzAssignValues(obj->values, NULL);
}
else {
WlzFreePlaneDomain( npdom );
WlzFreeVoxelValueTb( nvoxtab );
}
}
if( dstErr ){
*dstErr = errNum;
}
return obj1;
}
/*!
* \return New 3D domain object with corresponding WLZ_GREY_RGBA values.
* \ingroup WlzValuesUtils
* \brief Creates a WLZ_GREY_RGBA valued object from the given compound
* array. This is a static function which will always be called
* with valid parameters so they aren't checked.
* \param cObj Compound array object.
* \param cSpc The colour space.
* \param dstErr Destination error pointer may be NULL.
*/
static WlzObject *WlzCompoundToRGBA3D(WlzCompoundArray *cObj,
WlzRGBAColorSpace cSpc, WlzErrorNum *dstErr)
{
WlzIBox3 bBox;
WlzDomain dom;
WlzValues val;
WlzPixelV bgd;
WlzObject *rObj = NULL;
WlzErrorNum errNum = WLZ_ERR_NONE;
dom.core = NULL;
val.core = NULL;
bgd.v.rgbv = 0;
bgd.type = WLZ_GREY_RGBA;
bBox = WlzBoundingBox3I((WlzObject *)cObj, &errNum);
if(errNum == WLZ_ERR_NONE)
{
dom.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, bBox.zMin, bBox.zMax,
bBox.yMin, bBox.yMax, bBox.xMin, bBox.xMax,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
val.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY,
bBox.zMin, bBox.zMax, bgd, NULL,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
rObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, dom, val, NULL, NULL, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
int idP,
nPl;
nPl = bBox.zMax - bBox.zMin + 1;
for(idP = 0; idP < nPl; ++idP)
{
if(errNum == WLZ_ERR_NONE)
{
int idC;
WlzObject *rObj2 = NULL;
WlzCompoundArray *cObj2 = NULL;
WlzErrorNum errNum2 = WLZ_ERR_NONE;
cObj2 = WlzMakeCompoundArray(WLZ_COMPOUND_ARR_2, 1, cObj->n,
NULL, WLZ_2D_DOMAINOBJ, &errNum2);
idC = 0;
while((errNum2 == WLZ_ERR_NONE) && (idC < cObj->n))
{
int idP2,
nPl2;
WlzDomain dom2;
WlzValues val2;
dom2.core = NULL;
val2.core = NULL;
if((cObj->o[idC] != NULL) &&
(cObj->o[idC]->type == WLZ_3D_DOMAINOBJ))
{
idP2 = bBox.zMin + idP - cObj->o[idC]->domain.p->plane1;
nPl2 = cObj->o[idC]->domain.p->lastpl -
cObj->o[idC]->domain.p->plane1 + 1;
if((idP2 >= 0) && (idP2 <= nPl2))
{
dom2 = *(cObj->o[idC]->domain.p->domains + idP2);
val2 = *(cObj->o[idC]->values.vox->values + idP2);
}
}
cObj2->o[idC] = (dom2.core == NULL)?
WlzMakeEmpty(&errNum2):
WlzMakeMain(WLZ_2D_DOMAINOBJ, dom2, val2,
NULL, NULL, &errNum2);
++idC;
}
if(errNum2 == WLZ_ERR_NONE)
{
rObj2 = WlzCompoundToRGBA2D(cObj2, cSpc, &errNum2);
}
if(errNum2 == WLZ_ERR_NONE)
{
dom.p->domains[idP] = WlzAssignDomain(rObj2->domain, NULL);
val.vox->values[idP] = WlzAssignValues(rObj2->values, NULL);
}
(void )WlzFreeObj(rObj2);
(void )WlzFreeObj((WlzObject *)cObj2);
if(errNum2 != WLZ_ERR_NONE)
{
errNum = errNum2;
}
}
}
}
if(errNum != WLZ_ERR_NONE)
{
if(rObj != NULL)
{
(void )WlzFreeObj(rObj);
rObj = NULL;
}
else
{
(void )WlzFreePlaneDomain(dom.p);
(void )WlzFreeVoxelValueTb(val.vox);
}
}
if(dstErr)
{
*dstErr = errNum;
}
return(rObj);
}
