Index: trunk/psModules/src/imcombine/pmSubtraction.c =================================================================== --- trunk/psModules/src/imcombine/pmSubtraction.c (revision 20838) +++ trunk/psModules/src/imcombine/pmSubtraction.c (revision 21183) @@ -246,5 +246,5 @@ psImage *image, // Image to convolve psImage *mask, // Mask image - psMaskType maskVal, // Value to mask + psImageMaskType maskVal, // Value to mask const psKernel *kernel, // Kernel by which to convolve psRegion region,// Region of interest @@ -291,5 +291,5 @@ psImage *sys, // Systematic error image psImage *mask, // Mask image - psMaskType maskVal, // Value to mask + psImageMaskType maskVal, // Value to mask const psKernel *kernel, // Kernel by which to convolve psRegion region,// Region of interest @@ -373,6 +373,6 @@ float background, // Background value to apply psRegion region, // Region to convolve - psMaskType maskBad, // Value to give bad pixels - psMaskType maskPoor, // Value to give poor pixels + psImageMaskType maskBad, // Value to give bad pixels + psImageMaskType maskPoor, // Value to give poor pixels float poorFrac, // Fraction for "poor" bool useFFT, // Use FFT to convolve? @@ -385,7 +385,7 @@ } - psMaskType subBad; // Bad pixels in subtraction mask - psMaskType subConvBad; // Bad pixels in subtraction mask when convolving - psMaskType subConvPoor; // Poor pixels in subtraction mask when convolving + psImageMaskType subBad; // Bad pixels in subtraction mask + psImageMaskType subConvBad; // Bad pixels in subtraction mask when convolving + psImageMaskType subConvPoor; // Poor pixels in subtraction mask when convolving if (kernels->mode == PM_SUBTRACTION_MODE_1 || (kernels->mode == PM_SUBTRACTION_MODE_DUAL && !wantDual)) { subBad = PM_SUBTRACTION_MASK_BAD_1; @@ -437,6 +437,6 @@ for (int yTarget = rowMin, ySource = box; yTarget < rowMax; yTarget++, ySource++) { // Dereference images - psMaskType *target = &convMask->data.PS_TYPE_MASK_DATA[yTarget][colMin]; // Target values - psMaskType *source = &convolved->data.PS_TYPE_MASK_DATA[ySource][box]; // Source values + psImageMaskType *target = &convMask->data.PS_TYPE_IMAGE_MASK_DATA[yTarget][colMin]; // Target values + psImageMaskType *source = &convolved->data.PS_TYPE_IMAGE_MASK_DATA[ySource][box]; // Source values for (int xTarget = colMin; xTarget < colMax; xTarget++, target++, source++) { if (*source & subConvBad) { @@ -783,5 +783,5 @@ PS_ASSERT_VECTOR_TYPE(deviations, PS_TYPE_F32, -1); PS_ASSERT_IMAGE_NON_EMPTY(subMask, -1); - PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, -1); + PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, -1); // I used to measure the rms deviation about zero, and use that as the sigma against which to clip, but @@ -794,10 +794,10 @@ int numStamps = 0; // Number of used stamps - psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_MASK); // Mask, for statistics + psVector *mask = psVectorAlloc(stamps->num, PS_TYPE_VECTOR_MASK); // Mask, for statistics psVectorInit(mask, 0); for (int i = 0; i < stamps->num; i++) { pmSubtractionStamp *stamp = stamps->stamps->data[i]; // Stamp of interest if (stamp->status != PM_SUBTRACTION_STAMP_USED) { - mask->data.PS_TYPE_MASK_DATA[i] = 0xff; + mask->data.PS_TYPE_VECTOR_MASK_DATA[i] = 0xff; continue; } @@ -869,5 +869,5 @@ for (int y = stamp->y - footprint; y <= stamp->y + footprint; y++) { for (int x = stamp->x - footprint; x <= stamp->x + footprint; x++) { - subMask->data.PS_TYPE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ; + subMask->data.PS_TYPE_IMAGE_MASK_DATA[y][x] |= PM_SUBTRACTION_MASK_REJ; } } @@ -997,6 +997,6 @@ psImage *sys1, psImage *sys2, // Systematic error images psImage *subMask, // Input subtraction mask - psMaskType maskBad, // Mask value to give bad pixels - psMaskType maskPoor, // Mask value to give poor pixels + psImageMaskType maskBad, // Mask value to give bad pixels + psImageMaskType maskPoor, // Mask value to give poor pixels float poorFrac, // Fraction for "poor" const psRegion *region, // Patch to convolve @@ -1035,6 +1035,6 @@ if ((kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro1->mask) { - psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask - psMaskType **source = ro1->mask->data.PS_TYPE_MASK_DATA; // Source mask + psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask + psImageMaskType **source = ro1->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask for (int y = yMin; y < yMax; y++) { @@ -1045,6 +1045,6 @@ } if ((kernels->mode == PM_SUBTRACTION_MODE_2 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) && ro2->mask) { - psMaskType **target = convMask->data.PS_TYPE_MASK_DATA; // Target mask - psMaskType **source = ro2->mask->data.PS_TYPE_MASK_DATA; // Source mask + psImageMaskType **target = convMask->data.PS_TYPE_IMAGE_MASK_DATA; // Target mask + psImageMaskType **source = ro2->mask->data.PS_TYPE_IMAGE_MASK_DATA; // Source mask for (int y = yMin; y < yMax; y++) { @@ -1075,11 +1075,11 @@ psImage *sys2 = args->data[10]; // Systematic error image 2 psImage *subMask = args->data[11]; // Subtraction mask - psMaskType maskBad = PS_SCALAR_VALUE(args->data[12], U8); // Output mask value for bad pixels - psMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], U8); // Output mask value for poor pixels + psImageMaskType maskBad = PS_SCALAR_VALUE(args->data[12], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for bad pixels + psImageMaskType maskPoor = PS_SCALAR_VALUE(args->data[13], PS_TYPE_IMAGE_MASK_DATA); // Output mask value for poor pixels float poorFrac = PS_SCALAR_VALUE(args->data[14], F32); // Fraction for "poor" const psRegion *region = args->data[15]; // Region to convolve const pmSubtractionKernels *kernels = args->data[16]; // Kernels - bool doBG = PS_SCALAR_VALUE(args->data[17], U8); // Do background subtraction? - bool useFFT = PS_SCALAR_VALUE(args->data[18], U8); // Use FFT for convolution? + bool doBG = PS_SCALAR_VALUE(args->data[17], PS_TYPE_IMAGE_MASK_DATA); // Do background subtraction? + bool useFFT = PS_SCALAR_VALUE(args->data[18], PS_TYPE_IMAGE_MASK_DATA); // Use FFT for convolution? return subtractionConvolvePatch(numCols, numRows, x0, y0, out1, out2, convMask, ro1, ro2, sys1, sys2, @@ -1088,5 +1088,5 @@ bool pmSubtractionConvolve(pmReadout *out1, pmReadout *out2, const pmReadout *ro1, const pmReadout *ro2, - psImage *subMask, int stride, psMaskType maskBad, psMaskType maskPoor, + psImage *subMask, int stride, psImageMaskType maskBad, psImageMaskType maskPoor, float poorFrac, float sysError, const psRegion *region, const pmSubtractionKernels *kernels, bool doBG, bool useFFT) @@ -1121,5 +1121,5 @@ if (subMask) { PS_ASSERT_IMAGE_NON_NULL(subMask, false); - PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_MASK, false); + PS_ASSERT_IMAGE_TYPE(subMask, PS_TYPE_IMAGE_MASK, false); PS_ASSERT_IMAGE_SIZE(subMask, numCols, numRows, false); } @@ -1182,5 +1182,5 @@ if (kernels->mode == PM_SUBTRACTION_MODE_1 || kernels->mode == PM_SUBTRACTION_MODE_DUAL) { if (!out1->mask) { - out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + out1->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); } convMask = out1->mask; @@ -1194,5 +1194,5 @@ } else { if (!out2->mask) { - out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_MASK); + out2->mask = psImageAlloc(numCols, numRows, PS_TYPE_IMAGE_MASK); } convMask = out2->mask; @@ -1285,6 +1285,6 @@ psMutexUnlock(subMask); } - PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_U8); - PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_U8); + PS_ARRAY_ADD_SCALAR(args, maskBad, PS_TYPE_IMAGE_MASK); + PS_ARRAY_ADD_SCALAR(args, maskPoor, PS_TYPE_IMAGE_MASK); PS_ARRAY_ADD_SCALAR(args, poorFrac, PS_TYPE_F32); psArrayAdd(args, 1, subRegion);