Index: /trunk/psModules/src/Makefile.am
===================================================================
--- /trunk/psModules/src/Makefile.am	(revision 1831)
+++ /trunk/psModules/src/Makefile.am	(revision 1832)
@@ -1,4 +1,5 @@
 lib_LIBRARIES = libpsmodule.a
 bin_PROGRAMS = tst_pmFlatField
+bin_PROGRAMS = tst_pmMaskBadPixels
 
 libpsmodule_a_SOURCES = pmFlatField.c pmMaskBadPixels.c
@@ -6,5 +7,8 @@
 libpsmodule_adir = .
 
-
 tst_pmFlatField_SOURCES = tst_pmFlatField.c
 tst_pmFlatField_LDFLAGS = libpsmodule.a
+
+tst_pmMaskBadPixels_SOURCES = tst_pmMaskBadPixels.c
+tst_pmMaskBadPixels_LDFLAGS = libpsmodule.a
+
Index: /trunk/psModules/src/Makefile.in
===================================================================
--- /trunk/psModules/src/Makefile.in	(revision 1831)
+++ /trunk/psModules/src/Makefile.in	(revision 1832)
@@ -132,5 +132,5 @@
 target_alias = @target_alias@
 lib_LIBRARIES = libpsmodule.a
-bin_PROGRAMS = tst_pmFlatField
+bin_PROGRAMS = tst_pmMaskBadPixels
 
 libpsmodule_a_SOURCES = pmFlatField.c pmMaskBadPixels.c
@@ -140,4 +140,7 @@
 tst_pmFlatField_SOURCES = tst_pmFlatField.c
 tst_pmFlatField_LDFLAGS = libpsmodule.a
+
+tst_pmMaskBadPixels_SOURCES = tst_pmMaskBadPixels.c
+tst_pmMaskBadPixels_LDFLAGS = libpsmodule.a
 subdir = src
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
@@ -152,11 +155,11 @@
 	pmMaskBadPixels.$(OBJEXT)
 libpsmodule_a_OBJECTS = $(am_libpsmodule_a_OBJECTS)
-bin_PROGRAMS = tst_pmFlatField$(EXEEXT)
+bin_PROGRAMS = tst_pmMaskBadPixels$(EXEEXT)
 PROGRAMS = $(bin_PROGRAMS)
 
-am_tst_pmFlatField_OBJECTS = tst_pmFlatField.$(OBJEXT)
-tst_pmFlatField_OBJECTS = $(am_tst_pmFlatField_OBJECTS)
-tst_pmFlatField_LDADD = $(LDADD)
-tst_pmFlatField_DEPENDENCIES =
+am_tst_pmMaskBadPixels_OBJECTS = tst_pmMaskBadPixels.$(OBJEXT)
+tst_pmMaskBadPixels_OBJECTS = $(am_tst_pmMaskBadPixels_OBJECTS)
+tst_pmMaskBadPixels_LDADD = $(LDADD)
+tst_pmMaskBadPixels_DEPENDENCIES =
 
 DEFAULT_INCLUDES =  -I. -I$(srcdir) -I.
@@ -165,5 +168,5 @@
 @AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/pmFlatField.Po \
 @AMDEP_TRUE@	./$(DEPDIR)/pmMaskBadPixels.Po \
-@AMDEP_TRUE@	./$(DEPDIR)/tst_pmFlatField.Po
+@AMDEP_TRUE@	./$(DEPDIR)/tst_pmMaskBadPixels.Po
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -173,10 +176,10 @@
 LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
-DIST_SOURCES = $(libpsmodule_a_SOURCES) $(tst_pmFlatField_SOURCES)
+DIST_SOURCES = $(libpsmodule_a_SOURCES) $(tst_pmMaskBadPixels_SOURCES)
 HEADERS = $(libpsmodule_a_HEADERS)
 
 DIST_COMMON = $(libpsmodule_a_HEADERS) $(srcdir)/Makefile.in \
 	Makefile.am config.h.in
-SOURCES = $(libpsmodule_a_SOURCES) $(tst_pmFlatField_SOURCES)
+SOURCES = $(libpsmodule_a_SOURCES) $(tst_pmMaskBadPixels_SOURCES)
 
 all: config.h
@@ -270,7 +273,7 @@
 	  rm -f $$p $$f ; \
 	done
-tst_pmFlatField$(EXEEXT): $(tst_pmFlatField_OBJECTS) $(tst_pmFlatField_DEPENDENCIES) 
-	@rm -f tst_pmFlatField$(EXEEXT)
-	$(LINK) $(tst_pmFlatField_LDFLAGS) $(tst_pmFlatField_OBJECTS) $(tst_pmFlatField_LDADD) $(LIBS)
+tst_pmMaskBadPixels$(EXEEXT): $(tst_pmMaskBadPixels_OBJECTS) $(tst_pmMaskBadPixels_DEPENDENCIES) 
+	@rm -f tst_pmMaskBadPixels$(EXEEXT)
+	$(LINK) $(tst_pmMaskBadPixels_LDFLAGS) $(tst_pmMaskBadPixels_OBJECTS) $(tst_pmMaskBadPixels_LDADD) $(LIBS)
 
 mostlyclean-compile:
@@ -282,5 +285,5 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pmFlatField.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pmMaskBadPixels.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tst_pmFlatField.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tst_pmMaskBadPixels.Po@am__quote@
 
 .c.o:
Index: /trunk/psModules/src/pmFlatField.c
===================================================================
--- /trunk/psModules/src/pmFlatField.c	(revision 1831)
+++ /trunk/psModules/src/pmFlatField.c	(revision 1832)
@@ -18,6 +18,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-17 00:49:04 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-20 20:36:46 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -58,15 +58,15 @@
 
     inImage = in->image;
-    inMask = in->mask;
     flatImage = flat->image;
     if (inImage == NULL) {
         psError(__func__, " : Line %d - Null not allowed for input image", __LINE__);
         return false;
-    } else if(flatImage) {
+    } else if(flatImage == NULL) {
         psError(__func__, " : Line %d - Null not allowed for flat image", __LINE__);
         return false;
-    } else if(inMask == NULL) {
-        inMask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK);
+    } else if(in->mask == NULL) {
+        in->mask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK);
     }
+    inMask = in->mask;
 
     // Check input image and its mask are not larger than flat image
@@ -178,4 +178,5 @@
     }
 
+    printf("");
     return true;
 }
Index: /trunk/psModules/src/pmMaskBadPixels.c
===================================================================
--- /trunk/psModules/src/pmMaskBadPixels.c	(revision 1831)
+++ /trunk/psModules/src/pmMaskBadPixels.c	(revision 1832)
@@ -16,8 +16,9 @@
  * pixel on the mask. In the event that the mask image is too small (i.e., pixels on the input image refer to
  * pixels outside the range of the mask image), the function shall generate an error.
+ 
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-17 00:49:04 $
+ *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-20 20:36:46 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -40,4 +41,5 @@
     int jj = 0;
     int ii = 0;
+    int rRound = 0;
     int rowMin = 0;
     int rowMax = 0;
@@ -46,5 +48,5 @@
     int totOffCol = 0;
     int totOffRow = 0;
-    float r = 0.0;
+    float r = 0.0f;
     psElemType inType;
     psElemType maskType;
@@ -63,11 +65,11 @@
 
     inImage = in->image;
-    inMask = in->mask;
     if (inImage == NULL) {
         psError(__func__, " : Line %d - Null not allowed for input image", __LINE__);
         return false;
     } else if(inMask == NULL) {
-        inMask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK);
+        in->mask = psImageAlloc(inImage->numCols, inImage->numRows, PS_TYPE_MASK);
     }
+    inMask = in->mask;
 
     // Check input image and its mask are not larger than mask
@@ -135,34 +137,35 @@
     // Macro for all PS types
     #define PM_BAD_PIXELS(TYPE)                                                                              \
-case PS_TYPE_##TYPE:                                                                                 \
-    for(j=totOffRow; j<inImage->numRows; j++) {                                                      \
-        for(i=totOffCol; i<inImage->numCols; i++) {                                                  \
-            if(inImage->data.TYPE[j][i] > sat) {                                                     \
-                /* Pixels with flux greater than sat shall be masked */                              \
-                inMask->data.PS_TYPE_MASK_DATA[j][i] |= PM_MASK_SAT;                                 \
-            }                                                                                        \
-            if(mask->data.PS_TYPE_MASK_DATA[j][i] & maskVal) {                                       \
-                /* Pixels in mask which satisfy maskVal shall have their pixels masked in inMask */  \
-                inMask->data.PS_TYPE_MASK_DATA[j][i] |= mask->data.PS_TYPE_MASK_DATA[j][i]|maskVal;  \
-            }                                                                                        \
-            rowMin = MAX(j-grow, 0);                                                                 \
-            rowMax = MIN(j+grow, inImage->numRows-1);                                                \
-            colMin = MAX(i-grow, 0);                                                                 \
-            colMax = MIN(i+grow, inImage->numCols-1);                                                \
-            for(jj=rowMin; jj<rowMax; jj++) {                                                        \
-                for(ii=colMin; ii<colMax; ii++) {                                                    \
-                    if(mask->data.PS_TYPE_MASK_DATA[j][i] & growVal) {                               \
-                        r = sqrtf((ii-i)*(ii-i)+(jj-j)*(jj-j));                                      \
-                        if(r <= grow) {                                                              \
-                            /* Pixels in mask which satisfy growVal shall have their corresponding   \
-                            pixels,along with all pixels within the grow radius masked */            \
-                            inMask->data.PS_TYPE_MASK_DATA[j][i] |=                                  \
-                                    mask->data.PS_TYPE_MASK_DATA[j][i]&growVal;                          \
-                        }                                                                            \
-                    }                                                                                \
-                }                                                                                    \
-            }                                                                                        \
-        }                                                                                            \
-    }                                                                                                \
+case PS_TYPE_##TYPE:                                                                                         \
+    for(j=totOffRow; j<inImage->numRows; j++) {                                                              \
+        for(i=totOffCol; i<inImage->numCols; i++) {                                                          \
+            \
+            /* Pixels with flux greater than sat shall be masked */                                          \
+            if(inImage->data.TYPE[j][i] > sat) {                                                             \
+                inMask->data.PS_TYPE_MASK_DATA[j][i] |= PM_MASK_SAT;                                         \
+            }                                                                                                \
+            \
+            /* Pixels which satisfy maskVal shall be masked */                                               \
+            inMask->data.PS_TYPE_MASK_DATA[j][i] |= (mask->data.PS_TYPE_MASK_DATA[j][i]&maskVal);            \
+            \
+            /* Pixels which satisfy growVal and within the grow radius shall be masked */                    \
+            if(mask->data.PS_TYPE_MASK_DATA[j][i] & growVal) {                                               \
+                rowMin = MAX(j-grow, 0);                                                                     \
+                rowMax = MIN(j+grow+1, inImage->numRows);                                                    \
+                colMin = MAX(i-grow, 0);                                                                     \
+                colMax = MIN(i+grow+1, inImage->numCols);                                                    \
+                for(jj=rowMin; jj<rowMax; jj++) {                                                            \
+                    for(ii=colMin; ii<colMax; ii++) {                                                        \
+                        r = sqrtf((ii-i)*(ii-i)+(jj-j)*(jj-j));                                              \
+                        rRound = r + 0.5;                                                                    \
+                        if(rRound <= grow) {                                                                 \
+                            inMask->data.PS_TYPE_MASK_DATA[jj][ii] |=                                        \
+                                    (mask->data.PS_TYPE_MASK_DATA[j][i]&growVal);                            \
+                        }                                                                                    \
+                    }                                                                                        \
+                }                                                                                            \
+            }                                                                                                \
+        }                                                                                                    \
+    }                                                                                                        \
     break;
 
Index: /trunk/psModules/src/tst_pmFlatField.c
===================================================================
--- /trunk/psModules/src/tst_pmFlatField.c	(revision 1831)
+++ /trunk/psModules/src/tst_pmFlatField.c	(revision 1832)
@@ -5,8 +5,8 @@
  *  Detailed Description goes here.
  *
- *  @author Robert DeSonia, MHPCC
+ *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-14 02:29:40 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-20 20:36:46 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -15,10 +15,47 @@
 #include "pmFlatField.h"
 
+
+#define PRINT_MATRIX(IMAGE,TYPE)                                                                             \
+for(int i=IMAGE->numRows-1; i>-1; i--) {                                                                 \
+    for(int j=0; j<IMAGE->numCols; j++) {                                                                \
+        if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) {                                                 \
+            printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j]));             \
+        } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) {                                              \
+            printf("%d ", (int)IMAGE->data.TYPE[i][j]);                                                  \
+        } else {                                                                                         \
+            printf("%f ", (double)IMAGE->data.TYPE[i][j]);                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    printf("\n");                                                                                        \
+}                                                                                                        \
+printf("\n");
+
+
 int main(void)
 {
-    psVector* vec = psVectorAlloc(10,PS_TYPE_F32);
-    for (int i=0;i<10;i++) {
-        vec->data.F32[i] = i/9.0f;
+    psImage *inImage = psImageAlloc(3, 3, PS_TYPE_F64);
+    psImage *flatImage1 = psImageAlloc(3, 3, PS_TYPE_F64);
+    psImage *flatImage2 = psImageAlloc(3, 3, PS_TYPE_F64);
+    psReadout *inReadout  = psReadoutAlloc(0, 0, inImage);
+    psReadout *flatReadout  = psReadoutAlloc(0, 0, flatImage1);
+
+    for(int r=0;r<3;r++) {
+        for(int c=0;c<3;c++) {
+            inImage->data.F64[r][c]=8.0;
+            flatImage1->data.F64[r][c]=4.0;
+            flatImage2->data.F64[r][c]=0.0;
+        }
     }
-    //    pmFlatField(vec);
+
+    PRINT_MATRIX(inImage,F64);
+    PRINT_MATRIX(flatImage1, F64);
+    pmFlatField(inReadout, flatReadout);
+    PRINT_MATRIX(inImage,F64);
+
+    PRINT_MATRIX(inImage, F64);
+    PRINT_MATRIX(flatImage2, F64);
+    flatReadout->image = flatImage2;
+    pmFlatField(inReadout, flatReadout);
+    PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA);
+    return 0;
 }
Index: /trunk/psModules/src/tst_pmMaskBadPixels.c
===================================================================
--- /trunk/psModules/src/tst_pmMaskBadPixels.c	(revision 1832)
+++ /trunk/psModules/src/tst_pmMaskBadPixels.c	(revision 1832)
@@ -0,0 +1,62 @@
+
+/** @file  filename.h
+ *
+ *  @brief Contains the definitions for ...
+ *
+ *  Detailed Description goes here.
+ *
+ *  @author Ross Harman, MHPCC
+ *
+ *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-20 20:36:46 $
+ *
+ *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
+ */
+
+#include "pmMaskBadPixels.h"
+
+
+#define PRINT_MATRIX(IMAGE,TYPE)                                                                             \
+for(int i=0; i<IMAGE->numRows; i++) {                                                                 \
+    for(int j=0; j<IMAGE->numCols; j++) {                                                                \
+        if(PS_IS_PSELEMTYPE_COMPLEX(IMAGE->type.type)) {                                                 \
+            printf("%f+%fi ", creal(IMAGE->data.TYPE[i][j]), cimag(IMAGE->data.TYPE[i][j]));             \
+        } else if(PS_IS_PSELEMTYPE_INT(IMAGE->type.type)) {                                              \
+            printf("%d", (int)IMAGE->data.TYPE[i][j]);                                                  \
+        } else {                                                                                         \
+            printf("%f ", (double)IMAGE->data.TYPE[i][j]);                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    printf("\n");                                                                                        \
+}                                                                                                        \
+printf("\n");
+
+
+int main(void)
+{
+    int grow = 10;
+    int size = 50;
+    unsigned int maskVal = 0;
+    unsigned int growVal = 1;
+    float sat = 100.0f;
+    psImage *inImage = psImageAlloc(size, size, PS_TYPE_F64);
+    psImage *mask1 = psImageAlloc(size, size, PS_TYPE_MASK);
+    psImage *mask2 = psImageAlloc(size, size, PS_TYPE_MASK);
+    psReadout *inReadout  = psReadoutAlloc(0, 0, inImage);
+
+
+    for(int r=0;r<size;r++) {
+        for(int c=0;c<size;c++) {
+            inImage->data.F64[r][c]=6.0;
+            mask1->data.PS_TYPE_MASK_DATA[r][c]=0;
+            mask2->data.PS_TYPE_MASK_DATA[r][c]=0;
+        }
+    }
+
+    mask1->data.PS_TYPE_MASK_DATA[24][24]=1;
+    PRINT_MATRIX(inImage,F64);
+    PRINT_MATRIX(mask1, PS_TYPE_MASK_DATA);
+    pmMaskBadPixels(inReadout, mask1, maskVal, sat, growVal, grow);
+    PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA);
+    return 0;
+}
