int main(int argc, char **argv)
{
int idx,
option,
dither = 0,
overwrite = 1,
ok = 1,
usage = 0;
WlzImArNorm norm = WLZ_IMARNORM_NONE;
WlzErrorNum errNum = WLZ_ERR_NONE;
FILE *fP = NULL;
WlzObject *outObj = NULL;
WlzObject *inObj[2];
WlzBinaryOperatorType operator = WLZ_BO_ADD;
char *outObjFileStr;
char *inObjFileStr[2];
WlzPixelV gMin[3],
gMax[3];
const char *errMsg;
static char optList[] = "O:o:ab:dgilmsnNh",
outObjFileStrDef[] = "-",
inObjFileStrDef[] = "-";
opterr = 0;
inObj[0] = NULL;
inObj[1] = NULL;
outObjFileStr = outObjFileStrDef;
inObjFileStr[0] = inObjFileStrDef;
inObjFileStr[1] = inObjFileStrDef;
while(ok && ((option = getopt(argc, argv, optList)) != -1))
{
switch(option)
{
case 'O':
if((sscanf(optarg, "%d", &overwrite) != 1) ||
(overwrite < 0) || (overwrite > 2))
{
usage = 1;
ok = 0;
}
break;
case 'o':
outObjFileStr = optarg;
break;
case 'a':
operator = WLZ_BO_ADD;
break;
case 'b':
operator = atoi(optarg);
switch( operator ){
case WLZ_BO_ADD:
case WLZ_BO_SUBTRACT:
case WLZ_BO_MULTIPLY:
case WLZ_BO_DIVIDE:
case WLZ_BO_MODULUS:
case WLZ_BO_EQ:
case WLZ_BO_NE:
case WLZ_BO_GT:
case WLZ_BO_GE:
case WLZ_BO_LT:
case WLZ_BO_LE:
case WLZ_BO_AND:
case WLZ_BO_OR:
case WLZ_BO_XOR:
case WLZ_BO_MAX:
case WLZ_BO_MIN:
case WLZ_BO_MAGNITUDE:
break;
default:
usage = 1;
ok = 0;
break;
}
break;
case 'd':
operator = WLZ_BO_DIVIDE;
break;
case 'g':
operator = WLZ_BO_MAGNITUDE;
break;
case 'l':
operator = WLZ_BO_MODULUS;
break;
case 'm':
operator = WLZ_BO_MULTIPLY;
break;
case 's':
operator = WLZ_BO_SUBTRACT;
break;
case 'n':
norm = WLZ_IMARNORM_INPUT;
break;
case 'N':
norm = WLZ_IMARNORM_256;
break;
case 'i':
dither = 1;
break;
case 'h':
default:
usage = 1;
ok = 0;
break;
}
}
if((inObjFileStr[0] == NULL) || (*inObjFileStr[0] == '\0') ||
(inObjFileStr[1] == NULL) || (*inObjFileStr[1] == '\0') ||
(outObjFileStr == NULL) || (*outObjFileStr == '\0'))
{
ok = 0;
usage = 1;
}
if(ok && (optind < argc))
{
idx = 0;
while((idx < 2) && (optind < argc))
{
inObjFileStr[idx] = *(argv + optind);
++optind;
++idx;
}
}
if(ok && (optind != argc))
{
usage = 1;
ok = 0;
}
if(ok)
{
idx = 0;
while((errNum == WLZ_ERR_NONE) && (idx < 2))
{
errNum = WLZ_ERR_READ_EOF;
if((inObjFileStr[idx] == NULL) ||
(*inObjFileStr[idx] == '\0') ||
((fP = (strcmp(inObjFileStr[idx], "-")?
fopen(inObjFileStr[idx], "r"): stdin)) == NULL) ||
((inObj[idx]= WlzAssignObject(WlzReadObj(fP,
&errNum), NULL)) == NULL))
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to read object %d from file %s (%s)\n",
*argv, idx, inObjFileStr[idx], errMsg);
}
if(fP && strcmp(inObjFileStr[idx], "-"))
{
fclose(fP);
}
++idx;
}
}
if(ok)
{
idx = 0;
while((errNum == WLZ_ERR_NONE) && (idx < 2))
{
if((inObj[idx]->type != WLZ_2D_DOMAINOBJ) &&
(inObj[idx]->type != WLZ_3D_DOMAINOBJ))
{
ok = 0;
(void )fprintf(stderr, "%s: input object %d is not a domain object\n",
*argv, idx);
}
++idx;
}
}
if(ok && (norm == WLZ_IMARNORM_INPUT))
{
if(((errNum = WlzGreyRange(inObj[0], gMin, gMax)) != WLZ_ERR_NONE) ||
((errNum = WlzGreyRange(inObj[1], gMin + 1, gMax + 1)) != WLZ_ERR_NONE))
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to find input objects grey range (%s)\n",
*argv, errMsg);
}
}
if(ok)
{
if( WlzGreyTypeFromObj(inObj[0], &errNum) == WLZ_GREY_RGBA ){
if((outObj = WlzRGBAImageArithmetic(inObj[0], inObj[1], operator, 1,
&errNum)) == NULL)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to compute new object (%s).\n",
*argv, errMsg);
}
}
else if((outObj = WlzImageArithmetic(inObj[0], inObj[1], operator, 0,
&errNum)) == NULL)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to compute new object (%s).\n",
*argv, errMsg);
}
}
if(ok &&
(norm != WLZ_IMARNORM_NONE) &&
(WlzGreyTypeFromObj(inObj[0], &errNum) != WLZ_GREY_RGBA) )
{
if((errNum = WlzGreyRange(outObj, gMin+ 2, gMax + 2)) != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to find output object's grey range (%s)\n",
*argv, errMsg);
}
if(ok)
{
if(norm == WLZ_IMARNORM_256)
{
gMin[0].type = WLZ_GREY_UBYTE;
gMin[0].v.ubv = 0;
gMax[0].type = WLZ_GREY_UBYTE;
gMax[0].v.ubv = 255;
(void )WlzValueConvertPixel(gMin, gMin[0], gMin[2].type);
(void )WlzValueConvertPixel(gMax, gMax[0], gMax[2].type);
}
else
{
(void )WlzValueConvertPixel(gMin, gMin[0], gMin[2].type);
(void )WlzValueConvertPixel(gMax, gMax[0], gMax[2].type);
(void )WlzValueConvertPixel(gMin + 1, gMin[1], gMin[2].type);
(void )WlzValueConvertPixel(gMax + 1, gMax[1], gMax[2].type);
switch(gMin[2].type)
{
case WLZ_GREY_INT:
if(gMin[1].v.inv < gMin[0].v.inv)
{
gMin[0].v.inv = gMin[1].v.inv;
}
if(gMax[1].v.inv > gMax[0].v.inv)
{
gMax[0].v.inv = gMax[1].v.inv;
}
break;
case WLZ_GREY_SHORT:
if(gMin[1].v.shv < gMin[0].v.shv)
{
gMin[0].v.shv = gMin[1].v.shv;
}
if(gMax[1].v.shv > gMax[0].v.shv)
{
gMax[0].v.shv = gMax[1].v.shv;
}
break;
case WLZ_GREY_UBYTE:
if(gMin[1].v.ubv < gMin[0].v.ubv)
{
gMin[0].v.ubv = gMin[1].v.ubv;
}
if(gMax[1].v.ubv > gMax[0].v.ubv)
{
gMax[0].v.ubv = gMax[1].v.ubv;
}
break;
case WLZ_GREY_FLOAT:
if(gMin[1].v.flv < gMin[0].v.flv)
{
gMin[0].v.flv = gMin[1].v.flv;
}
if(gMax[1].v.flv > gMax[0].v.flv)
{
gMax[0].v.flv = gMax[1].v.flv;
}
break;
case WLZ_GREY_DOUBLE:
if(gMin[1].v.dbv < gMin[0].v.dbv)
{
gMin[0].v.dbv = gMin[1].v.dbv;
}
if(gMax[1].v.dbv > gMax[0].v.dbv)
{
gMax[0].v.dbv = gMax[1].v.dbv;
}
break;
default:
errNum = WLZ_ERR_GREY_TYPE;
break;
}
}
}
if((errNum = WlzGreySetRange(outObj, gMin[2], gMax[2],
gMin[0], gMax[0], dither)) != WLZ_ERR_NONE)
{
ok = 0;
(void )WlzStringFromErrorNum(errNum, &errMsg);
(void )fprintf(stderr,
"%s: failed to set output object's grey range (%s)\n",
*argv, errMsg);
}
}
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, "-"))
{
fclose(fP);
}
}
WlzFreeObj(inObj[0]);
WlzFreeObj(inObj[1]);
WlzFreeObj(outObj);
if(usage)
{
fprintf(stderr,
"Usage: %s"
" [-O#] [-o<out file>] [-a] [-b <op>] [-d] [-g] [-i] [-l] [-m] [-s] [-h] "
"[<in object 0>] [<in object 1>]\n"
"Options:\n"
" -O Overwrite option (only useful for debugging)\n"
" -o Output file name.\n"
" -a Add the object's grey values.\n"
" -b <op> Apply binary operation to the grey-values.\n"
" op = %d - Add\n"
" = %d - SUBTRACT\n"
" = %d - MULTIPLY\n"
" = %d - DIVIDE\n"
" = %d - MODULUS\n"
" = %d - EQ\n"
" = %d - NE\n"
" = %d - GT\n"
" = %d - GE\n"
" = %d - LT\n"
" = %d - LE\n"
" = %d - AND\n"
" = %d - OR\n"
" = %d - XOR\n"
" = %d - MAX\n"
" = %d - MIN\n"
" = %d - MAGNITUDE\n"
" -d Divide the grey values of the 1st object by those of the 2nd.\n"
" -g Vector magnitude of horizontal and vertical component objects\n"
" -i Dither values if setting range\n"
" -l Compute the modulus of the grey values of the 1st object wrt\n"
" those of the 2nd.\n"
" -m Multiply the object's grey values.\n"
" -s Subtract the grey values of the 2nd object from those of the 1st.\n"
" -n Normalises the output object to the range of the input objects.\n"
" -N Normalises the output objects to the range [0-255].\n"
" -h Help, prints this usage message.\n"
"Computes an arithmetic binary (two objects) operation on two domain\n"
"objects. The default operator is add.\n"
"The input objects are read from stdin and values are written to stdout\n"
"unless the filenames are given.\n"
"Example:\n%s%s%s",
*argv,
WLZ_BO_ADD,
WLZ_BO_SUBTRACT,
WLZ_BO_MULTIPLY,
WLZ_BO_DIVIDE,
WLZ_BO_MODULUS,
WLZ_BO_EQ,
WLZ_BO_NE,
WLZ_BO_GT,
WLZ_BO_GE,
WLZ_BO_LT,
WLZ_BO_LE,
WLZ_BO_AND,
WLZ_BO_OR,
WLZ_BO_XOR,
WLZ_BO_MAX,
WLZ_BO_MIN,
WLZ_BO_MAGNITUDE,
"cat obj1.wlz | ",
*argv,
" -o obj3.wlz -a obj2.wlz\n"
"A new object 'obj3.wlz is formed by adding the grey values of obj1 and\n"
"obj2.wlz.\n");
}
return(!ok);
}
int main(int argc,
char **argv)
{
char optList[] = "hv";
int option;
/* int verboseFlg=0; */
WlzErrorNum errNum=WLZ_ERR_NONE;
char *tiffFile=NULL;
WlzObject *inObj, *outObj, *obj, **objVec;
int i, objVecCount;
WlzGreyType gType;
/* read the argument list and check for an input file */
opterr = 0;
while( (option = getopt(argc, argv, optList)) != EOF ){
switch( option ){
case 'v':
/* verboseFlg = 1; */
break;
case 'h':
default:
usage(argv[0]);
return WLZ_ERR_UNSPECIFIED;
}
}
if( optind < argc ){
tiffFile = *(argv+optind);
}
else {
usage(argv[0]);
return WLZ_ERR_UNSPECIFIED;
}
/* read the TIFF file */
if( (inObj = WlzAssignObject(WlzEffReadObj(NULL, tiffFile,
WLZEFF_FORMAT_TIFF, 0, 0, 0,
&errNum), NULL)) == NULL ){
usage(argv[0]);
return errNum;
}
/* if 2D then that is the shade file, else take max of 3D stack */
switch( inObj->type ){
case WLZ_2D_DOMAINOBJ:
outObj = inObj;
break;
case WLZ_3D_DOMAINOBJ:
if( (errNum = WlzExplode3D(&objVecCount, &objVec, inObj)) != WLZ_ERR_NONE ){
usage(argv[0]);
return errNum;
}
gType = WlzGreyTypeFromObj(objVec[0], &errNum);
outObj = WlzAssignObject(objVec[0], NULL);
for(i=1; i < objVecCount; i++){
if( gType == WLZ_GREY_RGBA ){
obj = WlzRGBAImageArithmetic(outObj, objVec[i], WLZ_BO_MAX, 0, &errNum);
}
else {
obj = WlzImageArithmetic(outObj, objVec[i], WLZ_BO_MAX, 0, &errNum);
}
if( obj ){
WlzFreeObj(outObj);
outObj = WlzAssignObject(obj, &errNum);
}
else {
break;
}
}
WlzFreeObj(inObj);
break;
default:
WlzFreeObj(inObj);
errNum = WLZ_ERR_OBJECT_TYPE;
}
/* write shade object */
if( errNum == WLZ_ERR_NONE ){
WlzWriteObj(stdout, outObj);
WlzFreeObj(outObj);
}
else {
usage(argv[0]);
}
return errNum;
}
/*!
* \return Shade corrected object or NULL on error.
* \ingroup WlzValueFilters
* \brief Shade corrects the given domain object with grey
* values.
* \f[
p_i = n \frac{(o_i - d_i)}{(s_i - d_i}
\f]
* The shade corrected image P with values \f$p_i\f$ is
* created by applying a correction factor to each image
* value of the given image O with values \f$o_i\f$.
* \f$s_i\f$ and \f$d_i\f$ are the bright and dark-field
* shade image values respectively.
* \param srcObj Given object to be shade corrected.
* \param shdObj Given bright field object.
* \param shdDFObj Given dark field object (may be NULL).
* \param nrmVal Normalization value.
* \param inPlace Modify the grey values of the given
* object in place if non-zero.
* \param dstErr Destination error pointer, may
* be null.
*/
WlzObject *WlzShadeCorrectBFDF(
WlzObject *srcObj,
WlzObject *shdObj,
WlzObject *shdDFObj,
double nrmVal,
int inPlace,
WlzErrorNum *dstErr)
{
WlzObject *rtnObj = NULL;
WlzObject *obj1, *obj2;
WlzCompoundArray *inCobj, *outCobj;
WlzObject **outArray;
WlzValues values;
int i;
WlzErrorNum errNum = WLZ_ERR_NONE;
if((srcObj == NULL) || (shdObj == NULL))
{
errNum = WLZ_ERR_OBJECT_NULL;
}
else if((srcObj->domain.core == NULL) || (shdObj->domain.core == NULL))
{
errNum = WLZ_ERR_DOMAIN_NULL;
}
else if((srcObj->values.core == NULL) || (shdObj->values.core == NULL))
{
errNum = WLZ_ERR_VALUES_NULL;
}
else if(WlzGreyTableIsTiled(srcObj->values.core->type) ||
WlzGreyTableIsTiled(shdObj->values.core->type))
{
errNum = WLZ_ERR_VALUES_TYPE;
}
else
{
switch(srcObj->type)
{
case WLZ_2D_DOMAINOBJ:
if(shdObj->type != srcObj->type)
{
errNum = WLZ_ERR_OBJECT_TYPE;
}
else if( shdDFObj ){
if( WlzGreyTypeFromObj(srcObj, &errNum) == WLZ_GREY_RGBA ){
obj1 = WlzRGBAImageArithmetic(srcObj, shdDFObj, WLZ_BO_SUBTRACT,
0, &errNum);
obj2 = WlzRGBAImageArithmetic(shdObj, shdDFObj, WLZ_BO_SUBTRACT,
0, &errNum);
}
else {
obj1 = WlzImageArithmetic(srcObj, shdDFObj, WLZ_BO_SUBTRACT,
0, &errNum);
obj2 = WlzImageArithmetic(shdObj, shdDFObj, WLZ_BO_SUBTRACT,
0, &errNum);
}
rtnObj = WlzShadeCorrect2D(obj1, obj2, nrmVal, inPlace, &errNum);
WlzFreeObj(obj1);
WlzFreeObj(obj2);;
}
else {
rtnObj = WlzShadeCorrect2D(srcObj, shdObj, nrmVal, inPlace, &errNum);
}
break;
case WLZ_COMPOUND_ARR_1:
case WLZ_COMPOUND_ARR_2:
inCobj = (WlzCompoundArray *) srcObj;
if( inCobj->n > 0 ){
if( (outArray = (WlzObject **)
AlcCalloc(inCobj->n, sizeof(WlzObject *))) == NULL){
errNum = WLZ_ERR_MEM_ALLOC;
}
else {
for(i=0; (i < inCobj->n) && (errNum == WLZ_ERR_NONE); i++){
/* allow special behaviour of a non-compound shade image
to be used for each object in a compound but must align */
switch( shdObj->type ){
case WLZ_2D_DOMAINOBJ:
case WLZ_3D_DOMAINOBJ:
outArray[i] = WlzShadeCorrectBFDF(inCobj->o[i],
shdObj, shdDFObj,
nrmVal, inPlace, &errNum);
break;
case WLZ_COMPOUND_ARR_1:
case WLZ_COMPOUND_ARR_2:
outArray[i] =
WlzShadeCorrectBFDF(inCobj->o[i],
((WlzCompoundArray *) shdObj)->o[i],
shdDFObj?
((WlzCompoundArray *) shdDFObj)->o[i]:NULL,
nrmVal, inPlace, &errNum);
break;
default:
errNum = WLZ_ERR_OBJECT_TYPE;
break;
}
}
if( errNum == WLZ_ERR_NONE ){
outCobj = WlzMakeCompoundArray(srcObj->type, 3, inCobj->n,
outArray, outArray[0]->type,
&errNum);
rtnObj = (WlzObject *) outCobj;
}
else {
while( i >= 0 ){
WlzFreeObj(outArray[i--]);
}
}
AlcFree(outArray);
}
}
else {
errNum = WLZ_ERR_OBJECT_DATA;
}
break;
case WLZ_3D_DOMAINOBJ:
errNum = WLZ_ERR_UNIMPLEMENTED;
break;
case WLZ_TRANS_OBJ:
if((rtnObj = WlzShadeCorrectBFDF(srcObj->values.obj,
shdObj, shdDFObj, nrmVal,
inPlace, &errNum)) != NULL){
values.obj = rtnObj;
return WlzMakeMain(WLZ_TRANS_OBJ, srcObj->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);
}
