IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 11, 2013, 9:23:27 AM (13 years ago)
Author:
eugene
Message:

new functions pmModelUseReff, pmModelAxesToParams, pmModelParamsToAxes; add useReff to pmModelSetShape; remove deprecated code (pmPSF_SXYtoModel, pmPSF_SXYtoModel); replace code which converts the PAR[SXX,SXY,SYY] values to shape and then axes with calls to pmModelParamsToAxes and pmModelAxesToParams

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

Legend:

Unmodified
Added
Removed

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

    r34403 r35646  
    118118}
    119119
    120 bool pmModelSetShape (float *Sxx, float *Sxy, float *Syy, pmMoments *moments) {
     120bool pmModelUseReff (pmModelType type) {
     121    bool useReff = false;
     122    useReff |= (type == pmModelClassGetType ("PS_MODEL_SERSIC"));
     123    useReff |= (type == pmModelClassGetType ("PS_MODEL_DEV"));
     124    useReff |= (type == pmModelClassGetType ("PS_MODEL_EXP"));
     125    return useReff;
     126}
     127
     128// this function and the one below handle the two cases, where the model shape is uses R_eff or Sigma
     129bool pmModelAxesToParams (float *Sxx, float *Sxy, float *Syy, psEllipseAxes axes, bool useReff)  {
     130
     131    psEllipseShape shape = psEllipseAxesToShape (axes);
     132
     133    if (!isfinite(shape.sx))  return false;
     134    if (!isfinite(shape.sy))  return false;
     135    if (!isfinite(shape.sxy)) return false;
     136
     137    // set the shape parameters
     138    if (useReff) {
     139        *Sxx  = PS_MAX(0.5, shape.sx);
     140        *Syy  = PS_MAX(0.5, shape.sy);
     141        *Sxy  = shape.sxy * 2.0;
     142    } else {
     143        *Sxx  = PS_MAX(0.5, M_SQRT2*shape.sx);
     144        *Syy  = PS_MAX(0.5, M_SQRT2*shape.sy);
     145        *Sxy  = shape.sxy;
     146    }
     147
     148    return true;
     149}
     150
     151bool pmModelParamsToAxes (psEllipseAxes *axes, float Sxx, float Sxy, float Syy, bool useReff)  {
     152
     153    psEllipseShape shape;
     154
     155    // set the shape parameters
     156    if (useReff) {
     157        shape.sx  = Sxx;
     158        shape.sy  = Syy;
     159        shape.sxy = Sxy / 2.0;
     160    } else {
     161        shape.sx  = Sxx / M_SQRT2;
     162        shape.sy  = Syy / M_SQRT2;
     163        shape.sxy = Sxy;
     164    }
     165
     166    if ((shape.sx == 0) || (shape.sy == 0)) {
     167        axes->major = 0.0;
     168        axes->minor = 0.0;
     169        axes->theta = 0.0;
     170    } else {
     171        // axes ratio < 20
     172        // replace with maxAR argument?
     173        *axes = psEllipseShapeToAxes (shape, 20.0);
     174    }
     175
     176    return true;
     177}
     178
     179// Reff says if this is a model which uses R_eff (like exp or dev) instead of Sigma
     180// set the parameter values SXX, SXY, SYY
     181bool pmModelSetShape (float *Sxx, float *Sxy, float *Syy, pmMoments *moments, bool useReff) {
    121182
    122183    psEllipseMoments emoments;
    … …  
    137198    axes.minor *= scale;
    138199
    139     psEllipseShape shape = psEllipseAxesToShape (axes);
    140 
    141     if (!isfinite(shape.sx))  return false;
    142     if (!isfinite(shape.sy))  return false;
    143     if (!isfinite(shape.sxy)) return false;
    144 
    145     // set the shape parameters
    146     *Sxx  = PS_MAX(0.5, M_SQRT2*shape.sx);
    147     *Syy  = PS_MAX(0.5, M_SQRT2*shape.sy);
    148     *Sxy  = shape.sxy;
     200    pmModelAxesToParams (Sxx, Sxy, Syy, axes, useReff);
    149201
    150202    return true;

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

    r34085 r35646  
    4444bool pmModelSetPosition (float *Xo, float *Yo, pmSource *source);
    4545bool pmModelSetNorm (float *Io, pmSource *source);
    46 bool pmModelSetShape (float *Sxx, float *Sxy, float *Syy, pmMoments *moments);
     46bool pmModelSetShape (float *Sxx, float *Sxy, float *Syy, pmMoments *moments, bool useReff);
     47
     48bool pmModelUseReff (pmModelType type);
     49bool pmModelAxesToParams (float *Sxx, float *Sxy, float *Syy, psEllipseAxes axes, bool useReff);
     50bool pmModelParamsToAxes (psEllipseAxes *axes, float Sxx, float Sxy, float Syy, bool useReff);
    4751
    4852// XXX void pmModelSetModelVarOption (bool option);

  • branches/eam_branches/ipp-20130509/psModules/src/objects/pmPCMdata.c

    r34854 r35646  
    291291    psAssert (modelPSF, "psf model must be defined");
    292292   
    293     psEllipseShape shape;
    294293    psEllipseAxes axes;
    295 
    296     shape.sx  = modelPSF->params->data.F32[PM_PAR_SXX];
    297     shape.sy  = modelPSF->params->data.F32[PM_PAR_SYY];
    298     shape.sxy = modelPSF->params->data.F32[PM_PAR_SXY];
    299     axes = psEllipseShapeToAxes (shape, 20.0);
     294    bool useReff = pmModelUseReff (modelPSF->type);
     295    psF32 *PAR = modelPSF->params->data.F32;
     296    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
    300297   
    301     float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*modelPSF->params->data.F32[PM_PAR_I0]);
     298    float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
    302299    float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
    303300
    … …  
    451448        psAssert (modelPSF, "psf model must be defined");
    452449   
    453         psEllipseShape shape;
    454450        psEllipseAxes axes;
    455 
    456         shape.sx  = modelPSF->params->data.F32[PM_PAR_SXX];
    457         shape.sy  = modelPSF->params->data.F32[PM_PAR_SYY];
    458         shape.sxy = modelPSF->params->data.F32[PM_PAR_SXY];
    459         axes = psEllipseShapeToAxes (shape, 20.0);
     451        bool useReff = pmModelUseReff (modelPSF->type);
     452        psF32 *PAR = modelPSF->params->data.F32;
     453        pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
    460454   
    461         float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*modelPSF->params->data.F32[PM_PAR_I0]);
     455        float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
    462456        float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
    463457

  • branches/eam_branches/ipp-20130509/psModules/src/objects/pmPSF.c

    r35560 r35646  
    249249// Mxy = SXY * (SXX^-4 + SYY^-4 - 2 SXY ^2)
    250250
     251// XXX deprecated
    251252// input: model->param, output: psf->param[PM_PAR_SXY]
    252 double pmPSF_SXYfromModel (psF32 *modelPar)
    253 {
    254     PS_ASSERT_PTR_NON_NULL(modelPar, NAN);
    255 
    256     double SXX = modelPar[PM_PAR_SXX];
    257     double SYY = modelPar[PM_PAR_SYY];
    258     double SXY = modelPar[PM_PAR_SXY];
    259 
    260     double par = SXY / PS_SQR(1.0 / PS_SQR(SXX) + 1.0 / PS_SQR(SYY));
    261     return (par);
    262 }
    263 
     253// XXX double pmPSF_SXYfromModel (psF32 *modelPar)
     254// XXX {
     255// XXX     PS_ASSERT_PTR_NON_NULL(modelPar, NAN);
     256// XXX
     257// XXX     double SXX = modelPar[PM_PAR_SXX];
     258// XXX     double SYY = modelPar[PM_PAR_SYY];
     259// XXX     double SXY = modelPar[PM_PAR_SXY];
     260// XXX
     261// XXX     double par = SXY / PS_SQR(1.0 / PS_SQR(SXX) + 1.0 / PS_SQR(SYY));
     262// XXX     return (par);
     263// XXX }
     264
     265// XXX deprecated
    264266// input: fitted psf->param, output: model->param[PM_PAR_SXY]
    265 double pmPSF_SXYtoModel (psF32 *fittedPar)
    266 {
    267     PS_ASSERT_PTR_NON_NULL(fittedPar, NAN);
    268 
    269     double SXX = fittedPar[PM_PAR_SXX];
    270     double SYY = fittedPar[PM_PAR_SYY];
    271     double fit = fittedPar[PM_PAR_SXY];
    272 
    273     double SXY = fit * PS_SQR(1.0 / PS_SQR(SXX) + 1.0 / PS_SQR(SYY));
    274 
    275     assert (!isnan(SXY));
    276 
    277     return SXY;
    278 }
    279 
    280 // New Concept: the PSF modelling function fits the polarization terms e0, e1, e2:
    281 
    282 // convert the parameters used in the fitted source model
    283 // to the parameters used in the 2D PSF model
    284 // XXX this function may be invalid for SERSIC, DEV, EXP models (SQRT2 not used?)
    285 bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis)
     267// XXX double pmPSF_SXYtoModel (psF32 *fittedPar)
     268// XXX {
     269// XXX     PS_ASSERT_PTR_NON_NULL(fittedPar, NAN);
     270// XXX
     271// XXX     double SXX = fittedPar[PM_PAR_SXX];
     272// XXX     double SYY = fittedPar[PM_PAR_SYY];
     273// XXX     double fit = fittedPar[PM_PAR_SXY];
     274// XXX
     275// XXX     double SXY = fit * PS_SQR(1.0 / PS_SQR(SXX) + 1.0 / PS_SQR(SYY));
     276// XXX
     277// XXX     assert (!isnan(SXY));
     278// XXX
     279// XXX     return SXY;
     280// XXX }
     281
     282// The PSF modelling function fits the polarization terms e0, e1, e2:
     283
     284// the FIT is the 2D representation of the shape using polarization parameters for the elliptical contour
     285// the MODEL is the realized psf model for a given location
     286
     287// convert the parameters (in situ) used in the fitted source model to the parameters used in
     288// the 2D PSF model
     289bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis, bool useReff)
    286290{
    287291    PS_ASSERT_PTR_NON_NULL(fittedPar, false);
    … …  
    298302        return false;
    299303    }
    300     psEllipseShape shape = psEllipseAxesToShape (axes);
    301 
    302     fittedPar[PM_PAR_SXX] = shape.sx * M_SQRT2;
    303     fittedPar[PM_PAR_SYY] = shape.sy * M_SQRT2;
    304     fittedPar[PM_PAR_SXY] = shape.sxy;
    305 
     304
     305    pmModelAxesToParams (&fittedPar[PM_PAR_SXX], &fittedPar[PM_PAR_SXX], &fittedPar[PM_PAR_SXX], axes, useReff);
    306306    return true;
    307307}
    308308
    309 // convert the PSF parameters used in the 2D PSF model fit into the
    310 // parameters used in the source model
    311 // XXX this function may be invalid for SERSIC, DEV, EXP models (SQRT2 not used?)
    312 psEllipsePol pmPSF_ModelToFit (psF32 *modelPar)
     309// convert the parameters (in situ) used in the 2D PSF model fit into the parameters used in
     310// the source model
     311psEllipsePol pmPSF_ModelToFit (psF32 *modelPar, bool useReff)
    313312{
    314313    // must assert non-NULL input parameter
    … …  
    319318    PS_ASSERT_PTR_NON_NULL(modelPar, pol);
    320319
    321     psEllipseShape shape;
    322 
    323     shape.sx  = modelPar[PM_PAR_SXX] / M_SQRT2;
    324     shape.sy  = modelPar[PM_PAR_SYY] / M_SQRT2;
    325     shape.sxy = modelPar[PM_PAR_SXY];
    326 
    327     pol = psEllipseShapeToPol (shape);
     320    psEllipseAxes axes;
     321    pmModelParamsToAxes (&axes, modelPar[PM_PAR_SXX], modelPar[PM_PAR_SXY], modelPar[PM_PAR_SYY], useReff);
     322
     323    pol = psEllipseAxesToPol (axes);
    328324
    329325    return pol;
    … …  
    332328// convert the parameters used in the fitted source model to the psEllipseAxes representation
    333329// (major,minor,theta)
    334 psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR, pmModelType type)
    335 {
    336     psEllipseShape shape;
     330psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, pmModelType type)
     331{
    337332    psEllipseAxes axes;
    338333    axes.major = NAN;
    339334    axes.minor = NAN;
    340335    axes.theta = NAN;
    341     //   XXX: must assert non-NULL input parameter
     336
    342337    PS_ASSERT_PTR_NON_NULL(modelPar, axes);
    343338
    344     bool useReff = false;
    345     useReff |= (type == pmModelClassGetType ("PS_MODEL_SERSIC"));
    346     useReff |= (type == pmModelClassGetType ("PS_MODEL_DEV"));
    347     useReff |= (type == pmModelClassGetType ("PS_MODEL_EXP"));
    348 
    349     if (useReff) {
    350         shape.sx  = modelPar[PM_PAR_SXX];
    351         shape.sy  = modelPar[PM_PAR_SYY];
    352         shape.sxy = modelPar[PM_PAR_SXY] / 2.0;
    353         // XXX I *think* dividing by 2.0 is the right direction, but this
    354         // needs to be checked with a real test
    355     } else {
    356         shape.sx  = modelPar[PM_PAR_SXX] / M_SQRT2;
    357         shape.sy  = modelPar[PM_PAR_SYY] / M_SQRT2;
    358         shape.sxy = modelPar[PM_PAR_SXY];
    359     }
    360 
    361     if ((shape.sx == 0) || (shape.sy == 0)) {
    362         axes.major = 0.0;
    363         axes.minor = 0.0;
    364         axes.theta = 0.0;
    365     } else {
    366         // XXX this is not really consistent with the model fit range above
    367         axes = psEllipseShapeToAxes (shape, maxAR);
    368     }
    369 
     339    bool useReff = pmModelUseReff (type);
     340    pmModelParamsToAxes (&axes, modelPar[PM_PAR_SXX], modelPar[PM_PAR_SXY], modelPar[PM_PAR_SYY], useReff);
    370341    return axes;
    371342}
    … …  
    377348    PS_ASSERT_PTR_NON_NULL(modelPar, false);
    378349
     350    modelPar[PM_PAR_SXX] = 0.0;
     351    modelPar[PM_PAR_SYY] = 0.0;
     352    modelPar[PM_PAR_SXY] = 0.0;
     353   
    379354    if ((axes.major <= 0) || (axes.minor <= 0)) {
    380         modelPar[PM_PAR_SXX] = 0.0;
    381         modelPar[PM_PAR_SYY] = 0.0;
    382         modelPar[PM_PAR_SXY] = 0.0;
    383355        return true;
    384356    }
    385 
    386     psEllipseShape shape = psEllipseAxesToShape (axes);
    387 
    388     bool useReff = false;
    389     useReff |= ( type == pmModelClassGetType ("PS_MODEL_SERSIC"));
    390     useReff |= ( type == pmModelClassGetType ("PS_MODEL_DEV"));
    391     useReff |= ( type == pmModelClassGetType ("PS_MODEL_EXP"));
    392 
    393     if (useReff) {
    394         modelPar[PM_PAR_SXX] = shape.sx;
    395         modelPar[PM_PAR_SYY] = shape.sy;
    396         modelPar[PM_PAR_SXY] = shape.sxy * 2.0; // XXX NEED factor of 2 here for correct angle conversion
    397     } else {
    398         modelPar[PM_PAR_SXX] = shape.sx * M_SQRT2;
    399         modelPar[PM_PAR_SYY] = shape.sy * M_SQRT2;
    400         modelPar[PM_PAR_SXY] = shape.sxy;
    401     }
     357   
     358    bool useReff = pmModelUseReff (type);
     359    pmModelAxesToParams (&modelPar[PM_PAR_SXX], &modelPar[PM_PAR_SXY], &modelPar[PM_PAR_SYY], axes, useReff);
    402360    return true;
    403361}
    … …  
    423381    par->data.F32[PM_PAR_SXY] = sxy;
    424382
    425     psEllipsePol pol = pmPSF_ModelToFit(par->data.F32);
     383    bool useReff = pmModelUseReff (options->type);
     384    psEllipsePol pol = pmPSF_ModelToFit(par->data.F32, useReff);
    426385
    427386    pmTrend2D *trend = NULL;

  • branches/eam_branches/ipp-20130509/psModules/src/objects/pmPSF.h

    r32347 r35646  
    107107
    108108bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, pmModelType type);
    109 bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis);
     109bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis, bool useReff);
    110110
    111 psEllipsePol pmPSF_ModelToFit (psF32 *modelPar);
    112 psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, double maxAR, pmModelType type);
     111psEllipsePol pmPSF_ModelToFit (psF32 *modelPar, bool useReff);
     112psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, pmModelType type);
    113113
    114114/// Calculate FWHM value from a PSF

  • branches/eam_branches/ipp-20130509/psModules/src/objects/pmPSFtryMakePSF.c

    r34403 r35646  
    214214        assert (source->modelEXT); // all unmasked sources should have modelEXT
    215215
    216         psEllipsePol pol = pmPSF_ModelToFit (source->modelEXT->params->data.F32);
     216        bool useReff = pmModelUseReff (source->modelEXT->type);
     217        psEllipsePol pol = pmPSF_ModelToFit (source->modelEXT->params->data.F32, useReff);
    217218
    218219        e0->data.F32[i] = pol.e0;

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

    r34403 r35646  
    11451145    bool status;
    11461146    psEllipseShape oldshape;
    1147     psEllipseShape newshape;
    11481147    psEllipseAxes axes;
    11491148
    … …  
    11661165    if (!isfinite(oldI0)) return false;
    11671166
     1167    bool useReff = pmModelUseReff (model->type);
     1168    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
     1169
    11681170    // increase size and height of source
    1169     axes = psEllipseShapeToAxes (oldshape, 20.0);
    11701171    axes.major *= SIZE;
    11711172    axes.minor *= SIZE;
    1172     newshape = psEllipseAxesToShape (axes);
     1173
     1174    pmModelAxesToParams (&PAR[PM_PAR_SXX], &PAR[PM_PAR_SXY], &PAR[PM_PAR_SYY], axes, useReff);
    11731175    PAR[PM_PAR_I0]  = FACTOR*oldI0;
    1174     PAR[PM_PAR_SXX] = newshape.sx;
    1175     PAR[PM_PAR_SYY] = newshape.sy;
    1176     PAR[PM_PAR_SXY] = newshape.sxy;
    11771176
    11781177    psImage *target = source->variance;
Note: See TracChangeset for help on using the changeset viewer.