Changeset 1385 for trunk/psLib/src/image

Timestamp:

Aug 4, 2004, 1:37:39 PM (22 years ago)

Author:

desonia

Message:

found the server astyle upgrade was faulty, so the format was reset.

Location:

trunk/psLib/src/image

Files:

• psImage.c (modified) (1 diff)
• psImage.h (modified) (1 diff)
• psImageExtraction.c (modified) (9 diffs)
• psImageIO.c (modified) (2 diffs)
• psImageManip.c (modified) (2 diffs)
• psImageStats.c (modified) (1 diff)

trunk/psLib/src/image/psImage.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-22 20:42:22 $
+ *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/image/psImage.h

@@ -11 +11 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-22 20:42:22 $
+ *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/image/psImageExtraction.c

@@ -9 +9 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-04 00:55:17 $
+*  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-04 23:37:39 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -29 +29 @@
     unsigned int outputRowSize;         // output row size in bytes
     unsigned int inputColOffset;        // offset in bytes to first subset pixel in input row
-    
+
     if ( image == NULL || image->data.V == NULL ) {
-            psError( __func__, "Can not subset image because input image or its pixel buffer is NULL." );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not subset image because input image or its pixel buffer is NULL." );
+        return NULL;
+    }
+
     if ( image->type.dimen != PS_DIMEN_IMAGE ) {
-            psError( __func__, "Can not subset image because input image is not an image." );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not subset image because input image is not an image." );
+        return NULL;
+    }
+
     if ( numCols < 1 || numRows < 1 ) {
-            psError( __func__, "Can not subset image because number of rows or columns are zero (%dx%d).",
-                     numCols, numRows );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not subset image because number of rows or columns are zero (%dx%d).",
+                 numCols, numRows );
+        return NULL;
+    }
+
     if ( col0 >= image->numCols || row0 >= image->numRows ) {
-            psError( __func__, "Can not subset image because col0,row0 (%d,%d) is not a valid pixel location.",
-                     col0, row0 );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not subset image because col0,row0 (%d,%d) is not a valid pixel location.",
+                 col0, row0 );
+        return NULL;
+    }
+
     /* validate subimage size */
     if ( col0 + numCols >= image->numCols || row0 + numRows >= image->numRows ) {
-            psError( __func__, "Can not subset image outside of image boundaries (size=%dx%d, "
-                     "subset=[%d:%d,%d:%d]).", image->numCols, image->numRows, col0,
-                     col0 + numCols, row0, row0 + numRows );
-            return NULL;
-        }
-        
-        
+        psError( __func__, "Can not subset image outside of image boundaries (size=%dx%d, "
+                 "subset=[%d:%d,%d:%d]).", image->numCols, image->numRows, col0,
+                 col0 + numCols, row0, row0 + numRows );
+        return NULL;
+    }
+
+
     elementSize = PSELEMTYPE_SIZEOF( image->type.type );
-    
+
     out = psImageRecycle( out, numCols, numRows, image->type.type );
-    
+
     // set the parent information into the child output image
     *( int* ) & out->row0 = row0;
     *( int* ) & out->col0 = col0;
     *( psImage** ) & out->parent = ( psImage* ) image;
-    
+
     // add output image as a child of the input image.
     image->nChildren++;
@@ -75 +75 @@
                       image->nChildren * sizeof( psImage* ) );
     image->children[ image->nChildren - 1 ] = out;
-    
+
     inputColOffset = elementSize * col0;
     outputRowSize = elementSize * numCols;
-    
+
     for ( int row = 0; row < numRows; row++ ) {
-            memcpy( out->data.V[ row ], image->data.U8[ row0 + row ] + inputColOffset,
-                    outputRowSize );
-        }
-        
+        memcpy( out->data.V[ row ], image->data.U8[ row0 + row ] + inputColOffset,
+                outputRowSize );
+    }
+
     return ( out );
 }
@@ -96 +96 @@
     int numRows;
     int numCols;
-    
+
     if ( input == NULL || input->data.V == NULL ) {
-            psError( __func__, "Can not copy image because input image or its pixel buffer is NULL." );
-            psFree( output );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not copy image because input image or its pixel buffer is NULL." );
+        psFree( output );
+        return NULL;
+    }
+
     if ( input == output ) {
-            psError( __func__, "Can not copy image because given input and output "
-                     "parameter reference the same psImage struct." );
-            psFree( output );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not copy image because given input and output "
+                 "parameter reference the same psImage struct." );
+        psFree( output );
+        return NULL;
+    }
+
     if ( input->type.dimen != PS_DIMEN_IMAGE ) {
-            psError( __func__, "Can not copy image because input image is not actually an image." );
-            psFree( output );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not copy image because input image is not actually an image." );
+        psFree( output );
+        return NULL;
+    }
+
     inDatatype = input->type.type;
     numRows = input->numRows;
@@ -121 +121 @@
     elements = numRows * numCols;
     elementSize = PSELEMTYPE_SIZEOF( inDatatype );
-    
+
     if ( inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR ) {
-            psError( __func__, "Can not copy image to/from a void* matrix" );
-            psFree( output );
-            return NULL;
-        }
-        
+        psError( __func__, "Can not copy image to/from a void* matrix" );
+        psFree( output );
+        return NULL;
+    }
+
     output = psImageRecycle( output, numCols, numRows, type );
-    
+
     // cover the trival case of copy of the same datatype.
     if ( type == inDatatype ) {
-            memcpy( output->data.V[ 0 ], input->data.V[ 0 ], elementSize * elements );
-            return output;
-        }
-        
+        memcpy( output->data.V[ 0 ], input->data.V[ 0 ], elementSize * elements );
+        return output;
+    }
+
     #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \
         ps##INTYPE *in = IN->data.INTYPE[0]; \
         ps##OUTTYPE *out = OUT->data.OUTTYPE[0]; \
         for (int e=0;e<ELEMENTS;e++) { \
-                *(out++) = *(in++); \
-            } \
-    }
-    
+            *(out++) = *(in++); \
+        } \
+    }
+
     #define PSIMAGE_COPY_CASE(OUT,OUTTYPE) \
     switch (inDatatype) { \
-            case PS_TYPE_S8: \
-            PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_S16: \
-            PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_S32: \
-            PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_S64: \
-            PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_U8: \
-            PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_U16: \
-            PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_U32: \
-            PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_U64: \
-            PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_F32: \
-            PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_F64: \
-            PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_C32: \
-            PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
-            break; \
-            case PS_TYPE_C64: \
-            PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
-            break; \
-            default: \
-            break; \
-        }
-        
+    case PS_TYPE_S8: \
+        PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_S16: \
+        PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_S32: \
+        PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_S64: \
+        PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_U8: \
+        PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_U16: \
+        PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_U32: \
+        PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_U64: \
+        PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_F32: \
+        PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_F64: \
+        PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_C32: \
+        PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
+        break; \
+    case PS_TYPE_C64: \
+        PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
+        break; \
+    default: \
+        break; \
+    }
+
     switch ( type ) {
-            case PS_TYPE_S8:
-            PSIMAGE_COPY_CASE( output, S8 );
-            break;
-            case PS_TYPE_S16:
-            PSIMAGE_COPY_CASE( output, S16 );
-            break;
-            case PS_TYPE_S32:
-            PSIMAGE_COPY_CASE( output, S32 );
-            break;
-            case PS_TYPE_S64:
-            PSIMAGE_COPY_CASE( output, S64 );
-            break;
-            case PS_TYPE_U8:
-            PSIMAGE_COPY_CASE( output, U8 );
-            break;
-            case PS_TYPE_U16:
-            PSIMAGE_COPY_CASE( output, U16 );
-            break;
-            case PS_TYPE_U32:
-            PSIMAGE_COPY_CASE( output, U32 );
-            break;
-            case PS_TYPE_U64:
-            PSIMAGE_COPY_CASE( output, U64 );
-            break;
-            case PS_TYPE_F32:
-            PSIMAGE_COPY_CASE( output, F32 );
-            break;
-            case PS_TYPE_F64:
-            PSIMAGE_COPY_CASE( output, F64 );
-            break;
-            case PS_TYPE_C32:
-            PSIMAGE_COPY_CASE( output, C32 );
-            break;
-            case PS_TYPE_C64:
-            PSIMAGE_COPY_CASE( output, C64 );
-            break;
-            default:
-            break;
-        }
+    case PS_TYPE_S8:
+        PSIMAGE_COPY_CASE( output, S8 );
+        break;
+    case PS_TYPE_S16:
+        PSIMAGE_COPY_CASE( output, S16 );
+        break;
+    case PS_TYPE_S32:
+        PSIMAGE_COPY_CASE( output, S32 );
+        break;
+    case PS_TYPE_S64:
+        PSIMAGE_COPY_CASE( output, S64 );
+        break;
+    case PS_TYPE_U8:
+        PSIMAGE_COPY_CASE( output, U8 );
+        break;
+    case PS_TYPE_U16:
+        PSIMAGE_COPY_CASE( output, U16 );
+        break;
+    case PS_TYPE_U32:
+        PSIMAGE_COPY_CASE( output, U32 );
+        break;
+    case PS_TYPE_U64:
+        PSIMAGE_COPY_CASE( output, U64 );
+        break;
+    case PS_TYPE_F32:
+        PSIMAGE_COPY_CASE( output, F32 );
+        break;
+    case PS_TYPE_F64:
+        PSIMAGE_COPY_CASE( output, F64 );
+        break;
+    case PS_TYPE_C32:
+        PSIMAGE_COPY_CASE( output, C32 );
+        break;
+    case PS_TYPE_C64:
+        PSIMAGE_COPY_CASE( output, C64 );
+        break;
+    default:
+        break;
+    }
     return output;
 }
@@ -247 +247 @@
     int delta = 1;
     psF64* outData;
-    
+
     if ( in == NULL || in->data.V == NULL ) {
-            psError( __func__, "Input image can not be NULL." );
-            psFree( out );
-            return NULL;
-        }
-        
+        psError( __func__, "Input image can not be NULL." );
+        psFree( out );
+        return NULL;
+    }
+
     if ( numRows == 0 || numCols == 0 ) {
-            psError( __func__, "The specified region contains no data (%dx%d)",
-                     numCols, numRows );
-            psFree( out );
-            return NULL;
-        }
-        
+        psError( __func__, "The specified region contains no data (%dx%d)",
+                 numCols, numRows );
+        psFree( out );
+        return NULL;
+    }
+
     type = in->type.type;
     inRows = in->numRows;
     inCols = in->numCols;
-    
+
     if ( direction == PS_CUT_X_NEG || direction == PS_CUT_Y_NEG ) {
-            delta = -1;
-        }
-        
+        delta = -1;
+    }
+
     // if numRows/numCols is negative, invert the problem to give positive
     // numRows/numCols (and cut in opposite direction).
     if ( numRows < 0 ) {
-            numRows = -numRows;
-            row -= ( numRows - 1 );
-            delta = -delta;
-        }
-        
+        numRows = -numRows;
+        row -= ( numRows - 1 );
+        delta = -delta;
+    }
+
     if ( numCols < 0 ) {
-            numCols = -numCols;
-            col -= ( numCols - 1 );
-            delta = -delta;
-        }
-        
+        numCols = -numCols;
+        col -= ( numCols - 1 );
+        delta = -delta;
+    }
+
     if ( mask != NULL ) {
-            if ( inRows != mask->numRows || inCols != mask->numCols ) {
-                    psError( __func__, "The mask and image dimensions did not match (%dx%d vs %dx%d)",
-                             mask->numCols, mask->numRows, in->numCols, in->numRows );
-                    psFree( out );
-                }
-            if ( mask->type.type != PS_TYPE_MASK ) {
-                    psError( __func__, "The mask datatype (%d) must be %s.",
-                             mask->type.type, PS_TYPE_MASK_NAME );
-                    psFree( out );
-                }
-        }
-        
+        if ( inRows != mask->numRows || inCols != mask->numCols ) {
+            psError( __func__, "The mask and image dimensions did not match (%dx%d vs %dx%d)",
+                     mask->numCols, mask->numRows, in->numCols, in->numRows );
+            psFree( out );
+        }
+        if ( mask->type.type != PS_TYPE_MASK ) {
+            psError( __func__, "The mask datatype (%d) must be %s.",
+                     mask->type.type, PS_TYPE_MASK_NAME );
+            psFree( out );
+        }
+    }
+
     if ( row >= inRows || col >= inCols ||
             col + numCols > in->numCols || row + numRows > in->numRows ) {
-            psError( __func__, "The specified image region (%d,%d to %d,%d) is outside of image area (0,0 to %d,%d).",
-                     col, row, col + numCols - 1, row + numRows - 1, in->numCols - 1, in->numRows - 1 );
-            psFree( out );
-            return NULL;
-        }
-        
+        psError( __func__, "The specified image region (%d,%d to %d,%d) is outside of image area (0,0 to %d,%d).",
+                 col, row, col + numCols - 1, row + numRows - 1, in->numCols - 1, in->numRows - 1 );
+        psFree( out );
+        return NULL;
+    }
+
     // verify that the stats struct specifies a single stats operation
     if ( stats == NULL || p_psGetStatValue( stats, &statVal ) == false ) {
-            psError( __func__, "The stat options didn't specify a single supported statistic type." );
-            psFree( out );
-            return NULL;
-        }
-        
+        psError( __func__, "The stat options didn't specify a single supported statistic type." );
+        psFree( out );
+        return NULL;
+    }
+
     // since stats input is const, I need to create a 'scratch' stats struct
     myStats = psAlloc( sizeof( psStats ) );
     *myStats = *stats;
-    
-    
-    
+
+
+
     if ( direction == PS_CUT_X_POS || direction == PS_CUT_X_NEG ) {
-            psVector * imgVec = psVectorAlloc( numRows, type );
-            psVector* maskVec = NULL;
-            psMaskType* maskData = NULL;
-            
-            // recycle output to make a proper sized/type output structure
-            // n.b. type is double as that is the type given for all stats in psStats.
-            out = psVectorRecycle( out, PS_TYPE_F64, numCols );
-            outData = out->data.F64;
-            if ( delta < 0 ) {
-                    outData += numCols - 1;
-                }
-                
-            if ( mask != NULL ) {
-                    maskVec = psVectorAlloc( numRows, mask->type.type );
-                }
-                
-            #define PSIMAGE_CUT_VERTICAL(TYPE) \
-            case PS_TYPE_##TYPE: { \
-                psMaskType* maskVecData = NULL; \
-                for (int c=0;c<numCols;c++) { \
-                        ps##TYPE *imgData = in->data.TYPE[row] + col + c; \
-                        ps##TYPE *imgVecData = imgVec->data.TYPE; \
-                        if (maskVec != NULL) { \
-                                maskVecData = maskVec->data.V; \
-                                maskData = (psMaskType*)(mask->data.V[row]) + col + c; \
-                            } \
-                        for (int r=0;r<numRows;r++) { \
-                                *(imgVecData++) = *imgData; \
-                                imgData += inCols; \
-                                if (maskVecData != NULL) { \
-                                        *(maskVecData++) = *maskData; \
-                                        maskData += inCols; \
-                                    } \
-                            } \
-                        myStats = psVectorStats(myStats,imgVec,maskVec,maskVal); \
-                        (void)p_psGetStatValue(myStats,&statVal); \
-                        *outData = statVal; \
-                        outData += delta; \
+        psVector * imgVec = psVectorAlloc( numRows, type );
+        psVector* maskVec = NULL;
+        psMaskType* maskData = NULL;
+
+        // recycle output to make a proper sized/type output structure
+        // n.b. type is double as that is the type given for all stats in psStats.
+        out = psVectorRecycle( out, PS_TYPE_F64, numCols );
+        outData = out->data.F64;
+        if ( delta < 0 ) {
+            outData += numCols - 1;
+        }
+
+        if ( mask != NULL ) {
+            maskVec = psVectorAlloc( numRows, mask->type.type );
+        }
+
+        #define PSIMAGE_CUT_VERTICAL(TYPE) \
+    case PS_TYPE_##TYPE: { \
+            psMaskType* maskVecData = NULL; \
+            for (int c=0;c<numCols;c++) { \
+                ps##TYPE *imgData = in->data.TYPE[row] + col + c; \
+                ps##TYPE *imgVecData = imgVec->data.TYPE; \
+                if (maskVec != NULL) { \
+                    maskVecData = maskVec->data.V; \
+                    maskData = (psMaskType*)(mask->data.V[row]) + col + c; \
+                } \
+                for (int r=0;r<numRows;r++) { \
+                    *(imgVecData++) = *imgData; \
+                    imgData += inCols; \
+                    if (maskVecData != NULL) { \
+                        *(maskVecData++) = *maskData; \
+                        maskData += inCols; \
                     } \
-                break; \
-            }
-            
-            switch ( type ) {
-                    PSIMAGE_CUT_VERTICAL( U8 );
-                    PSIMAGE_CUT_VERTICAL( U16 );
-                    PSIMAGE_CUT_VERTICAL( U32 );
-                    PSIMAGE_CUT_VERTICAL( U64 );
-                    PSIMAGE_CUT_VERTICAL( S8 );
-                    PSIMAGE_CUT_VERTICAL( S16 );
-                    PSIMAGE_CUT_VERTICAL( S32 );
-                    PSIMAGE_CUT_VERTICAL( S64 );
-                    PSIMAGE_CUT_VERTICAL( F32 );
-                    PSIMAGE_CUT_VERTICAL( F64 );
-                    PSIMAGE_CUT_VERTICAL( C32 );
-                    PSIMAGE_CUT_VERTICAL( C64 );
-                    default:
-                    psError( __func__, "Unsupported datatype (%d)", type );
-                    psFree( out );
-                    out = NULL;
-                }
-            psFree( imgVec );
-            psFree( maskVec );
-        } else if ( direction == PS_CUT_Y_POS || direction == PS_CUT_Y_NEG ) { // Cut in Y direction
+                } \
+                myStats = psVectorStats(myStats,imgVec,maskVec,maskVal); \
+                (void)p_psGetStatValue(myStats,&statVal); \
+                *outData = statVal; \
+                outData += delta; \
+            } \
+            break; \
+        }
+
+        switch ( type ) {
+            PSIMAGE_CUT_VERTICAL( U8 );
+            PSIMAGE_CUT_VERTICAL( U16 );
+            PSIMAGE_CUT_VERTICAL( U32 );
+            PSIMAGE_CUT_VERTICAL( U64 );
+            PSIMAGE_CUT_VERTICAL( S8 );
+            PSIMAGE_CUT_VERTICAL( S16 );
+            PSIMAGE_CUT_VERTICAL( S32 );
+            PSIMAGE_CUT_VERTICAL( S64 );
+            PSIMAGE_CUT_VERTICAL( F32 );
+            PSIMAGE_CUT_VERTICAL( F64 );
+            PSIMAGE_CUT_VERTICAL( C32 );
+            PSIMAGE_CUT_VERTICAL( C64 );
+        default:
+            psError( __func__, "Unsupported datatype (%d)", type );
+            psFree( out );
+            out = NULL;
+        }
+        psFree( imgVec );
+        psFree( maskVec );
+    } else
+        if ( direction == PS_CUT_Y_POS || direction == PS_CUT_Y_NEG ) { // Cut in Y direction
             psVector * imgVec = NULL;
             psVector* maskVec = NULL;
             int elementSize = PSELEMTYPE_SIZEOF( type );
-            
+
             // fill in psVectors to fake out the statistics functions.
             imgVec = psAlloc( sizeof( psVector ) );
@@ -390 +391 @@
             imgVec->n = imgVec->nalloc = numCols;
             if ( mask != NULL ) {
-                    maskVec = psAlloc( sizeof( psVector ) );
-                    maskVec->type = mask->type;
-                    maskVec->n = maskVec->nalloc = numCols;
-                }
-                
+                maskVec = psAlloc( sizeof( psVector ) );
+                maskVec->type = mask->type;
+                maskVec->n = maskVec->nalloc = numCols;
+            }
+
             // recycle output to make a proper sized/type output structure
             // n.b. type is double as that is the type given for all stats in psStats.
@@ -400 +401 @@
             outData = out->data.F64;
             if ( delta < 0 ) {
-                    outData += numRows - 1;
+                outData += numRows - 1;
+            }
+
+            for ( int r = 0;r < numRows;r++ ) {
+                // point the vector struct to the data to calculate the stats
+                imgVec->data.V = ( void* ) ( in->data.U8[ row + r ] + col * elementSize );
+                if ( maskVec != NULL ) {
+                    maskVec->data.V = ( void* ) ( mask->data.U8[ row + r ] + col * sizeof( psMaskType ) );
                 }
-                
-            for ( int r = 0;r < numRows;r++ ) {
-                    // point the vector struct to the data to calculate the stats
-                    imgVec->data.V = ( void* ) ( in->data.U8[ row + r ] + col * elementSize );
-                    if ( maskVec != NULL ) {
-                            maskVec->data.V = ( void* ) ( mask->data.U8[ row + r ] + col * sizeof( psMaskType ) );
-                        }
-                    myStats = psVectorStats( myStats, imgVec, maskVec, maskVal );
-                    ( void ) p_psGetStatValue( myStats, &statVal ); // we know it works cause we tested it above
-                    *outData = statVal;
-                    outData += delta;
-                }
+                myStats = psVectorStats( myStats, imgVec, maskVec, maskVal );
+                ( void ) p_psGetStatValue( myStats, &statVal ); // we know it works cause we tested it above
+                *outData = statVal;
+                outData += delta;
+            }
             psFree( imgVec );
             psFree( maskVec );
@@ -421 +422 @@
             out = NULL;
         }
-        
+
     psFree( myStats );
-    
+
     return out;
 }

trunk/psLib/src/image/psImageIO.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-27 23:09:23 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -303 +303 @@
                         extnum, numHDUs);
                 return false;
-            } else if (numHDUs == extnum) {
-                createNewHDU = true;
-            } else if (fits_movabs_hdu(fptr, extnum+1, &hduType, &status) != 0) {
-                fits_get_errstatus(status, fitsErr);
-                status = 0;
-                (void)fits_close_file(fptr, &status);
-                psError(__func__,"Could not index to HDU #%d for file %s. (%s)",
-                        extnum, filename, fitsErr);
-                return false;
-            }
+            } else
+                if (numHDUs == extnum) {
+                    createNewHDU = true;
+                } else
+                    if (fits_movabs_hdu(fptr, extnum+1, &hduType, &status) != 0) {
+                        fits_get_errstatus(status, fitsErr);
+                        status = 0;
+                        (void)fits_close_file(fptr, &status);
+                        psError(__func__,"Could not index to HDU #%d for file %s. (%s)",
+                                extnum, filename, fitsErr);
+                        return false;
+                    }
         }
 

trunk/psLib/src/image/psImageManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-29 01:20:10 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -582 +582 @@
             return NULL;
         }
-    } else if (fabsf(angle-180.0f) < FLT_EPSILON) {
-        // perform 1/2 rotate
-        int numRows = in->numRows;
-        int lastRow = numRows - 1;
-        int numCols = in->numCols;
-        int lastCol = numCols - 1;
-        psElemType type = in->type.type;
-        out = psImageRecycle(out,numCols,numRows,type);
-
-        #define PSIMAGE_ROTATE_180_CASE(TYPE) \
-    case PS_TYPE_##TYPE: { \
-            for (int row=0;row<numRows;row++) { \
-                ps##TYPE* outRow = out->data.TYPE[row]; \
-                ps##TYPE* inRow = in->data.TYPE[lastRow-row]; \
-                for (int col=0;col<numCols;col++) { \
-                    outRow[col] = inRow[lastCol - col]; \
+    } else
+        if (fabsf(angle-180.0f) < FLT_EPSILON) {
+            // perform 1/2 rotate
+            int numRows = in->numRows;
+            int lastRow = numRows - 1;
+            int numCols = in->numCols;
+            int lastCol = numCols - 1;
+            psElemType type = in->type.type;
+            out = psImageRecycle(out,numCols,numRows,type);
+
+            #define PSIMAGE_ROTATE_180_CASE(TYPE) \
+        case PS_TYPE_##TYPE: { \
+                for (int row=0;row<numRows;row++) { \
+                    ps##TYPE* outRow = out->data.TYPE[row]; \
+                    ps##TYPE* inRow = in->data.TYPE[lastRow-row]; \
+                    for (int col=0;col<numCols;col++) { \
+                        outRow[col] = inRow[lastCol - col]; \
+                    } \
                 } \
             } \
-        } \
-        break;
-
-        switch (type) {
-            PSIMAGE_ROTATE_180_CASE(U8);
-            PSIMAGE_ROTATE_180_CASE(U16);
-            PSIMAGE_ROTATE_180_CASE(U32);
-            PSIMAGE_ROTATE_180_CASE(U64);
-            PSIMAGE_ROTATE_180_CASE(S8);
-            PSIMAGE_ROTATE_180_CASE(S16);
-            PSIMAGE_ROTATE_180_CASE(S32);
-            PSIMAGE_ROTATE_180_CASE(S64);
-            PSIMAGE_ROTATE_180_CASE(F32);
-            PSIMAGE_ROTATE_180_CASE(F64);
-            PSIMAGE_ROTATE_180_CASE(C32);
-            PSIMAGE_ROTATE_180_CASE(C64);
-        default:
-            psError(__func__,"Unsupported type (%d)",type);
-            psFree(out);
-            return NULL;
-        }
-    } else if (fabsf(angle-270.0f) < FLT_EPSILON) {
-        // perform 1/4 rotate clockwise
-        int numRows = in->numCols;
-        int lastRow = numRows - 1;
-        int numCols = in->numRows;
-        psElemType type = in->type.type;
-        out = psImageRecycle(out,numCols,numRows,type);
-
-        #define PSIMAGE_ROTATE_RIGHT_90(TYPE) \
-    case PS_TYPE_##TYPE: { \
-            ps##TYPE** inData = in->data.TYPE; \
-            for (int row=0;row<numRows;row++) { \
-                ps##TYPE* outRow = out->data.TYPE[row]; \
-                for (int col=0;col<numCols;col++) { \
-                    outRow[col] = inData[col][lastRow-row]; \
+            break;
+
+            switch (type) {
+                PSIMAGE_ROTATE_180_CASE(U8);
+                PSIMAGE_ROTATE_180_CASE(U16);
+                PSIMAGE_ROTATE_180_CASE(U32);
+                PSIMAGE_ROTATE_180_CASE(U64);
+                PSIMAGE_ROTATE_180_CASE(S8);
+                PSIMAGE_ROTATE_180_CASE(S16);
+                PSIMAGE_ROTATE_180_CASE(S32);
+                PSIMAGE_ROTATE_180_CASE(S64);
+                PSIMAGE_ROTATE_180_CASE(F32);
+                PSIMAGE_ROTATE_180_CASE(F64);
+                PSIMAGE_ROTATE_180_CASE(C32);
+                PSIMAGE_ROTATE_180_CASE(C64);
+            default:
+                psError(__func__,"Unsupported type (%d)",type);
+                psFree(out);
+                return NULL;
+            }
+        } else
+            if (fabsf(angle-270.0f) < FLT_EPSILON) {
+                // perform 1/4 rotate clockwise
+                int numRows = in->numCols;
+                int lastRow = numRows - 1;
+                int numCols = in->numRows;
+                psElemType type = in->type.type;
+                out = psImageRecycle(out,numCols,numRows,type);
+
+                #define PSIMAGE_ROTATE_RIGHT_90(TYPE) \
+            case PS_TYPE_##TYPE: { \
+                    ps##TYPE** inData = in->data.TYPE; \
+                    for (int row=0;row<numRows;row++) { \
+                        ps##TYPE* outRow = out->data.TYPE[row]; \
+                        for (int col=0;col<numCols;col++) { \
+                            outRow[col] = inData[col][lastRow-row]; \
+                        } \
+                    } \
                 } \
-            } \
-        } \
-        break;
-
-        switch (type) {
-            PSIMAGE_ROTATE_RIGHT_90(U8);
-            PSIMAGE_ROTATE_RIGHT_90(U16);
-            PSIMAGE_ROTATE_RIGHT_90(U32);
-            PSIMAGE_ROTATE_RIGHT_90(U64);
-            PSIMAGE_ROTATE_RIGHT_90(S8);
-            PSIMAGE_ROTATE_RIGHT_90(S16);
-            PSIMAGE_ROTATE_RIGHT_90(S32);
-            PSIMAGE_ROTATE_RIGHT_90(S64);
-            PSIMAGE_ROTATE_RIGHT_90(F32);
-            PSIMAGE_ROTATE_RIGHT_90(F64);
-            PSIMAGE_ROTATE_RIGHT_90(C32);
-            PSIMAGE_ROTATE_RIGHT_90(C64);
-        default:
-            psError(__func__,"Unsupported type (%d)",type);
-            psFree(out);
-            return NULL;
-        }
-    } else if (fabsf(angle) < FLT_EPSILON) {
-        out = psImageCopy(out,in,in->type.type);
-    } else {
-        psElemType type = in->type.type;
-        int numRows = in->numRows;
-        int numCols = in->numCols;
-        double centerX = (float)(numCols) / 2.0f;
-        float centerY = (float)(numRows) / 2.0f;
-        float t = angle*(3.14159265358f/180.0f);
-        float cosT = cosf(t);
-        float sinT = sinf(t);
-
-        // calculate the corners of the rotated image so we know the proper output image size.
-        //    x' = x cos(t) + y sin(t);  i.e, x' = (x-centerX)*cosT + (y-centerY)*sinT;
-        //    y' = y cos(t) - x sin(t);  i.e. y' = (y-centerY)*cosT - (x-centerX)*sinT;
-
-
-        int outCols = ceil(abs(numCols*cosT)+abs(numRows*sinT))+1;
-        int outRows = ceil(abs(numCols*sinT)+abs(numRows*cosT))+1;
-        float minX = (float)outCols/-2.0f;
-        int intMinY = outRows/-2;
-
-        out = psImageRecycle(out,outCols,outRows,type);
-
-        /* optimized public domain rotation routine by Karl Lager
-        float cosT,sinT;
-        cosT = cos(t);
-        sinT = sin(t);
-        for (y = min_y; y <= max_y; y++)
-         { x' = min_x * cosT + y * sinT + x1';
-           y' = y * cosT - min_x * sinT + y1';
-           for (x = min_x; x <= max_x; x++)
-            { if (x', y') is in the bounds of the bitmap, 
-                 get pixel(x', y') and plot the pixel to 
-                 (x, y) on screen.
-              x' += cosT;
-              y' -= sinT;
-            }
-         }
-        */
-
-        // precalculate some figures that are used within loop
-        float minXTimesCosTPlusCenterX = minX*cosT+centerX;
-        float CenterYMinusminXTimesSinT = centerY-minX*sinT;
-
-        #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \
-            if (unexposedValue < PS_MIN_##TYPE || unexposedValue > PS_MAX_##TYPE) { \
-                psError(__func__,"The given unexposedValue (%g) is outside of the " \
-                        "image type's range (%g->%g).", \
-                        unexposedValue, (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
-                psFree(out); \
-                out = NULL; \
-                break; \
-            } \
-            float inX; \
-            float inY; \
-            ps##TYPE* outRow; \
-            for (int y = 0; y < outRows; y++) { \
-                inX = minXTimesCosTPlusCenterX + (y+intMinY) * sinT; \
-                inY = CenterYMinusminXTimesSinT + (y+intMinY) * cosT; \
-                outRow = out->data.TYPE[y]; \
-                for (int x = 0; x < outCols; x++) { \
-                    outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(in,inX,inY,unexposedValue); \
-                    inX += cosT; \
-                    inY -= sinT; \
-                } \
-            } \
-        }
-
-        #define PSIMAGE_ROTATE_ARBITRARY_CASE(MODE) \
-    case PS_INTERPOLATE_##MODE: \
-        switch (type) { \
-        case PS_TYPE_U8: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(U8,MODE); \
-            break; \
-        case PS_TYPE_U16: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(U16,MODE); \
-            break; \
-        case PS_TYPE_U32: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(U32,MODE); \
-            break; \
-        case PS_TYPE_U64: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(U64,MODE); \
-            break; \
-        case PS_TYPE_S8: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(S8,MODE); \
-            break; \
-        case PS_TYPE_S16: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(S16,MODE); \
-            break; \
-        case PS_TYPE_S32: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(S32,MODE); \
-            break; \
-        case PS_TYPE_S64: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(S64,MODE); \
-            break; \
-        case PS_TYPE_F32: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(F32,MODE); \
-            break; \
-        case PS_TYPE_F64: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(F64,MODE); \
-            break; \
-        case PS_TYPE_C32: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(C32,MODE); \
-            break; \
-        case PS_TYPE_C64: \
-            PSIMAGE_ROTATE_ARBITRARY_LOOP(C64,MODE); \
-            break; \
-        default: \
-            psError(__func__,"Image type (%d) not supported",type); \
-            psFree(out); \
-            out = NULL; \
-        } \
-        break;
-
-        switch (mode) {
-            PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT);
-            PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR);
-        default:
-            psError(__func__,"Unsupported interpolation mode (%d)",mode);
-            psFree(out);
-            out = NULL;
-        }
-    }
+                break;
+
+                switch (type) {
+                    PSIMAGE_ROTATE_RIGHT_90(U8);
+                    PSIMAGE_ROTATE_RIGHT_90(U16);
+                    PSIMAGE_ROTATE_RIGHT_90(U32);
+                    PSIMAGE_ROTATE_RIGHT_90(U64);
+                    PSIMAGE_ROTATE_RIGHT_90(S8);
+                    PSIMAGE_ROTATE_RIGHT_90(S16);
+                    PSIMAGE_ROTATE_RIGHT_90(S32);
+                    PSIMAGE_ROTATE_RIGHT_90(S64);
+                    PSIMAGE_ROTATE_RIGHT_90(F32);
+                    PSIMAGE_ROTATE_RIGHT_90(F64);
+                    PSIMAGE_ROTATE_RIGHT_90(C32);
+                    PSIMAGE_ROTATE_RIGHT_90(C64);
+                default:
+                    psError(__func__,"Unsupported type (%d)",type);
+                    psFree(out);
+                    return NULL;
+                }
+            } else
+                if (fabsf(angle) < FLT_EPSILON) {
+                    out = psImageCopy(out,in,in->type.type);
+                } else {
+                    psElemType type = in->type.type;
+                    int numRows = in->numRows;
+                    int numCols = in->numCols;
+                    double centerX = (float)(numCols) / 2.0f;
+                    float centerY = (float)(numRows) / 2.0f;
+                    float t = angle*(3.14159265358f/180.0f);
+                    float cosT = cosf(t);
+                    float sinT = sinf(t);
+
+                    // calculate the corners of the rotated image so we know the proper output image size.
+                    //    x' = x cos(t) + y sin(t);  i.e, x' = (x-centerX)*cosT + (y-centerY)*sinT;
+                    //    y' = y cos(t) - x sin(t);  i.e. y' = (y-centerY)*cosT - (x-centerX)*sinT;
+
+
+                    int outCols = ceil(abs(numCols*cosT)+abs(numRows*sinT))+1;
+                    int outRows = ceil(abs(numCols*sinT)+abs(numRows*cosT))+1;
+                    float minX = (float)outCols/-2.0f;
+                    int intMinY = outRows/-2;
+
+                    out = psImageRecycle(out,outCols,outRows,type);
+
+                    /* optimized public domain rotation routine by Karl Lager
+                    float cosT,sinT;
+                    cosT = cos(t);
+                    sinT = sin(t);
+                    for (y = min_y; y <= max_y; y++)
+                     { x' = min_x * cosT + y * sinT + x1';
+                       y' = y * cosT - min_x * sinT + y1';
+                       for (x = min_x; x <= max_x; x++)
+                        { if (x', y') is in the bounds of the bitmap, 
+                             get pixel(x', y') and plot the pixel to 
+                             (x, y) on screen.
+                          x' += cosT;
+                          y' -= sinT;
+                        }
+                     }
+                    */
+
+                    // precalculate some figures that are used within loop
+                    float minXTimesCosTPlusCenterX = minX*cosT+centerX;
+                    float CenterYMinusminXTimesSinT = centerY-minX*sinT;
+
+                    #define PSIMAGE_ROTATE_ARBITRARY_LOOP(TYPE,MODE) { \
+                        if (unexposedValue < PS_MIN_##TYPE || unexposedValue > PS_MAX_##TYPE) { \
+                            psError(__func__,"The given unexposedValue (%g) is outside of the " \
+                                    "image type's range (%g->%g).", \
+                                    unexposedValue, (double)PS_MIN_##TYPE,(double)PS_MAX_##TYPE); \
+                            psFree(out); \
+                            out = NULL; \
+                            break; \
+                        } \
+                        float inX; \
+                        float inY; \
+                        ps##TYPE* outRow; \
+                        for (int y = 0; y < outRows; y++) { \
+                            inX = minXTimesCosTPlusCenterX + (y+intMinY) * sinT; \
+                            inY = CenterYMinusminXTimesSinT + (y+intMinY) * cosT; \
+                            outRow = out->data.TYPE[y]; \
+                            for (int x = 0; x < outCols; x++) { \
+                                outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(in,inX,inY,unexposedValue); \
+                                inX += cosT; \
+                                inY -= sinT; \
+                            } \
+                        } \
+                    }
+
+                    #define PSIMAGE_ROTATE_ARBITRARY_CASE(MODE) \
+                case PS_INTERPOLATE_##MODE: \
+                    switch (type) { \
+                    case PS_TYPE_U8: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(U8,MODE); \
+                        break; \
+                    case PS_TYPE_U16: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(U16,MODE); \
+                        break; \
+                    case PS_TYPE_U32: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(U32,MODE); \
+                        break; \
+                    case PS_TYPE_U64: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(U64,MODE); \
+                        break; \
+                    case PS_TYPE_S8: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(S8,MODE); \
+                        break; \
+                    case PS_TYPE_S16: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(S16,MODE); \
+                        break; \
+                    case PS_TYPE_S32: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(S32,MODE); \
+                        break; \
+                    case PS_TYPE_S64: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(S64,MODE); \
+                        break; \
+                    case PS_TYPE_F32: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(F32,MODE); \
+                        break; \
+                    case PS_TYPE_F64: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(F64,MODE); \
+                        break; \
+                    case PS_TYPE_C32: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(C32,MODE); \
+                        break; \
+                    case PS_TYPE_C64: \
+                        PSIMAGE_ROTATE_ARBITRARY_LOOP(C64,MODE); \
+                        break; \
+                    default: \
+                        psError(__func__,"Image type (%d) not supported",type); \
+                        psFree(out); \
+                        out = NULL; \
+                    } \
+                    break;
+
+                    switch (mode) {
+                        PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT);
+                        PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR);
+                    default:
+                        psError(__func__,"Unsupported interpolation mode (%d)",mode);
+                        psFree(out);
+                        out = NULL;
+                    }
+                }
 
     return out;

trunk/psLib/src/image/psImageStats.c

@@ -271 +271 @@
             if ((i != 0) && (j != 0)) {
                 coeffs->coeff[i][j]*= 4.0;
-            } else if ((i == 0) && (j == 0)) {
-                coeffs->coeff[i][j]*= 1.0;
-            } else {
-                coeffs->coeff[i][j]*= 2.0;
-            }
+            } else
+                if ((i == 0) && (j == 0)) {
+                    coeffs->coeff[i][j]*= 1.0;
+                } else {
+                    coeffs->coeff[i][j]*= 2.0;
+                }
         }
     }