/*! * \return * \brief * \param obj * \param dstErr */ static WlzObject *WlzObjToConvexPolygon3d( WlzObject *obj, WlzErrorNum *dstErr) { WlzObject *polygon=NULL, *obj1, *obj2; WlzDomain domain, *domains, *new_domains; WlzValues values; int p; WlzErrorNum errNum=WLZ_ERR_NONE; /* the object and domain have been checked therefore can create the new straight away and fill each plane appropriately */ if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_POLYGON, obj->domain.p->plane1, obj->domain.p->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] = obj->domain.p->voxel_size[2]; values.core = NULL; polygon = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } if( errNum == WLZ_ERR_NONE ){ domains = obj->domain.p->domains; new_domains = domain.p->domains; values.core = NULL; for(p=obj->domain.p->plane1; p <= obj->domain.p->lastpl; p++, domains++, new_domains++){ if( (*domains).core ){ obj1 = WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, values, NULL, NULL, NULL); if((obj2 = WlzObjToConvexPolygon(obj1, &errNum)) != NULL){ *new_domains = WlzAssignDomain(obj2->domain, NULL); WlzFreeObj(obj2); } else { WlzFreeObj(polygon); polygon = NULL; break; } WlzFreeObj(obj1); } else { (*new_domains).core = NULL; } } } if( dstErr ){ *dstErr = errNum; } return polygon; }
/*! * \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 New Woolz object without holes or NULL on error. * \ingroup WlzDomainOps * \brief Fills the holes in the given object's domain (which are by * definition not connected to the outside). When the given * object's domain has more than one component part, the * object should first be labeled, this function should then be * called for each of the labeled parts and then the union of * the filled domains should be formed. * \param srcObj Given 3D domain object. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzDomainFill3D( WlzObject *srcObj, WlzErrorNum *dstErr) { int nPln = 0; WlzObject *bndObj = NULL, *filObj = NULL, *gvnObj = NULL, *sedObj = NULL, *shlObj = NULL; WlzPixelV zeroV; WlzValues nullVal; WlzErrorNum errNum = WLZ_ERR_NONE; nullVal.core = NULL; zeroV.type = WLZ_GREY_UBYTE; zeroV.v.ubv = 0; if(srcObj == NULL) { errNum = WLZ_ERR_OBJECT_NULL; } else if(srcObj->type != WLZ_3D_DOMAINOBJ) { errNum = WLZ_ERR_OBJECT_TYPE; } else if(srcObj->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } else { gvnObj = WlzMakeMain(srcObj->type, srcObj->domain, nullVal, NULL, NULL, &errNum); } /* Create a then shell 1 voxel thick just inside the given objects's * domain. */ if(errNum == WLZ_ERR_NONE) { WlzObject *difObj = NULL; difObj = WlzAssignObject( WlzBoundaryDomain(gvnObj, &errNum), NULL); if(errNum == WLZ_ERR_NONE) { WlzIBox3 clipBox; /* Clip the dilated shell domain to make sure it stays within the * bounding box of the given object then all planes will align. */ clipBox.xMin = gvnObj->domain.p->kol1; clipBox.yMin = gvnObj->domain.p->line1; clipBox.zMin = gvnObj->domain.p->plane1; clipBox.xMax = gvnObj->domain.p->lastkl; clipBox.yMax = gvnObj->domain.p->lastln; clipBox.zMax = gvnObj->domain.p->lastpl; shlObj = WlzAssignObject( WlzClipObjToBox3D(difObj, clipBox, &errNum), NULL); } (void )WlzFreeObj(difObj); } /* Make sure that the bounding box of the thin shell domain fits it and * that it's first and last planes have interrvals. */ if(errNum == WLZ_ERR_NONE) { errNum = WlzStandardPlaneDomain(shlObj->domain.p, NULL); } /* Create a value table for the shell object with values set to zero. */ if(errNum == WLZ_ERR_NONE) { WlzValues val; WlzObjectType tType; tType = WlzGreyTableType(WLZ_GREY_TAB_INTL, WLZ_GREY_UBYTE, NULL); val.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, shlObj->domain.p->plane1, shlObj->domain.p->lastpl, zeroV, NULL, &errNum); if(errNum == WLZ_ERR_NONE) { int p; nPln = shlObj->domain.p->lastpl - shlObj->domain.p->plane1 + 1; shlObj->values = WlzAssignValues(val, NULL); #ifdef _OPENMP #pragma omp parallel for shared(shlObj) #endif for(p = 0; p < nPln; ++p) { if(errNum == WLZ_ERR_NONE) { WlzDomain dom2; WlzErrorNum errNum2; dom2 = shlObj->domain.p->domains[p]; if(dom2.core) { WlzValues val2; WlzObject *shlObj2; shlObj2 = WlzMakeMain(WLZ_2D_DOMAINOBJ, dom2, nullVal, NULL, NULL, &errNum2); if(errNum2 == WLZ_ERR_NONE) { val2.i = WlzMakeIntervalValues(tType, shlObj2, zeroV, &errNum2); /* WlzMakeIntervalValues() sets all values to zero. */ } if(errNum2 == WLZ_ERR_NONE) { shlObj->values.vox->values[p] = WlzAssignValues(val2, NULL); } (void )WlzFreeObj(shlObj2); if(errNum2 == WLZ_ERR_NONE) { #ifdef _OPENMP #pragma omp critical { #endif if((errNum == WLZ_ERR_NONE) && (errNum2 != WLZ_ERR_NONE)) { errNum = errNum2; } #ifdef _OPENMP } #endif } } } } } } /* Compute the (plane-wise) boundary list for the given object. */ if(errNum == WLZ_ERR_NONE) { bndObj = WlzObjToBoundary(gvnObj, 0, &errNum); } /* Sweep down through the boundary object setting the values of * those voxels in the shell object to a non zero value when they * correspond to top level boundaries. */ if(errNum == WLZ_ERR_NONE) { int p; #ifdef _OPENMP #pragma omp parallel for shared(bndObj,shlObj) #endif for(p = 0; p < nPln; ++p) { if(errNum == WLZ_ERR_NONE) { WlzDomain bDom2; bDom2 = bndObj->domain.p->domains[p]; if(bDom2.core) { WlzDomain iDom2; WlzValues iVal2; WlzObject *iObj2 = NULL; WlzGreyValueWSpace *gVWSp = NULL; WlzErrorNum errNum2 = WLZ_ERR_NONE; iDom2 = shlObj->domain.p->domains[p]; iVal2 = shlObj->values.vox->values[p]; iObj2 = WlzMakeMain(WLZ_2D_DOMAINOBJ, iDom2, iVal2, NULL, NULL, &errNum2); if(errNum == WLZ_ERR_NONE) { gVWSp = WlzGreyValueMakeWSp(iObj2, &errNum2); } if(errNum2 == WLZ_ERR_NONE) { WlzBoundList *bnd, *bnd2; bnd2 = bDom2.b; for(bnd = bnd2; bnd != NULL; bnd = bnd->next) { if(bnd->poly != NULL) { WlzPolygonDomain *ply; ply = bnd->poly; if(ply) { int i; WlzIVertex2 *vtx; vtx = ply->vtx; for(i = 0; i < ply->nvertices; ++i) { WlzGreyValueGet(gVWSp, 0, vtx[i].vtY, vtx[i].vtX); *(gVWSp->gPtr[0].ubp) = 255; } } } } } else { #ifdef _OPENMP #pragma omp critical { #endif if(errNum == WLZ_ERR_NONE) { errNum = errNum2; } #ifdef _OPENMP } #endif } (void )WlzFreeObj(iObj2); WlzGreyValueFreeWSp(gVWSp); } } } } /* Threshold the shell object, throwing away all but where the voxels * are set to create a seed domain. Then remove the value table from * the shell object and free it as it's no longer needed. */ if(errNum == WLZ_ERR_NONE) { WlzObject *tObj = NULL; WlzPixelV tV; tV.type = WLZ_GREY_UBYTE; tV.v.ubv = 1; tObj = WlzAssignObject( WlzThreshold(shlObj, tV, WLZ_THRESH_HIGH, &errNum), NULL); if(errNum == WLZ_ERR_NONE) { sedObj = WlzAssignObject( WlzMakeMain(tObj->type, tObj->domain, nullVal, NULL, NULL, &errNum), NULL); } (void )WlzFreeObj(tObj); tObj = NULL; if(errNum == WLZ_ERR_NONE) { tObj = WlzAssignObject( WlzMakeMain(shlObj->type, shlObj->domain, nullVal, NULL, NULL, &errNum), NULL); } (void )WlzFreeObj(shlObj); shlObj = NULL; if(errNum == WLZ_ERR_NONE) { shlObj = tObj; tObj = NULL; } (void )WlzFreeObj(tObj); #ifdef WLZ_DOMOMAINFILL3D_DEBUG { FILE *fP; fP = fopen("debug-shlObj-00.wlz", "w"); (void )WlzWriteObj(fP, shlObj); (void )fclose(fP); } #endif } /* Label the shell domain using 26-connectivity in 3D and then * keep only those component objects which intersect the seed domain. * Then free the shell and seed domains replacing the shell domain * with the union of the intersecting labeled component objects. * Finaly free the intersecting component objects, keeping only the * new shell domain. */ if(errNum == WLZ_ERR_NONE) { int i, j, nCSObj = 0; WlzIBox3 bBox; WlzObject **csObj = NULL; bBox = WlzBoundingBox3I(shlObj, &errNum); if(errNum == WLZ_ERR_NONE) { int maxCSObj; maxCSObj = ((bBox.xMax - bBox.xMin + 1) * (bBox.yMax - bBox.yMin + 1) * (bBox.zMax - bBox.zMin + 1)) / 8; if(maxCSObj < 8) { maxCSObj = 8; } errNum = WlzLabel(shlObj, &nCSObj, &csObj, maxCSObj, 0, WLZ_26_CONNECTED); } if(errNum == WLZ_ERR_NONE) { for(i = 0; i < nCSObj; ++i) { if(!WlzHasIntersection(csObj[i], sedObj, &errNum)) { (void )WlzFreeObj(csObj[i]); csObj[i] = NULL; } } } if(errNum == WLZ_ERR_NONE) { /* Squeeze out any NULL objects reseting their number.*/ for(i = 0, j = 0; i < nCSObj; ++i) { if(csObj[i]) { csObj[j++] = csObj[i]; } } nCSObj = j; } if(errNum == WLZ_ERR_NONE) { WlzObject *iObj = NULL, *uObj = NULL; uObj = WlzAssignObject( WlzUnionN(nCSObj, csObj, 0, &errNum), NULL); iObj = WlzAssignObject( WlzIntersect2(uObj, shlObj, &errNum), NULL); (void )WlzFreeObj(uObj); (void )WlzFreeObj(shlObj); shlObj = iObj; #ifdef WLZ_DOMOMAINFILL3D_DEBUG { FILE *fP; fP = fopen("debug-shlObj-01.wlz", "w"); (void )WlzWriteObj(fP, shlObj); (void )fclose(fP); } #endif } if(csObj) { for(i = 0; i < nCSObj; ++i) { (void )WlzFreeObj(csObj[i]); } (void )AlcFree(csObj); } } /* Sweep down through the boundary lists again creating new boundary lists * which do not have boundaries that do not intersect the new shell domain. * Then create a new filled object from these boundary lists. */ if(errNum == WLZ_ERR_NONE) { int p, nPlnFil; WlzDomain filDom; nPlnFil = shlObj->domain.p->lastpl - shlObj->domain.p->plane1 + 1; filDom.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, shlObj->domain.p->plane1, shlObj->domain.p->lastpl, shlObj->domain.p->line1, shlObj->domain.p->lastln, shlObj->domain.p->kol1, shlObj->domain.p->lastkl, &errNum); #ifdef _OPENMP #pragma omp parallel for shared(bndObj,shlObj) #endif for(p = 0; p < nPlnFil; ++p) { if(errNum == WLZ_ERR_NONE) { WlzDomain bDom2; bDom2 = bndObj->domain.p->domains[p]; if(bDom2.core) { WlzDomain sDom2; WlzObject *fObj2 = NULL; WlzBoundList *newBnd = NULL; WlzErrorNum errNum2 = WLZ_ERR_NONE; sDom2 = shlObj->domain.p->domains[p]; if(sDom2.core) { newBnd = WlzDomFill3DDoBound2D(bDom2.b, sDom2, &errNum2); if(newBnd != NULL) { fObj2 = WlzBoundToObj(newBnd, WLZ_SIMPLE_FILL, &errNum2); (void )WlzFreeBoundList(newBnd); } if(errNum2 == WLZ_ERR_NONE) { if(fObj2) { filDom.p->domains[p] = WlzAssignDomain(fObj2->domain, NULL); } } else { #ifdef _OPENMP #pragma omp critical { #endif if(errNum == WLZ_ERR_NONE) { errNum = errNum2; } #ifdef _OPENMP } #endif } (void )WlzFreeObj(fObj2); } } } } if(errNum == WLZ_ERR_NONE) { errNum = WlzStandardPlaneDomain(filDom.p, NULL); } if(errNum == WLZ_ERR_NONE) { WlzObject *tObj0 = NULL, *tObj1 = NULL; /* Put back any isolated voxels this function has removed. */ tObj0 = WlzAssignObject( WlzMakeMain(srcObj->type, filDom, nullVal, NULL, NULL, &errNum), NULL); if(errNum == WLZ_ERR_NONE) { tObj1 = WlzUnion2(gvnObj, tObj0, &errNum); } if(errNum == WLZ_ERR_NONE) { filObj = WlzMakeMain(tObj1->type, tObj1->domain, nullVal, NULL, NULL, &errNum); } (void )WlzFreeObj(tObj0); (void )WlzFreeObj(tObj1); } } (void )WlzFreeObj(bndObj); (void )WlzFreeObj(gvnObj); (void )WlzFreeObj(shlObj); (void )WlzFreeObj(sedObj); if((errNum != WLZ_ERR_NONE) && (filObj != NULL)) { (void )WlzFreeObj(filObj); filObj = NULL; } if(dstErr) { *dstErr = errNum; } return(filObj); }
/*! * \return New 3D object. * \ingroup WlzAllocation * \brief Constructs a 3D domain object from 2D domain objects read * from the given files. Each file is read in turn and added * to the 3D object. An empty plane can be specified by * setting the file string to NULL. Either all or none of * the 2D objects must have values. When the 2D objects * have values then the background value of the first 2D * object is set to be the background value of the 3D object. * \param nFileStr Number of file strings. * \param fileStr File strings. * \param plane1 The plane coordinate of the first * 2D object. * \param xSz Column voxel size. * \param ySz Line voxel size. * \param zSz Plane voxel size. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzConstruct3DObjFromFile(int nFileStr, char **fileStr, int plane1, float xSz, float ySz, float zSz, WlzErrorNum *dstErr) { int idx, lastpl; WlzDomain dom3D; WlzValues val3D; WlzObject *obj2D = NULL, *obj3D = NULL; WlzPixelV bgd; FILE *fP = NULL; WlzErrorNum errNum = WLZ_ERR_NONE; dom3D.core = NULL; val3D.core = NULL; lastpl = plane1 + nFileStr - 1; if((nFileStr <= 0) || (fileStr == NULL) || (*fileStr == NULL)) { errNum = WLZ_ERR_PARAM_NULL; } else { if((fP = fopen(*fileStr, "r")) == NULL) { errNum = WLZ_ERR_READ_EOF; } else { obj2D = WlzReadObj(fP, &errNum); (void )fclose(fP); fP = NULL; } } if(errNum == WLZ_ERR_NONE) { switch(obj2D->type) { case WLZ_EMPTY_OBJ: break; case WLZ_2D_DOMAINOBJ: if(obj2D->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* Make a plane domain, set column and line bounds later. */ if(errNum == WLZ_ERR_NONE) { dom3D.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, plane1, lastpl, 0, 1, 0, 1, &errNum); } if(errNum == WLZ_ERR_NONE) { dom3D.p->voxel_size[0] = xSz; dom3D.p->voxel_size[1] = ySz; dom3D.p->voxel_size[2] = zSz; } /* Make a voxel value table. */ if(errNum == WLZ_ERR_NONE) { if(obj2D->values.core) { bgd = WlzGetBackground(obj2D, &errNum); if(errNum == WLZ_ERR_NONE) { val3D.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, plane1, lastpl, bgd, NULL, &errNum); } } } idx = 0; while((errNum == WLZ_ERR_NONE) && (idx < nFileStr)) { if(obj2D) { switch(obj2D->type) { case WLZ_EMPTY_OBJ: break; case WLZ_2D_DOMAINOBJ: if(obj2D->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } if(errNum == WLZ_ERR_NONE) { *(dom3D.p->domains + idx) = WlzAssignDomain(obj2D->domain, NULL); if(val3D.core) { if((obj2D->domain.core != NULL) && (obj2D->values.core == NULL)) { errNum = WLZ_ERR_VALUES_NULL; } else { *(val3D.vox->values + idx) = WlzAssignValues(obj2D->values, NULL); } } } WlzFreeObj(obj2D); obj2D = NULL; } if(errNum == WLZ_ERR_NONE) { ++idx; if((idx < nFileStr) && *(fileStr + idx)) { if((fP = fopen(*(fileStr + idx), "r")) == NULL) { errNum = WLZ_ERR_READ_EOF; } else { obj2D = WlzReadObj(fP, &errNum); (void )fclose(fP); fP = NULL; } } } } if(errNum == WLZ_ERR_NONE) { errNum = WlzStandardPlaneDomain(dom3D.p, val3D.vox); } if(errNum == WLZ_ERR_NONE) { obj3D = WlzMakeMain(WLZ_3D_DOMAINOBJ, dom3D, val3D, NULL, NULL, &errNum); } if(errNum != WLZ_ERR_NONE) { if(dom3D.core) { (void )WlzFreeDomain(dom3D); } if(val3D.core) { (void )WlzFreeValues(val3D); } } if(dstErr) { *dstErr = errNum; } return(obj3D); }
/*! * \return New 3D object. * \ingroup WlzAllocation * \brief Constructs a 3D domain object from 2D domain objects. Each * 2D object is assigned in turn to the 3D object no domains * or values are copied. An empty can be specified by * setting the 2D object to NULL. Either all or none of * the 2D objects must have values. When the 2D objects * have values then the background value of the first 2D * object is set to be the background value of the 3D object. * \param nObjs Number of objects. * \param objs The 2D objects, the first of which * MUST not be NULL. * \param plane1 The plane coordinate of the first * 2D object. * \param xSz Column voxel size. * \param ySz Line voxel size. * \param zSz Plane voxel size. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzConstruct3DObjFromObj(int nObjs, WlzObject **objs, int plane1, float xSz, float ySz, float zSz, WlzErrorNum *dstErr) { int idx, lastpl; WlzDomain dom3D; WlzValues val3D; WlzObject *obj2D, *obj3D = NULL; WlzPixelV bgd; WlzErrorNum errNum = WLZ_ERR_NONE; dom3D.core = NULL; val3D.core = NULL; lastpl = plane1 + nObjs - 1; if((nObjs <= 0) || (objs == NULL)) { errNum = WLZ_ERR_PARAM_NULL; } else if((obj2D = *objs) == NULL) { errNum = WLZ_ERR_OBJECT_NULL; } else { switch(obj2D->type) { case WLZ_EMPTY_OBJ: break; case WLZ_2D_DOMAINOBJ: if(obj2D->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* Make a plane domain, set column and line bounds later. */ if(errNum == WLZ_ERR_NONE) { dom3D.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, plane1, lastpl, 0, 1, 0, 1, &errNum); } if(errNum == WLZ_ERR_NONE) { dom3D.p->voxel_size[0] = xSz; dom3D.p->voxel_size[1] = ySz; dom3D.p->voxel_size[2] = zSz; } /* Make a voxel value table. */ if(errNum == WLZ_ERR_NONE) { if(obj2D->values.core) { bgd = WlzGetBackground(obj2D, &errNum); if(errNum == WLZ_ERR_NONE) { val3D.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, plane1, lastpl, bgd, NULL, &errNum); } } } for(idx = 0; (errNum == WLZ_ERR_NONE) && (idx < nObjs); ++idx) { obj2D = *(objs + idx); if(obj2D) { switch(obj2D->type) { case WLZ_EMPTY_OBJ: break; case WLZ_2D_DOMAINOBJ: if(obj2D->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } if(errNum == WLZ_ERR_NONE) { *(dom3D.p->domains + idx) = WlzAssignDomain(obj2D->domain, NULL); if(val3D.core) { if((obj2D->domain.core != NULL) && (obj2D->values.core == NULL)) { errNum = WLZ_ERR_VALUES_NULL; } else { *(val3D.vox->values + idx) = WlzAssignValues(obj2D->values, NULL); } } } } } if(errNum == WLZ_ERR_NONE) { errNum = WlzStandardPlaneDomain(dom3D.p, val3D.vox); } if(errNum == WLZ_ERR_NONE) { obj3D = WlzMakeMain(WLZ_3D_DOMAINOBJ, dom3D, val3D, NULL, NULL, &errNum); } if(errNum != WLZ_ERR_NONE) { if(dom3D.core) { (void )WlzFreeDomain(dom3D); } if(val3D.core) { (void )WlzFreeValues(val3D); } } if(dstErr) { *dstErr = errNum; } return(obj3D); }
void read_reference_object_cb( Widget w, XtPointer client_data, XtPointer call_data) { XmFileSelectionBoxCallbackStruct *cbs = (XmFileSelectionBoxCallbackStruct *) call_data; WlzEffFormat image_type; WlzObject *obj; String icsfile; WlzDomain domain; WlzValues values; WlzObject *newObj; WlzErrorNum errNum=WLZ_ERR_NONE; /* set hour glass cursor */ HGU_XmSetHourGlassCursor(globals.topl); /* read the new reference object note the switch is to allow direct read given the image type to include the model input options */ if( client_data ){ image_type = (WlzEffFormat) client_data; if((icsfile = HGU_XmGetFileStr(globals.topl, cbs->value, cbs->dir))){ obj = WlzEffReadObj(NULL, icsfile, image_type, 0, 0, 0, &errNum); AlcFree(icsfile); } else { obj = NULL; } } else { obj = HGU_XmReadExtFFObject(read_obj_dialog, cbs, &image_type, &errNum); } if( obj == NULL){ HGU_XmUserError(globals.topl, "Read Reference Object:\n" " No reference object read - either the\n" " selected file is empty or it is not the\n" " correct object type - please check the\n" " file or make a new selection", XmDIALOG_FULL_APPLICATION_MODAL); /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); return; } if( obj->values.core == NULL ){ HGU_XmUserError(globals.topl, "Read Reference Object:\n" " The reference object must have a grey-\n" " value table. Please select an alternate\n" " object", XmDIALOG_FULL_APPLICATION_MODAL); WlzFreeObj( obj ); /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); return; } /* install the new reference object */ switch( obj->type ){ case WLZ_2D_DOMAINOBJ: if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, 0, 0, obj->domain.i->line1, obj->domain.i->lastln, obj->domain.i->kol1, obj->domain.i->lastkl, &errNum))){ domain.p->domains[0] = WlzAssignDomain(obj->domain, NULL); if((values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, 0, 0, WlzGetBackground(obj, NULL), NULL, &errNum))){ values.vox->values[0] = WlzAssignValues(obj->values, NULL); newObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, obj->plist, NULL, &errNum); WlzFreeObj(obj); obj = newObj; } } globals.origObjType = WLZ_2D_DOMAINOBJ; break; case WLZ_3D_DOMAINOBJ: globals.origObjType = WLZ_3D_DOMAINOBJ; break; default: HGU_XmUserError(globals.topl, "Read Reference Object:\n" " The reference object must be a 2- or 3-D\n" " grey-level image. Please select an alternate\n" " object", XmDIALOG_FULL_APPLICATION_MODAL); WlzFreeObj( obj ); /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); return; } globals.origObjExtType = image_type; /* set title and reference file list */ if((icsfile = HGU_XmGetFileStr(globals.topl, cbs->value, cbs->dir))) { Widget cascade; HGU_XmFileListAddFile(globals.fileList, icsfile, image_type); HGU_XmFileListWriteResourceFile(globals.fileList, globals.resourceFile); if((cascade = XtNameToWidget(globals.topl, "*file_menu*_pulldown*Recent"))){ HGU_XmFileListResetMenu(globals.fileList, cascade, referenceFileListCb); } if( XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &icsfile) ) { set_topl_title(icsfile); globals.file = icsfile; } } MAPaintLogData("ReferenceFile", globals.file, 0, NULL); /* clear feedback object and install new reference object */ if( errNum == WLZ_ERR_NONE ){ if( globals.fb_obj ){ WlzFreeObj(globals.fb_obj); globals.fb_obj = NULL; } install_paint_reference_object( obj ); } /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); if( errNum != WLZ_ERR_NONE ){ MAPaintReportWlzError(globals.topl, "read_reference_object_cb", errNum); } return; }
void referenceFileListCb( Widget w, XtPointer client_data, XtPointer call_data) { HGU_XmFileListCallbackStruct *cbs= (HGU_XmFileListCallbackStruct *) client_data; WlzObject *obj; Widget cascade; WlzErrorNum errNum=WLZ_ERR_NONE; HGU_XmSetHourGlassCursor(globals.topl); if( cbs == NULL ){ /* clear list selection */ HGU_XmFileListClearList(globals.fileList); HGU_XmFileListWriteResourceFile(globals.fileList, globals.resourceFile); if((cascade = XtNameToWidget(globals.topl, "*file_menu*_pulldown*Recent"))){ HGU_XmFileListResetMenu(globals.fileList, cascade, referenceFileListCb); } } else if((obj = HGU_XmFileListReadObject(w, cbs, &errNum))){ WlzDomain domain; WlzValues values; WlzObject *newObj; switch( obj->type ){ case WLZ_2D_DOMAINOBJ: if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, 0, 0, obj->domain.i->line1, obj->domain.i->lastln, obj->domain.i->kol1, obj->domain.i->lastkl, &errNum))){ domain.p->domains[0] = WlzAssignDomain(obj->domain, NULL); if((values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, 0, 0, WlzGetBackground(obj, NULL), NULL, &errNum))){ values.vox->values[0] = WlzAssignValues(obj->values, NULL); newObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, NULL); WlzFreeObj(obj); obj = newObj; } } globals.origObjType = WLZ_2D_DOMAINOBJ; break; case WLZ_3D_DOMAINOBJ: globals.origObjType = WLZ_3D_DOMAINOBJ; break; default: HGU_XmUserError(globals.topl, "Read Reference Object:\n" " The reference object must be a 2- or 3-D\n" " grey-level image. Please select an alternate\n" " object", XmDIALOG_FULL_APPLICATION_MODAL); WlzFreeObj( obj ); /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); return; } MAPaintLogData("ReferenceFile", refFileList[0], 0, NULL); install_paint_reference_object( obj ); /* set the title of the top-level window */ set_topl_title(cbs->file); globals.file = AlcStrDup(cbs->file); globals.origObjExtType = cbs->format; /* add to the file list and write file */ HGU_XmFileListAddFile(globals.fileList, cbs->file, cbs->format); HGU_XmFileListWriteResourceFile(globals.fileList, globals.resourceFile); if((cascade = XtNameToWidget(globals.topl, "*file_menu*_pulldown*Recent"))){ HGU_XmFileListResetMenu(globals.fileList, cascade, referenceFileListCb); } } HGU_XmUnsetHourGlassCursor(globals.topl); if( errNum != WLZ_ERR_NONE ){ MAPaintReportWlzError(globals.topl, "ReferenceFileListCb", errNum); } return; }
void file_menu_init( Widget topl) { Widget rc, form, toggle; Visual *visual; Arg arg[1]; char fileStr[128]; FILE *fp; WlzEffFormat image_type=WLZEFF_FORMAT_WLZ; /* set the top-level title */ set_topl_title(NULL); /* get the visual explicitly */ visual = HGU_XmWidgetToVisual(topl); XtSetArg(arg[0], XmNvisual, visual); /* create the read-model file selection dialog */ read_model_dialog = XmCreateFileSelectionDialog(topl, "read_model_dialog", arg, 1); XtAddCallback(read_model_dialog, XmNokCallback, read_reference_object_cb, (XtPointer) WLZEFF_FORMAT_WLZ); XtAddCallback(read_model_dialog, XmNokCallback, PopdownCallback, NULL); XtAddCallback( read_model_dialog, XmNcancelCallback, PopdownCallback, NULL); XtAddCallback(read_model_dialog, XmNmapCallback, FSBPopupCallback, NULL); XtManageChild( read_model_dialog ); /* create the read-obj file selection dialog */ read_obj_dialog = HGU_XmCreateExtFFObjectFSB(topl, "read_obj_dialog", read_reference_object_cb, NULL); if((rc = XtNameToWidget(read_obj_dialog, "*.formatFormRC"))){ /* add a form to include file type and fill-blanks toggle */ form = XtVaCreateManagedWidget("read_file_form", xmFormWidgetClass, rc, XmNborderWidth, 0, NULL); /* add a fill-blanks toggles */ toggle = XtVaCreateManagedWidget("fill_blanks", xmToggleButtonGadgetClass, form, XmNindicatorOn, True, XmNindicatorType, XmN_OF_MANY, XmNset, False, XmNtopAttachment, XmATTACH_FORM, XmNleftAttachment, XmATTACH_FORM, NULL); toggle = XtVaCreateManagedWidget("min_domain", xmToggleButtonGadgetClass, form, XmNindicatorOn, True, XmNindicatorType, XmN_OF_MANY, XmNset, True, XmNtopAttachment, XmATTACH_FORM, XmNleftAttachment, XmATTACH_WIDGET, XmNleftWidget, toggle, NULL); } HGU_XmExtFFObjectFSBSetType(read_obj_dialog, WLZEFF_FORMAT_WLZ); XtManageChild( read_obj_dialog ); /* add to the save restore list */ HGU_XmSaveRestoreAddWidget( read_obj_dialog, HGU_XmFSD_SaveFunc, (XtPointer) XtName(topl), NULL, NULL ); /* create the write-obj file selection dialog */ write_obj_dialog = HGU_XmCreateExtFFObjectFSB(topl, "write_obj_dialog", write_reference_object_cb, NULL); HGU_XmExtFFObjectFSBSetType(write_obj_dialog, WLZEFF_FORMAT_WLZ); /* initialise the reference file list pulldown */ if( !globals.sectViewFlg ){ Widget cascade; if((cascade = XtNameToWidget(globals.topl, "*file_menu*_pulldown*Recent"))){ globals.resourceFile = (String) AlcMalloc(sizeof(char) * (strlen(getenv("HOME")) + 16)); sprintf(globals.resourceFile, "%s/%s", getenv("HOME"), ".maRecentFiles"); globals.fileList = HGU_XmFileListCreateList(globals.resourceFile, NULL); HGU_XmFileListResetMenu(globals.fileList, cascade, referenceFileListCb); } } /* add to the save restore list */ HGU_XmSaveRestoreAddWidget( write_obj_dialog, HGU_XmFSD_SaveFunc, (XtPointer) XtName(topl), NULL, NULL ); /* create the object properties dialog */ obj_props_dialog_init( topl ); globals.file = NULL; globals.obj = NULL; globals.orig_obj = NULL; globals.fb_obj = NULL; globals.origObjExtType = image_type; /* setup the theiler directory and menu item - check for stage */ XtGetApplicationResources(topl, &globals, set_att_res, XtNumber(set_att_res), NULL, 0); /* check the logfile */ if( globals.logfile ){ if( (globals.logfileFp = fopen(globals.logfile, "w")) == NULL ){ fprintf(stderr, "MAPaint: something wrong with the logfile %s\n" "Please check name and permissions\n" "Logging not enabled\n\007", globals.logfile); } else { char timeBuf[16]; struct hostent *hstnt; fprintf(stderr, "MAPaint: logging enabled to %s\n", globals.logfile); MAPaintLogData("Filename", globals.logfile, 0, NULL); MAPaintLogData("User", getenv("USER"), 0, NULL); #if defined (LINUX2) || defined (DARWIN) strcpy(timeBuf, "00/00/00"); #else tmpTime = time(NULL); cftime(timeBuf, "%d/%m/%Y", &tmpTime); #endif /* LINUX2 */ MAPaintLogData("Date", timeBuf, 0, NULL); #if defined (LINUX2) || defined (DARWIN) strcpy(timeBuf, "00.00"); #else cftime(timeBuf, "%H.%M", &tmpTime); #endif /* LINUX2 */ MAPaintLogData("Time", timeBuf, 0, NULL); hstnt = gethostbyname(getenv("HOST")); MAPaintLogData("Host", getenv("HOST"), 0, NULL); MAPaintLogData("Hostname", hstnt->h_name, 0, NULL); } } else { globals.logfileFp = NULL; } /* check base directory - if the string has come from the resources then we need to duplicate it to allow it to be freed possibly some memory leakage here */ /* note: only non-NULL if set by the user, if NULL then attempt to find the cdrom or copied data */ if( globals.base_theiler_dir ){ globals.base_theiler_dir = AlcStrDup( globals.base_theiler_dir ); } /* else { FILE *pp;*/ /* search for the Theiler mode directory as per the CDROM should search local disc first */ /*#if defined (LINUX2) if((pp = popen("find /mnt -maxdepth 4 -name Models", "r"))){ while( fscanf(pp, "%s", fileStr) != EOF ){ if( strstr(fileStr, "Models") ){ globals.base_theiler_dir = AlcStrDup(fileStr); break; } } pclose(pp); } #elif defined (DARWIN) if( (pp = popen("find /Volumes -maxdepth 4 -name Models", "r")) ){ while( fscanf(pp, "%s", fileStr) != EOF ){ if( strstr(fileStr, "Models") ){ globals.base_theiler_dir = AlcStrDup(fileStr); break; } } pclose(pp); } #elif defined (SUNOS4) || defined (SUNOS5) if( pp = popen("find /cdrom -maxdepth 4 -name Models", "r") ){ while( fscanf(pp, "%s", fileStr) != EOF ){ if( strstr(fileStr, "Models") ){ globals.base_theiler_dir = AlcStrDup(fileStr); break; } } pclose(pp); } #else globals.base_theiler_dir = NULL; #endif }*/ if( globals.theiler_stage ){ char *tStr; if((tStr = theilerString(globals.theiler_stage))){ globals.theiler_stage = AlcStrDup(tStr); } else { globals.theiler_stage = NULL; } } theiler_menu_init( topl ); /* check for an initial reference file else check Theiler stage */ if( initial_reference_file != NULL ){ WlzObject *obj; /* open the reference object file and install */ if( (fp = fopen(initial_reference_file, "r")) ){ HGU_XmSetHourGlassCursor(topl); if((obj = WlzReadObj( fp, NULL ))){ WlzDomain domain; WlzValues values; WlzObject *newObj; switch( obj->type ){ case WLZ_2D_DOMAINOBJ: domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, 0, 0, obj->domain.i->line1, obj->domain.i->lastln, obj->domain.i->kol1, obj->domain.i->lastkl, NULL); domain.p->domains[0] = WlzAssignDomain(obj->domain, NULL); values.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, 0, 0, WlzGetBackground(obj, NULL), NULL, NULL); values.vox->values[0] = WlzAssignValues(obj->values, NULL); newObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, NULL); WlzFreeObj(obj); obj = newObj; globals.origObjType = WLZ_2D_DOMAINOBJ; break; case WLZ_3D_DOMAINOBJ: globals.origObjType = WLZ_3D_DOMAINOBJ; break; default: HGU_XmUserError(globals.topl, "Read Reference Object:\n" " The reference object must be a 2- or 3-D woolz\n" " grey-level image. Please select an alternate\n" " object", XmDIALOG_FULL_APPLICATION_MODAL); WlzFreeObj( obj ); /* set hour glass cursor */ HGU_XmUnsetHourGlassCursor(globals.topl); return; } HGU_XmFileListAddFile(globals.fileList, initial_reference_file, image_type); HGU_XmFileListWriteResourceFile(globals.fileList, globals.resourceFile); MAPaintLogData("ReferenceFile", initial_reference_file, 0, NULL); install_paint_reference_object( obj ); /* set the globals reference file */ globals.file = initial_reference_file; /* set the title of the top-level window */ set_topl_title(globals.file); } else { /* if it fails to read, check the file name or the file content for special options */ if( strstr(initial_reference_file, "MAPaint") ){ /* standard MAPaint startup */ globals.app_name = "MAPaint"; /* set the title of the top-level window */ set_topl_title(globals.file); } else if( strstr(initial_reference_file, "SectionView") ){ /* restricted section view startup */ globals.app_name = "SectionView"; globals.sectViewFlg = 1; /* set the title of the top-level window */ set_topl_title(globals.file); } else if( theilerString(initial_reference_file) ){ /* load in theiler stage anatomy etc. */ globals.app_name = "SectionView"; globals.sectViewFlg = 1; set_theiler_stage_cb(topl, theilerString(initial_reference_file), NULL); } else { char strBuf[33]; /* check the content */ rewind(fp); fscanf(fp, "%32s", strBuf); if( strstr(strBuf, "MAPaint") ){ /* standard MAPaint startup */ globals.app_name = "MAPaint"; /* set the title of the top-level window */ set_topl_title(globals.file); } else if( strstr(strBuf, "SectionView") ){ /* restricted section view startup */ globals.app_name = "SectionView"; globals.sectViewFlg = 1; /* set the title of the top-level window */ set_topl_title(globals.file); } else if( theilerString(strBuf) ){ /* load in theiler stage anatomy etc. */ globals.app_name = "SectionView"; globals.sectViewFlg = 1; set_theiler_stage_cb(topl, theilerString(strBuf), NULL); } } /* set the globals reference file */ globals.file = NULL; } (void) fclose( fp ); HGU_XmUnsetHourGlassCursor(topl); } } else if( globals.theiler_stage ){ globals.app_name = "MAPaint"; set_theiler_stage_cb(topl, theilerString(globals.theiler_stage), NULL); } /* reset the colormap */ if( globals.sectViewFlg == 1 ){ init_paint_cmapstruct(globals.topl); } /* check for an initial domain file */ if( initial_domain_file != NULL ){ WlzObject *obj; /* open the domain object file and put it in as a 3D feedback option */ if( (fp = fopen(initial_domain_file, "rb")) ){ HGU_XmSetHourGlassCursor(topl); if((obj = WlzReadObj( fp, NULL ))){ if( globals.fb_obj ){ WlzFreeObj(globals.fb_obj); } globals.fb_obj = WlzAssignObject(obj, NULL); setup_ref_display_list_cb(read_obj_dialog, NULL, NULL); } (void) fclose( fp ); HGU_XmUnsetHourGlassCursor(topl); } } return; }
/*! * \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 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. * \ingroup WlzAllocation * \brief Creates a new or adds to an existing 3D spatial domain * object using a rectangular buffer of values to a single * plane of the given current object (which may be NULL or * empty if the object is to be created). * The returned object will share domains and values of * planes other than the given plane with the current object. * \param cObj Given current object. * \param og Origin of rectangular buffer. * \param sz Buffer size (note 2D). * \param gType Grey type which must be consistent * with the current object (if it is * valid) and the buffer of values. * \param bufSz Number of values in the buffer * (ie sz.vtX * sz.vtY). * \param bufP Given buffer of values. * \param dstErr Destination error pointer, may be NULL. */ WlzObject *WlzBuildObj3(WlzObject *cObj, WlzIVertex3 og, WlzIVertex2 sz, WlzGreyType gType, int bufSz, WlzGreyP bufP, WlzErrorNum *dstErr) { int nPlnReq = 1; WlzDomain cDom, nDom; WlzValues cVal, nVal; WlzObject *nObj = NULL; WlzErrorNum errNum = WLZ_ERR_NONE; cDom.core = NULL; nDom.core = NULL; cVal.core = NULL; nVal.core = NULL; if(cObj) { WlzGreyType cGType = WLZ_GREY_ERROR;; switch(cObj->type) { case WLZ_EMPTY_OBJ: cObj = NULL; break; case WLZ_3D_DOMAINOBJ: if(cObj->domain.core == NULL) { errNum = WLZ_ERR_DOMAIN_NULL; } else if(cObj->values.core == NULL) { errNum = WLZ_ERR_VALUES_NULL; } else { cDom = cObj->domain; cVal = cObj->values; cGType = WlzGreyTypeFromObj(cObj, &errNum); } if((errNum == WLZ_ERR_NONE) && (cGType != gType)) { errNum = WLZ_ERR_GREY_TYPE; } break; default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } /* Create a new object with new plane domain and voxel values. */ if(errNum == WLZ_ERR_NONE) { WlzIBox3 nBox; WlzPixelV bgdV; float vxSz[3]; nBox.xMin = og.vtX; nBox.yMin = og.vtY; nBox.zMin = og.vtZ; nBox.xMax = og.vtX + sz.vtX - 1; nBox.yMax = og.vtY + sz.vtY - 1; nBox.zMax = og.vtZ; if(cObj) { nPlnReq = (og.vtZ < cDom.p->plane1) || (og.vtZ > cDom.p->lastpl) || ((*(cDom.p->domains + og.vtZ - cDom.p->plane1)).core == NULL); nBox.xMin = ALG_MIN(nBox.xMin, cDom.p->kol1); nBox.yMin = ALG_MIN(nBox.yMin, cDom.p->line1); nBox.zMin = ALG_MIN(nBox.zMin, cDom.p->plane1); nBox.xMax = ALG_MAX(nBox.xMax, cDom.p->lastkl); nBox.yMax = ALG_MAX(nBox.yMax, cDom.p->lastln); nBox.zMax = ALG_MAX(nBox.zMax, cDom.p->lastpl); vxSz[0] = cDom.p->voxel_size[0]; vxSz[1] = cDom.p->voxel_size[1]; vxSz[2] = cDom.p->voxel_size[2]; bgdV = WlzGetBackground(cObj, &errNum); } else { vxSz[0] = vxSz[1] = vxSz[2] = 1.0f; bgdV.type = WLZ_GREY_INT; bgdV.v.inv = 0; } if(errNum == WLZ_ERR_NONE) { nDom.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, nBox.zMin, nBox.zMax, nBox.yMin, nBox.yMax, nBox.xMin, nBox.xMax, &errNum); } if(errNum == WLZ_ERR_NONE) { nVal.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, nBox.zMin, nBox.zMax, bgdV, NULL, &errNum); } if(errNum == WLZ_ERR_NONE) { nDom.p->voxel_size[0] = vxSz[0]; nDom.p->voxel_size[1] = vxSz[1]; nDom.p->voxel_size[2] = vxSz[2]; nObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, nDom, nVal, NULL, NULL, &errNum); } } /* Set the domain and values on each plane for the new object. */ if(errNum == WLZ_ERR_NONE) { int idZ; for(idZ = nDom.p->plane1; idZ <= nDom.p->lastpl; ++idZ) { int idP; WlzDomain nDom2; WlzValues nVal2; nDom2.core = NULL; nVal2.core = NULL; idP = idZ - nDom.p->plane1; if(idZ == og.vtZ) { /* Plane with buffer. */ WlzIVertex2 og2, sz2; WlzObject *cObj2 = NULL, *nObj2 = NULL; og2.vtX = og.vtX; og2.vtY = og.vtY; sz2.vtX = sz.vtX; sz2.vtY = sz.vtY; if(nPlnReq == 0) { int idP; idP = idZ - cDom.p->plane1; cObj2 = WlzMakeMain(WLZ_2D_DOMAINOBJ, *(cDom.p->domains + idP), *(cVal.vox->values + idP), NULL, NULL, &errNum); } nObj2 = WlzBuildObj2(cObj2, og2, sz2, gType, bufSz, bufP, &errNum); if(errNum == WLZ_ERR_NONE) { nDom2 = WlzAssignDomain(nObj2->domain, NULL); nVal2 = WlzAssignValues(nObj2->values, NULL); } (void )WlzFreeObj(cObj2); (void )WlzFreeObj(nObj2); } else if((idZ >= cDom.p->plane1) && (idZ <= cDom.p->lastpl)) { /* Not buffer plane, but previously existing plane. */ int idQ; idQ = idZ - cDom.p->plane1; nDom2 = WlzAssignDomain(*(cDom.p->domains + idQ), NULL); nVal2 = WlzAssignValues(*(cVal.vox->values + idQ), NULL); } if(errNum == WLZ_ERR_NONE) { *(nDom.p->domains + idP) = nDom2; *(nVal.vox->values + idP) = nVal2; } else { break; } } } if(dstErr) { *dstErr = errNum; } return(nObj); }
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; }
static WlzObject *WlzGreyTemplate3d( WlzObject *obj, WlzObject *tmpl, WlzPixelV tmplVal, WlzErrorNum *dstErr) { WlzObject *rtnObj=NULL; WlzObject *tmpObj = NULL, *obj1 = NULL, *obj2 = NULL; WlzDomain domain, *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 template and create the return object */ if( errNum == WLZ_ERR_NONE ){ if( tmpl == NULL ){ errNum = WLZ_ERR_OBJECT_NULL; } else { values.core = NULL; switch( tmpl->type ){ case WLZ_2D_DOMAINOBJ: pdom = obj->domain.p; if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, pdom->plane1, pdom->lastpl, pdom->line1, pdom->lastpl, pdom->kol1, pdom->lastkl, &errNum)) != NULL){ domain.p->voxel_size[0] = pdom->voxel_size[0]; domain.p->voxel_size[1] = pdom->voxel_size[1]; domain.p->voxel_size[2] = pdom->voxel_size[2]; for(p=pdom->plane1; p <= pdom->lastpl; p++){ domain.p->domains[p - pdom->plane1] = WlzAssignDomain(tmpl->domain, NULL); } rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } break; case WLZ_2D_POLYGON: pdom = obj->domain.p; if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, pdom->plane1, pdom->lastpl, pdom->line1, pdom->lastpl, pdom->kol1, pdom->lastkl, &errNum)) != NULL){ domain.p->voxel_size[0] = pdom->voxel_size[0]; domain.p->voxel_size[1] = pdom->voxel_size[1]; domain.p->voxel_size[2] = pdom->voxel_size[2]; obj1 = WlzPolyToObj(tmpl->domain.poly, WLZ_SIMPLE_FILL, &errNum); for(p=pdom->plane1; p <= pdom->lastpl; p++){ domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain, NULL); } WlzFreeObj(obj1); rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } break; case WLZ_BOUNDLIST: pdom = obj->domain.p; if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, pdom->plane1, pdom->lastpl, pdom->line1, pdom->lastpl, pdom->kol1, pdom->lastkl, &errNum)) != NULL){ domain.p->voxel_size[0] = pdom->voxel_size[0]; domain.p->voxel_size[1] = pdom->voxel_size[1]; domain.p->voxel_size[2] = pdom->voxel_size[2]; obj1 = WlzBoundToObj(tmpl->domain.b, WLZ_SIMPLE_FILL, &errNum); for(p=pdom->plane1; p <= pdom->lastpl; p++){ domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain, NULL); } WlzFreeObj(obj1); rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } break; case WLZ_3D_DOMAINOBJ: if( tmpl->domain.p ){ switch( tmpl->domain.p->type ){ case WLZ_2D_DOMAINOBJ: domain.p = tmpl->domain.p; break; case WLZ_PLANEDOMAIN_POLYGON: case WLZ_PLANEDOMAIN_CONV_HULL: pdom = tmpl->domain.p; if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, pdom->plane1, pdom->lastpl, pdom->line1, pdom->lastpl, pdom->kol1, pdom->lastkl, &errNum)) != NULL){ domain.p->voxel_size[0] = pdom->voxel_size[0]; domain.p->voxel_size[1] = pdom->voxel_size[1]; domain.p->voxel_size[2] = pdom->voxel_size[2]; for(p=pdom->plane1; p <= pdom->lastpl; p++){ if( pdom->domains[p-pdom->plane1].core ){ obj1 = WlzPolyToObj(pdom->domains[p-pdom->plane1].poly, WLZ_SIMPLE_FILL, &errNum); domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain, NULL); } WlzFreeObj(obj1); } values.core = NULL; rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } break; case WLZ_PLANEDOMAIN_BOUNDLIST: pdom = tmpl->domain.p; if((domain.p = WlzMakePlaneDomain(WLZ_PLANEDOMAIN_DOMAIN, pdom->plane1, pdom->lastpl, pdom->line1, pdom->lastpl, pdom->kol1, pdom->lastkl, &errNum)) != NULL){ domain.p->voxel_size[0] = pdom->voxel_size[0]; domain.p->voxel_size[1] = pdom->voxel_size[1]; domain.p->voxel_size[2] = pdom->voxel_size[2]; for(p=pdom->plane1; p <= pdom->lastpl; p++){ if( pdom->domains[p-pdom->plane1].core ){ obj1 = WlzBoundToObj(pdom->domains[p-pdom->plane1].b, WLZ_SIMPLE_FILL, &errNum); domain.p->domains[p - pdom->plane1] = WlzAssignDomain(obj1->domain, NULL); } WlzFreeObj(obj1); } values.core = NULL; rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } break; default: errNum = WLZ_ERR_DOMAIN_TYPE; break; } if( errNum == WLZ_ERR_NONE ){ rtnObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, domain, values, NULL, NULL, &errNum); } } else { errNum = WLZ_ERR_DOMAIN_NULL; } break; case WLZ_EMPTY_OBJ: return WlzMakeEmpty(dstErr); default: errNum = WLZ_ERR_OBJECT_TYPE; break; } } } /* now we have a 3D obj and 3D template so run through the template and map values as required, note we must check that all the valuetables have the same type ie switch to obj type if necessary */ if( errNum == WLZ_ERR_NONE ){ WlzDomain *objDoms; WlzValues *objVals; WlzGreyType gtype=WLZ_GREY_UBYTE; /* attach a voxel table with empty values list */ values.vox = WlzMakeVoxelValueTb(obj->values.vox->type, rtnObj->domain.p->plane1, rtnObj->domain.p->lastpl, obj->values.vox->bckgrnd, NULL, NULL); rtnObj->values = WlzAssignValues(values, NULL); /* 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++){ if(((*domains).core)){ if((p >= obj->domain.p->plane1) && (p <= obj->domain.p->lastpl) && (objDoms[p - obj->domain.p->plane1].core) ){ tmpObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, objDoms[p - obj->domain.p->plane1], objVals[p - obj->domain.p->plane1], NULL, NULL, NULL); gtype = WlzGreyTableTypeToGreyType(tmpObj->values.core->type, NULL); } else { tmpObj = WlzMakeEmpty(NULL); } tmpObj = WlzAssignObject(tmpObj, NULL); values.core = NULL; obj1 = WlzAssignObject( WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, values, NULL, NULL, NULL), NULL); if((obj2 = WlzGreyTemplate(tmpObj, obj1, tmplVal, &errNum)) != NULL){ *valuess = WlzAssignValues(obj2->values, NULL); WlzFreeObj(obj2); } WlzFreeObj(obj1); WlzFreeObj(tmpObj); } } /* now check all valuetables have the same grey type */ domains = rtnObj->domain.p->domains; valuess = rtnObj->values.vox->values; for(p=pdom->plane1; p <= pdom->lastpl; p++, domains++, valuess++){ if((*domains).core && (WlzGreyTableTypeToGreyType((*valuess).core->type, NULL) != gtype)){ obj1 = WlzAssignObject( WlzMakeMain(WLZ_2D_DOMAINOBJ, *domains, *valuess, NULL, NULL, NULL), NULL); if((obj2 = WlzConvertPix(obj1, gtype, &errNum)) != NULL){ /* substitute the valuetable in the voxel table array */ WlzFreeValues(*valuess); *valuess = WlzAssignValues(obj2->values, NULL); WlzFreeObj(obj2); } WlzFreeObj(obj1); } } } if( dstErr ){ *dstErr = errNum; } return rtnObj; }
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); }
/*! * \return New Woolz domain object with gradient grey values or NULL * on error. * \ingroup WlzValuesFilters * \brief Computes the magnitude of the gray values in the * 3 given Woolz 3D domain objects. * \param srcObj0 First object. * \param srcObj1 Second object. * \param srcObj2 Third object. * \param dstErr Destination error pointer, may * be null. */ static WlzObject *WlzGreyMagnitude3D(WlzObject *srcObj0, WlzObject *srcObj1, WlzObject *srcObj2, WlzErrorNum *dstErr) { int idN, idP, nPlanes; WlzDomain dstDom; WlzValues dstVal; WlzObject *dstObj2D, *istObj = NULL, *dstObj = NULL; WlzObject *srcObjA[3], *iObj3DA[3], *iObj2DA[3]; WlzPixelV bgdV; WlzErrorNum errNum = WLZ_ERR_NONE; dstDom.core = NULL; dstVal.core = NULL; iObj3DA[0] = iObj3DA[1] = iObj3DA[2] = NULL; if((srcObj0->domain.core->type != WLZ_PLANEDOMAIN_DOMAIN) || (srcObj1->domain.core->type != WLZ_PLANEDOMAIN_DOMAIN) || (srcObj2->domain.core->type != WLZ_PLANEDOMAIN_DOMAIN)) { errNum = WLZ_ERR_DOMAIN_TYPE; } else if ((srcObj0->values.core->type != WLZ_VOXELVALUETABLE_GREY) || (srcObj1->values.core->type != WLZ_VOXELVALUETABLE_GREY) || (srcObj2->values.core->type != WLZ_VOXELVALUETABLE_GREY)) { errNum = WLZ_ERR_VALUES_TYPE; } else { srcObjA[0] = srcObj0; srcObjA[1] = srcObj1; srcObjA[2] = srcObj2; istObj = WlzIntersectN(3, srcObjA, 0, &errNum); } if(errNum == WLZ_ERR_NONE) { if(istObj->type == WLZ_EMPTY_OBJ) { dstObj = istObj; } else { dstDom = WlzAssignDomain(istObj->domain, NULL); WlzFreeObj(istObj); idN = 0; while((errNum == WLZ_ERR_NONE) && (idN < 3)) { iObj3DA[idN] = WlzMakeMain(WLZ_3D_DOMAINOBJ, dstDom, srcObjA[idN]->values, NULL, NULL, &errNum); ++idN; } if(errNum == WLZ_ERR_NONE) { idP = 0; nPlanes = dstDom.p->lastpl - dstDom.p->plane1 + 1; while((errNum == WLZ_ERR_NONE) && (idP < nPlanes)) { if((dstDom.p->domains + idN)->core == NULL) { (dstVal.vox->values + idP)->core = NULL; } else { dstObj2D = NULL; iObj2DA[0] = iObj2DA[1] = iObj2DA[2] = NULL; idN = 0; /* Make 2D objects. */ while((errNum == WLZ_ERR_NONE) && (idN < 3)) { iObj2DA[idN] = WlzMakeMain(WLZ_2D_DOMAINOBJ, *(iObj3DA[idN]->domain.p->domains + idP), *(iObj3DA[idN]->values.vox->values + idP), NULL, NULL, &errNum); ++idN; } /* Compute magnitude. */ if(errNum == WLZ_ERR_NONE) { dstObj2D = WlzGreyMagnitude2D3(iObj2DA[0], iObj2DA[1], iObj2DA[2], &errNum); } /* If first plane get grey type and background, then create new * 3D object with new voxel values. */ if((idP == 0) && (errNum == WLZ_ERR_NONE)) { bgdV = WlzGetBackground(iObj2DA[0], &errNum); if(errNum == WLZ_ERR_NONE) { dstVal.vox = WlzMakeVoxelValueTb(WLZ_VOXELVALUETABLE_GREY, dstDom.p->plane1, dstDom.p->lastpl, bgdV, NULL, &errNum); } if(errNum == WLZ_ERR_NONE) { dstObj = WlzMakeMain(WLZ_3D_DOMAINOBJ, dstDom, dstVal, NULL, NULL, &errNum); } } /* Add 2D values to the 3D objects values. */ if(errNum == WLZ_ERR_NONE) { *(dstVal.vox->values + idP) = WlzAssignValues(dstObj2D->values, NULL); } /* Free temporary 2D object. */ if(dstObj2D) { WlzFreeObj(dstObj2D); } idN = 0; while(idN < 3) { if(iObj2DA[idN]) { WlzFreeObj(iObj2DA[idN]); } ++idN; } } ++idP; } } /* Free 3D intersection gradient objects. */ idN = 0; while(idN < 3) { if(iObj3DA[idN]) { WlzFreeObj(iObj3DA[idN]); } ++idN; } /* Decrement link count to the destination 3D domain. */ (void )WlzFreeDomain(dstDom); } } if((errNum != WLZ_ERR_NONE) && (dstObj != NULL)) { WlzFreeObj(dstObj); dstObj = NULL; } if(dstErr) { *dstErr = errNum; } return(dstObj); }