/*!
* \return Coordinates of center of mass.
* \ingroup WlzFeatures
* \brief Calculates the centre of mass of a transformed object.
* \param srcObj Given object.
* \param trans Given transform.
* \param binObjFlag Binary object flag.
* \param dstMass Destination pointer for mass,
* may be NULL.
* \param dstErr Destination pointer for error,
* may be NULL.
*/
static WlzDVertex3 WlzCentreOfMassTrans3D(WlzObject *srcObj,
WlzAffineTransform *trans,
int binObjFlag,
double *dstMass,
WlzErrorNum *dstErr)
{
double mass;
WlzDVertex3 cMass;
WlzErrorNum errNum = WLZ_ERR_NONE;
cMass = WlzCentreOfMass3D(srcObj, binObjFlag, &mass, &errNum);
if(errNum == WLZ_ERR_NONE)
{
cMass = WlzAffineTransformVertexD3(trans, cMass, &errNum);
errNum = WLZ_ERR_TRANSFORM_TYPE;
}
if((errNum == WLZ_ERR_NONE) && dstMass)
{
*dstMass = mass;
}
if(dstErr)
{
*dstErr = errNum;
}
return(cMass);
}
int main(int argc, char **argv)
{
int tI,
idN,
option,
con = WLZ_0_CONNECTED,
nLo = 0,
nHi = 0,
maxSep = 1024,
nObj = 0,
ok = 1,
usage = 0;
char tC;
double tD,
mrkMass = 1.0,
rad = 0.0;
int tR[4];
WlzPixelV gV,
bV;
WlzBlobMark mrk = WLZ_BLOBMARK_CIRCLE;
WlzObject *inObj = NULL,
*outObj = NULL,
*mrkObj = NULL;
WlzObject **lObj = NULL;
FILE *fP = NULL;
char *inObjFileStr,
*outObjFileStr;
WlzErrorNum errNum = WLZ_ERR_NONE;
const char *errMsg;
static char optList[] = "c:g:G:hm:n:N:o:r:x:",
fileStrDef[] = "-";
opterr = 0;
memset(&gV, 0, sizeof(WlzPixelV));
bV.type = WLZ_GREY_UBYTE;
bV.v.ubv = 0;
gV.type = WLZ_GREY_ERROR;
inObjFileStr = fileStrDef;
outObjFileStr = fileStrDef;
while((usage == 0) && ((option = getopt(argc, argv, optList)) != -1))
{
switch(option)
{
case 'c':
if(sscanf(optarg, "%d", &tI) != 1)
{
usage = 1;
}
else
{
switch(tI)
{
case 4:
con = WLZ_4_CONNECTED;
break;
case 6:
con = WLZ_6_CONNECTED;
break;
case 8:
con = WLZ_8_CONNECTED;
break;
case 18:
con = WLZ_18_CONNECTED;
break;
case 26:
con = WLZ_26_CONNECTED;
break;
default:
usage = 1;
break;
}
}
break;
case 'g':
switch(gV.type)
{
case WLZ_GREY_UBYTE:
if((sscanf(optarg, "%d", &tI) != 1) ||
(tI < 0) || (tI > 255))
{
usage = 1;
}
else
{
gV.v.ubv = tI;
}
break;
case WLZ_GREY_SHORT:
if((sscanf(optarg, "%d", &tI) != 1) ||
(tI < SHRT_MIN) || (tI > SHRT_MAX))
{
usage = 1;
}
else
{
gV.v.shv = tI;
}
break;
case WLZ_GREY_INT:
if(sscanf(optarg, "%d", &tI) != 1)
{
usage = 1;
}
else
{
gV.v.inv = tI;
}
break;
case WLZ_GREY_FLOAT:
if((sscanf(optarg, "%lg", &tD) != 1) ||
(tD < -(FLT_MAX)) || (tD > FLT_MAX))
{
usage = 1;
}
else
{
gV.v.flv = tD;
}
break;
case WLZ_GREY_DOUBLE:
if(sscanf(optarg, "%lg", &tD) != 1)
{
usage = 1;
}
else
{
gV.v.dbv = tD;
}
break;
case WLZ_GREY_RGBA:
tR[3] = 255;
tR[0] = tR[1] = tR[2] = 0;
if((sscanf(optarg, "%d,%d,%d,%d",
&(tR[0]), &(tR[1]), &(tR[2]), &(tR[3])) == 0) ||
(tR[0] < 0) || (tR[0] > 255) ||
(tR[1] < 0) || (tR[1] > 255) ||
(tR[2] < 0) || (tR[2] > 255) ||
(tR[3] < 0) || (tR[3] > 255))
{
usage = 1;
}
else
{
WLZ_RGBA_RGBA_SET(gV.v.rgbv, tR[0], tR[1], tR[2], tR[3]);
}
break;
default:
usage = 1;
break;
}
break;
case 'G':
if(sscanf(optarg, "%c", &tC) != 1)
{
usage = 1;
}
switch(tC)
{
case 'v':
gV.type = WLZ_GREY_ERROR;
break;
case 'u':
gV.type = WLZ_GREY_UBYTE;
break;
case 's':
gV.type = WLZ_GREY_SHORT;
break;
case 'i':
gV.type = WLZ_GREY_INT;
break;
case 'f':
gV.type = WLZ_GREY_FLOAT;
break;
case 'd':
gV.type = WLZ_GREY_DOUBLE;
break;
case 'r':
gV.type = WLZ_GREY_RGBA;
break;
default:
usage = 1;
break;
}
break;
case 'm':
if((sscanf(optarg, "%d", &tI) != 1) ||
((tI != WLZ_BLOBMARK_CIRCLE) && (tI != WLZ_BLOBMARK_SQUARE)))
{
usage = 1;
}
else
{
mrk = (WlzBlobMark )tI;
}
break;
case 'n':
if((sscanf(optarg, "%d", &nLo) != 1) || (nLo < 0))
{
usage = 1;
}
break;
case 'N':
if((sscanf(optarg, "%d", &nHi) != 1) || (nHi < 0))
{
usage = 1;
}
break;
case 'o':
outObjFileStr = optarg;
break;
case 'r':
if((sscanf(optarg, "%lg", &rad) != 1) || (rad < 0.0))
{
usage = 1;
}
break;
case 'x':
if((sscanf(optarg, "%d", &maxSep) != 1) || (maxSep < 1))
{
usage = 1;
}
case 'h': /* FALLTHROUGH */
default:
usage = 1;
break;
}
}
if((usage == 0) && (nLo > nHi) && (nHi != 0))
{
usage = 1;
}
if((usage == 0) && (optind < argc))
{
if((optind + 1) != argc)
{
usage = 1;
}
else
{
inObjFileStr = *(argv + optind);
}
}
ok = (usage == 0);
/* Read input domain object. */
if(ok)
{
if((inObjFileStr == NULL) ||
(*inObjFileStr == '\0') ||
((fP = (strcmp(inObjFileStr, "-")?
fopen(inObjFileStr, "r"): stdin)) == NULL) ||
((inObj = WlzAssignObject(WlzReadObj(fP, &errNum), NULL)) == NULL) ||
(errNum != WLZ_ERR_NONE))
{
ok = 0;
}
if(fP)
{
if(strcmp(inObjFileStr, "-"))
{
(void )fclose(fP);
}
fP = NULL;
}
}
/* Check object type and connectivity. */
if(ok)
{
switch(inObj->type)
{
case WLZ_2D_DOMAINOBJ:
switch(con)
{
case WLZ_0_CONNECTED:
con = WLZ_8_CONNECTED;
break;
case WLZ_4_CONNECTED: /* FALLTHROUGH */
case WLZ_8_CONNECTED:
break;
default:
ok = 0;
errNum = WLZ_ERR_PARAM_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Connectivity for 2D must be 4 or 8 (%s).\n",
*argv, errMsg);
break;
}
break;
case WLZ_3D_DOMAINOBJ:
switch(con)
{
case WLZ_0_CONNECTED:
con = WLZ_26_CONNECTED;
break;
case WLZ_6_CONNECTED: /* FALLTHROUGH */
case WLZ_18_CONNECTED: /* FALLTHROUGH */
case WLZ_26_CONNECTED:
break;
default:
ok = 0;
errNum = WLZ_ERR_PARAM_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Connectivity for 3D must be 6, 18 or 26 (%s).\n",
*argv, errMsg);
break;
}
break;
default:
ok = 0;
errNum = WLZ_ERR_OBJECT_TYPE;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Input object must either a 2 or 3D domain object (%s).\n",
*argv, errMsg);
break;
}
}
/* Make basic marker with centre at the origin. */
if(ok)
{
double mrkRad;
if(rad > 0.5)
{
mrkRad = rad;
}
else
{
mrkRad = 127;
}
if(mrk == WLZ_BLOBMARK_SQUARE)
{
mrkObj = WlzMakeCuboidObject(inObj->type, mrkRad, mrkRad, mrkRad,
0, 0, 0, &errNum);
}
else /* mrk = WLZ_BLOBMARK_CIRCLE */
{
mrkObj = WlzMakeSphereObject(inObj->type, mrkRad, 0, 0, 0, &errNum);
}
if(mrkObj == NULL)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to create basic marker object (%s).\n",
*argv, errMsg);
}
else
{
mrkMass = WlzVolume(mrkObj, NULL);
}
}
/* Label the given domain. */
if(ok)
{
errNum = WlzLabel(inObj, &nObj, &lObj, maxSep, 1, con);
if((errNum != WLZ_ERR_NONE) || (nObj == 0))
{
ok = 0;
if(errNum == WLZ_ERR_NONE)
{
errNum = WLZ_ERR_DOMAIN_DATA;
}
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to split the given object into separate regions (%s)\n",
*argv, errMsg);
}
}
/* Work through the separate object list removing small/large objects
* according to the low and high thresholds. */
if(ok)
{
int idM;
for(idN = 0, idM = 0; idN < nObj; ++idN)
{
int vol;
vol = WlzVolume(lObj[idN], &errNum);
if(errNum == WLZ_ERR_NONE)
{
if(((nLo > 0) && (vol < nLo)) || ((nHi > 0) && (vol > nHi)))
{
(void )WlzFreeObj(lObj[idN]);
}
else
{
lObj[idM] = lObj[idN];
++idM;
}
}
}
nObj = idM;
if(nObj == 0)
{
ok = 0;
errNum = WLZ_ERR_DOMAIN_DATA;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to find and separate regions (%s)\n",
*argv, errMsg);
}
}
/* Build a marker object by adding a mark at the centre of mass of each
* separate fragment. */
if(ok)
{
WlzObject *obj0 = NULL;
idN = 0;
obj0 = WlzMakeEmpty(&errNum);
while((errNum == WLZ_ERR_NONE) && (idN < nObj))
{
double mass;
WlzDVertex3 com;
WlzObject *obj1 = NULL,
*obj2 = NULL;
WlzAffineTransform *tr = NULL;
com = WlzCentreOfMass3D(lObj[idN], 1, &mass, &errNum);
if(errNum == WLZ_ERR_NONE)
{
double s;
if(rad < 0.5)
{
double t;
t = mass / mrkMass;
if(inObj->type == WLZ_2D_DOMAINOBJ)
{
s = sqrt(t);
}
else /* inObj->type == WLZ_3D_DOMAINOBJ */
{
s = cbrt(t);
}
}
else
{
s = 1.0;
}
tr = (inObj->type == WLZ_2D_DOMAINOBJ)?
WlzAffineTransformFromPrimVal(
WLZ_TRANSFORM_2D_AFFINE, com.vtX, com.vtY, 0.0,
s, 0.0, 0.0, 0.0, 0.0, 0.0, 0, &errNum):
WlzAffineTransformFromPrimVal(
WLZ_TRANSFORM_3D_AFFINE, com.vtX, com.vtY, com.vtZ,
s, 0.0, 0.0, 0.0, 0.0, 0.0, 0, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
obj1 = WlzAffineTransformObj(mrkObj, tr, WLZ_INTERPOLATION_NEAREST,
&errNum);
}
if(errNum == WLZ_ERR_NONE)
{
obj2 = WlzUnion2(obj0, obj1, &errNum);
}
if(errNum == WLZ_ERR_NONE)
{
(void )WlzFreeObj(obj0);
obj0 = obj2;
obj2 = NULL;
}
(void )WlzFreeObj(obj1);
(void )WlzFreeObj(obj2);
(void )WlzFreeAffineTransform(tr);
++idN;
}
if(errNum == WLZ_ERR_NONE)
{
WlzValues val;
WlzObjectType vTT;
val.core = NULL;
if(gV.type != WLZ_GREY_ERROR)
{
vTT = WlzGreyTableType(WLZ_GREY_TAB_RAGR, gV.type, NULL);
if(inObj->type == WLZ_2D_DOMAINOBJ)
{
val.v = WlzNewValueTb(obj0, vTT, bV, &errNum);
}
else /* inObj->type == WLZ_3D_DOMAINOBJ */
{
val.vox = WlzNewValuesVox(obj0, vTT, bV, &errNum);
}
}
if(errNum == WLZ_ERR_NONE)
{
outObj = WlzMakeMain(inObj->type, obj0->domain, val, NULL, NULL,
&errNum);
}
if((errNum == WLZ_ERR_NONE) && (gV.type != WLZ_GREY_ERROR))
{
errNum = WlzGreySetValue(outObj, gV);
}
}
}
if(ok)
{
errNum = WLZ_ERR_WRITE_EOF;
if(((fP = (strcmp(outObjFileStr, "-")?
fopen(outObjFileStr, "w"): stdout)) == NULL) ||
((errNum = WlzWriteObj(fP, outObj)) != WLZ_ERR_NONE))
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: Failed to write output object (%s).\n",
*argv, errMsg);
}
if(fP && strcmp(outObjFileStr, "-"))
{
(void )fclose(fP);
}
}
(void )WlzFreeObj(inObj);
if(lObj != NULL)
{
for(idN = 0; idN < nObj; ++idN)
{
(void )WlzFreeObj(lObj[idN]);
}
AlcFree(lObj);
}
(void )WlzFreeObj(outObj);
if(usage)
{
(void )fprintf(stderr,
"Usage: %s%sExample: %s%s",
*argv,
" [-c#] [-g#] [-G#] [-h] [-m#] [-n#] [-N#]\n"
" [-o<output object>] [-r#]] [-x#] [<input object>]\n"
"Options:\n"
" -c Connectivity: 4, 6, 8, 18 or 26 connected (default 8 for 2D\n"
" domains and 26 for 3D domains).\n"
" -g Grey value for marker. This is a single number for all except\n"
" RGBA (colour) grey values. RGBA components must be separated by\n"
" by a comma.\n"
" -G Grey value type for marker specified by letter:\n"
" v no grey values (default).\n"
" u unsigned byte grey values.\n"
" s short grey values.\n"
" i int grey values.\n"
" f int grey values.\n"
" d int grey values.\n"
" r red, green, blue, alpha grey values.\n"
" -h Help, prints usage message.\n"
" -m Marker type specified by a number:\n"
" 1 circle/sphere (default)\n"
" 2 square/cube\n"
" -n Threshold minimum area/volume of blob for a marker (default\n"
" >= 1).\n"
" -N Threshold maximum area/volume of blob for a marker. If zero\n"
" there is no upper limit. (default 0).\n"
" -o Output object file.\n"
" -r Marker radius. Attempts to keep the same area/volume if zero.\n"
" (default 0).\n"
" -x Maximum number of separate regions in the object (default 1024).\n"
"Reads a spatial domain object and replaces each spatialy separate\n"
"region with a marker placed at the centre of mass of the region.\n"
"All files are read from the standard input and written to the standard\n"
"output unless filenames are given.\n"
"If grey values are required then the grey value type must be set before\n"
"the actual grey value.\n",
*argv,
" -o out.wlz -n 4 -r 10 -G r -g 200,100,0,255 in.wlz\n"
"A spatial domain object is read from the file in.wlz and each\n"
"spatialy separate region of the domain is replaced by a circle or\n"
"sphere of radius 10 (pixels). All small regions with less than four\n"
"(pixels voxels) is ignored. The output object (with grey values set\n"
"to orange) is written to the file out.wlz.\n");
}
return(!ok);
}
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;
}
int main(int argc, char **argv)
{
int option,
binObjFlag = 0,
ok = 1,
usage = 0;
WlzErrorNum errNum = WLZ_ERR_NONE;
FILE *fP = NULL;
WlzObject *inObj = NULL;
double mass;
WlzDVertex3 cOfMass;
char *outFileStr,
*inObjFileStr;
static char optList[] = "o:bh",
outFileStrDef[] = "-",
inObjFileStrDef[] = "-";
opterr = 0;
outFileStr = outFileStrDef;
inObjFileStr = inObjFileStrDef;
while(ok && ((option = getopt(argc, argv, optList)) != -1))
{
switch(option)
{
case 'o':
outFileStr = optarg;
break;
case 'b':
binObjFlag = 1;
break;
case 'h':
default:
usage = 1;
ok = 0;
break;
}
}
if((inObjFileStr == NULL) || (*inObjFileStr == '\0') ||
(outFileStr == NULL) || (*outFileStr == '\0'))
{
ok = 0;
usage = 1;
}
if(ok && (optind < argc))
{
if((optind + 1) != argc)
{
usage = 1;
ok = 0;
}
else
{
inObjFileStr = *(argv + optind);
}
}
if(ok)
{
if((inObjFileStr == NULL) ||
(*inObjFileStr == '\0') ||
((fP = (strcmp(inObjFileStr, "-")?
fopen(inObjFileStr, "r"): stdin)) == NULL) ||
((inObj= WlzReadObj(fP, &errNum)) == NULL) ||
(errNum != WLZ_ERR_NONE))
{
ok = 0;
(void )fprintf(stderr,
"%s: failed to read object from file %s\n",
*argv, inObjFileStr);
}
if(fP && strcmp(inObjFileStr, "-"))
{
fclose(fP);
}
}
if(ok)
{
cOfMass = WlzCentreOfMass3D(inObj, binObjFlag, &mass, &errNum);
if(errNum != WLZ_ERR_NONE)
{
ok = 0;
(void )fprintf(stderr,
"%s: failed to compute centre of mass of object\n",
*argv);
}
}
if(ok)
{
if(((fP = (strcmp(outFileStr, "-")?
fopen(outFileStr, "w"):
stdout)) == NULL))
{
ok = 0;
(void )fprintf(stderr,
"%s: failed to write output data\n",
*argv);
}
else
{
(void )fprintf(fP, "%g %g %g %g\n",
mass, cOfMass.vtX, cOfMass.vtY, cOfMass.vtZ);
}
if(fP && strcmp(outFileStr, "-"))
{
fclose(fP);
}
}
if(usage)
{
(void )fprintf(stderr,
"Usage: %s%s%s%sExample: %s%s",
*argv,
" [-o<out file>] [-b] [-h] [<in object>]\n"
"Version: ",
WlzVersion(),
"\n"
"Options:\n"
" -o Output file name.\n"
" -b Always consider object a binary object.\n"
" -h Help, prints this usage message.\n"
"Calculates the mass and centre of mass of the input Woolz 2 or 3D\n"
"domain object. The mass and centre of mass are written to the output\n"
"file in the following order:\n"
" <mass> <x> <y> <z>\n"
"Where x, y and z are the column, line and plane coordinates of the\n"
"centre of mass.\n"
"The input object is read from stdin and values are written to stdout\n"
"unless the filenames are given.\n",
*argv,
" -o out.txt myobj.wlz\n"
"The input Woolz object is read from myobj.wlz. It's mass and centre of\n"
"mass are written to out.txt.\n");
}
return(!ok);
}
