IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5435


Ignore:
Timestamp:
Oct 20, 2005, 1:06:24 PM (21 years ago)
Author:
gusciora
Message:

....

Location:
trunk/psModules
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/psModules/src/astrom/pmAstrometry.c

    r5170 r5435  
    88*  @author GLG, MHPCC
    99*
    10 *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-09-28 20:43:52 $
     10*  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-10-20 23:06:24 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7171        }
    7272        psFree(fpa->chips);
    73         psFree(fpa->header);
    74         psFree(fpa->db);
     73        psFree(fpa->private);
     74        psFree(fpa->phu);
    7575    }
    7676}
    … …  
    9393        psFree(chip->cells);
    9494        psFree(chip->parent);
    95         psFree(chip->extname);
    96         psFree(chip->pixels);
    97         psFree(chip->header);
     95        psFree(chip->private);
    9896    }
    9997}
    … …  
    106104        psFree(cell->toSky);
    107105        psFree(cell->concepts);
     106        psFree(cell->camera);
    108107        psFree(cell->analysis);
    109108        //
    … …  
    117116        psFree(cell->readouts);
    118117        psFree(cell->parent);
    119         psFree(cell->extname);
    120         psFree(cell->pixels);
    121         psFree(cell->header);
     118        psFree(cell->private);
    122119    }
    123120}
    … …  
    128125        psFree(readout->image);
    129126        psFree(readout->mask);
     127        psFree(readout->weight);
     128        psFree(readout->bias);
    130129        psFree(readout->analysis);
    131         psFree(readout->concepts);
    132130        psFree(readout->parent);
    133131    }
    … …  
    145143    tmpReadout->image = NULL;
    146144    tmpReadout->mask = NULL;
     145    tmpReadout->weight = NULL;
     146    tmpReadout->bias = NULL;
    147147    tmpReadout->analysis = psMetadataAlloc();
    148     tmpReadout->concepts = psMetadataAlloc();
    149148    tmpReadout->parent = cell;
    150149    if (cell != NULL) {
    … …  
    155154}
    156155
    157 pmCell *pmCellAlloc(pmChip *chip)
     156pmCell *pmCellAlloc(
     157    pmChip *chip,
     158    psMetadata *cameradata,
     159    psString name
     160)
    158161{
    159162    pmCell *tmpCell = (pmCell *) psAlloc(sizeof(pmCell));
    … …  
    164167    tmpCell->toFPA = NULL;
    165168    tmpCell->toSky = NULL;
    166     tmpCell->analysis = psMetadataAlloc();
    167169    tmpCell->concepts = psMetadataAlloc();
     170    psBool rc = psMetadataAddStr(tmpCell->concepts, PS_LIST_HEAD, "CELL.NAME", 0, NULL, name);
     171    if (rc == false) {
     172        psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CELL.NAME to metadata.\n");
     173    }
     174    tmpCell->camera = cameradata;
     175    psMemIncrRefCounter((psMetadata *) cameradata);
     176    tmpCell->analysis = NULL;
    168177    tmpCell->readouts = psArrayAlloc(0);
    169178    tmpCell->parent = chip;
    … …  
    172181    }
    173182    tmpCell->valid = false;
    174     tmpCell->extname = NULL;
    175     tmpCell->pixels = NULL;
    176     tmpCell->header = NULL;
     183    tmpCell->private = NULL;
    177184
    178185    psMemSetDeallocator(tmpCell, (psFreeFunc) cellFree);
    … …  
    180187}
    181188
    182 pmChip *pmChipAlloc(pmFPA *fpa)
     189pmChip *pmChipAlloc(
     190    pmFPA *fpa,
     191    psString name
     192)
    183193{
    184194    pmChip *tmpChip = (pmChip *) psAlloc(sizeof(pmChip));
    … …  
    189199    tmpChip->fromFPA = NULL;
    190200    tmpChip->concepts = psMetadataAlloc();
    191     tmpChip->analysis = psMetadataAlloc();
     201    psBool rc = psMetadataAddStr(tmpChip->concepts, PS_LIST_HEAD, "CHIP.NAME", 0, NULL, name);
     202    if (rc == false) {
     203        psLogMsg(__func__, PS_LOG_WARN, "WARNING: Could not add CHIP.NAME to metadata.\n");
     204    }
     205    tmpChip->analysis = NULL;
    192206    tmpChip->cells = psArrayAlloc(0);
    193207    tmpChip->parent = fpa;
    … …  
    196210    }
    197211    tmpChip->valid = false;
    198     tmpChip->extname = NULL;
    199     tmpChip->pixels = NULL;
    200     tmpChip->header = NULL;
     212    tmpChip->private = NULL;
    201213
    202214    psMemSetDeallocator(tmpChip, (psFreeFunc) chipFree);
    … …  
    204216}
    205217
    206 pmFPA *pmFPAAlloc(
    207     const psMetadata *camera,
    208     psDB *db)
     218pmFPA *pmFPAAlloc(const psMetadata *camera)
    209219{
    210220    pmFPA *tmpFPA = (pmFPA *) psAlloc(sizeof(pmFPA));
    … …  
    214224    tmpFPA->projection = NULL;
    215225    tmpFPA->concepts = psMetadataAlloc();
    216     tmpFPA->analysis = psMetadataAlloc();
     226    tmpFPA->analysis = NULL;
    217227    tmpFPA->camera = camera;
    218228    psMemIncrRefCounter((psPtr) camera);
    219229    tmpFPA->chips = psArrayAlloc(0);
    220     tmpFPA->header = NULL;
    221     tmpFPA->db = db;
    222     psMemIncrRefCounter((psPtr) db);
     230    tmpFPA->private = NULL;
     231    tmpFPA->phu = NULL;
    223232
    224233    psMemSetDeallocator(tmpFPA, (psFreeFunc) FPAFree);
    … …  
    739748psMetadataItem *pmReadoutGetConcept(pmReadout *readout, const char *concept)
    740749{
    741     return(psMetadataLookup(readout->concepts, concept));
     750    //    return(psMetadataLookup(readout->concepts, concept));
     751    return(NULL);
    742752}
    743753
  • trunk/psModules/src/astrom/pmAstrometry.h

    r5170 r5435  
    88*  @author GLG, MHPCC
    99*
    10 *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-09-28 20:43:52 $
     10*  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-10-20 23:06:24 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424/// @addtogroup AstroImage
    2525/// @{
     26
     27// XXXX: This is incorrect.  Must determine what p_pmHDU is.
     28typedef struct
     29{
     30    int what;
     31}
     32p_pmHDU;
    2633
    2734/** Focal plane data structure
    … …  
    5259    const psMetadata *camera;           ///< Camera configuration
    5360    psArray *chips;                     ///< The chips
    54     // FITS data
    55     psMetadata *header;                 ///< The FITS header, if it corresponds to this level
    56     psDB *db;                           ///< Database handle
     61    p_pmHDU *private;                   ///< FITS data
     62    psMetadata *phu;                    ///< Primary Header
    5763}
    5864pmFPA;
    … …  
    8692    pmFPA *parent;                      ///< Parent FPA
    8793    bool valid;                         ///< Do we bother about reading and working with this chip?
    88     // FITS data
    89     const char *extname;                ///< Extension name, if it corresponds to this level
    90     psArray *pixels;                    ///< The pixel data, if it corresponds to this level
    91     psMetadata *header;                 ///< The FITS header, if it corresponds to this level
     94    p_pmHDU *private;                   ///< FITS data
    9295}
    9396pmChip;
    … …  
    113116    // Information
    114117    psMetadata *concepts;               ///< Cache for PS concepts
     118    psMetadata *camera;                 ///< Camera Info
    115119    psMetadata *analysis;               ///< Cell-level analysis metadata
    116120    psArray *readouts;                  ///< The readouts (referred to by number)
    117121    pmChip *parent;                     ///< Parent chip
    118122    bool valid;                         ///< Do we bother about reading and working with this cell?
    119     // FITS data
    120     const char *extname;                ///< Extension name, if it corresponds to this level
    121     psArray *pixels;                    ///< The pixel data, if it corresponds to this level
    122     psMetadata *header;                 ///< The FITS header, if it corresponds to this level
     123    p_pmHDU *private;                   ///< FITS data
    123124}
    124125pmCell;
    … …  
    143144    // Information
    144145    psImage *image;                     ///< Imaging area of readout
    145     // XXX: The following mask was removed from the pmReadout struct in recent SDRS
    146     // versions.  However, I'm keeping it here since al ot of modules still require
    147     // it.
    148146    psImage *mask;                      ///< Mask of input image
     147    psImage *weight;                    ///< Weight of input image
     148    psList *bias;                       ///< List of bias section (sub-)images
    149149    psMetadata *analysis;               ///< Readout-level analysis metadata
    150     psMetadata *concepts;               ///< Cache for PS Concepts
    151150    pmCell *parent;                     ///< Parent cell
    152151}
    … …  
    178177 */
    179178pmCell *pmCellAlloc(
    180     pmChip *chip                        ///< Parent chip
     179    pmChip *chip,                        ///< Parent chip
     180    psMetadata *cameradata,
     181    psString name
    181182);
    182183
    … …  
    191192 *  @return pmChip*    newly allocated pmChip
    192193 */
    193 pmChip *pmChipAlloc(pmFPA *fpa);
     194pmChip *pmChipAlloc(
     195    pmFPA *fpa,
     196    psString name
     197
     198);
    194199
    195200/** Allocates a pmFPA
    … …  
    202207 */
    203208pmFPA *pmFPAAlloc(
    204     const psMetadata *camera,           ///< Camera configuration
    205     psDB *db                            ///< Database handle
     209    const psMetadata *camera            ///< Camera configuration
    206210);
    207211
  • trunk/psModules/src/config/pmConfig.c

    r5356 r5435  
    33 *  @author PAP, IfA
    44 *
    5  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2005-10-17 23:37:11 $
     5 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2005-10-20 23:06:24 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    404404    return recipe;
    405405}
     406
     407/******************************************************************************
     408pmConfigDB(*site)
     409 
     410XXX: What should we use for the Database namespace in the call to psDBInit()?
     411This is currently NULL.
     412 *****************************************************************************/
     413
     414psDB *pmConfigDB(
     415    psMetadata *site)
     416{
     417    PS_ASSERT_PTR_NON_NULL(site, NULL);
     418    psBool mdStatus01 = false;
     419    psBool mdStatus02 = false;
     420    psBool mdStatus03 = false;
     421
     422    psString dbServer = psMetadataLookupStr(&mdStatus01, site, "DBSERVER");
     423    psString dbUsername = psMetadataLookupStr(&mdStatus02, site, "DBUSER");
     424    psString dbPassword = psMetadataLookupStr(&mdStatus03, site, "DBPASSWORD");
     425    if (!(mdStatus01 & mdStatus02 & mdStatus03)) {
     426        psLogMsg(__func__, PS_LOG_WARN, "Could not determine database server name, userID, and password from site metadata.\n");
     427        return(NULL);
     428    }
     429
     430    return(psDBInit(dbServer, dbUsername, dbPassword, NULL));
     431}
  • trunk/psModules/src/config/pmConfig.h

    r5355 r5435  
    33 *  @author PAP, IfA
    44 *
    5  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2005-10-17 21:34:12 $
     5 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2005-10-20 23:06:24 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    8484);
    8585
     86/** pmConfigDB
     87 *
     88 * pmConfigDB shall use the site configuration data to open a database handle.
     89 * This is fairly straightforward at the moment, but will change when we beef up
     90 * security. (TBD)
     91 *
     92 */
     93psDB *pmConfigDB(
     94    psMetadata *site
     95);
     96
     97
    8698#endif
  • trunk/psModules/src/detrend/pmFlatField.c

    r5170 r5435  
    1818 *  @author Ross Harman, MHPCC
    1919 *
    20  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    21  *  @date $Date: 2005-09-28 20:43:52 $
     20 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     21 *  @date $Date: 2005-10-20 23:06:24 $
    2222 *
    2323 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3838
    3939
    40 bool pmFlatField(pmReadout *in, pmReadout *mask, const pmReadout *flat)
     40bool pmFlatField(
     41    pmReadout *in,
     42    const pmReadout *flat)
    4143{
    4244    // XXX: Not sure if this is correct.  Must consult with IfA.
    43     PS_ASSERT_PTR_NON_NULL(mask, false);
     45    PS_ASSERT_PTR_NON_NULL(in->mask, false);
    4446    int i = 0;
    4547    int j = 0;
    … …  
    5658    // Check for nulls
    5759    if (in == NULL) {
    58         return true;       // Readout may not have data in it
     60        return true;       // Readout might have data in it
    5961    } else if(flat==NULL) {
    6062        psError( PS_ERR_BAD_PARAMETER_NULL, true,
    … …  
    7476        return false;
    7577    }
    76     inMask = mask->image;
     78    inMask = in->mask;
    7779
    7880    // Check input image and its mask are not larger than flat image
  • trunk/psModules/src/detrend/pmFlatField.h

    r5170 r5435  
    1818 *  @author Ross Harman, MHPCC
    1919 *
    20  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    21  *  @date $Date: 2005-09-28 20:43:52 $
     20 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     21 *  @date $Date: 2005-10-20 23:06:24 $
    2222 *
    2323 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3737bool pmFlatField(
    3838    pmReadout *in,          ///< Readout with input image
    39     pmReadout *mask,        ///< Input image mask
    4039    const pmReadout *flat   ///< Readout with flat image
    4140);
  • trunk/psModules/src/detrend/pmNonLinear.c

    r5170 r5435  
    55 *  @author GLG, MHPCC
    66 *
    7  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2005-09-28 20:43:52 $
     7 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2005-10-20 23:06:24 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5656inFluxe, and the corresponding value in outFlux.  The image pixel will then
    5757be set to the value from outFlux.
     58 
     59XXX: Must assert that filename exists.  This should probably happen in
     60the lookup files.
    5861 *****************************************************************************/
    59 pmReadout *pmNonLinearityLookup(pmReadout *inputReadout,
    60                                 const psVector *inFlux,
    61                                 const psVector *outFlux)
     62pmReadout *pmNonLinearityLookup(
     63    pmReadout *inputReadout,
     64    const char *filename
     65)
    6266{
    6367    PS_ASSERT_PTR_NON_NULL(inputReadout,NULL);
    6468    PS_ASSERT_PTR_NON_NULL(inputReadout->image,NULL);
    6569    PS_ASSERT_IMAGE_TYPE(inputReadout->image, PS_TYPE_F32, NULL);
    66     PS_ASSERT_PTR_NON_NULL(inFlux,NULL);
    67     if (inFlux->n < 2) {
    68         psError(PS_ERR_UNKNOWN,true, "pmNonLinearityLookup(): input vector less than 2 elements.  Returning inputReadout image.");
    69         return(inputReadout);
    70     }
    71     PS_ASSERT_PTR_NON_NULL(outFlux,NULL);
    72     psS32 tableSize = inFlux->n;
    73     if (inFlux->n != outFlux->n) {
    74         tableSize = PS_MIN(inFlux->n, outFlux->n);
     70    psLookupTable *tmpLT = psLookupTableAlloc(filename, "%f %f", 0);
     71    psS32 numLines = psLookupTableRead(tmpLT);
     72    psS32 numPixels = 0;
     73    if (numLines < 2) {
    7574        psLogMsg(__func__, PS_LOG_WARN,
    76                  "WARNING: pmNonLinear.c: pmNonLinearityLookup(): input vectors have different sizes (%d, %d)\n", inFlux->n, outFlux->n);
    77     }
    78     PS_ASSERT_VECTOR_TYPE(inFlux, PS_TYPE_F32, NULL);
    79     PS_ASSERT_VECTOR_TYPE(outFlux, PS_TYPE_F32, NULL);
    80 
    81     psS32 i;
    82     psS32 j;
    83     psS32 binNum;
    84     psScalar x;
    85     psS32 numPixels = 0;
    86     psF32 slope;
    87 
    88     x.type.type = PS_TYPE_F32;
    89     for (i=0;i<inputReadout->image->numRows;i++) {
    90         for (j=0;j<inputReadout->image->numCols;j++) {
    91             x.data.F32 = inputReadout->image->data.F32[i][j];
    92             binNum = p_psVectorBinDisect((psVector *)inFlux, &x);
    93 
    94             if (binNum == -2) {
    95                 // We get here if x is below the table lookup range.
    96                 inputReadout->image->data.F32[i][j] = outFlux->data.F32[0];
    97                 numPixels++;
    98 
    99             } else if (binNum == -1) {
    100                 // We get here if x is above the table lookup range.
    101                 inputReadout->image->data.F32[i][j] = outFlux->data.F32[tableSize-1];
    102                 numPixels++;
    103 
    104             } else if (binNum < -2) {
    105                 // We get here if there was some other problem.
    106                 psError(PS_ERR_UNKNOWN,true, "pmNonLinearityLookup(): Could not perform p_psVectorBinDisect().  Returning inputReadout image.");
    107                 return(inputReadout);
    108                 numPixels++;
    109             } else {
    110                 // Perform linear interpolation.
    111                 slope = (outFlux->data.F32[binNum+1] - outFlux->data.F32[binNum]) /
    112                         (inFlux->data.F32[binNum+1]  - inFlux->data.F32[binNum]);
    113                 inputReadout->image->data.F32[i][j] = outFlux->data.F32[binNum] +
    114                                                       ((x.data.F32 - inFlux->data.F32[binNum]) * slope);
     75                 "WARNING: Lookup Table is too small.  Returning original pmReadout.\n");
     76    } else {
     77        for (psS32 i=0;i<inputReadout->image->numRows;i++) {
     78            for (psS32 j=0;j<inputReadout->image->numCols;j++) {
     79                psF64 tmpD = psLookupTableInterpolate(tmpLT, inputReadout->image->data.F32[i][j], 1);
     80                if (!isnan(tmpD)) {
     81                    inputReadout->image->data.F32[i][j] = tmpD;
     82                } else {
     83                    numPixels++;
     84                }
    11585            }
    11686        }
     87        if (numPixels > 0) {
     88            psLogMsg(__func__, PS_LOG_WARN,
     89                     "WARNING: pmNonLinear.c: pmNonLinearityLookup(): %d pixels outside table.", numPixels);
     90        }
    11791    }
    118     if (numPixels > 0) {
    119         psLogMsg(__func__, PS_LOG_WARN,
    120                  "WARNING: pmNonLinear.c: pmNonLinearityLookup(): %d pixels outside table.", numPixels);
    121     }
     92
    12293    return(inputReadout);
    12394}
  • trunk/psModules/src/detrend/pmNonLinear.h

    r5170 r5435  
    55 *  @author GLG, MHPCC
    66 *
    7  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2005-09-28 20:43:52 $
     7 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2005-10-20 23:06:24 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    1818#include "pmAstrometry.h"
    1919
    20 pmReadout *pmNonLinearityPolynomial(pmReadout *in,
    21                                     const psPolynomial1D *coeff);
     20pmReadout *pmNonLinearityPolynomial(
     21    pmReadout *in,
     22    const psPolynomial1D *coeff
     23);
    2224
    23 pmReadout *pmNonLinearityLookup(pmReadout *in,
    24                                 const psVector *inFlux,
    25                                 const psVector *outFlux);
     25pmReadout *pmNonLinearityLookup(
     26    pmReadout *in,
     27    const char *filename
     28);
    2629
    2730#endif
  • trunk/psModules/src/imsubtract/pmSubtractBias.c

    r5294 r5435  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-10-12 21:02:04 $
     8 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-20 23:06:24 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    282282XXX: The SDRS does not specify type support.  F32 is implemented here.
    283283 *****************************************************************************/
    284 pmReadout *pmSubtractBias(pmReadout *in,
    285                           void *fitSpec,
    286                           const psList *overscans,
    287                           pmOverscanAxis overScanAxis,
    288                           psStats *stat,
    289                           psS32 nBinOrig,
    290                           pmFit fit,
    291                           const pmReadout *bias)
     284pmReadout *pmSubtractBias(
     285    pmReadout *in,
     286    void *fitSpec,
     287    pmFit fit,
     288    bool overscan,
     289    psStats *stat,
     290    int nBin,
     291    const pmReadout *bias,
     292    const pmReadout *dark
     293)
    292294{
    293295    psTrace(".psModule.pmSubtracBias.pmSubtractBias", 4,
  • trunk/psModules/src/imsubtract/pmSubtractBias.h

    r5170 r5435  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-09-28 20:43:52 $
     8 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-20 23:06:24 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3838} pmFit;
    3939
    40 pmReadout *pmSubtractBias(pmReadout *in,                ///< The input pmReadout image
    41                           void *fitSpec,                ///< A polynomial or spline, defining the fit type.
    42                           const psList *overscans,      ///< A psList of overscan images
    43                           pmOverscanAxis overScanAxis,  ///< Defines how overscans are applied
    44                           psStats *stat,                ///< The statistic to be used in combining overscan data
    45                           int nBin,                     ///< The amount of binning to be done image pixels.
    46                           pmFit fit,                    ///< PM_FIT_SPLINE, PM_FIT_POLYNOMIAL, or PM_FIT_NONE
    47                           const pmReadout *bias);       ///< A possibly NULL bias pmReadout which is to be subtracted
     40pmReadout *pmSubtractBias(
     41    pmReadout *in,                      ///< The input pmReadout image
     42    void *fitSpec,                      ///< A polynomial or spline, defining the fit type.
     43    pmFit fit,                          ///< PM_FIT_SPLINE, PM_FIT_POLYNOMIAL, or PM_FIT_NONE
     44    bool overscan,
     45    psStats *stat,                      ///< The statistic to be used in combining overscan data
     46    int nBin,                           ///< The amount of binning to be done image pixels.
     47    const pmReadout *bias,              ///< A possibly NULL bias pmReadout which is to be subtracted
     48    const pmReadout *dark               ///< A possibly NULL bias pmReadout which is to be subtracted
     49)
     50// OLD: remove this
     51//    const psList *overscans,      ///< A psList of overscan images
     52//    pmOverscanAxis overScanAxis,  ///< Defines how overscans are applied
    4853
    4954#endif
  • trunk/psModules/src/objects/pmObjects.c

    r5255 r5435  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-10-10 19:53:40 $
     8 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-20 23:06:24 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    14451445XXX: What is mode?
    14461446XXX: The top, bottom of the contour is not correctly determined.
    1447 XXX EAM : this functions is using the model for the contour, but it should
     1447XXX EAM : this function is using the model for the contour, but it should
    14481448          be using only the image counts
    14491449*****************************************************************************/
  • trunk/psModules/test/astrom/tst_pmAstrometry.c

    r5169 r5435  
    11/** @file  tst_pmAstrometry.c
    22 *
    3  *  @brief Contains the tests for pmAstrometry.[ch].  Only the pmxxxAlloc()
     3 *  @brief Contains the tests: pmAstrometry.[ch].  Only the pmxxxAlloc()
    44 *  and psFree() functionality are used here.
    55 *
    66 *  @author George Gusciora, MHPCC
    77 *
    8  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-09-28 20:42:51 $
     8 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-20 23:06:24 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232                          };
    3333
     34#define CHIP_ALLOC_NAME "ChipName"
     35#define CELL_ALLOC_NAME "CellName"
     36
    3437psS32 main(psS32 argc, char* argv[])
    3538{
    … …  
    4447    // XXX: Do something more with these arguments.
    4548    const psMetadata *camera = psMetadataAlloc();
    46     psDB *db = NULL;
    47     pmFPA* fpa = pmFPAAlloc(camera, db);
     49    pmFPA* fpa = pmFPAAlloc(camera);
    4850
    4951    if (fpa == NULL) {
    50         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc returned a NULL.");
     52        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.");
    5153        return 1;
    5254    }
    5355
    5456    if (fpa->fromTangentPlane != NULL) {
    55         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->fromTangentPlane to NULL.");
     57        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->fromTangentPlane to NULL.");
    5658        return 2;
    5759    }
    5860
    5961    if (fpa->toTangentPlane != NULL) {
    60         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->toTangentPlane to NULL.");
     62        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->toTangentPlane to NULL.");
    6163        return 3;
    6264    }
    6365    if (fpa->projection != NULL) {
    64         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->projection to NULL.");
     66        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->projection to NULL.");
    6567        return 4;
    6668    }
    6769
    6870    if (fpa->concepts == NULL) {
    69         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->concepts.");
     71        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->concepts.");
    7072        return 5;
    7173    }
    7274
    73     if (fpa->analysis == NULL) {
    74         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->analysis.");
     75    if (fpa->analysis != NULL) {
     76        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->analysis to NULL.");
    7577        return 6;
    7678    }
    7779
    7880    if (fpa->camera != camera) {
    79         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->camera.");
     81        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->camera.");
    8082        return 7;
    8183    }
    8284
    8385    if (fpa->chips == NULL) {
    84         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->chips.");
     86        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->chips.");
    8587        return 8;
    8688    }
    8789
    88     if (fpa->header != NULL) {
    89         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->header to NULL.");
     90    if (fpa->private != NULL) {
     91        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc did not set ->private to NULL.");
    9092        return 9;
    9193    }
    9294
    93     if (fpa->db != db) {
    94         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc did not set ->db.");
     95    psFree(fpa);
     96    psFree(camera);
     97
     98    return 0;
     99}
     100
     101static psS32 testChipAlloc(void)
     102{
     103    const psMetadata *camera = psMetadataAlloc();
     104    pmFPA* fpa = pmFPAAlloc(camera);
     105    if (fpa == NULL) {
     106        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.");
     107        return 1;
     108    }
     109
     110    pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME);
     111    if (chip == NULL) {
     112        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL.");
     113        return 1;
     114    }
     115
     116    if (chip->col0 != -1) {
     117        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->col0 set improperly.\n");
     118        return 5;
     119    }
     120
     121    if (chip->row0 != -1) {
     122        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->row0 set improperly.\n");
     123        return 6;
     124    }
     125
     126    if (chip->toFPA != NULL) {
     127        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->toChip set improperly.\n");
     128        return 7;
     129    }
     130
     131    if (chip->fromFPA != NULL) {
     132        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->toFPA set improperly.\n");
     133        return 8;
     134    }
     135
     136    if (chip->concepts == NULL) {
     137        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->concepts set improperly.\n");
     138        return 21;
     139    } else {
     140        psMetadataItem *tmpMeta = psMetadataLookup(chip->concepts, "CHIP.NAME");
     141        if (0 != strcmp((char *) tmpMeta->data.V, CHIP_ALLOC_NAME)) {
     142            psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: The metadata was set improperly.\n");
     143            return (32);
     144        }
     145        // XXX: Code a test to ensure the metadata has the correct type
     146    }
     147
     148    if (chip->analysis != NULL) {
     149        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->analysis set improperly.\n");
    95150        return 10;
    96151    }
    97152
    98     psFree(camera);
    99     psFree(fpa);
    100 
    101     return 0;
    102 }
    103 
    104 static psS32 testChipAlloc(void)
    105 {
    106     const psMetadata *camera = psMetadataAlloc();
    107     psDB *db = NULL;
    108     pmFPA* fpa = pmFPAAlloc(camera, db);
    109     if (fpa == NULL) {
    110         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc returned a NULL.");
    111         return 1;
    112     }
    113 
    114     pmChip *chip = pmChipAlloc(fpa);
    115     if (chip == NULL) {
    116         psLogMsg(__func__,PS_LOG_ERROR, "pmChipAlloc returned a NULL.");
    117         return 1;
    118     }
    119 
    120     if (chip->col0 != -1) {
    121         psLogMsg(__func__, PS_LOG_ERROR, "chip->col0 set improperly.\n");
    122         return 5;
    123     }
    124 
    125     if (chip->row0 != -1) {
    126         psLogMsg(__func__, PS_LOG_ERROR, "chip->row0 set improperly.\n");
    127         return 6;
    128     }
    129 
    130     if (chip->toFPA != NULL) {
    131         psLogMsg(__func__, PS_LOG_ERROR, "chip->toChip set improperly.\n");
    132         return 7;
    133     }
    134 
    135     if (chip->fromFPA != NULL) {
    136         psLogMsg(__func__, PS_LOG_ERROR, "chip->toFPA set improperly.\n");
    137         return 8;
    138     }
    139 
    140     if (chip->concepts == NULL) {
    141         psLogMsg(__func__, PS_LOG_ERROR, "chip->concepts set improperly.\n");
    142         return 21;
    143     }
    144 
    145     if (chip->analysis == NULL) {
    146         psLogMsg(__func__, PS_LOG_ERROR, "chip->analysis set improperly.\n");
    147         return 10;
    148     }
    149 
    150153    if (chip->cells == NULL) {
    151         psLogMsg(__func__, PS_LOG_ERROR, "chip->cells set improperly.\n");
     154        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->cells set improperly.\n");
    152155        return 22;
    153156    }
    154157
    155158    if (chip->parent != fpa) {
    156         psLogMsg(__func__, PS_LOG_ERROR, "chip->parent set improperly.\n");
     159        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->parent set improperly.\n");
    157160        return 23;
    158161    }
    159162
    160163    if (chip->valid != false) {
    161         psLogMsg(__func__, PS_LOG_ERROR, "chip->valid set improperly.\n");
     164        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->valid set improperly.\n");
    162165        return 24;
    163166    }
    164167
    165     if (chip->extname != NULL) {
    166         psLogMsg(__func__, PS_LOG_ERROR, "chip->extname set improperly.\n");
     168    if (chip->private != NULL) {
     169        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: chip->private set improperly.\n");
    167170        return 25;
    168     }
    169 
    170     if (chip->pixels != NULL) {
    171         psLogMsg(__func__, PS_LOG_ERROR, "chip->pixels set improperly.\n");
    172         return 26;
    173     }
    174 
    175     if (chip->header != NULL) {
    176         psLogMsg(__func__, PS_LOG_ERROR, "chip->header set improperly.\n");
    177         return 27;
    178171    }
    179172
    … …  
    187180static psS32 testCellAlloc(void)
    188181{
    189     psDB *db = NULL;
    190182    const psMetadata *camera = psMetadataAlloc();
    191     pmFPA* fpa = pmFPAAlloc(camera, db);
     183    pmFPA* fpa = pmFPAAlloc(camera);
    192184    if (fpa == NULL) {
    193         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc returned a NULL.n");
    194         return 1;
    195     }
    196 
    197     pmChip *chip = pmChipAlloc(fpa);
     185        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.n");
     186        return 1;
     187    }
     188
     189    pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME);
    198190    if (chip == NULL) {
    199         psLogMsg(__func__,PS_LOG_ERROR, "pmChipAlloc returned a NULL.n");
     191        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL.n");
    200192        return 2;
    201193    }
    202194
    203     pmCell *cell = pmCellAlloc(chip);
     195    pmCell *cell = pmCellAlloc(chip, (psMetadata *) camera, CELL_ALLOC_NAME);
    204196    if (cell == NULL) {
    205         psLogMsg(__func__,PS_LOG_ERROR, "pmCellAlloc returned a NULL.n");
     197        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL.n");
    206198        return 3;
    207199    }
    208200
    209201    if (cell->col0 != -1) {
    210         psLogMsg(__func__, PS_LOG_ERROR, "cell->col0 set improperly.\n");
     202        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->col0 set improperly.\n");
    211203        return 5;
    212204    }
    213205
    214206    if (cell->row0 != -1) {
    215         psLogMsg(__func__, PS_LOG_ERROR, "cell->row0 set improperly.\n");
     207        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->row0 set improperly.\n");
    216208        return 6;
    217209    }
    218210
    219211    if (cell->toChip != NULL) {
    220         psLogMsg(__func__, PS_LOG_ERROR, "cell->toChip set improperly.\n");
     212        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toChip set improperly.\n");
    221213        return 7;
    222214    }
    223215
    224216    if (cell->toFPA != NULL) {
    225         psLogMsg(__func__, PS_LOG_ERROR, "cell->toFPA set improperly.\n");
     217        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toFPA set improperly.\n");
    226218        return 8;
    227219    }
    228220
    229221    if (cell->toSky != NULL) {
    230         psLogMsg(__func__, PS_LOG_ERROR, "cell->toSky set improperly.\n");
     222        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->toSky set improperly.\n");
    231223        return 9;
    232224    }
    233225
    234     if (cell->analysis == NULL) {
    235         psLogMsg(__func__, PS_LOG_ERROR, "cell->analysis set improperly.\n");
     226    if (cell->concepts == NULL) {
     227        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->concepts set improperly.\n");
     228        return 21;
     229    } else {
     230        psMetadataItem *tmpMeta = psMetadataLookup(cell->concepts, "CELL.NAME");
     231        if (0 != strcmp((char *) tmpMeta->data.V, CELL_ALLOC_NAME)) {
     232            psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: The metadata was set improperly.\n");
     233            return (32);
     234        }
     235        // XXX: Code a test to ensure the metadata has the correct type
     236    }
     237
     238    if (cell->camera != camera) {
     239        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->camera set improperly.\n");
     240        return 20;
     241    }
     242
     243    if (cell->analysis != NULL) {
     244        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->analysis set improperly.\n");
    236245        return 10;
    237246    }
    238247
    239     if (cell->concepts == NULL) {
    240         psLogMsg(__func__, PS_LOG_ERROR, "cell->concepts set improperly.\n");
    241         return 21;
    242     }
    243 
    244248    if (cell->readouts == NULL) {
    245         psLogMsg(__func__, PS_LOG_ERROR, "cell->readouts set improperly.\n");
     249        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->readouts set improperly.\n");
    246250        return 22;
    247251    }
    248252
    249253    if (cell->parent != chip) {
    250         psLogMsg(__func__, PS_LOG_ERROR, "cell->parent set improperly.\n");
     254        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->parent set improperly.\n");
    251255        return 23;
    252256    }
    253257
    254258    if (cell->valid != false) {
    255         psLogMsg(__func__, PS_LOG_ERROR, "cell->valid set improperly.\n");
     259        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->valid set improperly.\n");
    256260        return 24;
    257261    }
    258262
    259     if (cell->extname != NULL) {
    260         psLogMsg(__func__, PS_LOG_ERROR, "cell->extname set improperly.\n");
    261         return 25;
    262     }
    263 
    264     if (cell->pixels != NULL) {
    265         psLogMsg(__func__, PS_LOG_ERROR, "cell->pixels set improperly.\n");
    266         return 26;
    267     }
    268 
    269     if (cell->header != NULL) {
    270         psLogMsg(__func__, PS_LOG_ERROR, "cell->header set improperly.\n");
     263    if (cell->private != NULL) {
     264        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: cell->private set improperly.\n");
    271265        return 27;
    272266    }
    … …  
    282276static psS32 testReadoutAlloc(void)
    283277{
    284     psDB *db = NULL;
    285278    const psMetadata *camera = psMetadataAlloc();
    286     pmFPA* fpa = pmFPAAlloc(camera, db);
     279    pmFPA* fpa = pmFPAAlloc(camera);
    287280
    288281    if (fpa == NULL) {
    289         psLogMsg(__func__,PS_LOG_ERROR, "pmFPAAlloc returned a NULL.\n");
    290         return 1;
    291     }
    292 
    293     pmChip *chip = pmChipAlloc(fpa);
     282        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmFPAAlloc returned a NULL.\n");
     283        return 1;
     284    }
     285
     286    pmChip *chip = pmChipAlloc(fpa, "ChipName");
    294287    if (chip == NULL) {
    295         psLogMsg(__func__,PS_LOG_ERROR, "pmChipAlloc returned a NULL.\n");
     288        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmChipAlloc returned a NULL.\n");
    296289        return 2;
    297290    }
    298291
    299     pmCell *cell = pmCellAlloc(chip);
     292    pmCell *cell = pmCellAlloc(chip, (psMetadata *) camera, "CellName");
    300293    if (cell == NULL) {
    301         psLogMsg(__func__,PS_LOG_ERROR, "pmCellAlloc returned a NULL.\n");
     294        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmCellAlloc returned a NULL.\n");
    302295        return 3;
    303296    }
    … …  
    305298    pmReadout *readout = pmReadoutAlloc(cell);
    306299    if (readout == NULL) {
    307         psLogMsg(__func__,PS_LOG_ERROR, "pmReadoutAlloc returned a NULL.\n");
     300        psLogMsg(__func__,PS_LOG_ERROR, "TEST ERROR: pmReadoutAlloc returned a NULL.\n");
    308301        return 4;
    309302    }
    310303
    311304    if (readout->col0 != -1) {
    312         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->col0 set improperly.\n");
     305        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->col0 set improperly.\n");
    313306        return 5;
    314307    }
    315308
    316309    if (readout->row0 != -1) {
    317         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->row0 set improperly.\n");
     310        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->row0 set improperly.\n");
    318311        return 6;
    319312    }
    320313
    321314    if (readout->colBins != -1) {
    322         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->colBins set improperly.\n");
     315        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->colBins set improperly.\n");
    323316        return 7;
    324317    }
    325318
    326319    if (readout->rowBins != -1) {
    327         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->colBins set improperly.\n");
     320        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->colBins set improperly.\n");
    328321        return 8;
    329322    }
    330323
    331324    if (readout->image != NULL) {
    332         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->image set improperly.\n");
    333         return 9;
     325        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->image set improperly.\n");
     326        return 10;
    334327    }
    335328
    336329    if (readout->mask != NULL) {
    337         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->mask set improperly.\n");
    338         return 10;
     330        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->mask set improperly.\n");
     331        return 12;
     332    }
     333
     334    if (readout->weight != NULL) {
     335        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->weight set improperly.\n");
     336        return 14;
     337    }
     338
     339    if (readout->bias != NULL) {
     340        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->bias set improperly.\n");
     341        return 16;
    339342    }
    340343
    341344    if (readout->analysis == NULL) {
    342         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->analysis set improperly.\n");
    343         return 11;
    344     }
    345 
    346     if (readout->concepts == NULL) {
    347         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->concepts set improperly.\n");
    348         return 12;
     345        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->analysis set improperly.\n");
     346        return 18;
    349347    }
    350348
    351349    if (readout->parent != cell) {
    352         psLogMsg(__func__, PS_LOG_ERROR, "pmReadout->parent set improperly.\n");
    353         return 15;
     350        psLogMsg(__func__, PS_LOG_ERROR, "TEST ERROR: pmReadout->parent set improperly.\n");
     351        return 20;
    354352    }
    355353
    … …  
    362360    return 0;
    363361}
     362
  • trunk/psModules/test/config/Makefile.am

    r5169 r5435  
    44AM_CFLAGS  = @AM_CFLAGS@ $(PSMODULE_CFLAGS) $(SRCINC)
    55
    6 TESTS =
     6TESTS = \
     7    tst_pmConfig
     8
     9tst_pmConfig_SOURCES = tst_pmConfig.c
    710
    811check_PROGRAMS = $(TESTS)
    … …  
    1013TESTS_ENVIRONMENT = perl $(top_srcdir)/test/runTest --verified=$(srcdir)/verified
    1114
    12 tests:
     15tests: $(TESTS)
     16
     17EXTRA_DIST = verified
     18
     19CLEANFILES = $(TESTS) temp/*
    1320
    1421test: check
  • trunk/psModules/test/detrend/tst_pmFlatField.c

    r5169 r5435  
    2121 *  @author Ross Harman, MHPCC
    2222 *
    23  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2005-09-28 20:42:52 $
     23 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2005-10-20 23:06:24 $
    2525 *
    2626 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    8585    inReadout->row0 = 0;
    8686    inReadout->col0 = 0;
     87    CREATE_AND_SET_IMAGE(inMask, U8, 0, 3,3);
     88    inReadout->mask = inMask;
     89    PRINT_MATRIX((inReadout->mask),U8,"Input mask:");
    8790    PRINT_MATRIX(inImage,F64,"Input image:");
    88 
    89     CREATE_AND_SET_IMAGE(inMask,U8,0,3,3)
    90     pmReadout *inMaskReadout = pmReadoutAlloc(NULL);
    91     inMaskReadout->image = inMask;
    92     inMaskReadout->row0 = 0;
    93     inMaskReadout->col0 = 0;
    94     PRINT_MATRIX(inMask,U8,"Input mask:");
    9591
    9692    CREATE_AND_SET_IMAGE(flatImage1,F64,2.0,3,3)
    … …  
    10197    PRINT_MATRIX(flatImage1,F64,"Flat image:");
    10298
    103     if ( !pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     99    if ( !pmFlatField(inReadout, flatReadout) ) {
    104100        psError(PS_ERR_UNKNOWN,true,"Test A - Returned false should be true");
    105101        return 1;
    … …  
    116112    PRINT_MATRIX(flatImage2, F64, "Flat image:");
    117113    flatReadout->image = flatImage2;
    118     if ( !pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     114    if ( !pmFlatField(inReadout, flatReadout) ) {
    119115        psError(PS_ERR_UNKNOWN,true,"Test B - Returned false should be true");
    120116        return 2;
    121117    }
    122     PRINT_MATRIX(inMaskReadout->image, PS_TYPE_MASK_DATA, "Resulting mask:");
     118    PRINT_MATRIX(inReadout->mask, PS_TYPE_MASK_DATA, "Resulting mask:");
    123119    PRINT_MATRIX(inImage,F64,"Resulting image:");
    124120    printFooter(stdout, "pmFlatField", "Test B - Mask flat image data", true);
    … …  
    135131    psFree(inReadout->mask);
    136132    inReadout->mask = mask1;
    137     if ( !pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     133    if ( !pmFlatField(inReadout, flatReadout) ) {
    138134        psError(PS_ERR_UNKNOWN,true,"Test C - Returned false should be true");
    139135        return 3;
    … …  
    149145    printNegativeTestHeader(stdout,"pmFlatField", "Test D - Attempt to use null flat readout",
    150146                            "Null not allowed for flat readout", 0);
    151     if( pmFlatField(inReadout, inMaskReadout, NULL) ) {
     147    if( pmFlatField(inReadout, NULL) ) {
    152148        psError(PS_ERR_UNKNOWN,true,"Test D - Returned true should be false");
    153149        return 4;
    … …  
    162158    psImage *temp = inReadout->image;
    163159    inReadout->image = NULL;
    164     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     160    if ( pmFlatField(inReadout, flatReadout) ) {
    165161        psError(PS_ERR_UNKNOWN,true,"Test E - Returned true should be false" );
    166162        return 5;
    167163    }
    168     inReadout->image = temp;
     164    inReadout->image = temp    ;
    169165    printFooter(stdout, "pmFlatField", "Test E - Attempt to use null input image", true);
    170166    printf("\n\n\n");
    … …  
    176172    temp = flatReadout->image;
    177173    flatReadout->image = NULL;
    178     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     174    if ( pmFlatField(inReadout, flatReadout) ) {
    179175        psError(PS_ERR_UNKNOWN,true,"Test F - Returned true should be false" );
    180176        return 6;
    … …  
    191187    temp = flatReadout->image;
    192188    flatReadout->image = smallFlat;
    193     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     189    if ( pmFlatField(inReadout, flatReadout) ) {
    194190        psError(PS_ERR_UNKNOWN,true,"Test G - Returned true should be false");
    195191        return 7;
    … …  
    198194    printFooter(stdout, "pmFlatField", "Test G - Attempt to use input image bigger than flat image", true);
    199195    printf("\n\n\n");
    200 
    201196
    202197    // Test H - Attempt to use input image mask bigger than flat image
    … …  
    204199                            "Input image mask size exceeds that of flat image", 0);
    205200    CREATE_AND_SET_IMAGE(largeMask,F64,0.0,5,5);
    206     temp = inReadout->mask;
    207     inMaskReadout->image = largeMask;
    208     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     201    inReadout->mask = largeMask;
     202    if ( pmFlatField(inReadout, flatReadout) ) {
    209203        psError(PS_ERR_UNKNOWN,true,"Test H - Returned true should be false");
    210204        return 8;
    211205    }
    212     inReadout->mask = temp;
    213206    printFooter(stdout, "pmFlatField", "Test H - Attempt to use input image mask bigger than flat image", true);
    214207    printf("\n\n\n");
    215 
     208    inReadout->mask = mask1;
    216209
    217210    // Test I - Attempt to use offset greater than input image
    … …  
    220213    *(int*)&inReadout->col0 = 50;
    221214    *(int*)&inReadout->row0 = 50;
    222     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     215    if ( pmFlatField(inReadout, flatReadout) ) {
    223216        psError(PS_ERR_UNKNOWN,true,"Test I - Returned true should be false");
    224217        return 9;
    … …  
    234227                            "Complex types not allowed for input image", 0);
    235228    *(psElemType* ) & inReadout->image->type.type = PS_TYPE_C64;
    236     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     229    if ( pmFlatField(inReadout, flatReadout) ) {
    237230        psError(PS_ERR_UNKNOWN,true,"Test J - Returned true should be false");
    238231        return 10;
    … …  
    247240                            "Complex types not allowed for flat image", 0);
    248241    *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_C64;
    249     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     242    if ( pmFlatField(inReadout, flatReadout) ) {
    250243        psError(PS_ERR_UNKNOWN,true,"Test K - Returned ture should be false");
    251244        return 11;
    … …  
    260253                            "Input and flat image types differ", 0);
    261254    *(psElemType* ) & flatReadout->image->type.type = PS_TYPE_F32;
    262     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     255    if ( pmFlatField(inReadout, flatReadout) ) {
    263256        psError(PS_ERR_UNKNOWN,true,"Test L - Returned true should be false");
    264257        return 12;
    … …  
    273266                            "Mask must be PS_TYPE_MASK type", 0);
    274267    *(psElemType* ) & inReadout->mask->type.type = PS_TYPE_F32;
    275     if ( pmFlatField(inReadout, inMaskReadout, flatReadout) ) {
     268    if ( pmFlatField(inReadout, flatReadout) ) {
    276269        psError(PS_ERR_UNKNOWN,true,"Test M - Returned true should be false");
    277270        return 13;
    … …  
    283276
    284277    // Free memory
    285     psFree(inMask);
    286     psFree(largeMask);
    287     inMaskReadout->image = NULL;
    288     psFree(inMaskReadout);
    289278    psFree(inReadout);
    290279    psFree(flatReadout);
    … …  
    293282    //psFree(flatImage1);
    294283    psFree(smallFlat);
     284    psFree(largeMask);
    295285
    296286    return 0;
  • trunk/psModules/test/detrend/tst_pmNonLinear.c

    r5169 r5435  
    1 /** @file tst_pmNonLinear.c
     1/* @file tst_pmNonLinear.c
    22 *
    33 *  @brief Contains the tests for pmNonLinear.c:
    … …  
    1616 *  @author GLG, MHPCC
    1717 *
    18  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    19  *  @date $Date: 2005-09-28 20:42:52 $
     18 *  XXX: Add tests in which the lookup file has incorrect number of entries,
     19 *  and where the data is outside the pmReadout range.
     20 *
     21 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     22 *  @date $Date: 2005-10-20 23:06:24 $
    2023 *
    2124 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3740                          };
    3841
    39 
    40 int main(int argc, char* argv[])
    41 {
    42     psLogSetFormat("HLNM");
    43     return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv);
    44 }
    45 
    4642#define NUM_ROWS 8
    4743#define NUM_COLS 8
     44#define LOOKUP_FILENAME ".tmp_tst_pmNonLinearLookupFile"
     45int main(int argc, char* argv[])
     46{
     47    psLogSetFormat("HLNM");
     48    //
     49    // We generate a lookup file for future tests.  We should probably remove
     50    // it when we're done.
     51    //
     52    FILE *fp = fopen(LOOKUP_FILENAME, "w");
     53    ;
     54    for (psS32 i=0;i<PS_MAX(NUM_COLS, NUM_ROWS)*3;i++) {
     55        fprintf(fp, "%f %f\n", (float) i, (float) (2 * i));
     56    }
     57    fclose(fp);
     58
     59    //    system("rm LOOKUP_FILENAME");
     60    return !runTestSuite(stderr, "Test Point Driver", tests, argc, argv);
     61}
     62
    4863int doNonLinearityPolynomialTest(int numCols, int numRows)
    4964{
    … …  
    105120    float expect;
    106121    int testStatus = true;
    107     int tableSize = PS_MAX(numCols, numRows)*2;
    108122    psImage *myImage = psImageAlloc(numCols, numRows, PS_TYPE_F32);
    109123    pmReadout *myReadout = pmReadoutAlloc(NULL);
    110124    myReadout->image = myImage;
    111     psVector *in = psVectorAlloc(tableSize, PS_TYPE_F32);
    112     psVector *out = psVectorAlloc(tableSize, PS_TYPE_F32);
    113125
    114126    printPositiveTestHeader(stdout, "pmNonLinear", "doNonLinearityLookupTest");
    … …  
    119131    }
    120132
    121     for (i=0;i<tableSize;i++) {
    122         in->data.F32[i] = (float) i;
    123         out->data.F32[i] = (float) (2 * i);
    124     }
    125 
    126     myReadout = pmNonLinearityLookup(myReadout, in, out);
     133    myReadout = pmNonLinearityLookup(myReadout, LOOKUP_FILENAME);
    127134    for (i=0;i<numRows;i++) {
    128135        for (j=0;j<numCols;j++) {
    … …  
    136143    }
    137144
    138 
    139     psFree(myReadout);
    140     psFree(in);
    141     psFree(out);
     145    psFree(myReadout);
    142146    printFooter(stdout, "pmNonLinear", "doNonLinearityLookupTest", true);
    143147    return(testStatus);
    … …  
    220224int test03()
    221225{
    222     int i;
    223     int j;
    224     int testStatus = true;
    225     int tableSize = PS_MAX(NUM_COLS, NUM_ROWS)*3;
     226    int testStatus = true;
    226227    psImage *myImage = psImageAlloc(NUM_COLS, NUM_ROWS, PS_TYPE_F32);
    227228    pmReadout *myReadout = pmReadoutAlloc(NULL);
    228229    pmReadout *rc = NULL;
    229230    myReadout->image = myImage;
    230     psVector *in = psVectorAlloc(tableSize, PS_TYPE_F32);
    231     psVector *inOne = psVectorAlloc(1, PS_TYPE_F32);
    232     psVector *inSmall = psVectorAlloc(tableSize-1, PS_TYPE_F32);
    233     psVector *inBig = psVectorAlloc(tableSize+1, PS_TYPE_F32);
    234     psVector *out = psVectorAlloc(tableSize, PS_TYPE_F32);
    235     psVector *outOne = psVectorAlloc(1, PS_TYPE_F32);
    236     psVector *outSmall = psVectorAlloc(tableSize-1, PS_TYPE_F32);
    237     psVector *outBig = psVectorAlloc(tableSize+1, PS_TYPE_F32);
    238231
    239232    test03Init(myReadout);
    240     for (i=0;i<tableSize;i++) {
    241         in->data.F32[i] = (float) i;
    242         out->data.F32[i] = (float) (2 * i);
    243         inBig->data.F32[i] = (float) i;
    244         outBig->data.F32[i] = (float) (2 * i);
    245         if (i < tableSize-1) {
    246             inSmall->data.F32[i] = (float) i;
    247             outSmall->data.F32[i] = (float) (2 * i);
    248         }
    249     }
    250     inBig->data.F32[tableSize] = (float) tableSize;
    251     outBig->data.F32[tableSize] = (float) (2 * tableSize);
    252     inOne->data.F32[0] = 0.0;
    253     outOne->data.F32[0] = 0.0;
    254 
    255233    printf("------------------------------------------------------------\n");
    256234    printf("Calling pmNonLinearityLookup() with NULL input pmReadout.  Should generate error, return NULL.\n");
    257     rc = pmNonLinearityLookup(NULL, in, out);
     235    rc = pmNonLinearityLookup(NULL, LOOKUP_FILENAME);
    258236    if (rc != NULL) {
    259237        printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n");
    … …  
    265243    psImage *tmpImage = myReadout->image;
    266244    myReadout->image = NULL;
    267     rc = pmNonLinearityLookup(myReadout, in, out);
     245    rc = pmNonLinearityLookup(myReadout, LOOKUP_FILENAME);
    268246    if (rc != NULL) {
    269247        printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n");
    … …  
    273251
    274252    printf("------------------------------------------------------------\n");
    275     printf("Calling pmNonLinearityLookup() with NULL inFlux psVector.  Should generate error, return NULL.\n");
    276     rc = pmNonLinearityLookup(myReadout, NULL, out);
    277     if (rc != NULL) {
    278         printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n");
    279         testStatus = false;
    280     }
    281 
    282     printf("------------------------------------------------------------\n");
    283     printf("Calling pmNonLinearityLookup() with NULL outFlux psVector.  Should generate error, return NULL.\n");
    284     rc = pmNonLinearityLookup(myReadout, in, NULL);
    285     if (rc != NULL) {
    286         printf("TEST ERROR: pmNonLinearityPolynomial() returned a non-NULL pmReadout\n");
    287         testStatus = false;
    288     }
    289 
    290     test03Init(myReadout);
    291     printf("------------------------------------------------------------\n");
    292     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    293     rc = pmNonLinearityLookup(myReadout, in, outBig);
     253    printf("Calling pmNonLinearityLookup() with non-existent lookup file.\n");
     254    rc = pmNonLinearityLookup(myReadout, "I_DONT_EXIST");
    294255    if (rc == NULL) {
    295256        printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    296257        testStatus = false;
    297258    }
    298     for (i=0;i<NUM_ROWS;i++) {
    299         for (j=0;j<NUM_COLS;j++) {
    300             psF32 expect = (float) (2 * (i + j));
    301             psF32 actual = rc->image->data.F32[i][j];
    302             if (FLT_EPSILON < fabs(expect - actual)) {
    303                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    304                 testStatus = false;
    305             }
    306         }
    307     }
    308 
    309 
    310     test03Init(myReadout);
    311     printf("------------------------------------------------------------\n");
    312     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    313     rc = pmNonLinearityLookup(myReadout, in, outSmall);
    314     if (rc == NULL) {
    315         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    316         testStatus = false;
    317     }
    318     for (i=0;i<NUM_ROWS;i++) {
    319         for (j=0;j<NUM_COLS;j++) {
    320             psF32 expect = (float) (2 * (i + j));
    321             psF32 actual = rc->image->data.F32[i][j];
    322             if (FLT_EPSILON < fabs(expect - actual)) {
    323                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    324                 testStatus = false;
    325             }
    326         }
    327     }
    328 
    329     test03Init(myReadout);
    330     printf("------------------------------------------------------------\n");
    331     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    332     rc = pmNonLinearityLookup(myReadout, inSmall, out);
    333     if (rc == NULL) {
    334         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    335         testStatus = false;
    336     }
    337     for (i=0;i<NUM_ROWS;i++) {
    338         for (j=0;j<NUM_COLS;j++) {
    339             psF32 expect = (float) (2 * (i + j));
    340             psF32 actual = rc->image->data.F32[i][j];
    341             if (FLT_EPSILON < fabs(expect - actual)) {
    342                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    343                 testStatus = false;
    344             }
    345         }
    346     }
    347 
    348     test03Init(myReadout);
    349     printf("------------------------------------------------------------\n");
    350     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    351     rc = pmNonLinearityLookup(myReadout, inBig, out);
    352     if (rc == NULL) {
    353         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    354         testStatus = false;
    355     }
    356     for (i=0;i<NUM_ROWS;i++) {
    357         for (j=0;j<NUM_COLS;j++) {
    358             psF32 expect = (float) (2 * (i + j));
    359             psF32 actual = rc->image->data.F32[i][j];
    360             if (FLT_EPSILON < fabs(expect - actual)) {
    361                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    362                 testStatus = false;
    363             }
    364         }
    365     }
    366 
    367     test03Init(myReadout);
    368     printf("------------------------------------------------------------\n");
    369     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    370     rc = pmNonLinearityLookup(myReadout, inSmall, outBig);
    371     if (rc == NULL) {
    372         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    373         testStatus = false;
    374     }
    375     for (i=0;i<NUM_ROWS;i++) {
    376         for (j=0;j<NUM_COLS;j++) {
    377             psF32 expect = (float) (2 * (i + j));
    378             psF32 actual = rc->image->data.F32[i][j];
    379             if (FLT_EPSILON < fabs(expect - actual)) {
    380                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    381                 testStatus = false;
    382             }
    383         }
    384     }
    385 
    386     test03Init(myReadout);
    387     printf("------------------------------------------------------------\n");
    388     printf("Calling pmNonLinearityLookup() with size difference in inFlux/outFLux psVectors.  Should generate warning.\n");
    389     rc = pmNonLinearityLookup(myReadout, inBig, outSmall);
    390     if (rc == NULL) {
    391         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    392         testStatus = false;
    393     }
    394     for (i=0;i<NUM_ROWS;i++) {
    395         for (j=0;j<NUM_COLS;j++) {
    396             psF32 expect = (float) (2 * (i + j));
    397             psF32 actual = rc->image->data.F32[i][j];
    398             if (FLT_EPSILON < fabs(expect - actual)) {
    399                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    400                 testStatus = false;
    401             }
    402         }
    403     }
    404 
    405     test03Init(myReadout);
    406     printf("------------------------------------------------------------\n");
    407     printf("Calling pmNonLinearityLookup() with inFlux psVector size 1.  Should generate error, return original pmReadout.\n");
    408     rc = pmNonLinearityLookup(myReadout, inOne, out);
    409     if (rc != myReadout) {
    410         printf("TEST ERROR: pmNonLinearityPolynomial() did not return the original pmReadout\n");
    411         testStatus = false;
    412     }
    413     for (i=0;i<NUM_ROWS;i++) {
    414         for (j=0;j<NUM_COLS;j++) {
    415             psF32 expect = (float) ((i + j));
    416             psF32 actual = rc->image->data.F32[i][j];
    417             if (FLT_EPSILON < fabs(expect - actual)) {
    418                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    419                 testStatus = false;
    420             }
    421         }
    422     }
     259
    423260
    424261    printf("------------------------------------------------------------\n");
    425262    printf("Calling pmNonLinearityLookup() with one pixels outside inFlux range.  Should generate warnings.\n");
    426     test03Init(myReadout);
    427     myReadout->image->data.F32[0][0] = -1;
    428     rc = pmNonLinearityLookup(myReadout, in, out);
    429     if (rc == NULL) {
    430         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    431         testStatus = false;
    432     }
    433     for (i=0;i<NUM_ROWS;i++) {
    434         for (j=0;j<NUM_COLS;j++) {
    435             psF32 expect = (float) (2 * (i + j));
    436             psF32 actual = rc->image->data.F32[i][j];
    437             if(i==0 && j==0) {
    438                 if(actual != 0.0) {
    439                     printf("TEST ERROR: image[%d][%d] is %f, should be %f\n",i,j,actual,0.0);
    440                 }
    441             } else {
    442                 if (FLT_EPSILON < fabs(expect - actual)) {
    443                     printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    444                     testStatus = false;
    445                 }
    446             }
    447         }
    448     }
    449 
    450     printf("------------------------------------------------------------\n");
    451     printf("Calling pmNonLinearityLookup() with one pixels outside inFlux range.  Should generate warnings.\n");
    452     test03Init(myReadout);
    453     myReadout->image->data.F32[NUM_ROWS-1][NUM_COLS-1] = 100;
    454     rc = pmNonLinearityLookup(myReadout, in, out);
    455     if (rc == NULL) {
    456         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    457         testStatus = false;
    458     }
    459     for (i=0;i<NUM_ROWS;i++) {
    460         for (j=0;j<NUM_COLS;j++) {
    461             psF32 expect = (float) (2 * (i + j));
    462             psF32 actual = rc->image->data.F32[i][j];
    463             if(i==(NUM_ROWS-1) && j==(NUM_COLS-1)) {
    464                 if(actual != (tableSize-1)*2) {
    465                     printf("TEST ERROR: image[%d][%d] is %f, should be %f\n",i,j,actual,(tableSize-1)*2.0);
    466                 }
    467             } else {
    468                 if (FLT_EPSILON < fabs(expect - actual)) {
    469                     printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    470                     testStatus = false;
    471                 }
    472             }
    473         }
    474     }
    475 
    476     test03Init(myReadout);
    477     printf("------------------------------------------------------------\n");
    478     printf("Calling pmNonLinearityLookup() with image values not in vector.\n");
    479     myReadout->image->data.F32[0][0] = 0.5;
    480     rc = pmNonLinearityLookup(myReadout, in, out);
    481     if (rc == NULL) {
    482         printf("TEST ERROR: pmNonLinearityPolynomial() returned a NULL pmReadout\n");
    483         testStatus = false;
    484     }
    485     for (i=0;i<NUM_ROWS;i++) {
    486         for (j=0;j<NUM_COLS;j++) {
    487             psF32 expect = (float) (2 * (i + j));
    488             if(i==0 && j==0) {
    489                 expect = 1.0;
    490             }
    491             psF32 actual = rc->image->data.F32[i][j];
    492             if (FLT_EPSILON < fabs(expect - actual)) {
    493                 printf("TEST ERROR: image[%d][%d] is %f, should be %f\n", i, j, actual, expect);
    494                 testStatus = false;
    495             }
    496         }
    497     }
    498 
    499     psFree(myReadout);
    500     psFree(in);
    501     psFree(inOne);
    502     psFree(inSmall);
    503     psFree(inBig);
    504     psFree(out);
    505     psFree(outOne);
    506     psFree(outSmall);
    507     psFree(outBig);
     263
     264    psFree(myReadout);
    508265
    509266    printFooter(stdout, "pmNonLinear", "Testing bad input parameter conditions.", true);
  • trunk/psModules/test/objects/tst_pmObjects01.c

    r5258 r5435  
    1 /** @file tst_pmFindObjects.c
     1/** @file tst_pmObjects.c
    22 *
    3  *  @brief Contains the tests for pmSubtractSky.c:
     3 *  @brief Contains the tests for pmObjects.c:
    44 *
    55 * test00: This code will ...
    … …  
    99 * XXX: Must test
    1010 *       pmSourceRoughClass
     11 *  many others...
     12 *
    1113 *
    1214 * XXX: Must test output results for many other functions.
    … …  
    2325Weakly Tested:
    2426    pmSourceMoments()
    25  
     27    most of psObjects.c is not tested
    2628 *
    27  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    28  *  @date $Date: 2005-10-10 21:55:42 $
     29 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     30 *  @date $Date: 2005-10-20 23:06:24 $
    2931 *
    3032 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4749//static int test06(void);
    4850//static int test07(void);
    49 /*
    50 static int test08(void);
     51//static int test08(void);
    5152static int test09(void);
    5253static int test15(void);
    5354static int test16(void);
    5455static int test20(void);
    55 */
    5656testDescription tests[] = {
    5757                              {test00, 000, "pmObjects: structure allocators and deallocators", true, false},
    … …  
    6363                              //                              {test06, 001, "pmObjects: pmSourceSetPixelsCircle()", true, false},
    6464                              //                              {test07, 001, "pmObjects: pmMin()", true, false},
    65                               /*
    66                                                             {test08, 001, "pmObjects: pmSourceModelGuess()", true, false},
    67                                                             {test09, 001, "pmObjects: pmSourceContour()", true, false},
    68                                                             {test15, 001, "pmObjects: pmSourceAddModel()", true, false},
    69                                                             {test16, 001, "pmObjects: pmSourceSubModel()", true, false},
    70                                                             {test20, 001, "pmObjects: pmSourceSubModel()", true, false},
    71                               */
     65                              //                              {test08, 001, "pmObjects: pmSourceModelGuess()", true, false},
     66                              {test09, 001, "pmObjects: pmSourceContour()", true, false},
     67                              {test15, 001, "pmObjects: pmSourceAddModel()", true, false},
     68                              {test16, 001, "pmObjects: pmSourceSubModel()", true, false},
     69                              {test20, 001, "pmObjects: pmSourceSubModel()", true, false},
    7270                              {NULL}
    7371                          };
    … …  
    975973}
    976974
     975#define TST09_NUM_ROWS 70
     976#define TST09_NUM_COLS 70
     977#define TST09_SKY 5.0
     978#define TST09_INNER_RADIUS 3
     979#define TST09_OUTER_RADIUS 10
     980#define LEVEL (TST09_SKY + 10.0)
     981/******************************************************************************
     982test09(): We first test pmSourceContour() with various NULL and unallowable
     983input parameters.
     984 
     985XXX: We don't verify the numbers.
     986 *****************************************************************************/
     987int test09( void )
     988{
     989    bool testStatus = true;
     990    psImage *imgData = psImageAlloc(TST09_NUM_COLS, TST09_NUM_ROWS, PS_TYPE_F32);
     991    psImageInit(imgData, TST09_SKY);
     992    psImage *imgMask = psImageAlloc(TST09_NUM_COLS, TST09_NUM_ROWS, PS_TYPE_U8);
     993    psImageInit(imgMask, 0);
     994    pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST09_NUM_ROWS / 2),
     995                                  (psF32) (TST09_NUM_COLS / 2),
     996                                  200.0,
     997                                  PM_PEAK_LONE);
     998    pmSource *tmpSource = pmSourceAlloc();
     999    tmpSource->pixels = imgData;
     1000    tmpSource->mask = imgMask;
     1001    tmpSource->peak = tmpPeak;
     1002    psBool rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0);
     1003    if (rc == false) {
     1004        printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n");
     1005        testStatus = false;
     1006    }
     1007
     1008    printf("----------------------------------------------------------------------------------\n");
     1009    printf("Calling pmSourceContour with NULL pmSource .  Should generate error, return FALSE.\n");
     1010    rc = pmSourceContour(NULL, imgData, LEVEL, PS_CONTOUR_CRUDE);
     1011    if (rc != false) {
     1012        printf("TEST ERROR: pmSourceContour() returned TRUE.\n");
     1013        testStatus = false;
     1014        psFree(rc);
     1015    }
     1016
     1017    printf("----------------------------------------------------------------------------------\n");
     1018    printf("Calling pmSourceContour with NULL psImage .  Should generate error, return FALSE.\n");
     1019    rc = pmSourceContour(tmpSource, NULL, LEVEL, PS_CONTOUR_CRUDE);
     1020    if (rc != FALSE) {
     1021        printf("TEST ERROR: pmSourceContour() returned TRUE.\n");
     1022        testStatus = false;
     1023        psFree(rc);
     1024    }
     1025
     1026    //
     1027    // XXX: pmSourceContour() has a problem with contour tops/bottoms.
     1028    // Must correct this.
     1029    //
     1030    if (1) {
     1031        printf("----------------------------------------------------------------------------------\n");
     1032        printf("Calling pmSourceContour with acceptable data.\n");
     1033        printf("NOTE: must figure out the parameters for this test to be meaningful.\n");
     1034        tmpSource->modelPSF->params->data.F32[0] = TST09_SKY;
     1035        tmpSource->modelPSF->params->data.F32[1] = 15.0;
     1036        tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST09_NUM_ROWS / 2);
     1037        tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST09_NUM_COLS / 2);
     1038        tmpSource->modelPSF->params->data.F32[4] = 2.0;
     1039        tmpSource->modelPSF->params->data.F32[5] = 2.0;
     1040        tmpSource->modelPSF->params->data.F32[6] = 2.0;
     1041        rc = pmSourceContour(tmpSource, imgData, LEVEL, PS_CONTOUR_CRUDE);
     1042        if (rc == false) {
     1043            printf("TEST ERROR: pmSourceContour() returned FALSE.\n");
     1044            testStatus = false;
     1045        } else {
     1046            psFree(rc);
     1047        }
     1048    }
     1049
     1050    psFree(tmpSource);
     1051    return(testStatus);
     1052}
     1053
     1054#define TST15_NUM_ROWS 100
     1055#define TST15_NUM_COLS 100
     1056#define TST15_SKY 10.0
     1057#define TST15_INNER_RADIUS 3
     1058#define TST15_OUTER_RADIUS 5
     1059/******************************************************************************
     1060test15(): We first test pmSourceAddModel() with various NULL and unallowable
     1061input parameters.
     1062 
     1063XXX: We don't verify the numbers.
     1064 *****************************************************************************/
     1065int test15( void )
     1066{
     1067    bool testStatus = true;
     1068    psImage *imgData = psImageAlloc(TST15_NUM_COLS, TST15_NUM_ROWS, PS_TYPE_F32);
     1069    psImageInit(imgData, TST15_SKY);
     1070    psImage *imgMask = psImageAlloc(TST15_NUM_COLS, TST15_NUM_ROWS, PS_TYPE_U8);
     1071    psImageInit(imgMask, 0);
     1072    pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST15_NUM_ROWS / 2),
     1073                                  (psF32) (TST15_NUM_COLS / 2),
     1074                                  200.0,
     1075                                  PM_PEAK_LONE);
     1076    pmSource *tmpSource = pmSourceAlloc();
     1077    tmpSource->pixels = imgData;
     1078    tmpSource->mask = imgMask;
     1079    tmpSource->peak = tmpPeak;
     1080    psBool rc = pmSourceLocalSky(tmpSource, PS_STAT_SAMPLE_MEAN, 10.0);
     1081    if (rc == false) {
     1082        printf("TEST ERROR: pmSourceLocalSky() returned a FALSE pmSource.\n");
     1083        testStatus = false;
     1084    }
     1085
     1086
     1087    tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS);
     1088    tmpSource->modelPSF->params->data.F32[0] = 5.0;
     1089    tmpSource->modelPSF->params->data.F32[1] = 70.0;
     1090    tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST15_NUM_ROWS / 2);
     1091    tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST15_NUM_COLS / 2);
     1092    tmpSource->modelPSF->params->data.F32[4] = 1.0;
     1093    tmpSource->modelPSF->params->data.F32[5] = 1.0;
     1094    tmpSource->modelPSF->params->data.F32[6] = 2.0;
     1095
     1096    printf("----------------------------------------------------------------------------------\n");
     1097    printf("Calling pmSourceAddModel with NULL psImage.  Should generate error, return FALSE.\n");
     1098    rc = pmSourceAddModel(NULL, tmpSource, true);
     1099    if (rc == true) {
     1100        printf("TEST ERROR: pmSourceAddModel() returned TRUE.\n");
     1101        testStatus = false;
     1102    }
     1103
     1104    printf("----------------------------------------------------------------------------------\n");
     1105    printf("Calling pmSourceAddModel with NULL psSrc.  Should generate error, return FALSE.\n");
     1106    rc = pmSourceAddModel(imgData, NULL, true);
     1107    if (rc == true) {
     1108        printf("TEST ERROR: pmSourceAddModel() returned TRUE.\n");
     1109        testStatus = false;
     1110    }
     1111
     1112    printf("----------------------------------------------------------------------------------\n");
     1113    printf("Calling pmSourceAddModel with acceptable data.\n");
     1114    rc = pmSourceAddModel(imgData, tmpSource, true);
     1115    if (rc != true) {
     1116        printf("TEST ERROR: pmSourceAddModel() returned FALSE.\n");
     1117        testStatus = false;
     1118    }
     1119
     1120    psFree(tmpSource);
     1121    psFree(imgData);
     1122    return(testStatus);
     1123}
     1124
     1125#define TST16_NUM_ROWS 100
     1126#define TST16_NUM_COLS 100
     1127#define TST16_SKY 10.0
     1128#define TST16_INNER_RADIUS 3
     1129#define TST16_OUTER_RADIUS 5
     1130/******************************************************************************
     1131test16(): We first test pmSourceSubModel() with various NULL and unallowable
     1132input parameters.
     1133 
     1134XXX: We don't verify the numbers.
     1135 *****************************************************************************/
     1136int test16( void )
     1137{
     1138    bool testStatus = true;
     1139    psImage *imgData = psImageAlloc(TST16_NUM_COLS, TST16_NUM_ROWS, PS_TYPE_F32);
     1140    for (psS32 i = 0 ; i < imgData->numRows; i++) {
     1141        for (psS32 j = 0 ; j < imgData->numCols; j++) {
     1142            imgData->data.F32[i][j] = TST16_SKY;
     1143        }
     1144    }
     1145    pmSource *tmpSource = NULL;
     1146    psBool rc = false;
     1147
     1148    pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST16_NUM_ROWS / 2),
     1149                                  (psF32) (TST16_NUM_COLS / 2),
     1150                                  200.0,
     1151                                  PM_PEAK_LONE);
     1152
     1153    printf("Calling pmSourceLocalSky with valid data.\n");
     1154    tmpPeak->x = (psF32) (TST16_NUM_ROWS / 2);
     1155    tmpPeak->y = (psF32) (TST16_NUM_COLS / 2);
     1156    tmpSource = pmSourceLocalSky(imgData,
     1157                                 tmpPeak,
     1158                                 PS_STAT_SAMPLE_MEAN,
     1159                                 (psF32) TST16_INNER_RADIUS,
     1160                                 (psF32) TST16_OUTER_RADIUS);
     1161
     1162    if (tmpSource == NULL) {
     1163        printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource.\n");
     1164        testStatus = false;
     1165    }
     1166
     1167    tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS);
     1168    tmpSource->modelPSF->params->data.F32[0] = 5.0;
     1169    tmpSource->modelPSF->params->data.F32[1] = 70.0;
     1170    tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST16_NUM_ROWS / 2);
     1171    tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST16_NUM_COLS / 2);
     1172    tmpSource->modelPSF->params->data.F32[4] = 1.0;
     1173    tmpSource->modelPSF->params->data.F32[5] = 1.0;
     1174    tmpSource->modelPSF->params->data.F32[6] = 2.0;
     1175
     1176    printf("----------------------------------------------------------------------------------\n");
     1177    printf("Calling pmSourceSubModel with NULL psImage.  Should generate error, return FALSE.\n");
     1178    rc = pmSourceSubModel(NULL, tmpSource, true);
     1179    if (rc == true) {
     1180        printf("TEST ERROR: pmSourceSubModel() returned TRUE.\n");
     1181        testStatus = false;
     1182    }
     1183
     1184    printf("----------------------------------------------------------------------------------\n");
     1185    printf("Calling pmSourceSubModel with NULL psSrc.  Should generate error, return FALSE.\n");
     1186    rc = pmSourceSubModel(imgData, NULL, true);
     1187    if (rc == true) {
     1188        printf("TEST ERROR: pmSourceSubModel() returned TRUE.\n");
     1189        testStatus = false;
     1190    }
     1191
     1192    printf("----------------------------------------------------------------------------------\n");
     1193    printf("Calling pmSourceSubModel with acceptable data.\n");
     1194    rc = pmSourceSubModel(imgData, tmpSource, true);
     1195    if (rc != true) {
     1196        printf("TEST ERROR: pmSourceSubModel() returned FALSE.\n");
     1197        testStatus = false;
     1198    }
     1199
     1200    psFree(tmpSource);
     1201    psFree(imgData);
     1202    return(testStatus);
     1203}
     1204
     1205#define TST20_NUM_ROWS 100
     1206#define TST20_NUM_COLS 100
     1207#define TST20_SKY 10.0
     1208#define TST20_INNER_RADIUS 3
     1209#define TST20_OUTER_RADIUS 5
     1210/******************************************************************************
     1211test20(): We first test pmSourceSubModel() with various NULL and unallowable
     1212input parameters.
     1213 
     1214XXX: We don't verify the numbers.
     1215 *****************************************************************************/
     1216int test20( void )
     1217{
     1218    bool testStatus = true;
     1219    psImage *imgData = psImageAlloc(TST20_NUM_COLS, TST20_NUM_ROWS, PS_TYPE_F32);
     1220    for (psS32 i = 0 ; i < imgData->numRows; i++) {
     1221        for (psS32 j = 0 ; j < imgData->numCols; j++) {
     1222            imgData->data.F32[i][j] = TST20_SKY;
     1223        }
     1224    }
     1225    pmSource *tmpSource = NULL;
     1226    psBool rc = false;
     1227
     1228    pmPeak *tmpPeak = pmPeakAlloc((psF32) (TST20_NUM_ROWS / 2),
     1229                                  (psF32) (TST20_NUM_COLS / 2),
     1230                                  200.0,
     1231                                  PM_PEAK_LONE);
     1232
     1233    printf("Calling pmSourceLocalSky with valid data.\n");
     1234    tmpPeak->x = (psF32) (TST20_NUM_ROWS / 2);
     1235    tmpPeak->y = (psF32) (TST20_NUM_COLS / 2);
     1236    tmpSource = pmSourceLocalSky(imgData,
     1237                                 tmpPeak,
     1238                                 PS_STAT_SAMPLE_MEAN,
     1239                                 (psF32) TST20_INNER_RADIUS,
     1240                                 (psF32) TST20_OUTER_RADIUS);
     1241
     1242    if (tmpSource == NULL) {
     1243        printf("TEST ERROR: pmSourceLocalSky() returned a NULL pmSource.\n");
     1244        testStatus = false;
     1245    }
     1246
     1247    tmpSource->modelPSF = pmModelAlloc(PS_MODEL_GAUSS);
     1248
     1249
     1250    tmpSource->modelPSF->params->data.F32[0] = 5.0;
     1251    tmpSource->modelPSF->params->data.F32[1] = 70.0;
     1252    tmpSource->modelPSF->params->data.F32[2] = (psF32) (TST20_NUM_ROWS / 2);
     1253    tmpSource->modelPSF->params->data.F32[3] = (psF32) (TST20_NUM_COLS / 2);
     1254    tmpSource->modelPSF->params->data.F32[4] = 1.0;
     1255    tmpSource->modelPSF->params->data.F32[5] = 1.0;
     1256    tmpSource->modelPSF->params->data.F32[6] = 2.0;
     1257
     1258    printf("----------------------------------------------------------------------------------\n");
     1259    printf("Calling pmSourceFitModel with NULL psImage.  Should generate error, return FALSE.\n");
     1260    rc = pmSourceFitModel(tmpSource, NULL);
     1261    if (rc == true) {
     1262        printf("TEST ERROR: pmSourceFitModel() returned TRUE.\n");
     1263        testStatus = false;
     1264    }
     1265
     1266    printf("----------------------------------------------------------------------------------\n");
     1267    printf("Calling pmSourceFitModel with NULL pmSource.  Should generate error, return FALSE.\n");
     1268    rc = pmSourceFitModel(NULL, imgData);
     1269    if (rc == true) {
     1270        printf("TEST ERROR: pmSourceFitModel() returned TRUE.\n");
     1271        testStatus = false;
     1272    }
     1273
     1274    printf("----------------------------------------------------------------------------------\n");
     1275    printf("Calling pmSourceFitModel with acceptable data.\n");
     1276    rc = pmSourceFitModel(tmpSource, imgData);
     1277    printf("pmSourceFitModel returned %d\n", rc);
     1278
     1279    // XXX: Memory leaks are not being tested
     1280    psVector *junk = psVectorAlloc(10, PS_TYPE_F32);
     1281    junk->data.F32[0] = 0.0;
     1282
     1283    psFree(tmpSource);
     1284    psFree(imgData);
     1285    return(testStatus);
     1286}
     1287
     1288
    9771289// this code will
    9781290
Note: See TracChangeset for help on using the changeset viewer.