IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 24, 2004, 12:33:17 PM (22 years ago)
Author:
gusciora
Message:

Fixed many compilation bugs.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/pmSubtractBias.c

    r1880 r1883  
    88 *  @author George Gusciora, MHPCC
    99 *
    10  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2004-09-24 21:05:00 $
     10 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-09-24 22:33:17 $
    1212 *
    1313 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    2222#include<math.h>
    2323#include "pslib.h"
    24 
    25 
    26 //#include "pmSubtractBias.h"
    27 //    PM_OVERSCAN_NONE,                         ///< No overscan subtraction
    28 //    PM_OVERSCAN_ROWS,                         ///< Subtract rows
    29 //    PM_OVERSCAN_COLUMNS,                      ///< Subtract columns
    30 //    PM_OVERSCAN_ALL                           ///< Subtract the statistic of all pixels in overscan region
    31 //} pmOverScanAxis;
    32 //typedef enum {
    33 //    PM_FIT_NONE,                              ///< No fit
    34 //    PM_FIT_POLYNOMIAL,                        ///< Fit polynomial
    35 //    PM_FIT_SPLINE                             ///< Fit cubic splines
     24#include "pmSubtractBias.h"
    3625
    3726#define PM_SUBTRACT_BIAS_POLYNOMIAL_ORDER 2
    … …  
    7362// XXX: Is there already a function which does this?
    7463psImage *p_psImageSubtractScalar(psImage *image,
    75                                  float *scalar)
     64                                 float scalar)
    7665{
    7766    int i;
    … …  
    8069    for (i=0;i<image->numRows;i++) {
    8170        for (j=0;j<image->numCols;j++) {
    82             image->data.F32[i][j]-= scalar;
     71            (image->data.F32[i][j])-= scalar;
    8372        }
    8473    }
    … …  
    9584{
    9685    int numOptions = 0;
    97     psStatsOptions opt;
     86    psStatsOptions opt = 0;
    9887
    9988    if (stat->options & PS_STAT_SAMPLE_MEAN) {
    … …  
    137126    }
    138127
     128    if (numOptions == 0) {
     129        // XXX: psErrorMsg()
     130    }
    139131    if (numOptions != 1) {
    140 \\ XXX:
    141         Generate warning message.
    142     }
    143 
     132        // XXX:Generate warning message.
     133    }
    144134    return(opt);
    145135}
    146136
    147137// XXX: Must scale the overscan vector
    148 psVector *ScaleOverscanVector(overscanVector,
    149                               (in->image)->numCols,
     138
     139psVector *ScaleOverscanVector(psVector *overscanVector,
     140                              int n,
    150141                              pmFit fit)
    151142{
    152143    return(overscanVector);
    153144}
    154 
    155145
    156146psReadout *pmSubtractBias(psReadout *in,
    … …  
    158148                          const psList *overscans,
    159149                          pmOverscanAxis overScanAxis,
    160                           const psStats *stat,
     150                          psStats *stat,
    161151                          int nBin,
    162152                          pmFit fit,
    … …  
    165155    int i;
    166156    int j;
    167     int nBin;
    168     int numBins;
     157    int numBins = 0;
    169158    static psVector *overscanVector = NULL;
    170159    psVector *tmpRow = NULL;
    171160    psVector *tmpCol = NULL;
    172     psVector *tmpMask = NULL;
    173161    psVector *myBin = NULL;
    174162    psVector *binVec = NULL;
    175     psList *tmpOverscan = NULL;
     163    psListElem *tmpOverscan = NULL;
     164    double statValue;
     165    psImage *myOverscanImage = NULL;
     166    psPolynomial1D *myPoly;
     167    psSpline1D *mySpline;
    176168
    177169    if (in == NULL) {
    … …  
    208200    if (overScanAxis == PM_OVERSCAN_ALL) {
    209201        psImageStats(stat, in->image, in->mask, 0xffffffff);
    210         p_psImageSubtractScalar(in->image, stat->value);
     202        p_psGetStatValue(stat, &statValue);
     203        p_psImageSubtractScalar(in->image, statValue);
    211204        return(in);
    212205    }
    … …  
    215208    // having to copy every element in that vector?
    216209
    217     // XXX: If we get here, do we know that overScanAxis == PM_OVERSCAN_ROW
     210    // XXX: If we get here, do we know that overScanAxis == PM_OVERSCAN_ROWS
    218211    // or PM_OVERSCAN_COL?
    219212
    220213    // XXX: How to use multiple overscans?  Currently, only the first is used.
    221     if ((overScanAxis == PM_OVERSCAN_ROW) || (overScanAxis == PM_OVERSCAN_COL)) {
    222         myOverscanImage = (psImage *) overscans->data;
    223 
    224         if (overScanAxis == PM_OVERSCAN_ROW) {
    225             overscanVector = psVectorAlloc((myOverscanImage->image)->numCols, PS_TYPE_F32);
     214    if ((overScanAxis == PM_OVERSCAN_ROWS) || (overScanAxis == PM_OVERSCAN_COLUMNS)) {
     215        myOverscanImage = (psImage *) ((overscans->head)->data);
     216
     217        if (overScanAxis == PM_OVERSCAN_ROWS) {
     218            overscanVector = psVectorAlloc(myOverscanImage->numCols, PS_TYPE_F32);
    226219            for (i=0;i<overscanVector->n;i++) {
    227220                overscanVector->data.F32[i] = 0.0;
    228221            }
    229222            tmpRow = psVectorAlloc((in->image)->numCols, PS_TYPE_F32);
    230             tmpMask = psVectorAlloc((in->image)->numCols, PS_TYPE_U8);
    231 
    232             tmpOverscan = (psList *) overscans;
     223
     224            tmpOverscan = (psListElem *) overscans->head;
    233225            while (tmpOverscan) {
    234226                myOverscanImage = (psImage *) tmpOverscan->data;
    235                 for (i=0;i<(myOverscanImage->image)->numCols;i++) {
    236                     for (j=0;j<(myOverscanImage->image)->numRows;j++) {
    237                         tmpRow->data.F32[j] = (myOverscanImage->image)->data.F32[i][j];
    238                         tmpMask->data.U8[j] = (myOverscanImage->mask)->data.U8[i][j];
     227                for (i=0;i<myOverscanImage->numCols;i++) {
     228                    for (j=0;j<myOverscanImage->numRows;j++) {
     229                        tmpRow->data.F32[j] = myOverscanImage->data.F32[i][j];
    239230                    }
    240                     stat = psVectorStats(stat, tmpRow, tmpMask, 0xffffffff);
    241                     overscanVector->data.F32[i] = stat->value;
    242                 }
    243                 //                tmpOverscan = tmpOverscan->next;
    244 tmpOverscan = NULL:
    245                           }
    246 
    247                           psFree(tmpRow);
    248             psFree(tmpMask);
     231                    stat = psVectorStats(stat, tmpRow, NULL, 0xffffffff);
     232                    p_psGetStatValue(stat, &statValue);
     233                    overscanVector->data.F32[i] = statValue;
     234
     235                }
     236                // tmpOverscan = tmpOverscan->next;
     237                tmpOverscan = NULL;
     238            }
     239            psFree(tmpRow);
    249240            ScaleOverscanVector(overscanVector, (in->image)->numCols, fit);
    250241        }
    251         if (overScanAxis == PM_OVERSCAN_COL) {
    252             overscanVector = psVectorAlloc((myOverscanImage->image)->numRows, PS_TYPE_F32);
     242        if (overScanAxis == PM_OVERSCAN_COLUMNS) {
     243            overscanVector = psVectorAlloc(myOverscanImage->numRows, PS_TYPE_F32);
    253244            for (i=0;i<overscanVector->n;i++) {
    254245                overscanVector->data.F32[i] = 0.0;
    255246            }
    256             tmpcol = psVectorAlloc((in->image)->numRows, PS_TYPE_F32);
    257             tmpMask = psVectorAlloc((in->image)->nuRows, PS_TYPE_U8);
    258 
    259             tmpOverscan = (psList *) overscans;
     247            tmpCol = psVectorAlloc((in->image)->numRows, PS_TYPE_F32);
     248
     249            tmpOverscan = (psListElem *) overscans->head;
    260250            while (tmpOverscan) {
    261                 for (i=0;i<(myOverscanImage->image)->numRows;i++) {
    262                     for (j=0;j<(myOverscanImage->image)->numCols;j++) {
    263                         tmpRow->data.F32[j] = (myOverscanImage->image)->data.F32[i][j];
    264                         tmpMask->data.U8[j] = (myOverscanImage->mask)->data.U8[i][j];
     251                for (i=0;i<myOverscanImage->numRows;i++) {
     252                    for (j=0;j<myOverscanImage->numCols;j++) {
     253                        tmpRow->data.F32[j] = myOverscanImage->data.F32[i][j];
    265254                    }
    266                     stat = psVectorStats(stat, tmpRow, tmpMask, 0xffffffff);
    267                     overscanVector->data.F32[i] = stat->value;
     255                    stat = psVectorStats(stat, tmpRow, NULL, 0xffffffff);
     256                    p_psGetStatValue(stat, &statValue);
     257                    overscanVector->data.F32[i] = statValue;
    268258                }
    269259                //                tmpOverscan = tmpOverscan->next;
    270 tmpOverscan = NULL:
    271                           }
    272                           psFree(tmpCol);
    273             psFree(tmpMask);
     260                tmpOverscan = NULL;
     261            }
     262            psFree(tmpCol);
    274263            ScaleOverscanVector(overscanVector, (in->image)->numRows, fit);
    275264        }
    … …  
    277266        if ((nBin > 0) && (nBin < overscanVector->n)) {
    278267            numBins = 1+((overscanVector->n)/nBin);
    279             psVector *myBin = psVectorAlloc(numBins, PS_TYPE_F32);
     268            myBin = psVectorAlloc(numBins, PS_TYPE_F32);
    280269            binVec = psVectorAlloc(nBin, PS_TYPE_F32);
    281270
    … …  
    292281                }
    293282                stat = psVectorStats(stat, binVec, NULL, 0);
    294                 myBin->data.F32[i] = stat->value;
     283                p_psGetStatValue(stat, &statValue);
     284                myBin->data.F32[i] = statValue;
     285
    295286            }
    296287            // Change the effective size of overscanVector.
    … …  
    314305
    315306            } else if (fit == PM_FIT_SPLINE) {
    316                 mySpline = (psSPline1D *) fitSpec;
     307                mySpline = (psSpline1D *) fitSpec;
    317308                // XXX: What is the point of doing this?
    318309            }
    319310        }
    320311
    321         if (overScanAxis == PM_OVERSCAN_ROW) {
     312        if (overScanAxis == PM_OVERSCAN_ROWS) {
    322313            for (i=0;i<(in->image)->numCols;i++) {
    323314                for (j=0;j<(in->image)->numRows;j++) {
    … …  
    327318        }
    328319
    329         if (overScanAxis == PM_OVERSCAN_COLUMN) {
     320        if (overScanAxis == PM_OVERSCAN_COLUMNS) {
    330321            for (i=0;i<(in->image)->numRows;i++) {
    331322                for (j=0;j<(in->image)->numCols;j++) {
    … …  
    343334
    344335    // XXX: psErrorMsg(): Shouldn't get here?
    345 }
    346 
     336    return(in);
     337}
     338
     339
Note: See TracChangeset for help on using the changeset viewer.