Changeset 2204 for trunk/psLib/src/imageops

Timestamp:

Oct 26, 2004, 2:57:34 PM (22 years ago)

Author:

desonia

Message:

converted native C types to ps Types, where practical.

Location:

trunk/psLib/src/imageops

Files:

• psImageConvolve.c (modified) (17 diffs)
• psImageConvolve.h (modified) (6 diffs)
• psImageStats.c (modified) (9 diffs)
• psImageStats.h (modified) (3 diffs)

trunk/psLib/src/imageops/psImageConvolve.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-06 21:31:30 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-27 00:57:31 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 static void freeKernel(psKernel* ptr);
 
-psKernel* psKernelAlloc(int xMin, int xMax, int yMin, int yMax)
+psKernel* psKernelAlloc(psS32 xMin, psS32 xMax, psS32 yMin, psS32 yMax)
 {
     psKernel* result;
-    int numRows;
-    int numCols;
+    psS32 numRows;
+    psS32 numCols;
 
     // following is explicitly spelled out in the SDRS as a requirement
@@ -40 +40 @@
                  yMin, yMax);
 
-        int temp = yMin;
+        psS32 temp = yMin;
         yMin = yMax;
         yMax = temp;
@@ -51 +51 @@
                  xMin, xMax);
 
-        int temp = xMin;
+        psS32 temp = xMin;
         xMin = xMax;
         xMax = temp;
@@ -70 +70 @@
     psKernelType** kernelRows = result->p_kernelRows;
     psKernelType** imageRows = result->image->data.PS_TYPE_KERNEL_DATA;
-    for (int i = 0; i < numRows; i++) {
+    for (psS32 i = 0; i < numRows; i++) {
         kernelRows[i] = imageRows[i] - xMin;
     }
@@ -91 +91 @@
                            const psVector* xShifts,
                            const psVector* yShifts,
-                           bool relative)
+                           psBool relative)
 {
-    int x = 0;
-    int y = 0;
-    int t = 0;
-    int deltaT;
-    int oldX;
-    int oldY;
-    int xMin = 0;
-    int xMax = 0;
-    int yMin = 0;
-    int yMax = 0;
-    int length = 0;
+    psS32 x = 0;
+    psS32 y = 0;
+    psS32 t = 0;
+    psS32 deltaT;
+    psS32 oldX;
+    psS32 oldY;
+    psS32 xMin = 0;
+    psS32 xMax = 0;
+    psS32 yMin = 0;
+    psS32 yMax = 0;
+    psS32 length = 0;
     psKernelType normalizeTime = 1.0;  // fraction of total time for each shift clock
     psKernel* result = NULL;
@@ -153 +153 @@
         y = 0; \
         t = 0; \
-        for (int lcv = 0; lcv < length; lcv++) { \
+        for (psS32 lcv = 0; lcv < length; lcv++) { \
             if (relative) { \
                 x += xShiftData[lcv]; \
@@ -181 +181 @@
         y = 0; \
         t = 0; \
-        for (int i = 0; i < length; i++) { \
+        for (psS32 i = 0; i < length; i++) { \
             deltaT = t; \
             oldX = x; \
@@ -228 +228 @@
 }
 
-psImage* psImageConvolve(psImage* out, const psImage* in, const psKernel* kernel, bool direct)
+psImage* psImageConvolve(psImage* out, const psImage* in, const psKernel* kernel, psBool direct)
 {
     if (in == NULL) {
@@ -242 +242 @@
         return NULL;
     }
-    int xMin = kernel->xMin;
-    int xMax = kernel->xMax;
-    int yMin = kernel->yMin;
-    int yMax = kernel->yMax;
+    psS32 xMin = kernel->xMin;
+    psS32 xMax = kernel->xMax;
+    psS32 yMin = kernel->yMin;
+    psS32 yMax = kernel->yMax;
     psKernelType** kData = kernel->kernel;
 
     // make the output image to the proper size and type
-    int numRows = in->numRows;
-    int numCols = in->numCols;
+    psS32 numRows = in->numRows;
+    psS32 numCols = in->numCols;
 
 
@@ -261 +261 @@
             ps##TYPE** inData = in->data.TYPE; \
             out = psImageRecycle(out, numCols, numRows, PS_TYPE_##TYPE); \
-            for (int row=0;row<numRows;row++) { \
+            for (psS32 row=0;row<numRows;row++) { \
                 ps##TYPE* outRow = out->data.TYPE[row]; \
-                for (int col=0;col<numCols;col++) { \
+                for (psS32 col=0;col<numCols;col++) { \
                     ps##TYPE pixel = 0.0; \
-                    for (int kRow = yMin; kRow < yMax; kRow++) { \
+                    for (psS32 kRow = yMin; kRow < yMax; kRow++) { \
                         if (row-kRow >= 0 && row-kRow < numRows) { \
-                            for (int kCol = xMin; kCol < xMax; kCol++) { \
+                            for (psS32 kCol = xMin; kCol < xMax; kCol++) { \
                                 if (col-kCol >= 0 && col-kCol < numCols) { \
                                     pixel += kData[kRow][kCol] * inData[row-kRow][col-kCol]; \
@@ -310 +310 @@
     } else {
         // fourier convolution
-        int paddedCols = numCols+2*FOURIER_PADDING;
-        int paddedRows = numRows+2*FOURIER_PADDING;
+        psS32 paddedCols = numCols+2*FOURIER_PADDING;
+        psS32 paddedRows = numRows+2*FOURIER_PADDING;
 
         // check to see if kernel is smaller, otherwise padding it up will fail.
-        int kRows = kernel->image->numRows;
-        int kCols = kernel->image->numCols;
+        psS32 kRows = kernel->image->numRows;
+        psS32 kCols = kernel->image->numCols;
         if (kRows >= numRows || kCols >= numCols) {
             psErrorMsg(PS_ERRORNAME_DOMAIN "psImageConvolve",
@@ -328 +328 @@
         // pad the image
         psImage* paddedImage = psImageAlloc(paddedCols,paddedRows,in->type.type);
-        int elementSize = PSELEMTYPE_SIZEOF(in->type.type);
+        psS32 elementSize = PSELEMTYPE_SIZEOF(in->type.type);
 
         // zero out padded area on top and bottom
@@ -335 +335 @@
 
         // fill in the image-containing rows.
-        int sidePaddingSize = FOURIER_PADDING*elementSize;
-        int imageRowSize = numCols*elementSize;
+        psS32 sidePaddingSize = FOURIER_PADDING*elementSize;
+        psS32 imageRowSize = numCols*elementSize;
         psU8* paddedData = paddedImage->data.U8[FOURIER_PADDING];
-        for (int row=0;row<numRows;row++) {
+        for (psS32 row=0;row<numRows;row++) {
             // zero out padded area on left edge.
             memset(paddedData,0,sidePaddingSize);
@@ -354 +354 @@
         psImage* paddedKernel = psImageAlloc(paddedCols,paddedRows,PS_TYPE_KERNEL);
         memset(paddedKernel->data.U8[0],0,sizeof(psKernelType)*numCols*numRows); // zero-out image
-        int yMax = kernel->yMax;
-        int xMax = kernel->xMax;
-        for (int row = kernel->yMin; row <= yMax;row++) {
-            int padRow = row;
+        psS32 yMax = kernel->yMax;
+        psS32 xMax = kernel->xMax;
+        for (psS32 row = kernel->yMin; row <= yMax;row++) {
+            psS32 padRow = row;
             if (padRow < 0) {
                 padRow += paddedRows;
@@ -363 +363 @@
             psKernelType* padData = paddedKernel->data.PS_TYPE_KERNEL_DATA[padRow];
             psKernelType* kernelRow = kernel->kernel[row];
-            for (int col = kernel->xMin; col <= xMax; col++) {
+            for (psS32 col = kernel->xMin; col <= xMax; col++) {
                 if (col < 0) {
                     padData[col+paddedCols] = kernelRow[col];
@@ -418 +418 @@
         out = psImageRecycle(out,numCols,numRows,PS_TYPE_F32);
         float factor = 1.0f/numCols/numRows;
-        for (int row = 0; row < numRows; row++) {
+        for (psS32 row = 0; row < numRows; row++) {
             psF32* outRow = out->data.F32[row];
             psC32* resultRow = complexOutSansPad->data.C32[row];
-            for (int col = 0; col < numCols; col++) {
+            for (psS32 col = 0; col < numCols; col++) {
                 outRow[col] = crealf(resultRow[col])*factor;
             }

trunk/psLib/src/imageops/psImageConvolve.h

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-23 18:30:57 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-27 00:57:31 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -15 +15 @@
 #ifndef PS_IMAGE_CONVOLVE_H
 #define PS_IMAGE_CONVOLVE_H
-
-#include<stdbool.h>
 
 #include "psImage.h"
@@ -32 +30 @@
 {
     psImage* image;                    ///< Kernel data, in the form of an image
-    int xMin;                          ///< Most negative x index
-    int yMin;                          ///< Most negative y index
-    int xMax;                          ///< Most positive x index
-    int yMax;                          ///< Most positive y index
+    psS32 xMin;                          ///< Most negative x index
+    psS32 yMin;                          ///< Most negative y index
+    psS32 xMax;                          ///< Most positive x index
+    psS32 yMax;                          ///< Most positive y index
     psKernelType** kernel;             ///< Pointer to the kernel data
     psKernelType** p_kernelRows;       ///< Pointer to the rows of the kernel data; not intended for user use.
@@ -68 +66 @@
  */
 psKernel* psKernelAlloc(
-    int xMin,                          ///< Most negative x index
-    int xMax,                          ///< Most positive x index
-    int yMin,                          ///< Most negative y index
-    int yMax                           ///< Most positive y index
+    psS32 xMin,                          ///< Most negative x index
+    psS32 xMax,                          ///< Most positive x index
+    psS32 yMin,                          ///< Most negative y index
+    psS32 yMax                           ///< Most positive y index
 );
 
@@ -94 +92 @@
     const psVector* xShifts,           ///< list of x-axis shifts
     const psVector* yShifts,           ///< list of y-axis shifts
-    bool relative
+    psBool relative
 );
 
@@ -118 +116 @@
     const psImage* in,                 ///< the psImage to convolve
     const psKernel* kernel,            ///< kernel to colvolve with
-    bool direct                        ///< specifies method, true=direct convolution, false=fourier
+    psBool direct                        ///< specifies method, true=direct convolution, false=fourier
 );
 

trunk/psLib/src/imageops/psImageStats.c

@@ -9 +9 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-10-14 01:06:44 $
+*  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-10-27 00:57:31 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -40 +40 @@
                       psImage* in,
                       psImage* mask,
-                      int maskVal)
+                      psS32 maskVal)
 {
     psVector* junkData = NULL;
@@ -106 +106 @@
                               psImage* in,
                               psImage* mask,
-                              unsigned int maskVal)
+                              psU32 maskVal)
 {
     psVector* junkData = NULL;
@@ -150 +150 @@
 
 // XXX: Why do we have this function?
-float *p_psCalcScaleFactorsFit(int n)
-{
-    int i = 0;
+float *p_psCalcScaleFactorsFit(psS32 n)
+{
+    psS32 i = 0;
     float tmp = 0.0;
     float *scalingFactors = (float *)psAlloc(n * sizeof(float));
@@ -175 +175 @@
 output a vector of evenly spaced floating point values between -1.0:1.0.
  *****************************************************************************/
-float *p_psCalcScaleFactorsEval(int n)
-{
-    int i = 0;
+float *p_psCalcScaleFactorsEval(psS32 n)
+{
+    psS32 i = 0;
     float tmp = 0.0;
 
@@ -196 +196 @@
 
 // XXX: Use a static array of CHebyshev polynomials.
-psPolynomial1D **p_psCreateChebyshevPolys(int maxChebyPoly)
+psPolynomial1D **p_psCreateChebyshevPolys(psS32 maxChebyPoly)
 {
     if (maxChebyPoly < 1) {
@@ -202 +202 @@
     }
     psPolynomial1D **chebPolys = NULL;
-    int i = 0;
-    int j = 0;
+    psS32 i = 0;
+    psS32 j = 0;
 
     chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
@@ -245 +245 @@
                                      const psImage* input)
 {
-    int x = 0;
-    int y = 0;
-    int i = 0;
-    int j = 0;
+    psS32 x = 0;
+    psS32 y = 0;
+    psS32 i = 0;
+    psS32 j = 0;
     float **sums = NULL;
     psPolynomial1D* *chebPolys = NULL;
-    int maxChebyPoly = 0;
+    psS32 maxChebyPoly = 0;
     float *cScalingFactors = NULL;
     float *rScalingFactors = NULL;
@@ -365 +365 @@
 psImage* psImageEvalPolynomial(psImage* input, const psPolynomial2D* coeffs)
 {
-    int x = 0;
-    int y = 0;
-    int i = 0;
-    int j = 0;
+    psS32 x = 0;
+    psS32 y = 0;
+    psS32 i = 0;
+    psS32 j = 0;
     //    float **sums = NULL;
     psPolynomial1D* *chebPolys = NULL;
-    int maxChebyPoly = 0;
+    psS32 maxChebyPoly = 0;
     float *cScalingFactors = NULL;
     float *rScalingFactors = NULL;

trunk/psLib/src/imageops/psImageStats.h

@@ -9 +9 @@
 *  @author George Gusciora, MHPCC
 *
-*  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-10-05 01:03:11 $
+*  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-10-27 00:57:31 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -40 +40 @@
     psImage* in,                       ///< image (or subimage) to calculate stats
     psImage* mask,                     ///< mask data for image (NULL ok)
-    int maskVal                        ///< mask Mask for mask
+    psS32 maskVal                        ///< mask Mask for mask
 );
 
@@ -55 +55 @@
     psImage* in,                       ///< Image data to be histogramed.
     psImage* mask,                     ///< mask data for image (NULL ok)
-    unsigned int maskVal               ///< mask Mask for mask
+    psU32 maskVal               ///< mask Mask for mask
 );