From 5ee8bda85276139b6d97ce082c37bba329bef353 Mon Sep 17 00:00:00 2001 From: giraffedata Date: Thu, 20 May 2010 23:57:15 +0000 Subject: Add some more code for more that two operands; not functional yet git-svn-id: http://svn.code.sf.net/p/netpbm/code/trunk@1223 9d0c8265-081b-0410-96cb-a4ca84ce46f8 --- other/pamarith.c | 89 +++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 63 insertions(+), 26 deletions(-) (limited to 'other') diff --git a/other/pamarith.c b/other/pamarith.c index d8ea19fa..dcca0a6e 100644 --- a/other/pamarith.c +++ b/other/pamarith.c @@ -400,48 +400,66 @@ doNormalizedArith(struct pam * const inpam1P, struct pam * const outpamP, enum function const function) { + /* Some of the logic in this subroutine is designed for future + expansion into non-dyadic computations. But for now, all + computations have exactly two operands. + */ unsigned int const operandCt = 2; - tuplen * tuplerown1; - tuplen * tuplerown2; + tuplen ** tuplerown; + /* tuplerown[0] is the current row in the first operand image */ + tuplen * tuplerownOut; unsigned int row; samplen * operands; + /* operand[0] is the first operand in the current one-sample + computation + */ + unsigned int * plane; + /* plane[0] is the plane number in the first operand image for + the current one-sample computation. plane[1] is the plane number + in the second operand image, etc. + */ MALLOCARRAY_NOFAIL(operands, operandCt); + MALLOCARRAY_NOFAIL(plane, operandCt); + MALLOCARRAY_NOFAIL(tuplerown, operandCt); - tuplerown1 = pnm_allocpamrown(inpam1P); - tuplerown2 = pnm_allocpamrown(inpam2P); + tuplerown[0] = pnm_allocpamrown(inpam1P); + tuplerown[1] = pnm_allocpamrown(inpam2P); tuplerownOut = pnm_allocpamrown(outpamP); for (row = 0; row < outpamP->height; ++row) { unsigned int col; - pnm_readpamrown(inpam1P, tuplerown1); - pnm_readpamrown(inpam2P, tuplerown2); + pnm_readpamrown(inpam1P, tuplerown[0]); + pnm_readpamrown(inpam2P, tuplerown[1]); for (col = 0; col < outpamP->width; ++col) { unsigned int outplane; for (outplane = 0; outplane < outpamP->depth; ++outplane) { - unsigned int const plane1 = MIN(outplane, inpam1P->depth-1); - unsigned int const plane2 = MIN(outplane, inpam2P->depth-1); + unsigned int op; - operands[0] = tuplerown1[col][plane1]; - operands[1] = tuplerown2[col][plane2]; + plane[0] = MIN(outplane, inpam1P->depth-1); + plane[1] = MIN(outplane, inpam2P->depth-1); + + for (op = 0; op < operandCt; ++op) + operands[op] = tuplerown[op][col][plane[op]]; tuplerownOut[col][outplane] = applyNormalizedFunction(function, operands, operandCt); assert(tuplerownOut[col][outplane] >= 0.); assert(tuplerownOut[col][outplane] <= 1.); - } } pnm_writepamrown(outpamP, tuplerownOut); } - pnm_freepamrown(tuplerown1); - pnm_freepamrown(tuplerown2); + pnm_freepamrown(tuplerown[0]); + pnm_freepamrown(tuplerown[1]); + free(tuplerown); pnm_freepamrown(tuplerownOut); + free(plane); free(operands); } @@ -701,14 +719,28 @@ doUnNormalizedArith(struct pam * const inpam1P, maxval to do the computation without time-consuming normalization of sample values. -----------------------------------------------------------------------------*/ + /* Some of the logic in this subroutine is designed for future + expansion into non-dyadic computations. But for now, all + computations have exactly two operands. + */ unsigned int const operandCt = 2; + sample const maxval = outpamP->maxval; - tuple * tuplerow1; - tuple * tuplerow2; + tuple ** tuplerow; + /* tuplerow[0] is the current row in the first operand image */ + tuple * tuplerowOut; unsigned int row; sample * operands; + /* operand[0] is the first operand in the current one-sample + computation + */ + unsigned int * plane; + /* plane[0] is the plane number in the first operand image for + the current one-sample computation. plane[1] is the plane number + in the second operand image, etc. + */ /* Input conditions: */ assert(inpam1P->maxval == maxval); @@ -716,25 +748,29 @@ doUnNormalizedArith(struct pam * const inpam1P, assert(outpamP->maxval == maxval); MALLOCARRAY_NOFAIL(operands, operandCt); + MALLOCARRAY_NOFAIL(plane, operandCt); + MALLOCARRAY_NOFAIL(tuplerow, operandCt); - tuplerow1 = pnm_allocpamrow(inpam1P); - tuplerow2 = pnm_allocpamrow(inpam2P); + tuplerow[0] = pnm_allocpamrow(inpam1P); + tuplerow[1] = pnm_allocpamrow(inpam2P); tuplerowOut = pnm_allocpamrow(outpamP); for (row = 0; row < outpamP->height; ++row) { unsigned int col; - pnm_readpamrow(inpam1P, tuplerow1); - pnm_readpamrow(inpam2P, tuplerow2); + pnm_readpamrow(inpam1P, tuplerow[0]); + pnm_readpamrow(inpam2P, tuplerow[1]); for (col = 0; col < outpamP->width; ++col) { unsigned int outplane; for (outplane = 0; outplane < outpamP->depth; ++outplane) { - unsigned int const plane1 = MIN(outplane, inpam1P->depth-1); - unsigned int const plane2 = MIN(outplane, inpam2P->depth-1); + unsigned int op; + + plane[0] = MIN(outplane, inpam1P->depth-1); + plane[1] = MIN(outplane, inpam2P->depth-1); - operands[0] = tuplerow1[col][plane1]; - operands[1] = tuplerow2[col][plane2]; + for (op = 0; op < operandCt; ++op) + operands[op] = tuplerow[op][col][plane[op]]; tuplerowOut[col][outplane] = applyUnNormalizedFunction(function, operands, operandCt, @@ -747,10 +783,11 @@ doUnNormalizedArith(struct pam * const inpam1P, pnm_writepamrow(outpamP, tuplerowOut); } - pnm_freepamrow(tuplerow1); - pnm_freepamrow(tuplerow2); + pnm_freepamrow(tuplerow[0]); + pnm_freepamrow(tuplerow[1]); + free(tuplerow); pnm_freepamrow(tuplerowOut); - + free(plane); free(operands); } -- cgit 1.4.1