Changeset 32752

Timestamp:

Nov 22, 2011, 10:28:34 AM (15 years ago)

Author:

eugene

Message:

merging changes from trunk (fix counting errors in psImageSmooth*, add psImageSmooth_PreAlloc to minimize memory locking)

Location:

tags/ipp-20111110/psLib

Files:

• src/imageops/psImageConvolve.c (modified) (13 diffs)
• src/imageops/psImageConvolve.h (modified) (2 diffs)
• src/sys/psMemory.c (modified) (6 diffs)
• test/imageops/Makefile.am (modified) (1 diff)
• test/imageops/tap_psImageSmooth.c (modified) (5 diffs)
• test/imageops/tap_psImageSmooth_PreAlloc.c (copied) (copied from trunk/psLib/test/imageops/tap_psImageSmooth_PreAlloc.c )

tags/ipp-20111110/psLib/src/imageops/psImageConvolve.c

@@ -569 +569 @@
 // Generate normalised Gaussian vector
 #define IMAGE_SMOOTH_GAUSS(TARGET, SIZE, SIGMA, TYPE) \
-    psVector *TARGET = psVectorAlloc(2 * SIZE + 1, PS_TYPE_##TYPE); /* Gaussian */ \
+    TARGET = psVectorAlloc(2 * SIZE + 1, PS_TYPE_##TYPE); /* Gaussian */ \
     double sum = 0.0; /* Sum of Gaussian, for normalisation */ \
     double factor = -0.5/PS_SQR(SIGMA); /* Multiplier for exponential */ \
@@ -587 +587 @@
     psKernel *kernel = psKernelAlloc(-size, size, -size, size); // Kernel to return
 
+    psVector *gaussNorm = NULL;
     IMAGE_SMOOTH_GAUSS(gaussNorm, size, sigma, F32);
     psF32 *gauss = &gaussNorm->data.F32[size]; // Convenient kernel-like indexing for Gaussian
@@ -602 +603 @@
 bool psImageSmooth(psImage *image, double  sigma, double  Nsigma)
 {
-    PS_ASSERT_IMAGE_NON_NULL(image, NULL);
+    PS_ASSERT_IMAGE_NON_NULL(image, false);
 
     // relevant terms
@@ -612 +613 @@
   case PS_TYPE_##TYPE: { \
         /* generate normalized gaussian */ \
+        psVector *gaussnorm = NULL; \
         IMAGE_SMOOTH_GAUSS(gaussnorm, Nrange, sigma, TYPE) \
         ps##TYPE *gauss = &gaussnorm->data.TYPE[Nrange]; \
@@ -622 +624 @@
                 ps##TYPE *vo = calculation->data.TYPE; \
                 int xMax = PS_MIN(Nrange, Nx); \
-                int convRange = PS_MIN(Nrange + 1, Nx); \
                 /* Smooth first Nrange pixels, with renorm */ \
                 for (int i = 0; i < xMax; i++, vi++, vo++) { \
+                    int convRange = PS_MIN(Nrange + 1, Nx - i);  \
                     ps##TYPE *vr = vi - i; \
                     ps##TYPE *vg = gauss - i; \
@@ -648 +650 @@
                     } \
                     /* Smooth last Nrange pixels, with renorm */ \
-                    /* XXX does this miss the last column? */ \
-                    for (int i = Nx - Nrange; i < Nx; i++, vi++, vo++) { \
+                    /* if Nx < 2*Nrange, this pass starts at i == Nrange */ \
+                    int xMin = PS_MAX(Nx - Nrange, Nrange); \
+                    for (int i = xMin; i < Nx; i++, vi++, vo++) { \
                         ps##TYPE *vr = vi - Nrange; \
                         ps##TYPE *vg = gauss - Nrange; \
@@ -670 +673 @@
         /* Smooth the first Nrange pixels, with renorm */ \
         int yMax = PS_MIN(Nrange, Ny); \
-        int convRange = PS_MIN(Nrange + 1, Ny); \
         for (int j = 0; j < yMax; j++) { \
+            int convRange = PS_MIN(Nrange + 1, Ny - j);                \
             psVector *calculation = psVectorAlloc(Nx, PS_TYPE_##TYPE); \
             /* Zero the output row */ \
@@ -715 +718 @@
                 calculation = save; \
             } \
-            /* Smooth last Nrange pixels, with renorm */ \
-            for (int j = Ny - Nrange; j < Ny; j++) { \
+            /* Smooth last Nrange pixels, with renorm */                \
+            /* if Ny < 2*Nrange, this pass starts at j == Nrange */ \
+            int yMin = PS_MAX(Ny - Nrange, Nrange); \
+            for (int j = yMin; j < Ny; j++) { \
                 /* save the Nrange-offset output row, then zero */ \
                 memset(calculation->data.TYPE, 0, Nx*sizeof(ps##TYPE)); \
@@ -765 +770 @@
 }
 
+void psImageSmooth_PreAlloc_DataFree (psImageSmooth_PreAlloc_Data *smdata) {
+    psFree (smdata->resultX);
+    psFree (smdata->resultY);
+    psFree (smdata->kernel);
+}
+
+psImageSmooth_PreAlloc_Data *psImageSmooth_PreAlloc_DataAlloc (psImage *image, double sigma, double Nsigma) {
+
+    psImageSmooth_PreAlloc_Data *smdata = psAlloc(sizeof(psImageSmooth_PreAlloc_Data));
+    psMemSetDeallocator(smdata, (psFreeFunc) psImageSmooth_PreAlloc_DataFree);
+
+    if (!image) {
+        // relevant terms
+        smdata->Nrange = sigma*Nsigma + 0.5;    // Number of pixels either side for convolution kernel
+        smdata->Nx = 0;
+        smdata->Ny = 0;
+        smdata->kernel = NULL;
+        smdata->resultX = NULL;
+        smdata->resultY = NULL;
+        return smdata;
+    }
+
+    // relevant terms
+    smdata->Nrange = sigma*Nsigma + 0.5;    // Number of pixels either side for convolution kernel
+    smdata->Nx = image->numCols;            // Number of columns
+    smdata->Ny = image->numRows;            // Number of rows
+
+    IMAGE_SMOOTH_GAUSS(smdata->kernel, smdata->Nrange, sigma, F32);
+       
+    // use a temp running buffer for X and Y directions.
+    smdata->resultX = psAlloc(smdata->Nx * sizeof(psF32));
+    memset (smdata->resultX, 0, smdata->Nx*sizeof(psF32));
+
+    smdata->resultY = psAlloc(smdata->Ny * sizeof(psF32));
+    memset (smdata->resultY, 0, smdata->Ny*sizeof(psF32));
+
+    return smdata;
+}
+
+// we can use the same DATA structure on multiple images of the same size
+bool psImageSmooth_PreAlloc_F32(psImage *image, psImageSmooth_PreAlloc_Data *smdata)
+{
+    PS_ASSERT_IMAGE_NON_NULL(image, false);
+    // assert on data type
+
+    // relevant terms
+    int Nrange = smdata->Nrange;    // Number of pixels either side for convolution kernel
+    int Nx = smdata->Nx;            // Number of columns
+    int Ny = smdata->Ny;            // Number of rows
+
+    psF32 *gauss = &smdata->kernel->data.F32[Nrange];
+    psF32 *resultX = smdata->resultX;
+    psF32 *resultY = smdata->resultY;
+       
+    /* Smooth in X direction */
+    {
+        for (int j = 0; j < Ny; j++) {
+            psF32 *vi = image->data.F32[j];
+            int xMax = PS_MIN(Nrange, Nx);
+            /* Smooth first Nrange pixels, with renorm */
+            for (int i = 0; i < xMax; i++, vi++) {
+                int convRange = PS_MIN(Nrange + 1, Nx - i);
+                psF32 *vr = vi - i;
+                psF32 *vg = gauss - i;
+                double g = 0.0;
+                double s = 0.0;
+                for (int n = -i; n < convRange; n++, vr++, vg++) {
+                    s += *vg * *vr;
+                    g += *vg;
+                }
+                resultX[i] = s / g;
+            }
+            /* If that's all the pixels we have, then we're done already */
+            if (Nx > Nrange) {
+                /* Smooth middle pixels; if Nx < 2*Nrange, this pass is skipped */
+                for (int i = Nrange; i < Nx - Nrange; i++, vi++) {
+                    psF32 *vr = vi - Nrange;
+                    psF32 *vg = gauss - Nrange;
+                    double s = 0;
+                    for (int n = -Nrange; n < Nrange + 1; n++, vr++, vg++) {
+                        s += *vg * *vr;
+                    }
+                    resultX[i] = s;
+                }
+                /* Smooth last Nrange pixels, with renorm */
+                // if Nx < 2*Nrange, this pass starts at i == Nrange
+                int xMin = PS_MAX(Nx - Nrange, Nrange);
+                for (int i = xMin; i < Nx; i++, vi++) {
+                    psF32 *vr = vi - Nrange;
+                    psF32 *vg = gauss - Nrange;
+                    double g = 0.0;
+                    double s = 0.0;
+                    for (int n = -Nrange; n < Nx - i; n++, vr++, vg++) {
+                        s += *vg * *vr;
+                        g += *vg;
+                    }
+                    resultX[i] = s / g;
+                }
+            }
+            memcpy(image->data.F32[j], resultX, Nx*sizeof(psF32));
+        }
+    }
+       
+    // this section probably hits the cache poorly for large images, but is probably OK for small ones
+    /* Smooth in Y direction */
+    {
+        for (int i = 0; i < Nx; i++) {
+            int yMax = PS_MIN(Nrange, Ny);
+            /* Smooth first Nrange pixels, with renorm */
+            for (int j = 0; j < yMax; j++) {
+                int convRange = PS_MIN(Nrange + 1, Ny - j);
+                psF32 *vg = gauss - j;
+                double g = 0.0;
+                double s = 0.0;
+                for (int n = -j; n < convRange; n++, vg++) {
+                    psF32 vr = image->data.F32[j+n][i];
+                    s += *vg * vr;
+                    g += *vg;
+                }
+                resultY[j] = s / g;
+            }
+            /* If that's all the pixels we have, then we're done already */
+            if (Ny > Nrange) {
+                /* Smooth middle pixels */
+                for (int j = Nrange; j < Ny - Nrange; j++) {
+                    psF32 *vg = gauss - Nrange;
+                    double s = 0;
+                    for (int n = -Nrange; n < Nrange + 1; n++, vg++) {
+                        psF32 vr = image->data.F32[j+n][i]; 
+                        s += *vg * vr;
+                    }
+                    resultY[j] = s;
+                }
+                /* Smooth last Nrange pixels, with renorm */
+                // if Ny < 2*Nrange, this pass starts at j == Nrange
+                int yMin = PS_MAX(Ny - Nrange, Nrange);
+                for (int j = yMin; j < Ny; j++) {
+                    psF32 *vg = gauss - Nrange;
+                    double g = 0.0;
+                    double s = 0.0;
+                    for (int n = -Nrange; n < Ny - j; n++, vg++) {
+                        psF32 vr = image->data.F32[j+n][i];
+                        s += *vg * vr;
+                        g += *vg;
+                    }
+                    resultY[j] = s / g;
+                }
+            }
+            // loop here 
+            for (int j = 0; j < Ny; j++) {
+                image->data.F32[j][i] = resultY[j];
+            }
+        }
+    }
+    return true;
+}
+
 static bool imageSmoothMaskPixels(psVector *out, const psImage *image, const psImage *mask,
                                   psImageMaskType maskVal, const psVector *x, const psVector *y,
@@ -849 +1011 @@
 
     // Generate normalized gaussian
+    psVector *gaussNorm = NULL;
     IMAGE_SMOOTH_GAUSS(gaussNorm, size, sigma, F32);
 
@@ -974 +1137 @@
 
     // Generate normalized gaussian
+    psVector *gaussNorm = NULL;
     IMAGE_SMOOTH_GAUSS(gaussNorm, size, sigma, F32);
     const psF32 *gauss = &gaussNorm->data.F32[size]; // Gaussian convolution kernel
@@ -1185 +1349 @@
 
     // Generate normalized gaussian
+    psVector *gaussNorm = NULL;
     IMAGE_SMOOTH_GAUSS(gaussNorm, size, sigma, F32);
 
@@ -1321 +1486 @@
 
     /* generate normalized gaussian */
+    psVector *gaussnorm = NULL;
     IMAGE_SMOOTH_GAUSS(gaussnorm, Nrange, sigma, F32);
     psF32 *gauss = &gaussnorm->data.F32[Nrange];

tags/ipp-20111110/psLib/src/imageops/psImageConvolve.h

@@ -25 +25 @@
 #define PS_TYPE_KERNEL_DATA F32        ///< the data member to use for kernel image */
 #define PS_TYPE_KERNEL_NAME "psF32"    ///< the data type for kernel as a string */
+
+/// a structure to contain data related to image smoothing with a 1D gauss kernel
+typedef struct {
+    int Nx;
+    int Ny;
+    int Nrange;
+    psF32 *resultX;
+    psF32 *resultY;
+    psVector *kernel;
+} psImageSmooth_PreAlloc_Data;
 
 /// A convolution kernel
@@ -277 +287 @@
 );
 
+psImageSmooth_PreAlloc_Data *psImageSmooth_PreAlloc_DataAlloc (psImage *image, double sigma, double Nsigma);
+bool psImageSmooth_PreAlloc_F32(psImage *image, psImageSmooth_PreAlloc_Data *smdata);
+
 /// Control threading for image convolution functions
 ///

tags/ipp-20111110/psLib/src/sys/psMemory.c

@@ -100 +100 @@
     PS_MEM_ABORT(__func__, "Unsafe to Continue\n"); \
 }
+
+static bool checkingForCorruption = false;
 
 static bool isBadMemBlock(FILE *output, const psMemBlock *memBlock, const char *file, unsigned int lineo, const char *func);
@@ -746 +748 @@
         }
         fprintf(output, _("\n\tMemory block is corrupted; buffer underflow detected.\n"));
+        if (!checkingForCorruption) {
+          p_psMemCheckCorruption(__FILE__, __LINE__, __func__, output, false);
+        }
         bad = true;
     }
@@ -755 +760 @@
         }
         fprintf(output, _("\n\tMemory block is corrupted; buffer overflow detected.\n"));
+        if (!checkingForCorruption) {
+          p_psMemCheckCorruption(__FILE__, __LINE__, __func__, output, false);
+        }
         bad = true;
     }
@@ -1208 +1216 @@
     #endif
 
+# if (PS_TRACE_ON)    
+    // before freeing a particular block of memory, fill the entire block with FF to poison it
+    // this should trigger any bad reactions early.  this may be costly, so on do it for
+    // unoptimzed builds
+    size_t totalSize = sizeof(psMemBlock) + memBlock->userMemorySize + sizeof(void *);
+    memset ((void *) memBlock, 0xff, totalSize);
+# endif
+
     free(memBlock);
 
@@ -1296 +1312 @@
     MUTEX_LOCK(&memBlockListMutex);
 
+    // this function calls 'isBadMemBlock', which may in turn call this function : avoid nested calls or we will be stuck forever
+    checkingForCorruption = true;
+
     psS32 nbad = 0;               // number of bad blocks
     for (psMemBlock *memBlock = (psMemBlock *) lastMemBlockAllocated; memBlock != NULL; memBlock = memBlock->nextBlock) {
@@ -1308 +1327 @@
         }
     }
+
+    checkingForCorruption = true;
 
     // release the lock on the memblock list

tags/ipp-20111110/psLib/test/imageops/Makefile.am

@@ -17 +17 @@
         tap_psImagePixelManip \
         tap_psImageSmooth \
+        tap_psImageSmooth_PreAlloc \
         tap_psImageStructManip \
         tap_psImageConvolve \

tags/ipp-20111110/psLib/test/imageops/tap_psImageSmooth.c

@@ -24 +24 @@
 #define TS00_IM_F64             0x00000004
 #define TS00_IM_S32             0x00000008
-#define VERBOSE 0
+#define VERBOSE 1
 
 static psBool testImageSmoothGeneric(
@@ -64 +64 @@
         }
     }
-    if (VERBOSE) {
-        p_psImagePrint(1, img, "The Smoothed Image");
-    }
-
     if (flags & TS00_IM_F64) {
         if (VERBOSE)
@@ -83 +79 @@
         }
     }
-
     if (flags & TS00_IM_S32) {
         if (VERBOSE)
@@ -100 +95 @@
     }
     if (VERBOSE) {
+        if (img) p_psImagePrint(1, img, "The Raw Image");
         printf(" %d columns\n", numCols);
         printf(" %d rows\n", numRows);
@@ -160 +156 @@
     ok(testImageSmoothGeneric(TS00_IM_F32, NUM_COLS, 1, SIGMA, NSIGMA, true), "testImageSmoothGeneric() successful");
     ok(testImageSmoothGeneric(TS00_IM_F32, 1, 1, SIGMA, NSIGMA, true), "testImageSmoothGeneric() successful");
-    ok(testImageSmoothGeneric(TS00_IM_F64, NUM_COLS, NUM_ROWS, SIGMA, NSIGMA, true), "testImageSmoothGeneric() successful");
-    ok(testImageSmoothGeneric(TS00_IM_S32, NUM_COLS, NUM_ROWS, SIGMA, NSIGMA, false), "testImageSmoothGeneric() successful");
+    // ok(testImageSmoothGeneric(TS00_IM_F64, NUM_COLS, NUM_ROWS, SIGMA, NSIGMA, true), "testImageSmoothGeneric() successful");
+    // ok(testImageSmoothGeneric(TS00_IM_S32, NUM_COLS, NUM_ROWS, SIGMA, NSIGMA, false), "testImageSmoothGeneric() successful");
     ok(testImageSmoothGeneric(TS00_IM_NULL, NUM_COLS, NUM_ROWS, SIGMA, NSIGMA, false), "testImageSmoothGeneric() successful");
 }