/*!
* \ingroup WlzAllocation
* \brief Free a 3D warp transform.
*
* \return Error number, values: WLZ_ERR_NONE and from WlzFreePlaneDomain().
* \param obj 3D warp transform object to be freed.
* \par Source:
* WlzFreeSpace.c
*/
WlzErrorNum WlzFree3DWarpTrans(Wlz3DWarpTrans *obj)
{
WlzErrorNum errNum = WLZ_ERR_NONE;
if(obj == NULL)
{
errNum = WLZ_ERR_OBJECT_NULL;
}
else
{
if(obj->intptdoms)
{
(void )AlcFree(obj->intptdoms);
}
if(obj->pdom)
{
errNum = WlzFreePlaneDomain(obj->pdom);
}
(void )AlcFree(obj);
}
return(errNum);
}
/*!
* \ingroup WlzBoundary
* \brief Return a domain object corresponding to the input boundary
object.
*
* \return Domain object corresponding to the input boundary, NULL on error.
* \param boundary Input boundary object.
* \param fillMode Fill mode for the individual polyline boundaries.
If the input object is a genuine boundary object then there will be no
self-intersecting polylines and <tt> fillMode = WLZ_SIMPLE_FILL </tt>
is appropriate. See WlzPolyToObj().
* \param dstErr Error return
* \par Source:
* WlzBoundToObj.c
*/
WlzObject *WlzBoundaryToObj(
WlzObject *boundary,
WlzPolyFillMode fillMode,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL, *tmpObj;
WlzDomain domain, *domains, *bnddmns;
WlzValues values;
int p;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check object */
if( boundary == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else {
switch( boundary->type ){
case WLZ_3D_DOMAINOBJ:
/* check plane domain */
if( boundary->domain.p == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else {
switch( boundary->domain.p->type ){
case WLZ_PLANEDOMAIN_BOUNDLIST:
if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN,
boundary->domain.p->plane1,
boundary->domain.p->lastpl,
boundary->domain.p->line1,
boundary->domain.p->lastln,
boundary->domain.p->kol1,
boundary->domain.p->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = boundary->domain.p->voxel_size[0];
domain.p->voxel_size[1] = boundary->domain.p->voxel_size[1];
domain.p->voxel_size[2] = boundary->domain.p->voxel_size[2];
domains = domain.p->domains;
bnddmns = boundary->domain.p->domains;
for(p=domain.p->plane1; p <= domain.p->lastpl;
p++, domains++, bnddmns++){
if( (*bnddmns).poly ){
if((tmpObj = WlzBoundToObj((*bnddmns).b, fillMode,
&errNum)) != NULL){
*domains = WlzAssignDomain(tmpObj->domain, NULL);
WlzFreeObj(tmpObj);
}
else {
WlzFreePlaneDomain(domain.p);
domain.p = NULL;
break;
}
}
}
if( domain.p ){
values.core = NULL;
if( (rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum)) == NULL ){
WlzFreePlaneDomain(domain.p);
}
}
}
break;
case WLZ_EMPTY_DOMAIN:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_DOMAIN_TYPE;
break;
}
}
break;
case WLZ_BOUNDLIST:
return WlzBoundToObj(boundary->domain.b, fillMode, dstErr);
case WLZ_TRANS_OBJ:
if((values.obj = WlzBoundaryToObj(boundary->values.obj, fillMode,
&errNum)) != NULL){
return WlzMakeMain(WLZ_TRANS_OBJ, boundary->domain, values,
NULL, NULL, dstErr);
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
/*!
* \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);
}
static WlzObject *WlzSelect1InN(
WlzObject *obj,
int first_pl,
int last_pl,
int step,
WlzErrorNum *dstErr)
{
WlzObject *nobj=NULL;
int p, new_p, new_plane1, new_lastpl;
WlzDomain domain;
WlzValues values;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check the object */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
if( errNum == WLZ_ERR_NONE ){
domain.core = NULL;
values.core = NULL;
switch( obj->type ){
case WLZ_3D_DOMAINOBJ:
if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
break;
}
if( obj->domain.core->type == WLZ_EMPTY_DOMAIN ){
return WlzMakeEmpty(dstErr);
}
break;
case WLZ_EMPTY_OBJ:
return WlzMakeEmpty(dstErr);
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
/* check the parameters */
if( errNum == WLZ_ERR_NONE ){
if( first_pl > last_pl ){
errNum = WLZ_ERR_PARAM_DATA;
}
else if( step <= 0 ){
errNum = WLZ_ERR_PARAM_DATA;
}
/* check for empty object */
else if((first_pl > obj->domain.p->lastpl) ||
(last_pl < obj->domain.p->plane1) ){
return WlzMakeEmpty(dstErr);
}
}
/* make a new planedomain and voxel table as required */
if( errNum == WLZ_ERR_NONE ){
for(p=first_pl; p <= last_pl; p += step){
if( p >= obj->domain.p->plane1 ){
new_plane1 = p / step;
break;
}
}
for(;p <= last_pl; p += step){
if( p > obj->domain.p->lastpl ){
break;
}
new_lastpl = p / step;
}
if((domain.p = WlzMakePlaneDomain(obj->domain.p->type,
new_plane1, new_lastpl,
obj->domain.p->line1,
obj->domain.p->lastln,
obj->domain.p->kol1,
obj->domain.p->lastkl,
&errNum)) != NULL){
domain.p->voxel_size[0] = obj->domain.p->voxel_size[0];
domain.p->voxel_size[1] = obj->domain.p->voxel_size[1];
domain.p->voxel_size[2] = step * (obj->domain.p->voxel_size[2]);
if( obj->values.core != NULL ){
if( (values.vox =
WlzMakeVoxelValueTb(obj->values.vox->type,
new_plane1, new_lastpl,
obj->values.vox->bckgrnd,
obj, &errNum)) == NULL ){
(void) WlzFreePlaneDomain(domain.p);
}
}
}
}
/* set domain and voxel values */
if( errNum == WLZ_ERR_NONE ){
for(p=first_pl; p <= last_pl; p += step){
if( p < obj->domain.p->plane1 ){
continue;
}
if( p > obj->domain.p->lastpl ){
break;
}
new_p = (p / step) - domain.p->plane1;
domain.p->domains[new_p] =
WlzAssignDomain(obj->domain.p->domains[p - obj->domain.p->plane1],
NULL);
if( obj->values.core != NULL ){
values.vox->values[new_p] =
WlzAssignValues(
obj->values.vox->values[p - obj->domain.p->plane1], NULL);
}
}
}
if( errNum == WLZ_ERR_NONE ){
nobj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values,
NULL, NULL, &errNum);
}
if( dstErr ){
*dstErr = errNum;
}
return nobj;
}
/*!
* \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);
}
