lsst.afw.math::Statistics Class Reference

#include <Statistics.h>

Public Types
typedef std::pair< double, double >	Value
	The type used to report (value, error) for desired statistics. More...

Public Member Functions
template<typename ImageT , typename MaskT , typename VarianceT >
	Statistics (ImageT const &img, MaskT const &msk, VarianceT const &var, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Constructor for Statistics object. More...
template<typename ImageT , typename MaskT , typename VarianceT , typename WeightT >
	Statistics (ImageT const &img, MaskT const &msk, VarianceT const &var, WeightT const &weights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
Value	getResult (Property const prop=NOTHING) const
	Return the value and error in the specified statistic (e.g. MEAN) More...
double	getError (Property const prop=NOTHING) const
	Return the error in the desired property (if specified in the constructor) More...
double	getValue (Property const prop=NOTHING) const
	Return the value of the desired property (if specified in the constructor) More...
lsst::afw::image::MaskPixel	getOrMask () const
template<>
	Statistics (afwImage::Mask< afwImage::MaskPixel > const &msk, afwImage::Mask< afwImage::MaskPixel > const &, afwImage::Mask< afwImage::MaskPixel > const &, int const flags, StatisticsControl const &sctrl)

Private Member Functions
template<typename ImageT , typename MaskT , typename VarianceT , typename WeightT >
void	doStatistics (ImageT const &img, MaskT const &msk, VarianceT const &var, WeightT const &weights, int const flags, StatisticsControl const &sctrl)

Private Attributes
long	_flags
int	_n
Value	_mean
Value	_variance
double	_min
double	_max
double	_sum
Value	_meanclip
Value	_varianceclip
Value	_median
double	_iqrange
lsst::afw::image::MaskPixel	_allPixelOrMask
StatisticsControl	_sctrl
bool	_weightsAreMultiplicative

Related Functions
(Note that these are not member functions.)
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::Image< Pixel > const &img, lsst::afw::image::Mask< image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle a watered-down front-end to the constructor (no variance) More...
template<typename ImageT , typename MaskT , typename VarianceT >
Statistics	makeStatistics (ImageT const &img, MaskT const &msk, VarianceT const &var, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle a straight front-end to the constructor. More...
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::MaskedImage< Pixel > const &mimg, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle MaskedImages, just pass the getImage() and getMask() values right on through. More...
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::MaskedImage< Pixel > const &mimg, lsst::afw::image::Image< WeightPixel > const &weights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Handle MaskedImages, just pass the getImage() and getMask() values right on through. More...
Statistics	makeStatistics (lsst::afw::image::Mask< lsst::afw::image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	Front end for specialization to handle Masks. More...
template<typename Pixel >
Statistics	makeStatistics (lsst::afw::image::Image< Pixel > const &img, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle regular (non-masked) Images. More...
template<typename EntryT >
Statistics	makeStatistics (std::vector< EntryT > const &v, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle std::vector<> More...
template<typename EntryT >
Statistics	makeStatistics (std::vector< EntryT > const &v, std::vector< WeightPixel > const &vweights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle std::vector<> More...
template<typename EntryT >
Statistics	makeStatistics (lsst::afw::math::MaskedVector< EntryT > const &mv, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle lsst::afw::math::MaskedVector<> More...
template<typename EntryT >
Statistics	makeStatistics (lsst::afw::math::MaskedVector< EntryT > const &mv, std::vector< WeightPixel > const &vweights, int const flags, StatisticsControl const &sctrl=StatisticsControl())
	The makeStatistics() overload to handle lsst::afw::math::MaskedVector<> More...

Detailed Description

A class to evaluate image statistics

The basic strategy is to construct a Statistics object from an Image and a statement of what we want to know. The desired results can then be returned using Statistics methods. A StatisticsControl object is used to pass parameters. The statistics currently implemented are listed in the enum Properties in Statistics.h.

       // sets NumSigclip (3.0), and NumIter (3) for clipping
       lsst::afw::math::StatisticsControl sctrl(3.0, 3); 

       sctrl.setNumSigmaClip(4.0);            // reset number of standard deviations for N-sigma clipping
       sctrl.setNumIter(5);                   // reset number of iterations for N-sigma clipping
       sctrl.setAndMask(0x1);                 // ignore pixels with these mask bits set
       sctrl.setNanSafe(true);                // check for NaNs & Infs, a bit slower (default=true)
       
       lsst::afw::math::Statistics statobj =
           lsst::afw::math::makeStatistics(*img, afwMath::NPOINT | 
                                                 afwMath::MEAN | afwMath::MEANCLIP, sctrl);
       double const n = statobj.getValue(lsst::afw::math::NPOINT);
       std::pair<double, double> const mean =
                                        statobj.getResult(lsst::afw::math::MEAN); // Returns (value, error)
       double const meanError = statobj.getError(lsst::afw::math::MEAN);                // just the error
* 

Note

Factory function: We used a helper function, makeStatistics, rather that the constructor directly so that the compiler could deduce the types – cf. std::make_pair)

Inputs: The class Statistics is templated, and makeStatistics() can take either: (1) an image, (2) a maskedImage, or (3) a std::vector<> Overloaded makeStatistics() functions then wrap what they were passed in Image/Mask-like classes and call the Statistics constructor.

Clipping: The clipping is done iteratively with numSigmaClip and numIter specified in the StatisticsControl object. The first clip (ie. the first iteration) is performed at: median +/- numSigmaClip*IQ_TO_STDEV*IQR, where IQ_TO_STDEV=~0.74 is the conversion factor between the IQR and sigma for a Gaussian distribution. All subsequent iterations perform clips at mean +/- numSigmaClip*stdev.

Examples:

imageStatistics.cc, and statistics.cc.

Definition at line 212 of file Statistics.h.

Member Typedef Documentation

typedef std::pair<double, double> lsst.afw.math::Statistics::Value

The type used to report (value, error) for desired statistics.

Definition at line 215 of file Statistics.h.

Constructor & Destructor Documentation

template<typename ImageT , typename MaskT , typename VarianceT >

lsst.afw.math::Statistics::Statistics ( ImageT const &  img, MaskT const &  msk, VarianceT const &  var, int const  flags, afwMath::StatisticsControl const &  sctrl = StatisticsControl()  )

explicit

Constructor for Statistics object.

Note

Most of the actual work is done in this constructor; the results are retrieved using getValue etc.

Parameters

img	Image whose properties we want
msk	Mask to control which pixels are included
var	Variances corresponding to values in Image
flags	Describe what we want to calculate
sctrl	Control how things are calculated

Definition at line 746 of file Statistics.cc.

                                          :
    _flags(flags), _mean(NaN, NaN), _variance(NaN, NaN), _min(NaN), _max(NaN), _sum(NaN),
    _meanclip(NaN, NaN), _varianceclip(NaN, NaN), _median(NaN, NaN), _iqrange(NaN),
    _sctrl(sctrl), _weightsAreMultiplicative(false)
{
    doStatistics(img, msk, var, var, _flags, _sctrl);
}

template<typename ImageT , typename MaskT , typename VarianceT , typename WeightT >

lsst.afw.math::Statistics::Statistics ( ImageT const &  img, MaskT const &  msk, VarianceT const &  var, WeightT const &  weights, int const  flags, afwMath::StatisticsControl const &  sctrl = StatisticsControl()  )

explicit

Parameters

img	Image whose properties we want
msk	Mask to control which pixels are included
var	Variances corresponding to values in Image
weights	Weights to use corresponding to values in Image
flags	Describe what we want to calculate
sctrl	Control how things are calculated

Definition at line 769 of file Statistics.cc.

                                          :
    _flags(flags), _mean(NaN, NaN), _variance(NaN, NaN), _min(NaN), _max(NaN), _sum(NaN),
    _meanclip(NaN, NaN), _varianceclip(NaN, NaN), _median(NaN, NaN), _iqrange(NaN),
    _sctrl(sctrl), _weightsAreMultiplicative(true)
{
    if (!isEmpty(weights)) {
        if (_sctrl.getWeightedIsSet() && !_sctrl.getWeighted()) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              "You must use the weights if you provide them");
        }

        _sctrl.setWeighted(true);
    }
    doStatistics(img, msk, var, weights, _flags, _sctrl);
}

template<>

lsst.afw.math::Statistics::Statistics	(	afwImage::Mask< afwImage::MaskPixel > const &	msk,
		afwImage::Mask< afwImage::MaskPixel > const &	,
		afwImage::Mask< afwImage::MaskPixel > const &	,
		int const	flags,
		StatisticsControl const &	sctrl
	)

Parameters

msk	Mask whose properties we want
flags	Describe what we want to calculate
sctrl	Control how things are calculated

Definition at line 1040 of file Statistics.cc.

                        :
    _flags(flags),
    _mean(NaN, NaN), _variance(NaN, NaN), _min(NaN), _max(NaN),
    _meanclip(NaN, NaN), _varianceclip(NaN, NaN), _median(NaN, NaN), _iqrange(NaN),
    _sctrl(sctrl) {
    
    if ((flags & ~(NPOINT | SUM)) != 0x0) {
        throw LSST_EXCEPT(pexExceptions::InvalidParameterError, "Statistics<Mask> only supports NPOINT and SUM");
    }
    
    typedef afwImage::Mask<afwImage::MaskPixel> Mask;
    
    _n = msk.getWidth()*msk.getHeight();
    if (_n == 0) {
        throw LSST_EXCEPT(pexExceptions::InvalidParameterError, "Image contains no pixels");
    }
    
    // Check that an int's large enough to hold the number of pixels
    assert(msk.getWidth()*static_cast<double>(msk.getHeight()) < std::numeric_limits<int>::max());
    
    afwImage::MaskPixel sum = 0x0;
    for (int y = 0; y != msk.getHeight(); ++y) {
        for (Mask::x_iterator ptr = msk.row_begin(y), end = msk.row_end(y); ptr != end; ++ptr) {
            sum |= (*ptr)[0];
        }
    }
    _sum = sum;
}

Member Function Documentation

template<typename ImageT , typename MaskT , typename VarianceT , typename WeightT >

void lsst.afw.math::Statistics::doStatistics ( ImageT const &  img, MaskT const &  msk, VarianceT const &  var, WeightT const &  weights, int const  flags, afwMath::StatisticsControl const &  sctrl  )

private

Parameters

img	Image whose properties we want
msk	Mask to control which pixels are included
var	Variances corresponding to values in Image
weights	Weights to use corresponding to values in Image
flags	Describe what we want to calculate
sctrl	Control how things are calculated

Definition at line 793 of file Statistics.cc.

{
    _n = img.getWidth()*img.getHeight();
    if (_n == 0) {
        throw LSST_EXCEPT(pexExceptions::InvalidParameterError, "Image contains no pixels");
    }
    
    // Check that an int's large enough to hold the number of pixels
    assert(img.getWidth()*static_cast<double>(img.getHeight()) < std::numeric_limits<int>::max());

    // get the standard statistics
    StandardReturn standard = getStandard(img, msk, var, weights, flags,
                                          _weightsAreMultiplicative,
                                          _sctrl.getAndMask(),
                                          _sctrl.getCalcErrorFromInputVariance(),
                                          _sctrl.getNanSafe(), _sctrl.getWeighted(),
                                          _sctrl._maskPropagationThresholds);

    _n = standard.get<0>();
    _sum = standard.get<1>();
    _mean = standard.get<2>();
    _variance = standard.get<3>();
    _min = standard.get<4>();
    _max = standard.get<5>();
    _allPixelOrMask = standard.get<6>();

    // ==========================================================
    // now only calculate it if it's specifically requested - these all cost more!

    // copy the image for any routines that will use median or quantiles
    if (flags & (MEDIAN | IQRANGE | MEANCLIP | STDEVCLIP | VARIANCECLIP)) {

        // make a vector copy of the image to get the median and quartiles (will move values)
        boost::shared_ptr<std::vector<typename ImageT::Pixel> > imgcp;
        if (_sctrl.getNanSafe()) {
            imgcp = makeVectorCopy<ChkFin>(img, msk, var, _sctrl.getAndMask());
        } else {
            imgcp = makeVectorCopy<AlwaysT>(img, msk, var, _sctrl.getAndMask());
        }

        // if we *only* want the median, just use percentile(), otherwise use medianAndQuartiles()
        if ( (flags & (MEDIAN)) && !(flags & (IQRANGE | MEANCLIP | STDEVCLIP | VARIANCECLIP)) ) {
            _median = Value(percentile(*imgcp, 0.5), NaN);
        } else {
            MedianQuartileReturn mq = medianAndQuartiles(*imgcp);
            _median = Value(mq.get<0>(), NaN);
            _iqrange = mq.get<2>() - mq.get<1>();
        }
        
        
        if (flags & (MEANCLIP | STDEVCLIP | VARIANCECLIP)) {            
            for (int i_i = 0; i_i < _sctrl.getNumIter(); ++i_i) {
                double const center = ((i_i > 0) ? _meanclip : _median).first;
                double const hwidth = (i_i > 0 && _n > 1) ?
                    _sctrl.getNumSigmaClip()*std::sqrt(_varianceclip.first) :
                    _sctrl.getNumSigmaClip()*IQ_TO_STDEV*_iqrange;
                std::pair<double, double> const clipinfo(center, hwidth);
                
                StandardReturn clipped = getStandard(img, msk, var, weights, flags, clipinfo,
                                                     _weightsAreMultiplicative,
                                                     _sctrl.getAndMask(),
                                                     _sctrl.getCalcErrorFromInputVariance(),
                                                     _sctrl.getNanSafe(), _sctrl.getWeighted(),
                                                     _sctrl._maskPropagationThresholds);
                
                int const nClip = clipped.get<0>();
                _meanclip = clipped.get<2>();     // clipped mean
                double const varClip = clipped.get<3>().first;  // clipped variance

                _varianceclip = Value(varClip, varianceError(varClip, nClip));
                // ... ignore other values
            }
        }
    }
}

double lsst.afw.math::Statistics::getError

(

afwMath::Property const

prop = NOTHING

)

const

Return the error in the desired property (if specified in the constructor)

Parameters

prop	the afw::math::Property to retrieve. If NOTHING (default) and you only asked for one property in the constructor, that property's error is returned

Note

You may have needed to specify ERROR to the ctor

Examples:

statistics.cc.

Definition at line 1020 of file Statistics.cc.

                                             {
    return getResult(prop).second;
}

lsst::afw::image::MaskPixel lsst.afw.math::Statistics::getOrMask ( ) const

inline

Definition at line 236 of file Statistics.h.

                                            {
        return _allPixelOrMask;
    }

std::pair< double, double > lsst.afw.math::Statistics::getResult

(

afwMath::Property const

iProp = NOTHING

)

const

Return the value and error in the specified statistic (e.g. MEAN)

Note

Only quantities requested in the constructor may be retrieved; in particular errors may not be available if you didn't specify ERROR in the constructor

See Also

getValue and getError

Todo:

uncertainties on MEANCLIP,STDEVCLIP are sketchy. _n != _nClip

Parameters

iProp

the afw::math::Property to retrieve. If NOTHING (default) and you only asked for one property (and maybe its error) in the constructor, that property is returned

Examples:

statistics.cc.

Definition at line 887 of file Statistics.cc.

                                                                {
    
    // if iProp == NOTHING try to return their heart's delight, as specified in the constructor
    afwMath::Property const prop =
        static_cast<afwMath::Property>(((iProp == NOTHING) ? _flags : iProp) & ~ERRORS);
    
    if (!(prop & _flags)) {             // we didn't calculate it
        throw LSST_EXCEPT(pexExceptions::InvalidParameterError,
                          (boost::format("You didn't ask me to calculate %d") % prop).str());
    }

    
    Value ret(NaN, NaN);
    switch (prop) {
        
      case NPOINT:
        ret.first = static_cast<double>(_n);
        if (_flags & ERRORS) {
            ret.second = 0;
        }
        break;
        
      case SUM:
        ret.first = static_cast<double>(_sum);
        if (_flags & ERRORS) {
            ret.second = 0;
        }
        break;
        
        // == means ==
      case MEAN:
        ret.first = _mean.first;
        if (_flags & ERRORS) {
            ret.second = ::sqrt(_mean.second);
        }
        break;
      case MEANCLIP:
        ret.first = _meanclip.first;
        if ( _flags & ERRORS ) {
            ret.second = ::sqrt(_meanclip.second);
        }
        break;
        
        // == stdevs & variances ==
      case VARIANCE:
        ret.first = _variance.first;
        if (_flags & ERRORS) {
            ret.second = ::sqrt(_variance.second);
        }
        break;
      case STDEV:
        ret.first = sqrt(_variance.first);
        if (_flags & ERRORS) {
            ret.second = 0.5*::sqrt(_variance.second)/ret.first;
        }
        break;
      case VARIANCECLIP:
        ret.first = _varianceclip.first;
        if (_flags & ERRORS) {
            ret.second = ret.second;
        }
        break;
      case STDEVCLIP:
        ret.first = sqrt(_varianceclip.first);
        if (_flags & ERRORS) {
            ret.second = 0.5*::sqrt(_varianceclip.second)/ret.first;
        }
        break;

      case MEANSQUARE:
        ret.first = (_n - 1)/static_cast<double>(_n)*_variance.first + ::pow(_mean.first, 2);
        if (_flags & ERRORS) {
            ret.second = ::sqrt(2*::pow(ret.first/_n, 2)); // assumes Gaussian
        }
        break;
        
        // == other stats ==
      case MIN:
        ret.first = _min;
        if ( _flags & ERRORS ) {
            ret.second = 0;
        }
        break;
      case MAX:
        ret.first = _max;
        if ( _flags & ERRORS ) {
            ret.second = 0;
        }
        break;
      case MEDIAN:
        ret.first = _median.first;
        if ( _flags & ERRORS ) {
            ret.second = sqrt(afwGeom::HALFPI*_variance.first/_n); // assumes Gaussian
        }
        break;
      case IQRANGE:
        ret.first = _iqrange;
        if ( _flags & ERRORS ) {
            ret.second = NaN;           // we're not estimating this properly
        }
        break;

        // no-op to satisfy the compiler
      case ERRORS:
        break;
        // default: redundant as 'ret' is initialized to NaN, NaN
      default:                          // we must have set prop to _flags
        assert (iProp == 0);
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "getValue() may only be called without a parameter"
                          " if you asked for only one statistic");
    }
    return ret;
}

double lsst.afw.math::Statistics::getValue

(

afwMath::Property const

prop = NOTHING

)

const

Return the value of the desired property (if specified in the constructor)

Parameters

prop	the afw::math::Property to retrieve. If NOTHING (default) and you only asked for one property in the constructor, that property is returned

Examples:

imageStatistics.cc, and statistics.cc.

Definition at line 1009 of file Statistics.cc.

                                             {
    return getResult(prop).first;
}

Friends And Related Function Documentation

template<typename Pixel >

Statistics makeStatistics ( lsst::afw::image::Image< Pixel > const &  img, lsst::afw::image::Mask< image::MaskPixel > const &  msk, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

Handle a watered-down front-end to the constructor (no variance)

Examples:

imageStatistics.cc.

Definition at line 304 of file Statistics.h.

                           {
    MaskImposter<WeightPixel> var;
    return Statistics(img, msk, var, flags, sctrl);
}

template<typename ImageT , typename MaskT , typename VarianceT >

Statistics makeStatistics ( ImageT const &  img, MaskT const &  msk, VarianceT const &  var, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

Handle a straight front-end to the constructor.

Definition at line 319 of file Statistics.h.

                           {
    return Statistics(img, msk, var, flags, sctrl);
}

template<typename Pixel >

Statistics makeStatistics ( lsst::afw::image::MaskedImage< Pixel > const &  mimg, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

Handle MaskedImages, just pass the getImage() and getMask() values right on through.

Definition at line 333 of file Statistics.h.

{
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance()) {
        return Statistics(*mimg.getImage(), *mimg.getMask(), *mimg.getVariance(), flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mimg.getImage(), *mimg.getMask(), var, flags, sctrl);
    }
}

template<typename Pixel >

Statistics makeStatistics ( lsst::afw::image::MaskedImage< Pixel > const &  mimg, lsst::afw::image::Image< WeightPixel > const &  weights, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

Handle MaskedImages, just pass the getImage() and getMask() values right on through.

Definition at line 352 of file Statistics.h.

{
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance() || 
        (!sctrl.getWeightedIsSet() && (weights.getWidth() != 0 && weights.getHeight() != 0))) {
        return Statistics(*mimg.getImage(), *mimg.getMask(), *mimg.getVariance(), weights, flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mimg.getImage(), *mimg.getMask(), var, weights, flags, sctrl);
    }
}

Statistics makeStatistics ( lsst::afw::image::Mask< lsst::afw::image::MaskPixel > const &  msk, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

Front end for specialization to handle Masks.

Note

The definition (in Statistics.cc) simply calls the specialized constructor

Definition at line 1082 of file Statistics.cc.

                           {
    return Statistics(msk, msk, msk, flags, sctrl);
}

template<typename Pixel >

Statistics makeStatistics ( lsst::afw::image::Image< Pixel > const &  img, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

The makeStatistics() overload to handle regular (non-masked) Images.

Parameters

img	Image (or Image) whose properties we want
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 384 of file Statistics.h.

  {
    // make a phony mask that will be compiled out
    MaskImposter<lsst::afw::image::MaskPixel> const msk;
    MaskImposter<WeightPixel> const var;
    return Statistics(img, msk, var, flags, sctrl);
}

template<typename EntryT >

Statistics makeStatistics ( std::vector< EntryT > const &  v, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

The makeStatistics() overload to handle std::vector<>

Parameters

v	Image (or MaskedImage) whose properties we want
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 431 of file Statistics.h.

                           {
    ImageImposter<EntryT> img(v);           // wrap the vector in a fake image
    MaskImposter<lsst::afw::image::MaskPixel> msk;     // instantiate a fake mask that will be compiled out.
    MaskImposter<WeightPixel> var;
    return Statistics(img, msk, var, flags, sctrl);
}

template<typename EntryT >

Statistics makeStatistics ( std::vector< EntryT > const &  v, std::vector< WeightPixel > const &  vweights, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

The makeStatistics() overload to handle std::vector<>

Parameters

v	Image (or MaskedImage) whose properties we want
vweights	Weights
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 446 of file Statistics.h.

                           {
    ImageImposter<EntryT> img(v);           // wrap the vector in a fake image
    MaskImposter<lsst::afw::image::MaskPixel> msk;     // instantiate a fake mask that will be compiled out.
    MaskImposter<WeightPixel> var;

    ImageImposter<WeightPixel> weights(vweights);
    
    return Statistics(img, msk, var, weights, flags, sctrl);
}

template<typename EntryT >

Statistics makeStatistics ( lsst::afw::math::MaskedVector< EntryT > const &  mv, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>

Parameters

mv	MaskedVector
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 465 of file Statistics.h.

                           {
    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance()) {
        return Statistics(*mv.getImage(), *mv.getMask(), *mv.getVariance(), flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mv.getImage(), *mv.getMask(), var, flags, sctrl);
    }
}

template<typename EntryT >

Statistics makeStatistics ( lsst::afw::math::MaskedVector< EntryT > const &  mv, std::vector< WeightPixel > const &  vweights, int const  flags, StatisticsControl const &  sctrl = StatisticsControl()  )

related

The makeStatistics() overload to handle lsst::afw::math::MaskedVector<>

Parameters

mv	MaskedVector
vweights	weights
flags	Describe what we want to calculate
sctrl	Control calculation

Definition at line 482 of file Statistics.h.

                           {
    ImageImposter<WeightPixel> weights(vweights);

    if (sctrl.getWeighted() || sctrl.getCalcErrorFromInputVariance()) {
        return Statistics(*mv.getImage(), *mv.getMask(), *mv.getVariance(), weights, flags, sctrl);
    } else {
        MaskImposter<WeightPixel> var;
        return Statistics(*mv.getImage(), *mv.getMask(), var, weights, flags, sctrl);
    }
}

Member Data Documentation

lsst::afw::image::MaskPixel lsst.afw.math::Statistics::_allPixelOrMask

private

Definition at line 253 of file Statistics.h.

long lsst.afw.math::Statistics::_flags

private

Definition at line 241 of file Statistics.h.

double lsst.afw.math::Statistics::_iqrange

private

Definition at line 252 of file Statistics.h.

double lsst.afw.math::Statistics::_max

private

Definition at line 247 of file Statistics.h.

Value lsst.afw.math::Statistics::_mean

private

Definition at line 244 of file Statistics.h.

Value lsst.afw.math::Statistics::_meanclip

private

Definition at line 249 of file Statistics.h.

Value lsst.afw.math::Statistics::_median

private

Definition at line 251 of file Statistics.h.

double lsst.afw.math::Statistics::_min

private

Definition at line 246 of file Statistics.h.

int lsst.afw.math::Statistics::_n

private

Definition at line 243 of file Statistics.h.

StatisticsControl lsst.afw.math::Statistics::_sctrl

private

Definition at line 255 of file Statistics.h.

double lsst.afw.math::Statistics::_sum

private

Definition at line 248 of file Statistics.h.

Value lsst.afw.math::Statistics::_variance

private

Definition at line 245 of file Statistics.h.

Value lsst.afw.math::Statistics::_varianceclip

private

Definition at line 250 of file Statistics.h.

bool lsst.afw.math::Statistics::_weightsAreMultiplicative

private

Definition at line 256 of file Statistics.h.

---

The documentation for this class was generated from the following files:

• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/math/Statistics.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/math/Statistics.cc