Changeset 4815 for trunk/psLib/src/imageops

Timestamp:

Aug 18, 2005, 11:44:40 AM (21 years ago)

Author:

drobbin

Message:

folded in code from bug 481. Tests still to be written.

Location:

trunk/psLib/src/imageops

Files:

• psImageConvolve.c (modified) (4 diffs)
• psImageConvolve.h (modified) (2 diffs)
• psImagePixelManip.c (modified) (2 diffs)
• psImagePixelManip.h (modified) (2 diffs)

trunk/psLib/src/imageops/psImageConvolve.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-12 19:33:49 $
+ *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-18 21:44:40 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -12 +12 @@
 
 #include <string.h>
-
+#include <math.h>
 #include "psImageConvolve.h"
 #include "psImageFFT.h"
@@ -279 +279 @@
 }
 
-psImage* psImageConvolve(psImage* out, const psImage* in, const psKernel* kernel, bool direct)
+psImage* psImageConvolve(psImage* out,
+                         const psImage* in,
+                         const psKernel* kernel,
+                         bool direct)
 {
     if (in == NULL) {
@@ -476 +479 @@
     return out;
 }
+
+void psImageSmooth (psImage *image,
+                    float sigma,
+                    float Nsigma)
+{
+
+    int Nx, Ny, Npixel, Nrange;
+    float factor, g, s;
+    psVector *temp;
+
+    // relevant terms
+    Nrange = sigma*Nsigma + 0.5;
+    Npixel = 2*Nrange + 1;
+    factor = -0.5/(sigma*sigma);
+
+    Nx = image->numCols;
+    Ny = image->numRows;
+
+    // generate gaussian
+    psVector *gaussnorm = psVectorAlloc (Npixel, PS_TYPE_F32);
+    for (int i = -Nrange; i < Nrange + 1; i++) {
+        gaussnorm->data.F32[i+Nrange] = exp (factor*i*i);
+    }
+    psF32 *gauss = &gaussnorm->data.F32[Nrange];
+
+    // smooth in X direction
+    temp = psVectorAlloc (Nx, PS_TYPE_F32);
+    for (int j = 0; j < Ny; j++) {
+        psF32 *vi = image->data.F32[j];
+        psF32 *vo = temp->data.F32;
+        for (int i = 0; i < Nx; i++) {
+            g = s = 0;
+            for (int n = -Nrange; n < Nrange + 1; n++) {
+                if (i+n < 0)
+                    continue;
+                if (i+n >= Nx)
+                    continue;
+                s += gauss[n]*vi[i+n];
+                g += gauss[n];
+            }
+            vo[i] = s / g;
+        }
+        memcpy (image->data.F32[j], temp->data.F32, Nx*sizeof(psF32));
+    }
+    psFree (temp);
+
+    // smooth in Y direction
+    temp = psVectorAlloc (image->numRows, PS_TYPE_F32);
+    for (int i = 0; i < Nx; i++) {
+        psF32  *vo = temp->data.F32;
+        psF32 **vi = image->data.F32;
+        for (int j = 0; j < Ny; j++) {
+            g = s = 0;
+            for (int n = -Nrange; n < Nrange + 1; n++) {
+                if (j+n < 0)
+                    continue;
+                if (j+n >= Ny)
+                    continue;
+                s += gauss[n]*vi[j+n][i];
+                g += gauss[n];
+            }
+            vo[j] = s / g;
+        }
+        // replace temp in image
+        for (int j = 0; j < Ny; j++) {
+            vi[j][i] = vo[j];
+        }
+    }
+    psFree (temp);
+    psFree (gaussnorm);
+}
+

trunk/psLib/src/imageops/psImageConvolve.h

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-12 19:12:01 $
+ *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-18 21:44:40 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -126 +126 @@
 );
 
+/** Smooths an image by parts using 1D Gaussian independently in x and y.
+ *
+ *  Applies a circularly symmetric Gaussian smoothing first in x and then in y
+ *  directions with just a vector.  This process is 2N faster than 2D convolutions (in general).
+ */
+void psImageSmooth(
+    psImage *image,                    ///< the image to be smoothed
+    float sigma,                       ///< the width of the smoothing kernel in pixels
+    float Nsigma                       ///< the size of the smoothing box in sigmas
+);
+
+
 #endif // #ifndef PS_IMAGE_CONVOLVE_H

trunk/psLib/src/imageops/psImagePixelManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-21 01:40:10 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-18 21:44:40 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -396 +396 @@
 }
 
+// mask the area contained by the region
+// the region is defined wrt the parent image
+void psImageMaskRegion(psImage *image,
+                       psRegion *region,
+                       bool logical_and,
+                       int maskValue)
+{
+
+    for (int iy = 0; iy < image->numRows; iy++) {
+        for (int ix = 0; ix < image->numCols; ix++) {
+            if (ix + image->col0 <  region->x0)
+                continue;
+            if (ix + image->col0 >= region->x1)
+                continue;
+            if (iy + image->row0 <  region->y0)
+                continue;
+            if (iy + image->row0 >= region->y1)
+                continue;
+            if (logical_and) {
+                image->data.U8[iy][ix] &= maskValue;
+            } else {
+                image->data.U8[iy][ix] |= maskValue;
+            }
+        }
+    }
+}
+
+// mask the area not contained by the region
+// the region is defined wrt the parent image
+void psImageKeepRegion(psImage *image,
+                       psRegion *region,
+                       bool logical_and,
+                       int maskValue)
+{
+
+    for (int iy = 0; iy < image->numRows; iy++) {
+        for (int ix = 0; ix < image->numCols; ix++) {
+            if (ix + image->col0 <  region->x0)
+                goto maskit;
+            if (ix + image->col0 >= region->x1)
+                goto maskit;
+            if (iy + image->row0 <  region->y0)
+                goto maskit;
+            if (iy + image->row0 >= region->y1)
+                goto maskit;
+            continue;
+maskit:
+            if (logical_and) {
+                image->data.U8[iy][ix] &= maskValue;
+            } else {
+                image->data.U8[iy][ix] |= maskValue;
+            }
+        }
+    }
+}
+
+// mask the area contained by the region
+// the region is defined wrt the parent image
+void psImageMaskCircle(psImage *image,
+                       double x,
+                       double y,
+                       double radius,
+                       bool logical_and,
+                       int maskValue)
+{
+
+    double dx, dy, r2, R2;
+
+    R2 = PS_SQR(radius);
+
+    for (int iy = 0; iy < image->numRows; iy++) {
+        for (int ix = 0; ix < image->numCols; ix++) {
+            dx = ix + image->col0 - x;
+            dy = iy + image->row0 - y;
+            r2 = PS_SQR(dx) + PS_SQR(dy);
+            if (r2 > R2)
+                continue;
+            if (logical_and) {
+                image->data.U8[iy][ix] &= maskValue;
+            } else {
+                image->data.U8[iy][ix] |= maskValue;
+            }
+        }
+    }
+}
+
+// mask the area contained by the region
+// the region is defined wrt the parent image
+void psImageKeepCircle(psImage *image,
+                       double x,
+                       double y,
+                       double radius,
+                       bool logical_and,
+                       int maskValue)
+{
+
+    double dx, dy, r2, R2;
+
+    R2 = PS_SQR(radius);
+
+    for (int iy = 0; iy < image->numRows; iy++) {
+        for (int ix = 0; ix < image->numCols; ix++) {
+            dx = ix + image->col0 - x;
+            dy = iy + image->row0 - y;
+            r2 = PS_SQR(dx) + PS_SQR(dy);
+            if (r2 < R2)
+                continue;
+            if (logical_and) {
+                image->data.U8[iy][ix] &= maskValue;
+            } else {
+                image->data.U8[iy][ix] |= maskValue;
+            }
+        }
+    }
+}
+

trunk/psLib/src/imageops/psImagePixelManip.h

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-21 01:40:10 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-08-18 21:44:40 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -87 +87 @@
     const char *op                     ///< the operation to perform for overlay
 );
+/** Sets the bits inside the region, ignoring pixels outside.
+ *
+ *  The pixels are set by combining the existing pixel value and the given maskValue
+ *  with a logical operation.  The allowed operations are =, AND, OR, and XOR.
+ */
+void psImageMaskRegion(
+    psImage *image,                    ///< the image to set
+    psRegion *region,                  ///< the specified region
+    bool logical_and,                  ///< the logical operation
+    int maskValue                      ///< the specified bits
+);
+
+/** Sets the bits outside the region, ignoring pixels inside.
+ *
+ *  The pixels are set by combining the existing pixel value and the given maskValue
+ *  with a logical operation.  The allowed operations are =, AND, OR, and XOR.
+ */
+void psImageKeepRegion(
+    psImage *image,                    ///< the image to set
+    psRegion *region,                  ///< the specified region
+    bool logical_and,                  ///< the logical operation
+    int maskValue                      ///< the specified bits
+);
+
+/** Sets the bits inside the circle, ignoring the pixels outside.
+ *
+ *  The pixel values are set by combining the existing pixel value and the given maskValue
+ *  with a logical operation.  The allowed operations are =, AND, OR, and XOR.
+ */
+void psImageMaskCircle(
+    psImage *image,                    ///< the image to set
+    double x,                          ///< the x coordinate of the circle's center
+    double y,                          ///< the y coordinate of the circle's center
+    double radius,                     ///< the radius of the specified circle
+    bool logical_and,                  ///< the logical operation
+    int maskValue                      ///< the specified bits
+);
+
+/** Sets the bits outside the circle, ignoring the pixels inside.
+ *
+ *  The pixel values are set by combining the existing pixel value and the given maskValue
+ *  with a logical operation.  The allowed operations are =, AND, OR, and XOR.
+ */
+void psImageKeepCircle(
+    psImage *image,                    ///< the image to set
+    double x,                          ///< the x coordinate of the circle's center
+    double y,                          ///< the y coordinate of the circle's center
+    double radius,                     ///< the radius of the specified circle
+    bool logical_and,                  ///< the logical operation
+    int maskValue                      ///< the specified bits
+);
 
 #endif // #ifndef PS_IMAGE_PIXEL_MANIP_H