/*!
* \return Woolz error code.
* \ingroup WlzTransform
* \brief Sets the interval for the profile for the given point
* with respect to the given object.
* \param obj Given object.
* \param pos Given point with respect to the given
* object.
* \param wSp profile walking work space.
*/
static WlzErrorNum WlzProfileSetIDom(
WlzObject *obj,
WlzIVertex3 pos,
WlzProfileWalkWSp *pWSp)
{
int msk;
WlzInterval *itv;
WlzIntervalLine *itvLn;
WlzErrorNum errNum = WLZ_ERR_NONE;
msk = (pWSp->inside << 1) |
(WlzInsideDomain(obj, pos.vtZ, pos.vtY, pos.vtX, &errNum) != 0);
if(errNum == WLZ_ERR_NONE)
{
itvLn = pWSp->domain.i->intvlines + 0;
switch(msk)
{
case 1: /* Was out, now in. Start new interval. */
itv = itvLn->intvs + itvLn->nintvs;
itv->ileft = itv->iright = pWSp->index;
pWSp->inside = 1;
++(itvLn->nintvs);
break;
case 3: /* Was in, still in. Just update interval. */
itv = itvLn->intvs + itvLn->nintvs - 1;
itv->iright = pWSp->index;
break;
default: /* Either was in, now out or was out, still out. */
break;
}
}
return(errNum);
}
/*!
* \return Object containing the point (x,y).
* \ingroup WlzBinaryOps
* \brief Takes a WLZ_2D_DOMAINOBJ, calls WlzLabel to split the domain
* and returns the one containing point(x,y).
* \param obj Given WLZ_2D_DOMAINOBJ object.
* \param x Column coordinate.
* \param y Line coordinate.
* \param dstErr Destination error code pointer, may be NULL.
*/
WlzObject *Wlz2DContains(WlzObject *obj,
double x,
double y,
WlzErrorNum *dstErr) {
WlzObject *retObj = NULL;
WlzObject **objArray;
int i, nobjs;
/* int maxNobjs=1024; */
int maxNobjs=2048;
int found = 0;
WlzErrorNum errNum=WLZ_ERR_NONE;
WlzConnectType connectivity = WLZ_8_CONNECTED;
/*
fprintf(stderr, "entering Wlz2DContains %f,%f\n", x,y);
fflush(stderr);
*/
if(obj->type != WLZ_2D_DOMAINOBJ) return (NULL);
/* get array of domains */
if(obj != NULL) {
errNum = WlzLabel(obj,
&nobjs,
&objArray,
maxNobjs,
0,
connectivity);
}
/*
fprintf(stderr, "got array of %d objects\n", nobjs);
fflush(stderr);
*/
/* select the required domain */
/* ie the one which contains clicked point */
if((errNum == WLZ_ERR_NONE) && (nobjs > 0)) {
for(i=0; i<nobjs; i++) {
/*
fprintf(stderr, "checking domain # %d\n", i);
fflush(stderr);
*/
if(WlzInsideDomain(objArray[i],
0.0,
y,
x,
&errNum)) {
if(errNum == WLZ_ERR_NONE) {
found = 1;
/*
fprintf(stderr, "domain # %d contains point\n", i);
fflush(stderr);
*/
break;
} else {
(void )fprintf(stderr,
"WlzInsideDomain, Wlz error: %d\n",
(int )errNum);
fflush(stderr);
}
} else {
WlzFreeObj(objArray[i]);
}
}
if((found == 1) && (errNum == WLZ_ERR_NONE)) {
/* retObj = objArray[i]; */
retObj = WlzCopyObject(objArray[i], &errNum);
WlzFreeObj(objArray[i]);
if(errNum != WLZ_ERR_NONE) {
(void )fprintf(stderr,
"WlzCopyObject, Wlz error: %d\n",
(int )errNum);
fflush(stderr);
}
}
}
*dstErr = errNum;
/*
fprintf(stderr, "leaving Wlz2DContains\n");
fflush(stderr);
*/
return retObj;
}
void warpSetSignalDomain(
WlzIVertex2 *selVtx)
{
WlzErrorNum errNum=WLZ_ERR_NONE;
WlzPixelV threshV, threshV1;
WlzObject *obj, *obj1;
WlzUInt combineMode;
/* image processing sequence */
if( warpGlobals.sgnlThreshObj == NULL ){
warpSetSignalThreshObj();
}
if( warpGlobals.sgnlThreshObj ){
obj1 = WlzAssignObject(warpGlobals.sgnlThreshObj, &errNum);
}
else {
return;
}
/* threshold the resultant image */
if( errNum == WLZ_ERR_NONE ){
switch( warpGlobals.thresholdType ){
case WLZ_RGBA_THRESH_NONE:
break;
case WLZ_RGBA_THRESH_SINGLE:
threshV.type = WLZ_GREY_INT;
threshV.v.inv = warpGlobals.threshRangeLow;
if( obj1 ){
/* clear signal object */
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
}
if((obj = WlzThreshold(obj1, threshV, WLZ_THRESH_HIGH, &errNum)) && (WlzVolume(obj, &errNum) > 0)){
obj = WlzAssignObject(obj, &errNum);
WlzFreeObj(obj1);
threshV.v.inv = warpGlobals.threshRangeHigh + 1;
if((obj1 = WlzThreshold(obj, threshV, WLZ_THRESH_LOW, &errNum)) && (WlzVolume(obj1, &errNum) > 0)){
warpGlobals.sgnlObj = WlzAssignObject(obj1, &errNum);
}
else {
if( obj1 ){
WlzFreeObj(obj1);
}
warpGlobals.sgnlObj = NULL;
}
WlzFreeObj(obj);
}
else {
if( obj ) {
WlzFreeObj(obj);
}
WlzFreeObj(obj1);
warpGlobals.sgnlObj = NULL;
}
}
break;
case WLZ_RGBA_THRESH_MULTI:
/* clear signal object */
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
}
/* set the thresholds and combine mode */
threshV.type = WLZ_GREY_RGBA;
WLZ_RGBA_RGBA_SET(threshV.v.rgbv,
warpGlobals.threshRangeRGBLow[0],
warpGlobals.threshRangeRGBLow[1],
warpGlobals.threshRangeRGBLow[2],
255);
threshV1.type = WLZ_GREY_RGBA;
WLZ_RGBA_RGBA_SET(threshV1.v.rgbv,
warpGlobals.threshRangeRGBHigh[0],
warpGlobals.threshRangeRGBHigh[1],
warpGlobals.threshRangeRGBHigh[2],
255);
WLZ_RGBA_RGBA_SET(combineMode,
WLZ_BO_AND, WLZ_BO_AND, WLZ_BO_AND, 255);
/* use multi-threshold */
if((obj = WlzRGBAMultiThreshold(obj1, threshV, threshV1,
combineMode, &errNum))){
if( WlzIsEmpty(obj, &errNum) ){
WlzFreeObj(obj);
warpGlobals.sgnlObj = NULL;
} else {
warpGlobals.sgnlObj = WlzAssignObject(obj, &errNum);
}
}
else {
warpGlobals.sgnlObj = NULL;
}
WlzFreeObj(obj1);
break;
case WLZ_RGBA_THRESH_BOX:
/* clear signal object */
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
}
/* use box-threshold */
if((obj = WlzRGBABoxThreshold(obj1,
warpGlobals.lowRGBPoint,
warpGlobals.highRGBPoint,
&errNum))){
if( WlzIsEmpty(obj, &errNum) ){
WlzFreeObj(obj);
warpGlobals.sgnlObj = NULL;
} else {
warpGlobals.sgnlObj = WlzAssignObject(obj, &errNum);
}
}
else {
warpGlobals.sgnlObj = NULL;
}
WlzFreeObj(obj1);
break;
case WLZ_RGBA_THRESH_SLICE:
/* clear signal object */
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
}
/* use slice-threshold */
if((obj = WlzRGBASliceThreshold(obj1,
warpGlobals.lowRGBPoint,
warpGlobals.highRGBPoint,
&errNum))){
if( WlzIsEmpty(obj, &errNum) ){
WlzFreeObj(obj);
warpGlobals.sgnlObj = NULL;
} else {
warpGlobals.sgnlObj = WlzAssignObject(obj, &errNum);
}
}
else {
warpGlobals.sgnlObj = NULL;
}
WlzFreeObj(obj1);
break;
case WLZ_RGBA_THRESH_SPHERE:
/* clear signal object */
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
}
/* use Ellipsoid-threshold */
if((obj = WlzRGBAEllipsoidThreshold(obj1,
warpGlobals.lowRGBPoint,
warpGlobals.highRGBPoint,
warpGlobals.colorEllipseEcc,
&errNum))){
if( WlzIsEmpty(obj, &errNum) ){
WlzFreeObj(obj);
warpGlobals.sgnlObj = NULL;
} else {
warpGlobals.sgnlObj = WlzAssignObject(obj, &errNum);
}
}
else {
warpGlobals.sgnlObj = NULL;
}
WlzFreeObj(obj1);
break;
default:
errNum = WLZ_ERR_PARAM_DATA;
if( obj1 ){
WlzFreeObj(obj1);
}
if( warpGlobals.sgnlObj ){
WlzFreeObj(warpGlobals.sgnlObj);
warpGlobals.sgnlObj = NULL;
}
break;
}
}
/* check for local mode */
if( warpGlobals.sgnlObj && !warpGlobals.globalThreshFlg ){
if( selVtx != NULL ){
warpGlobals.globalThreshVtx = *selVtx;
}
/* extract a local domain if the vertex is sensible */
if( warpGlobals.globalThreshVtx.vtX != -10000 ){
WlzObject **objs=NULL;
int i, numObjs;
double x, y;
obj1 = NULL;
x = warpGlobals.globalThreshVtx.vtX;
y = warpGlobals.globalThreshVtx.vtY;
errNum = WlzLabel(warpGlobals.sgnlObj, &numObjs, &objs, 8192, 0,
WLZ_4_CONNECTED);
if( (errNum == WLZ_ERR_INT_DATA) && (numObjs == 8192) ){
WlzObject *tmpObj1, *tmpObj2;
WlzDomain domain;
WlzValues values;
/* try again, smaller domain */
for(i=0; i < numObjs; i++){
WlzFreeObj( objs[i] );
}
AlcFree((void *) objs);
objs = NULL;
numObjs = 0;
domain.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_RECT,
y - 80, y + 80,
x - 80, x + 80, &errNum);
values.core = NULL;
if((tmpObj1 = WlzMakeMain(warpGlobals.sgnlObj->type, domain, values,
NULL, NULL, &errNum))){
if((tmpObj2 = WlzIntersect2(warpGlobals.sgnlObj, tmpObj1, &errNum))){
tmpObj2->values = WlzAssignValues(warpGlobals.sgnlObj->values, NULL);
errNum = WlzLabel(warpGlobals.sgnlObj, &numObjs, &objs, 8192, 0,
WLZ_4_CONNECTED);
WlzFreeObj(tmpObj2);
if((errNum == WLZ_ERR_INT_DATA) && (numObjs == 8192) ){
errNum = WLZ_ERR_NONE;
}
}
WlzFreeObj(tmpObj1);
}
}
if( errNum == WLZ_ERR_NONE ){
for(i=0; i < numObjs; i++){
if( WlzInsideDomain( objs[i], 0.0, y, x, NULL ) ){
obj1 = WlzMakeMain(objs[i]->type,
objs[i]->domain,
objs[i]->values,
NULL, NULL, NULL);
obj1 = WlzAssignObject(obj1, NULL);
}
WlzFreeObj( objs[i] );
}
AlcFree((void *) objs);
}
if( obj1 ){
WlzFreeObj(warpGlobals.sgnlObj);
warpGlobals.sgnlObj = obj1;
}
}
else {
WlzFreeObj(warpGlobals.sgnlObj);
warpGlobals.sgnlObj = NULL;
}
}
/* check for increment mode */
if( warpGlobals.incrThreshFlg && sgnlIncrObj() ){
if( warpGlobals.sgnlObj ){
if((obj1 = WlzUnion2(warpGlobals.sgnlObj, sgnlIncrObj(),
&errNum))){
WlzFreeObj(warpGlobals.sgnlObj);
warpGlobals.sgnlObj = WlzAssignObject(obj1, &errNum);
}
}
else {
warpGlobals.sgnlObj = WlzAssignObject(sgnlIncrObj(),
&errNum);
}
}
if( errNum != WLZ_ERR_NONE ){
MAPaintReportWlzError(globals.topl, "warpSetSignalDomain", errNum);
}
return;
}
int main(
int argc,
char **argv)
{
WlzObject *obj1, *obj2;
int verboseFlg=0;
char *nameStr;
double xsize=1.0, ysize=1.0, zsize=1.0;
int i, j;
double dist, minDist;
double dist1, dist2, dist3, dist4;
int numVtxs1, numVtxs2;
WlzDVertex3 *edgeVtxs1, *edgeVtxs2;
WlzDVertex3 cmVtx1, cmVtx2;
double vol1, vol2;
double mass1, mass2;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check input arguments */
nameStr = argv[0];
argv++;
argc--;
while( argc > 0 )
{
switch( argv[0][1] )
{
case 'h':
usage(nameStr);
return 0;
case 'v':
verboseFlg = 1;
break;
default:
usage(nameStr);
return 1;
}
argc--;
argv++;
}
/* read the objects */
if((obj1 = WlzReadObj(stdin, NULL)) &&
(obj2 = WlzReadObj(stdin, NULL)) ){
if( obj1->type != obj2->type ){
return 1;
}
if((obj1->type != WLZ_2D_DOMAINOBJ) &&
(obj1->type != WLZ_3D_DOMAINOBJ)){
usage(nameStr);
return 1;
}
/* get edge vertices */
numVtxs1 = WlzEdgeVertices(obj1, &edgeVtxs1, NULL);
numVtxs2 = WlzEdgeVertices(obj2, &edgeVtxs2, NULL);
/* renormalise with pixel sizes */
if( obj1->type == WLZ_3D_DOMAINOBJ ){
xsize = obj1->domain.p->voxel_size[0];
ysize = obj1->domain.p->voxel_size[1];
zsize = obj1->domain.p->voxel_size[2];
for(i=0; i < numVtxs1; i++){
edgeVtxs1[i].vtX *= xsize;
edgeVtxs1[i].vtY *= ysize;
edgeVtxs1[i].vtZ *= zsize;
}
for(i=0; i < numVtxs2; i++){
edgeVtxs2[i].vtX *= xsize;
edgeVtxs2[i].vtY *= ysize;
edgeVtxs2[i].vtZ *= zsize;
}
}
/* get centre of mass vertices */
if( obj1->type == WLZ_2D_DOMAINOBJ ){
WlzDVertex2 vtx2;
vtx2 = WlzCentreOfMass2D(obj1, 0, &mass1, &errNum);
cmVtx1.vtX = vtx2.vtX;
cmVtx1.vtY = vtx2.vtY;
cmVtx1.vtZ = 0.0;
vtx2 = WlzCentreOfMass2D(obj2, 0, &mass2, &errNum);
cmVtx2.vtX = vtx2.vtX;
cmVtx2.vtY = vtx2.vtY;
cmVtx2.vtZ = 0.0;
}
else {
cmVtx1 = WlzCentreOfMass3D(obj1, 0, &mass1, &errNum);
cmVtx2 = WlzCentreOfMass3D(obj2, 0, &mass2, &errNum);
cmVtx1.vtX *= xsize;
cmVtx1.vtY *= ysize;
cmVtx1.vtZ *= zsize;
cmVtx2.vtX *= xsize;
cmVtx2.vtY *= ysize;
cmVtx2.vtZ *= zsize;
}
/* find distance between centres of mass */
dist1 = vtxDist(cmVtx1, cmVtx2);
/* find cm 1 to surface 2 dist */
if( numVtxs2 > 0 ){
minDist = vtxDist(cmVtx1, edgeVtxs2[0]);
for(j=0; j < numVtxs2; j++){
dist = vtxDist(cmVtx1, edgeVtxs2[j]);
if( dist < minDist ){
minDist = dist;
}
}
dist2 = minDist;
if( !WlzInsideDomain(obj2, cmVtx1.vtZ/zsize,
cmVtx1.vtY/ysize, cmVtx1.vtX/xsize,
&errNum) ){
dist2 *= -1.0;
}
}
else {
dist2 = 0.0;
}
/* find surface 1 to cm 2 dist */
if( numVtxs1 > 0 ){
minDist = vtxDist(cmVtx2, edgeVtxs1[0]);
for(j=0; j < numVtxs1; j++){
dist = vtxDist(cmVtx2, edgeVtxs1[j]);
if( dist < minDist ){
minDist = dist;
}
}
dist3 = minDist;
if( !WlzInsideDomain(obj1, cmVtx2.vtZ/zsize,
cmVtx2.vtY/ysize, cmVtx2.vtX/xsize,
&errNum) ){
dist3 *= -1.0;
}
}
else {
dist3 = 0.0;
}
/* find min distance between surfaces */
if( (numVtxs1 > 0) && (numVtxs2 > 0) ){
minDist = vtxDist(edgeVtxs1[0], edgeVtxs2[0]);
for(i=0; i < numVtxs1; i++){
for(j=0; j < numVtxs2; j++){
dist = vtxDist(edgeVtxs1[i], edgeVtxs2[j]);
if( dist < minDist ){
minDist = dist;
}
}
}
dist4 = minDist;
}
else {
dist4 = 0.0;
}
/* get the volumes */
if( obj1->type == WLZ_2D_DOMAINOBJ ){
vol1 = WlzArea(obj1, &errNum);
vol2 = WlzArea(obj2, &errNum);
}
else {
vol1 = WlzVolume(obj1, &errNum);
vol2 = WlzVolume(obj2, &errNum);
vol1 *= xsize*ysize*zsize;
vol2 *= xsize*ysize*zsize;
}
/* print it */
fprintf(stdout, "%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f\n",
vol1, vol2, mass1, mass2, dist1, dist2, dist3, dist4);
}
return 0;
}
/*!
* \return projection object
* \ingroup WlzTransform
* \brief Use the view transform to define a projection from
* 3D to 2D. Currently only the domain is projected as
* an opaque shadow.
* This is old code temporarily kept for compatibility.
* \param obj source 3D object
* \param viewStr view structure defining the projection
* \param intFunc grey-value summation function
* \param intFuncData data to be passed to the integration function
* \param dstErr error return
*/
WlzObject *WlzGetProjectionFromObject(
WlzObject *obj,
WlzThreeDViewStruct *viewStr,
Wlz3DProjectionIntFn intFunc,
void *intFuncData,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj=NULL,
*obj1;
WlzThreeDViewStruct *viewStr1=NULL;
WlzDomain domain;
WlzValues values;
WlzGreyType srcGType = WLZ_GREY_UBYTE,
dstGType = WLZ_GREY_UBYTE;
WlzPixelV pixval;
WlzPixelP pixptr;
WlzIntervalWSpace iwsp;
WlzGreyWSpace gwsp;
WlzGreyValueWSpace *gVWSp = NULL;
WlzDVertex3 vtx, vtx1;
double x, y, z;
double *s_to_x=NULL;
double *s_to_y=NULL;
double *s_to_z=NULL;
int k, xp, yp, s, sp;
int length = 0, size = 0, occupiedFlg;
WlzErrorNum errNum=WLZ_ERR_NONE;
/* check inputs */
if( obj == NULL ){
errNum = WLZ_ERR_OBJECT_NULL;
}
else if( obj->type != WLZ_3D_DOMAINOBJ ){
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if( obj->domain.core == NULL ){
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if( obj->domain.core->type != WLZ_PLANEDOMAIN_DOMAIN ){
errNum = WLZ_ERR_DOMAIN_TYPE;
}
if( (errNum == WLZ_ERR_NONE) && (viewStr == NULL) ){
errNum = WLZ_ERR_OBJECT_NULL;
}
/* create new view transform */
if( errNum == WLZ_ERR_NONE ){
if((viewStr1 = WlzMake3DViewStruct(WLZ_3D_VIEW_STRUCT, &errNum)) != NULL){
/* need to worry about fixed line mode here sometime */
viewStr1->fixed = viewStr->fixed;
viewStr1->theta = viewStr->theta;
viewStr1->phi = viewStr->phi;
viewStr1->zeta = viewStr->zeta;
viewStr1->dist = viewStr->dist;
viewStr1->scale = viewStr->scale;
viewStr1->voxelSize[0] = viewStr->voxelSize[0];
viewStr1->voxelSize[1] = viewStr->voxelSize[1];
viewStr1->voxelSize[2] = viewStr->voxelSize[2];
viewStr1->voxelRescaleFlg = viewStr->voxelRescaleFlg;
viewStr1->interp = viewStr->interp;
viewStr1->view_mode = viewStr->view_mode;
viewStr1->up = viewStr->up;
/* now intialize it */
/* could optimise by setting fixed point to object centre */
if( (errNum = WlzInit3DViewStruct(viewStr1, obj)) != WLZ_ERR_NONE ){
WlzFree3DViewStruct(viewStr1);
viewStr1 = NULL;
}
}
}
/* set up orthogonal line parameters & luts */
if( errNum == WLZ_ERR_NONE ){
length = WLZ_NINT(viewStr1->maxvals.vtZ) -
WLZ_NINT(viewStr1->minvals.vtZ) + 1;
s_to_x = (double *) AlcMalloc(sizeof(double) * length );
s_to_y = (double *) AlcMalloc(sizeof(double) * length );
s_to_z = (double *) AlcMalloc(sizeof(double) * length );
/* transform a perpendicular vector */
vtx.vtX = 0.0;
vtx.vtY = 0.0;
vtx.vtZ = 1.0;
Wlz3DSectionTransformInvVtx(&vtx, viewStr1);
vtx1.vtX = 0.0;
vtx1.vtY = 0.0;
vtx1.vtZ = 0.0;
Wlz3DSectionTransformInvVtx(&vtx1, viewStr1);
vtx.vtX -= vtx1.vtX;
vtx.vtY -= vtx1.vtY;
vtx.vtZ -= vtx1.vtZ;
/* assign lut values */
s = (int )(WLZ_NINT(viewStr1->minvals.vtZ) - viewStr1->dist);
for(sp=0; sp < length; sp++, s++){
s_to_x[sp] = s * vtx.vtX;
s_to_y[sp] = s * vtx.vtY;
s_to_z[sp] = s * vtx.vtZ;
}
}
/* if there is an integration function then allocate space for
the grey-level array */
if( (errNum == WLZ_ERR_NONE) && (intFunc) ){
srcGType = WlzGreyTypeFromObj(obj, &errNum);
switch( srcGType ){
case WLZ_GREY_LONG:
size = sizeof(WlzLong)*length;
break;
case WLZ_GREY_INT:
size = sizeof(int)*length;
break;
case WLZ_GREY_SHORT:
size = sizeof(short)*length;
break;
case WLZ_GREY_UBYTE:
size = sizeof(WlzUByte)*length;
break;
case WLZ_GREY_FLOAT:
size = sizeof(float)*length;
break;
case WLZ_GREY_DOUBLE:
size = sizeof(double)*length;
break;
case WLZ_GREY_RGBA:
size = sizeof(int)*length;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
if( (pixptr.p.inp = (int *) AlcMalloc(size)) == NULL ){
errNum = WLZ_ERR_MEM_ALLOC;
}
pixptr.type = srcGType;
/* set up the grey-value workspace for random access */
gVWSp = WlzGreyValueMakeWSp(obj, &errNum);
}
/* create rectangular projection image */
if( errNum == WLZ_ERR_NONE ){
if((domain.i = WlzMakeIntervalDomain(WLZ_INTERVALDOMAIN_RECT,
WLZ_NINT(viewStr1->minvals.vtY),
WLZ_NINT(viewStr1->maxvals.vtY),
WLZ_NINT(viewStr1->minvals.vtX),
WLZ_NINT(viewStr1->maxvals.vtX),
&errNum)) != NULL){
values.core = NULL;
if((rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, domain, values, NULL, NULL,
&errNum)) != NULL){
/* note the grey-values required are determined by the integration
function. Here we use WlzUByte and reset later if needed */
dstGType = WLZ_GREY_UBYTE;
pixval.type = WLZ_GREY_UBYTE;
pixval.v.ubv = (WlzUByte )0;
if((values.v = WlzNewValueTb(rtnObj,
WlzGreyTableType(WLZ_GREY_TAB_RECT,
dstGType, NULL),
pixval, &errNum)) != NULL){
rtnObj->values = WlzAssignValues(values, &errNum);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
else {
WlzFreeDomain(domain);
domain.core = NULL;
}
}
}
/* scan image setting values */
if( errNum == WLZ_ERR_NONE ){
errNum = WlzInitGreyScan(rtnObj, &iwsp, &gwsp);
}
if( errNum == WLZ_ERR_NONE ){
while( (errNum = WlzNextGreyInterval(&iwsp)) == WLZ_ERR_NONE ){
yp = iwsp.linpos - WLZ_NINT(viewStr1->minvals.vtY);
for(k=iwsp.lftpos; k <= iwsp.rgtpos; k++){
xp = k - WLZ_NINT(viewStr1->minvals.vtX);
vtx.vtX = viewStr1->xp_to_x[xp] + viewStr1->yp_to_x[yp];
vtx.vtY = viewStr1->xp_to_y[xp] + viewStr1->yp_to_y[yp];
vtx.vtZ = viewStr1->xp_to_z[xp] + viewStr1->yp_to_z[yp];
/* get the projection values */
/* if no function then just check for occupancy */
if( intFunc == NULL ){
occupiedFlg = 0;
sp = (int )(viewStr1->dist - WLZ_NINT(viewStr1->minvals.vtZ));
for(; !occupiedFlg && (sp < length); sp++){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
if( WlzInsideDomain(obj, z, y, x, &errNum) ){
occupiedFlg = 1;
}
}
sp = (int )(viewStr1->dist - WLZ_NINT(viewStr1->minvals.vtZ) - 1);
for(; !occupiedFlg && (sp >= 0); sp--){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
if( WlzInsideDomain(obj, z, y, x, &errNum) ){
occupiedFlg = 1;
}
}
/* set the integrated value - only WlzUByte at the moment */
*(gwsp.u_grintptr.ubp) = (WlzUByte )occupiedFlg;
gwsp.u_grintptr.ubp++;
}
/* use integration function */
else {
/* set array of pixel values */
for(sp=0; sp < length; sp++){
x = vtx.vtX + s_to_x[sp];
y = vtx.vtY + s_to_y[sp];
z = vtx.vtZ + s_to_z[sp];
WlzGreyValueGet(gVWSp, WLZ_NINT(z), WLZ_NINT(y),
WLZ_NINT(x));
switch( srcGType ){
case WLZ_GREY_LONG:
pixptr.p.lnp[sp] = gVWSp->gVal[0].lnv;
break;
case WLZ_GREY_INT:
pixptr.p.inp[sp] = gVWSp->gVal[0].inv;
break;
case WLZ_GREY_SHORT:
pixptr.p.shp[sp] = gVWSp->gVal[0].shv;
break;
case WLZ_GREY_UBYTE:
pixptr.p.ubp[sp] = gVWSp->gVal[0].ubv;
break;
case WLZ_GREY_FLOAT:
pixptr.p.flp[sp] = gVWSp->gVal[0].flv;
break;
case WLZ_GREY_DOUBLE:
pixptr.p.dbp[sp] = gVWSp->gVal[0].dbv;
break;
case WLZ_GREY_RGBA:
pixptr.p.rgbp[sp] = gVWSp->gVal[0].rgbv;
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
/* call integration function and seet value */
intFunc(pixptr, length, (int )(viewStr1->dist -
WLZ_NINT(viewStr1->minvals.vtZ)),
intFuncData, &errNum);
}
}
}
(void )WlzEndGreyScan(&iwsp, &gwsp);
if(errNum == WLZ_ERR_EOO) /* Reset error from end of intervals */
{
errNum = WLZ_ERR_NONE;
}
/* if no integration function then threshold - binary only */
if( intFunc == NULL ){
pixval.v.ubv = 1;
rtnObj = WlzAssignObject(rtnObj, NULL);
if((obj1 = WlzThreshold(rtnObj, pixval, WLZ_THRESH_HIGH,
&errNum)) != NULL){
WlzFreeObj(rtnObj);
values.core = NULL;
rtnObj = WlzMakeMain(WLZ_2D_DOMAINOBJ, obj1->domain, values, NULL, NULL,
&errNum);
WlzFreeObj(obj1);
}
else {
WlzFreeObj(rtnObj);
rtnObj = NULL;
}
}
}
/* clear space */
if( viewStr1 ){
errNum = WlzFree3DViewStruct(viewStr1);
}
if( s_to_x ){
AlcFree( s_to_x );
}
if( s_to_y ){
AlcFree( s_to_y );
}
if( s_to_z ){
AlcFree( s_to_z );
}
/* check error and return */
if( dstErr ){
*dstErr = errNum;
}
return rtnObj;
}
