Index: trunk/psLib/src/imageops/psImageConvolve.c =================================================================== --- trunk/psLib/src/imageops/psImageConvolve.c (revision 20830) +++ trunk/psLib/src/imageops/psImageConvolve.c (revision 21183) @@ -7,6 +7,6 @@ /// @author Eugene Magnier, IfA /// -/// @version $Revision: 1.81 $ $Name: not supported by cvs2svn $ -/// @date $Date: 2008-11-26 00:43:12 $ +/// @version $Revision: 1.82 $ $Name: not supported by cvs2svn $ +/// @date $Date: 2009-01-27 06:39:37 $ /// /// Copyright 2004-2007 Institute for Astronomy, University of Hawaii @@ -319,9 +319,9 @@ } -psImage *psImageConvolveMaskDirect(psImage *out, const psImage *mask, psMaskType maskVal, - psMaskType setVal, int xMin, int xMax, int yMin, int yMax) +psImage *psImageConvolveMaskDirect(psImage *out, const psImage *mask, psImageMaskType maskVal, + psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax) { PS_ASSERT_IMAGE_NON_NULL(mask, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); if (out == mask && ((maskVal & setVal) || !setVal)) { psError(PS_ERR_BAD_PARAMETER_VALUE, true, @@ -352,10 +352,10 @@ if (!out) { // Propagate the non-masked values - out = (psImage*)psBinaryOp(NULL, (const psPtr)mask, "&", psScalarAlloc(~maskVal, PS_TYPE_MASK)); + out = (psImage*)psBinaryOp(NULL, (const psPtr)mask, "&", psScalarAlloc(~maskVal, PS_TYPE_IMAGE_MASK)); } // Dereference mask images - psMaskType **maskData = mask->data.PS_TYPE_MASK_DATA; - psMaskType **outData = out->data.PS_TYPE_MASK_DATA; + psImageMaskType **maskData = mask->data.PS_TYPE_IMAGE_MASK_DATA; + psImageMaskType **outData = out->data.PS_TYPE_IMAGE_MASK_DATA; if (setVal) { @@ -376,5 +376,5 @@ for (int row = 0; row < numRows; row++) { for (int col = 0; col < numCols; col++) { - psMaskType pixel = outData[row][col]; // Pixel value to set + psImageMaskType pixel = outData[row][col]; // Pixel value to set if (pixel & maskVal) { // Already done this one @@ -395,9 +395,9 @@ -psImage *psImageConvolveMaskFFT(psImage *out, const psImage *mask, psMaskType maskVal, - psMaskType setVal, int xMin, int xMax, int yMin, int yMax, float thresh) +psImage *psImageConvolveMaskFFT(psImage *out, const psImage *mask, psImageMaskType maskVal, + psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax, float thresh) { PS_ASSERT_IMAGE_NON_NULL(mask, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); PS_ASSERT_FLOAT_LARGER_THAN(thresh, 0.0, NULL); PS_ASSERT_FLOAT_LESS_THAN(thresh, 1.0, NULL); @@ -431,5 +431,5 @@ for (int y = 0; y < numRows; y++) { for (int x = 0; x < numCols; x++) { - if (mask->data.PS_TYPE_MASK_DATA[y][x] & maskVal) { + if (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] & maskVal) { onoff->data.F32[y][x] = 1.0; } @@ -452,10 +452,10 @@ if (!out) { - out = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + out = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); } for (int y = 0; y < numRows; y++) { for (int x = 0; x < numCols; x++) { - out->data.PS_TYPE_MASK_DATA[y][x] = (convolved->data.F32[y][x] >= thresh) ? - (mask->data.PS_TYPE_MASK_DATA[y][x] | setVal) : mask->data.PS_TYPE_MASK_DATA[y][x]; + out->data.PS_TYPE_IMAGE_MASK_DATA[y][x] = (convolved->data.F32[y][x] >= thresh) ? + (mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] | setVal) : mask->data.PS_TYPE_IMAGE_MASK_DATA[y][x]; } } @@ -651,5 +651,5 @@ case PS_TYPE_##TYPE: { \ psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_##TYPE); /* Calculation image; BW */ \ - psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */ \ + psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */ \ \ /** Smooth in X direction **/ \ @@ -658,5 +658,5 @@ int xMin = PS_MAX(i - size, 0); \ int xMax = PS_MIN(i + size, xLast); \ - const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin]; \ + const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin]; \ const ps##TYPE *imageData = &image->data.TYPE[j][xMin]; \ int uMin = - PS_MIN(i, size); /* Minimum kernel index */ \ @@ -673,8 +673,8 @@ /* BW */ \ calculation->data.TYPE[i][j] = sumIG / sumG; \ - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0; \ + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0; \ } else { \ /* BW */ \ - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF; \ + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF; \ } \ } \ @@ -688,5 +688,5 @@ int yMin = PS_MAX(j - size, 0); \ int yMax = PS_MIN(j + size, yLast); \ - const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */ \ + const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */ \ const ps##TYPE *imageData = &calculation->data.TYPE[i][yMin]; /* BW */ \ int vMin = - PS_MIN(j, size); /* Minimum kernel index */ \ @@ -714,5 +714,5 @@ const psImage *image, const psImage *mask, - psMaskType maskVal, + psImageMaskType maskVal, float sigma, float numSigma, @@ -721,5 +721,5 @@ PS_ASSERT_IMAGE_NON_NULL(image, NULL); PS_ASSERT_IMAGE_NON_NULL(mask, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL); @@ -751,5 +751,5 @@ case PS_TYPE_F32: { psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */ - psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */ + psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */ /** Smooth in X direction **/ @@ -758,5 +758,5 @@ int xMin = PS_MAX(i - size, 0); int xMax = PS_MIN(i + size, xLast); - const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin]; + const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin]; const psF32 *imageData = &image->data.F32[j][xMin]; int uMin = - PS_MIN(i, size); /* Minimum kernel index */ @@ -776,8 +776,8 @@ /* BW */ calculation->data.F32[i][j] = sumIG / sumG; - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0; + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0; } else { /* BW */ - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF; + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF; } } @@ -791,5 +791,5 @@ int yMin = PS_MAX(j - size, 0); int yMax = PS_MIN(j + size, yLast); - const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */ + const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */ const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */ int vMin = - PS_MIN(j, size); /* Minimum kernel index */ @@ -832,5 +832,5 @@ const psImage *image, const psImage *mask, - psMaskType maskVal, + psImageMaskType maskVal, psVector *gaussNorm, float minGauss, @@ -848,5 +848,5 @@ int xMin = PS_MAX(i - size, 0); int xMax = PS_MIN(i + size, xLast); - const psMaskType *maskData = &mask->data.PS_TYPE_MASK_DATA[j][xMin]; + const psImageMaskType *maskData = &mask->data.PS_TYPE_IMAGE_MASK_DATA[j][xMin]; const psF32 *imageData = &image->data.F32[j][xMin]; int uMin = - PS_MIN(i, size); /* Minimum kernel index */ @@ -863,8 +863,8 @@ /* BW */ calculation->data.F32[i][j] = sumIG / sumG; - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0; + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0; } else { /* BW */ - calcMask->data.PS_TYPE_MASK_DATA[i][j] = 0xFF; + calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][j] = 0xFF; } } @@ -876,5 +876,5 @@ psImage *calculation, psImage *calcMask, - psMaskType maskVal, + psImageMaskType maskVal, psVector *gaussNorm, float minGauss, @@ -892,5 +892,5 @@ int yMin = PS_MAX(j - size, 0); int yMax = PS_MIN(j + size, yLast); - const psMaskType *maskData = &calcMask->data.PS_TYPE_MASK_DATA[i][yMin]; /* BW */ + const psImageMaskType *maskData = &calcMask->data.PS_TYPE_IMAGE_MASK_DATA[i][yMin]; /* BW */ const psF32 *imageData = &calculation->data.F32[i][yMin]; /* BW */ int vMin = - PS_MIN(j, size); /* Minimum kernel index */ @@ -921,5 +921,5 @@ const psImage *mask = job->args->data[3]; // input mask - psMaskType maskVal = PS_SCALAR_VALUE(job->args->data[4],U8); + psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA); psVector *gaussNorm = job->args->data[5]; // gauss kernel float minGauss = PS_SCALAR_VALUE(job->args->data[6],F32); @@ -941,5 +941,5 @@ psImage *calculation = job->args->data[1]; // calculation image psImage *calcMask = job->args->data[2]; // calculation mask - psMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],U8); + psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[3],PS_TYPE_IMAGE_MASK_DATA); psVector *gaussNorm = job->args->data[4]; // gauss kernel @@ -956,5 +956,5 @@ const psImage *image, const psImage *mask, - psMaskType maskVal, + psImageMaskType maskVal, float sigma, float numSigma, @@ -963,5 +963,5 @@ PS_ASSERT_IMAGE_NON_NULL(image, NULL); PS_ASSERT_IMAGE_NON_NULL(mask, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); PS_ASSERT_IMAGES_SIZE_EQUAL(image, mask, NULL); @@ -999,5 +999,5 @@ case PS_TYPE_F32: { psImage *calculation = psImageAlloc(numRows, numCols, PS_TYPE_F32); /* Calculation image; BW */ - psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_MASK); /* Mask for calculation image; BW */ + psImage *calcMask = psImageAlloc(numRows, numCols, PS_TYPE_IMAGE_MASK); /* Mask for calculation image; BW */ /** Smooth in X direction **/ @@ -1011,5 +1011,5 @@ psArrayAdd(job->args, 1, (psImage *) image); // cast away const psArrayAdd(job->args, 1, (psImage *) mask); // cast away const - PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_U8); + PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK); psArrayAdd(job->args, 1, gaussNorm); PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32); @@ -1046,5 +1046,5 @@ psArrayAdd(job->args, 1, calculation); psArrayAdd(job->args, 1, calcMask); - PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_U8); + PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK); psArrayAdd(job->args, 1, gaussNorm); PS_ARRAY_ADD_SCALAR(job->args, minGauss, PS_TYPE_F32); @@ -1091,5 +1091,5 @@ bool psImageSmoothMaskF32 (psImage *image, psImage *mask, - psMaskType maskVal, + psImageMaskType maskVal, double sigma, double Nsigma) @@ -1122,5 +1122,5 @@ psVector *calculation = psVectorAlloc(Nx, PS_TYPE_F32); for (int j = 0; j < Ny; j++) { - psU8 *vm = mask->data.U8[j]; + psImageMaskType *vm = mask->data.PS_TYPE_IMAGE_MASK_DATA[j]; psF32 *vi = image->data.F32[j]; psF32 *vo = calculation->data.F32; @@ -1128,5 +1128,5 @@ for (int i = 0; i < Nx; i++, vi++, vo++, vm++) { int offset = PS_MIN (i, Nrange); - psU8 *sm = vm - offset; + psImageMaskType *sm = vm - offset; psF32 *si = vi - offset; psF32 *sg = gauss - offset; @@ -1171,5 +1171,5 @@ int yMax = PS_MIN (j + Nrange + 1, Ny); for (int n = yMin; n < yMax; n++) { - psU8 *vm = mask->data.U8[n]; + psImageMaskType *vm = mask->data.PS_TYPE_IMAGE_MASK_DATA[n]; psF32 *vi = image->data.F32[n]; psF32 *vo = output->data.F32; @@ -1214,11 +1214,11 @@ const psImage *input, // Input image int start, int stop, // Range of rows - psMaskType maskVal, // Value to mask; NOTE subtle difference! + psImageMaskType maskVal, // Value to mask; NOTE subtle difference! int xMin, int xMax // Range in x for kernel ) { // Dereference mask images - psMaskType **inputData = input->data.PS_TYPE_MASK_DATA; - psMaskType **targetData = target->data.PS_TYPE_MASK_DATA; + psImageMaskType **inputData = input->data.PS_TYPE_IMAGE_MASK_DATA; + psImageMaskType **targetData = target->data.PS_TYPE_IMAGE_MASK_DATA; int numCols = input->numCols; // Number of columns @@ -1241,5 +1241,5 @@ min = PS_MAX(0, min); max = PS_MIN(numCols - 1, max); - memset(&targetData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK)); + memset(&targetData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK)); } } @@ -1247,5 +1247,5 @@ // Mask from the minimum to the end of the row min = PS_MAX(0, min); - memset(&targetData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK)); + memset(&targetData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK)); } } @@ -1256,11 +1256,11 @@ const psImage *input, // Input image int start, int stop, // Range of rows - psMaskType setVal, // Value to set; NOTE subtle difference! + psImageMaskType setVal, // Value to set; NOTE subtle difference! int yMin, int yMax // Range in y for kernel ) { // Dereference mask images - psMaskType **inputData = input->data.PS_TYPE_MASK_DATA; - psMaskType **targetData = target->data.PS_TYPE_MASK_DATA; + psImageMaskType **inputData = input->data.PS_TYPE_IMAGE_MASK_DATA; + psImageMaskType **targetData = target->data.PS_TYPE_IMAGE_MASK_DATA; int numRows = input->numRows; // Number of rows @@ -1308,5 +1308,5 @@ int start = PS_SCALAR_VALUE(args->data[2], S32); // Row/col to start at int stop = PS_SCALAR_VALUE(args->data[3], S32); // Row/col to stop at - psMaskType maskVal = PS_SCALAR_VALUE(args->data[4], U8); // Value to mask/set + psImageMaskType maskVal = PS_SCALAR_VALUE(args->data[4], PS_TYPE_IMAGE_MASK_DATA); // Value to mask/set int kernelMin = PS_SCALAR_VALUE(args->data[5], S32); // Minimum range for kernel int kernelMax = PS_SCALAR_VALUE(args->data[6], S32); // Maximum range for kernel @@ -1317,12 +1317,12 @@ } -psImage *psImageConvolveMask(psImage *out, const psImage *mask, psMaskType maskVal, - psMaskType setVal, int xMin, int xMax, int yMin, int yMax) +psImage *psImageConvolveMask(psImage *out, const psImage *mask, psImageMaskType maskVal, + psImageMaskType setVal, int xMin, int xMax, int yMin, int yMax) { PS_ASSERT_IMAGE_NON_NULL(mask, NULL); - PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(mask, PS_TYPE_IMAGE_MASK, NULL); if (out) { PS_ASSERT_IMAGE_NON_NULL(out, NULL); - PS_ASSERT_IMAGE_TYPE(out, PS_TYPE_MASK, NULL); + PS_ASSERT_IMAGE_TYPE(out, PS_TYPE_IMAGE_MASK, NULL); PS_ASSERT_IMAGES_SIZE_EQUAL(out, mask, NULL); if (out == mask && ((maskVal & setVal) || !setVal)) { @@ -1354,5 +1354,5 @@ // Propagate the non-masked values - out = (psImage*)psBinaryOp(out, (const psPtr)mask, "&", psScalarAlloc(~setVal, PS_TYPE_MASK)); + out = (psImage*)psBinaryOp(out, (const psPtr)mask, "&", psScalarAlloc(~setVal, PS_TYPE_IMAGE_MASK)); if (!setVal) { @@ -1360,5 +1360,5 @@ } - psImage *conv = psImageAlloc(numCols, numRows, PS_TYPE_MASK); // Temporary convolved image + psImage *conv = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); // Temporary convolved image psImageInit(conv, 0); @@ -1377,5 +1377,5 @@ PS_ARRAY_ADD_SCALAR(job->args, start, PS_TYPE_S32); PS_ARRAY_ADD_SCALAR(job->args, stop, PS_TYPE_S32); - PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_MASK); + PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK); PS_ARRAY_ADD_SCALAR(job->args, xMin, PS_TYPE_S32); PS_ARRAY_ADD_SCALAR(job->args, xMax, PS_TYPE_S32); @@ -1415,5 +1415,5 @@ PS_ARRAY_ADD_SCALAR(job->args, start, PS_TYPE_S32); PS_ARRAY_ADD_SCALAR(job->args, stop, PS_TYPE_S32); - PS_ARRAY_ADD_SCALAR(job->args, setVal, PS_TYPE_MASK); + PS_ARRAY_ADD_SCALAR(job->args, setVal, PS_TYPE_IMAGE_MASK); PS_ARRAY_ADD_SCALAR(job->args, yMin, PS_TYPE_S32); PS_ARRAY_ADD_SCALAR(job->args, yMax, PS_TYPE_S32); @@ -1460,5 +1460,5 @@ min = PS_MAX(0, min); max = PS_MIN(numCols - 1, max); - memset(&convData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK)); + memset(&convData[y][min], 0xff, (max - min + 1) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK)); } } @@ -1466,5 +1466,5 @@ // Mask from the minimum to the end of the row min = PS_MAX(0, min); - memset(&convData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_MASK)); + memset(&convData[y][min], 0xff, (numCols - min) * PSELEMTYPE_SIZEOF(PS_TYPE_IMAGE_MASK)); } }