IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 22, 2012, 3:33:32 PM (14 years ago)
Author:
eugene
Message:

read the time table in psTime.c; updates to the variance model tests; better trace options for output masks; convert to new PM_SOURCE_PHOTFIT version of weighting

Location:
branches/eam_branches/ipp-20120601/psModules/src/objects
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmModelFuncs.h

    r34049 r34053  
    2929# define PM_MODEL_FUNCS_H
    3030
    31 # define HAVE_MODEL_VAR 1
    32 
    3331/// @addtogroup Objects Object Detection / Analysis Functions
    3432/// @{
    … …  
    5755    PM_MODEL_OP_NORM     = 0x20,
    5856    PM_MODEL_OP_NOISE    = 0x40,
    59 # if (HAVE_MODEL_VAR)
    6057    PM_MODEL_OP_MODELVAR = 0x80,
    61 # endif
    6258} pmModelOpMode;
    6359

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmModelUtils.c

    r33417 r34053  
    4343
    4444#include "pmErrorCodes.h"
     45
     46// XX static bool useModelVar = false;
     47// XX
     48// XX void pmModelSetModelVarOption (bool option) {
     49// XX   useModelVar = option;
     50// XX }
     51// XX bool pmModelGetModelVarOption (void) {
     52// XX   return useModelVar;
     53// XX }
    4554
    4655/*****************************************************************************

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmModelUtils.h

    r31153 r34053  
    4646bool pmModelSetShape (float *Sxx, float *Sxy, float *Syy, pmMoments *moments);
    4747
     48// XXX void pmModelSetModelVarOption (bool option);
     49// XXX bool pmModelGetModelVarOption (void);
     50
    4851/// @}
    4952# endif /* PM_MODEL_UTILS_H */

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSource.c

    r34049 r34053  
    5151    psFree(tmp->pixels);
    5252    psFree(tmp->variance);
    53 # if (HAVE_MODEL_VAR)
    5453    psFree(tmp->modelVar);
    55 # endif
    5654    psFree(tmp->maskObj);
    5755    psFree(tmp->maskView);
    … …  
    8078    psFree (source->pixels);
    8179    psFree (source->variance);
    82 # if (HAVE_MODEL_VAR)
    8380    psFree (source->modelVar);
    84 # endif
    8581    psFree (source->maskObj);
    8682    psFree (source->maskView);
    … …  
    9086    source->pixels = NULL;
    9187    source->variance = NULL;
    92 # if (HAVE_MODEL_VAR)
    9388    source->modelVar = NULL;
    94 # endif
    9589    source->maskObj = NULL;
    9690    source->maskView = NULL;
    … …  
    122116    source->pixels = NULL;
    123117    source->variance = NULL;
    124 # if (HAVE_MODEL_VAR)
    125118    source->modelVar = NULL;
    126 # endif
    127119    source->maskObj = NULL;
    128120    source->maskView = NULL;
    … …  
    212204    source->pixels   = in->pixels   ? psImageCopyView(NULL, in->pixels)   : NULL;
    213205    source->variance = in->variance ? psImageCopyView(NULL, in->variance) : NULL;
    214 # if (HAVE_MODEL_VAR)
    215206    source->modelVar = NULL;
    216 # endif
    217207    source->maskView = in->maskView ? psImageCopyView(NULL, in->maskView) : NULL;
    218208
    … …  
    10441034    bool addNoise = mode & PM_MODEL_OP_NOISE;
    10451035
    1046 # if (HAVE_MODEL_VAR)
    10471036    bool addModelVar = mode & PM_MODEL_OP_MODELVAR;
    10481037    if (addModelVar) psAssert (source->modelVar, "programming error");
    1049 # endif
    10501038
    10511039    // require the use of pmModelAddWithOffset if we are adding noise (because the model size and norm are rescaled)
    … …  
    10701058        }
    10711059
    1072 # if (HAVE_MODEL_VAR)
    1073         psF32 **target = addModelVar ? source->modelVar->data.F32 : source->pixels->data.F32;
    1074 # else
    1075         psF32 **target = source->pixels->data.F32;
    1076 # endif
     1060        psF32 **target = NULL;
     1061        target = addModelVar ? source->modelVar->data.F32 : source->pixels->data.F32;
    10771062
    10781063        for (int iy = 0; iy < source->modelFlux->numRows; iy++) {
    … …  
    10891074            }
    10901075        }
    1091 # if (HAVE_MODEL_VAR)
     1076        // do not change the flag here if we are adding/subtracting from modelVar
    10921077        if (!addModelVar) {
    1093             if (add) {
    1094                 source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
    1095             } else {
    1096                 source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
    1097             }
     1078          if (add) {
     1079            source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
     1080          } else {
     1081            source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
     1082          }
    10981083        }
    1099 # else
    1100         if (add) {
    1101             source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
    1102         } else {
    1103             source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
    1104         }
    1105 # endif
    11061084        return true;
    11071085    }
    … …  
    11111089        target = source->variance;
    11121090    }
    1113 # if (HAVE_MODEL_VAR)
    11141091    if (addModelVar) {
    1115         target = source->modelVar;
    1116     }
    1117 # endif
     1092      target = source->modelVar;
     1093    }
    11181094
    11191095    if (add) {
    11201096        status = pmModelAddWithOffset (target, source->maskObj, model, PM_MODEL_OP_FULL, maskVal, dx, dy);
    1121 # if (HAVE_MODEL_VAR)
    11221097        if (!addNoise && !addModelVar) source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
    1123 # else
    1124         source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
    1125 # endif
    11261098    } else {
    11271099        status = pmModelSubWithOffset (target, source->maskObj, model, PM_MODEL_OP_FULL, maskVal, dx, dy);
    1128 # if (HAVE_MODEL_VAR)
    11291100        if (!addNoise && !addModelVar) source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
    1130 # else
    1131         source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
    1132 # endif
    11331101    }
    11341102    if (!status) {

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSource.h

    r34049 r34053  
    7272    psImage *pixels;                    ///< Rectangular region including object pixels.
    7373    psImage *variance;                  ///< Image variance.
    74 # if (HAVE_MODEL_VAR)
    7574    psImage *modelVar;                  ///< variance based on current models
    76 # endif
    7775    psImage *maskObj;                   ///< unique mask for this object which marks included pixels associated with objects.
    7876    psImage *maskView;                  ///< view into global image mask for this object region

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSourcePhotometry.c

    r34049 r34053  
    899899}
    900900
    901 # if (HAVE_MODEL_VAR)
    902901double pmSourceModelWeight(const pmSource *Mi, int term, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
    903 # else
    904 double pmSourceModelWeight(const pmSource *Mi, int term, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
    905 # endif
    906902{
    907903    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
    908 # if (HAVE_MODEL_VAR)
    909     double flux = 0, wt = 1.0, factor = 0;
    910 # else
    911     double flux = 0, wt = 0, factor = 0;
    912 # endif
     904    double flux = 0;
     905    double wt = 1.0;
     906    double factor = 0;
    913907
    914908    const psImage *Pi = Mi->modelFlux;
    915909    assert (Pi != NULL);
    916910
    917 # if (HAVE_MODEL_VAR)
    918911    const psImage *Wi = NULL;
    919912    switch (fitVarMode) {
    … …  
    921914        break;
    922915      case PM_SOURCE_PHOTFIT_IMAGE_VAR:
     916      case PM_SOURCE_PHOTFIT_MODEL_SKY:
     917        Wi = Mi->variance;
     918        psAssert (Wi, "programming error");
     919        break;
     920      case PM_SOURCE_PHOTFIT_MODEL_VAR:
     921        Wi = Mi->modelVar;
     922        psAssert (Wi, "programming error");
     923        break;
     924      case PM_SOURCE_PHOTFIT_NONE:
     925        psAbort("programming error");
     926    }   
     927    const psImage *Ti = Mi->maskObj;
     928    assert (Ti != NULL);
     929
     930    for (int yi = 0; yi < Pi->numRows; yi++) {
     931        for (int xi = 0; xi < Pi->numCols; xi++) {
     932            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal)
     933                continue;
     934            if (fitVarMode != PM_SOURCE_PHOTFIT_CONST) {
     935                wt = covarFactor * Wi->data.F32[yi][xi];
     936                if (wt == 0) continue;
     937            }
     938            switch (term) {
     939              case 0:
     940                factor = 1;
     941                break;
     942              case 1:
     943                factor = xi + Pi->col0;
     944                break;
     945              case 2:
     946                factor = yi + Pi->row0;
     947                break;
     948              default:
     949                psAbort("invalid term for pmSourceWeight");
     950            }
     951
     952            // wt is 1.0 for CONST
     953            flux += (factor * Pi->data.F32[yi][xi]) / wt;
     954        }
     955    }
     956    return flux;
     957}
     958
     959double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
     960{
     961    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
     962    PS_ASSERT_PTR_NON_NULL(Mj, NAN);
     963    int Xs, Xe, Ys, Ye;
     964    int xi, xj, yi, yj;
     965    int xIs, xJs, yIs, yJs;
     966    int xIe, yIe;
     967    double flux;
     968    double wt = 1.0;
     969
     970    const psImage *Pi = Mi->modelFlux;
     971    assert (Pi != NULL);
     972    const psImage *Pj = Mj->modelFlux;
     973    assert (Pj != NULL);
     974
     975    const psImage *Wi = NULL;
     976    switch (fitVarMode) {
     977      case PM_SOURCE_PHOTFIT_CONST:
     978        break;
     979      case PM_SOURCE_PHOTFIT_IMAGE_VAR:
     980      case PM_SOURCE_PHOTFIT_MODEL_SKY:
     981        Wi = Mi->variance;
     982        psAssert (Wi, "programming error");
     983        break;
     984      case PM_SOURCE_PHOTFIT_MODEL_VAR:
     985        Wi = Mi->modelVar;
     986        psAssert (Wi, "programming error");
     987        break;
     988      case PM_SOURCE_PHOTFIT_NONE:
     989        psAbort("programming error");
     990    }   
     991
     992    const psImage *Ti = Mi->maskObj;
     993    assert (Ti != NULL);
     994    const psImage *Tj = Mj->maskObj;
     995    assert (Tj != NULL);
     996
     997    Xs = PS_MAX (Pi->col0, Pj->col0);
     998    Xe = PS_MIN (Pi->col0 + Pi->numCols, Pj->col0 + Pj->numCols);
     999
     1000    Ys = PS_MAX (Pi->row0, Pj->row0);
     1001    Ye = PS_MIN (Pi->row0 + Pi->numRows, Pj->row0 + Pj->numRows);
     1002
     1003    xIs = Xs - Pi->col0;
     1004    xJs = Xs - Pj->col0;
     1005    yIs = Ys - Pi->row0;
     1006    yJs = Ys - Pj->row0;
     1007
     1008    xIe = Xe - Pi->col0;
     1009    yIe = Ye - Pi->row0;
     1010
     1011    // note that weight is addressing the same image pixels
     1012    flux = 0;
     1013    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
     1014        for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
     1015            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal)
     1016                continue;
     1017            if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj] & maskVal)
     1018                continue;
     1019
     1020            float value = (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
     1021            switch (fitVarMode) {
     1022              case PM_SOURCE_PHOTFIT_CONST:
     1023                wt = 1.0;
     1024                break;
     1025              case PM_SOURCE_PHOTFIT_IMAGE_VAR:
     1026              case PM_SOURCE_PHOTFIT_MODEL_SKY:
     1027              case PM_SOURCE_PHOTFIT_MODEL_VAR:
     1028                wt = covarFactor * Wi->data.F32[yi][xi];
     1029                break;
     1030              case PM_SOURCE_PHOTFIT_NONE:
     1031                psAbort("programming error");
     1032            }
     1033            // skip pixels with nonsense weight values
     1034            if (wt <= 0) continue;
     1035
     1036            flux += value / wt;
     1037        }
     1038    }
     1039    return flux;
     1040}
     1041
     1042double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
     1043{
     1044    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
     1045    PS_ASSERT_PTR_NON_NULL(Mj, NAN);
     1046    int Xs, Xe, Ys, Ye;
     1047    int xi, xj, yi, yj;
     1048    int xIs, xJs, yIs, yJs;
     1049    int xIe, yIe;
     1050    double flux;
     1051    double wt = 1.0;
     1052
     1053    const psImage *Pi = Mi->pixels;
     1054    assert (Pi != NULL);
     1055    const psImage *Pj = Mj->modelFlux;
     1056    assert (Pj != NULL);
     1057
     1058    const psImage *Wi = NULL;
     1059    switch (fitVarMode) {
     1060      case PM_SOURCE_PHOTFIT_CONST:
     1061        break;
     1062      case PM_SOURCE_PHOTFIT_IMAGE_VAR:
     1063      case PM_SOURCE_PHOTFIT_MODEL_SKY:
    9231064        Wi = Mi->variance;
    9241065        psAssert (Wi, "programming error");
    … …  
    9311072        psAbort("programming error");
    9321073    }   
    933 # else
    934     const psImage *Wi = Mi->variance;
    935     if (!unweighted_sum) {
    936         assert (Wi != NULL);
    937     }
    938 # endif
    939     const psImage *Ti = Mi->maskObj;
    940     assert (Ti != NULL);
    941 
    942     for (int yi = 0; yi < Pi->numRows; yi++) {
    943         for (int xi = 0; xi < Pi->numCols; xi++) {
    944             if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal)
    945                 continue;
    946 # if (HAVE_MODEL_VAR)
    947             if (fitVarMode != PM_SOURCE_PHOTFIT_CONST) {
    948                 wt = covarFactor * Wi->data.F32[yi][xi];
    949                 if (wt == 0) continue;
    950             }
    951 # else
    952             if (!unweighted_sum) {
    953                 wt = covarFactor * Wi->data.F32[yi][xi];
    954                 if (wt == 0)
    955                     continue;
    956             }
    957 # endif
    958 
    959             switch (term) {
    960               case 0:
    961                 factor = 1;
    962                 break;
    963               case 1:
    964                 factor = xi + Pi->col0;
    965                 break;
    966               case 2:
    967                 factor = yi + Pi->row0;
    968                 break;
    969               default:
    970                 psAbort("invalid term for pmSourceWeight");
    971             }
    972 
    973 # if (HAVE_MODEL_VAR)
    974             // wt is 1.0 for CONST
    975             flux += (factor * Pi->data.F32[yi][xi]) / wt;
    976 # else
    977             if (unweighted_sum) {
    978                 flux += (factor * Pi->data.F32[yi][xi]);
    979             } else {
    980                 flux += (factor * Pi->data.F32[yi][xi]) / wt;
    981             }
    982 # endif
    983         }
    984     }
    985     return flux;
    986 }
    987 
    988 # if (HAVE_MODEL_VAR)
    989 double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
    990 # else
    991 double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
    992 # endif
    993 {
    994     PS_ASSERT_PTR_NON_NULL(Mi, NAN);
    995     PS_ASSERT_PTR_NON_NULL(Mj, NAN);
    996     int Xs, Xe, Ys, Ye;
    997     int xi, xj, yi, yj;
    998     int xIs, xJs, yIs, yJs;
    999     int xIe, yIe;
    1000 # if (HAVE_MODEL_VAR)
    1001     double flux;
    1002     double wt = 1.0;
    1003 # else
    1004     double flux, wt;
    1005 # endif
    1006 
    1007     const psImage *Pi = Mi->modelFlux;
    1008     assert (Pi != NULL);
    1009     const psImage *Pj = Mj->modelFlux;
    1010     assert (Pj != NULL);
    1011 
    1012 # if (HAVE_MODEL_VAR)
    1013     const psImage *Wi = NULL;
    1014     switch (fitVarMode) {
    1015       case PM_SOURCE_PHOTFIT_CONST:
    1016         break;
    1017       case PM_SOURCE_PHOTFIT_IMAGE_VAR:
    1018         Wi = Mi->variance;
    1019         psAssert (Wi, "programming error");
    1020         break;
    1021       case PM_SOURCE_PHOTFIT_MODEL_VAR:
    1022         Wi = Mi->modelVar;
    1023         psAssert (Wi, "programming error");
    1024         break;
    1025       case PM_SOURCE_PHOTFIT_NONE:
    1026         psAbort("programming error");
    1027     }   
    1028 # else
    1029     const psImage *Wi = Mi->variance;
    1030     if (!unweighted_sum) {
    1031         assert (Wi != NULL);
    1032     }
    1033 # endif
    10341074
    10351075    const psImage *Ti = Mi->maskObj;
    … …  
    10521092    yIe = Ye - Pi->row0;
    10531093
    1054     // note that weight is addressing the same image pixels
     1094    // note that weight is addressing the same image pixels,
    10551095    flux = 0;
    10561096    for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    … …  
    10611101                continue;
    10621102
    1063 # if (HAVE_MODEL_VAR)
    10641103            float value = (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    10651104            switch (fitVarMode) {
    … …  
    10681107                break;
    10691108              case PM_SOURCE_PHOTFIT_IMAGE_VAR:
     1109              case PM_SOURCE_PHOTFIT_MODEL_SKY:
    10701110              case PM_SOURCE_PHOTFIT_MODEL_VAR:
    10711111                wt = covarFactor * Wi->data.F32[yi][xi];
    … …  
    10781118
    10791119            flux += value / wt;
    1080 # else
    1081             // XXX skip the nonsense weight pixels?
    1082             if (unweighted_sum) {
    1083                 flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    1084             } else {
    1085                 wt = covarFactor * Wi->data.F32[yi][xi];
    1086                 if (wt > 0) {
    1087                     flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]) / wt;
    1088                 }
    1089             }
    1090 # endif
    10911120        }
    10921121    }
    10931122    return flux;
    10941123}
    1095 
    1096 # if (HAVE_MODEL_VAR)
    1097 double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
    1098 # else
    1099 double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
    1100 # endif
    1101 {
    1102     PS_ASSERT_PTR_NON_NULL(Mi, NAN);
    1103     PS_ASSERT_PTR_NON_NULL(Mj, NAN);
    1104     int Xs, Xe, Ys, Ye;
    1105     int xi, xj, yi, yj;
    1106     int xIs, xJs, yIs, yJs;
    1107     int xIe, yIe;
    1108 # if (HAVE_MODEL_VAR)
    1109     double flux;
    1110     double wt = 1.0;
    1111 # else
    1112     double flux, wt;
    1113 # endif
    1114 
    1115     const psImage *Pi = Mi->pixels;
    1116     assert (Pi != NULL);
    1117     const psImage *Pj = Mj->modelFlux;
    1118     assert (Pj != NULL);
    1119 
    1120 # if (HAVE_MODEL_VAR)
    1121     const psImage *Wi = NULL;
    1122     switch (fitVarMode) {
    1123       case PM_SOURCE_PHOTFIT_CONST:
    1124         break;
    1125       case PM_SOURCE_PHOTFIT_IMAGE_VAR:
    1126         Wi = Mi->variance;
    1127         psAssert (Wi, "programming error");
    1128         break;
    1129       case PM_SOURCE_PHOTFIT_MODEL_VAR:
    1130         Wi = Mi->modelVar;
    1131         psAssert (Wi, "programming error");
    1132         break;
    1133       case PM_SOURCE_PHOTFIT_NONE:
    1134         psAbort("programming error");
    1135     }   
    1136 # else
    1137     const psImage *Wi = Mi->variance;
    1138     if (!unweighted_sum) {
    1139         assert (Wi != NULL);
    1140     }
    1141 # endif
    1142 
    1143     const psImage *Ti = Mi->maskObj;
    1144     assert (Ti != NULL);
    1145     const psImage *Tj = Mj->maskObj;
    1146     assert (Tj != NULL);
    1147 
    1148     Xs = PS_MAX (Pi->col0, Pj->col0);
    1149     Xe = PS_MIN (Pi->col0 + Pi->numCols, Pj->col0 + Pj->numCols);
    1150 
    1151     Ys = PS_MAX (Pi->row0, Pj->row0);
    1152     Ye = PS_MIN (Pi->row0 + Pi->numRows, Pj->row0 + Pj->numRows);
    1153 
    1154     xIs = Xs - Pi->col0;
    1155     xJs = Xs - Pj->col0;
    1156     yIs = Ys - Pi->row0;
    1157     yJs = Ys - Pj->row0;
    1158 
    1159     xIe = Xe - Pi->col0;
    1160     yIe = Ye - Pi->row0;
    1161 
    1162     // note that weight is addressing the same image pixels,
    1163     flux = 0;
    1164     for (yi = yIs, yj = yJs; yi < yIe; yi++, yj++) {
    1165         for (xi = xIs, xj = xJs; xi < xIe; xi++, xj++) {
    1166             if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal)
    1167                 continue;
    1168             if (Tj->data.PS_TYPE_IMAGE_MASK_DATA[yj][xj] & maskVal)
    1169                 continue;
    1170 
    1171 # if (HAVE_MODEL_VAR)
    1172             float value = (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    1173             switch (fitVarMode) {
    1174               case PM_SOURCE_PHOTFIT_CONST:
    1175                 wt = 1.0;
    1176                 break;
    1177               case PM_SOURCE_PHOTFIT_IMAGE_VAR:
    1178               case PM_SOURCE_PHOTFIT_MODEL_VAR:
    1179                 wt = covarFactor * Wi->data.F32[yi][xi];
    1180                 break;
    1181               case PM_SOURCE_PHOTFIT_NONE:
    1182                 psAbort("programming error");
    1183             }
    1184             // skip pixels with nonsense weight values
    1185             if (wt <= 0) continue;
    1186 
    1187             flux += value / wt;
    1188 
    1189 # else
    1190             // XXX skip the nonsense weight pixels?
    1191             if (unweighted_sum) {
    1192                 flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    1193             } else {
    1194                 wt = covarFactor * Wi->data.F32[yi][xi];
    1195                 if (wt > 0) {
    1196                     flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]) / wt;
    1197                 }
    1198             }
    1199 # endif
    1200         }
    1201     }
    1202     return flux;
    1203 }

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSourcePhotometry.h

    r34049 r34053  
    3838} pmSourcePhotometryMode;
    3939
    40 # if (HAVE_MODEL_VAR)
    4140typedef enum {
    4241    PM_SOURCE_PHOTFIT_NONE       = 0,
    … …  
    4443    PM_SOURCE_PHOTFIT_IMAGE_VAR  = 2,
    4544    PM_SOURCE_PHOTFIT_MODEL_VAR  = 3,
     45    PM_SOURCE_PHOTFIT_MODEL_SKY  = 4,   // XXX bad name: set variance floor based on mean variance image (variance of sky)
    4646} pmSourceFitVarMode;
    47 # endif
    4847
    4948bool pmSourcePhotometryModel(
    … …  
    8483bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal, psImageMaskType markVal);
    8584
    86 # if (HAVE_MODEL_VAR)
    8785double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
    8886double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
    8987double pmSourceModelWeight(const pmSource *Mi, int term, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
    90 # else
    91 double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
    92 double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
    93 double pmSourceModelWeight(const pmSource *Mi, int term, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
    94 # endif
    9588
    9689bool pmSourceNeighborFlags (pmSource *source);
Note: See TracChangeset for help on using the changeset viewer.