35 #include <type_traits>
52 double const IQ_TO_STDEV = 0.741301109252802;
58 bool operator()(T)
const {
61 template <
typename Ta,
typename Tb>
62 bool operator()(Ta, Tb)
const {
65 template <
typename Ta,
typename Tb,
typename Tc>
66 bool operator()(Ta, Tb, Tc)
const {
75 bool operator()(T)
const {
78 template <
typename Ta,
typename Tb>
79 bool operator()(Ta, Tb)
const {
82 template <
typename Ta,
typename Tb,
typename Tc>
83 bool operator()(Ta, Tb, Tc)
const {
92 bool operator()(T val)
const {
98 class CheckValueLtMin {
100 template <
typename Tval,
typename Tmin>
101 bool operator()(Tval val, Tmin
min)
const {
102 return (
static_cast<Tmin
>(val) <
min);
107 class CheckValueGtMax {
109 template <
typename Tval,
typename Tmax>
110 bool operator()(Tval val, Tmax
max)
const {
111 return (
static_cast<Tmax
>(val) >
max);
116 class CheckClipRange {
118 template <
typename Tval,
typename Tcen,
typename Tmax>
119 bool operator()(Tval val, Tcen center, Tmax cliplimit)
const {
120 Tmax tmp =
fabs(val - center);
121 return (tmp <= cliplimit);
126 using ChkFin = CheckFinite;
127 using ChkMin = CheckValueLtMin;
128 using ChkMax = CheckValueGtMax;
129 using ChkClip = CheckClipRange;
130 using AlwaysT = AlwaysTrue;
131 using AlwaysF = AlwaysFalse;
136 inline double varianceError(
double const variance,
int const n) {
156 template <
typename IsFinite,
typename HasValueLtMin,
typename HasValueGtMax,
typename InClipRange,
157 bool useWeights,
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
158 StandardReturn processPixels(ImageT
const &img, MaskT
const &msk, VarianceT
const &var,
159 WeightT
const &weights,
int const,
int const nCrude,
int const stride,
160 double const meanCrude,
double const cliplimit,
161 bool const weightsAreMultiplicative,
int const andMask,
162 bool const calcErrorFromInputVariance,
172 double min = (nCrude) ? meanCrude : MAX_DOUBLE;
173 double max = (nCrude) ? meanCrude : -MAX_DOUBLE;
179 for (
int iY = 0; iY < img.getHeight(); iY += stride) {
180 typename MaskT::x_iterator mptr = msk.row_begin(iY);
181 typename VarianceT::x_iterator vptr = var.row_begin(iY);
182 typename WeightT::x_iterator wptr = weights.row_begin(iY);
184 for (
typename ImageT::x_iterator ptr = img.row_begin(iY),
end = ptr + img.getWidth(); ptr !=
end;
185 ++ptr, ++mptr, ++vptr, ++wptr) {
186 if (IsFinite()(*ptr) && !(*mptr & andMask) &&
187 InClipRange()(*ptr, meanCrude, cliplimit)) {
189 double const delta = (*ptr - meanCrude);
192 double weight = *wptr;
193 if (weightsAreMultiplicative) {
203 sumw2 += weight * weight;
204 sumx += weight * delta;
205 sumx2 += weight * delta * delta;
207 if (calcErrorFromInputVariance) {
208 double const var = *vptr;
209 sumvw2 += var * weight * weight;
213 sumx2 += delta * delta;
215 if (calcErrorFromInputVariance) {
216 double const var = *vptr;
221 allPixelOrMask |= *mptr;
223 if (HasValueLtMin()(*ptr,
min)) {
226 if (HasValueGtMax()(*ptr,
max)) {
231 for (
int bit = 0, nBits = maskPropagationThresholds.
size(); bit < nBits; ++bit) {
237 if (!weightsAreMultiplicative) {
241 weight = 1.0 / weight;
244 rejectedWeightsByBit[bit] += weight;
261 for (
int bit = 0, nBits = maskPropagationThresholds.
size(); bit < nBits; ++bit) {
262 double hypotheticalTotalWeight = sumw + rejectedWeightsByBit[bit];
263 rejectedWeightsByBit[bit] /= hypotheticalTotalWeight;
264 if (rejectedWeightsByBit[bit] > maskPropagationThresholds[bit]) {
265 allPixelOrMask |= (1 << bit);
274 variance *= sumw * sumw / (sumw * sumw - sumw2);
277 if (calcErrorFromInputVariance) {
278 meanVar = sumvw2 / (sumw * sumw);
280 meanVar =
variance * sumw2 / (sumw * sumw);
283 double varVar = varianceError(
variance, n);
285 sumx += sumw * meanCrude;
288 return StandardReturn(n, sumx, Statistics::Value(mean, meanVar), Statistics::Value(
variance, varVar),
min,
289 max, allPixelOrMask);
292 template <
typename IsFinite,
typename HasValueLtMin,
typename HasValueGtMax,
typename InClipRange,
293 bool useWeights,
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
294 StandardReturn processPixels(ImageT
const &img, MaskT
const &msk, VarianceT
const &var,
295 WeightT
const &weights,
int const flags,
int const nCrude,
int const stride,
296 double const meanCrude,
double const cliplimit,
297 bool const weightsAreMultiplicative,
int const andMask,
298 bool const calcErrorFromInputVariance,
bool doGetWeighted,
301 return processPixels<IsFinite, HasValueLtMin, HasValueGtMax, InClipRange, true>(
302 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
303 andMask, calcErrorFromInputVariance, maskPropagationThresholds);
305 return processPixels<IsFinite, HasValueLtMin, HasValueGtMax, InClipRange, false>(
306 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
307 andMask, calcErrorFromInputVariance, maskPropagationThresholds);
311 template <
typename IsFinite,
typename HasValueLtMin,
typename HasValueGtMax,
typename InClipRange,
312 bool useWeights,
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
313 StandardReturn processPixels(ImageT
const &img, MaskT
const &msk, VarianceT
const &var,
314 WeightT
const &weights,
int const flags,
int const nCrude,
int const stride,
315 double const meanCrude,
double const cliplimit,
316 bool const weightsAreMultiplicative,
int const andMask,
317 bool const calcErrorFromInputVariance,
bool doCheckFinite,
bool doGetWeighted,
320 return processPixels<CheckFinite, HasValueLtMin, HasValueGtMax, InClipRange, useWeights>(
321 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
322 andMask, calcErrorFromInputVariance, doGetWeighted, maskPropagationThresholds);
324 return processPixels<AlwaysTrue, HasValueLtMin, HasValueGtMax, InClipRange, useWeights>(
325 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
326 andMask, calcErrorFromInputVariance, doGetWeighted, maskPropagationThresholds);
347 template <
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
348 StandardReturn getStandard(ImageT
const &img, MaskT
const &msk, VarianceT
const &var, WeightT
const &weights,
349 int const flags,
bool const weightsAreMultiplicative,
int const andMask,
350 bool const calcErrorFromInputVariance,
bool doCheckFinite,
bool doGetWeighted,
355 double meanCrude = 0.0;
358 int const nPix = img.getWidth() * img.getHeight();
366 double cliplimit = -1;
367 StandardReturn values = processPixels<ChkFin, AlwaysF, AlwaysF, AlwaysT, true>(
368 img, msk, var, weights, flags, nCrude, strideCrude, meanCrude, cliplimit,
369 weightsAreMultiplicative, andMask, calcErrorFromInputVariance, doCheckFinite, doGetWeighted,
370 maskPropagationThresholds);
371 nCrude = std::get<0>(values);
372 double sumCrude = std::get<1>(values);
376 meanCrude = sumCrude / nCrude;
383 if (flags & (
MIN |
MAX)) {
384 return processPixels<ChkFin, ChkMin, ChkMax, AlwaysT, true>(
385 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
386 andMask, calcErrorFromInputVariance,
true, doGetWeighted, maskPropagationThresholds);
388 return processPixels<ChkFin, AlwaysF, AlwaysF, AlwaysT, true>(
389 img, msk, var, weights, flags, nCrude, 1, meanCrude, cliplimit, weightsAreMultiplicative,
390 andMask, calcErrorFromInputVariance, doCheckFinite, doGetWeighted, maskPropagationThresholds);
412 template <
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
413 StandardReturn getStandard(ImageT
const &img, MaskT
const &msk, VarianceT
const &var, WeightT
const &weights,
416 bool const weightsAreMultiplicative,
int const andMask,
417 bool const calcErrorFromInputVariance,
bool doCheckFinite,
bool doGetWeighted,
419 double const center = clipinfo.first;
420 double const cliplimit = clipinfo.second;
423 return StandardReturn(0, NaN, Statistics::Value(NaN, NaN), Statistics::Value(NaN, NaN), NaN, NaN,
429 int const stride = 1;
432 if (flags & (
MIN |
MAX)) {
433 return processPixels<ChkFin, ChkMin, ChkMax, ChkClip, true>(
434 img, msk, var, weights, flags, nCrude, stride, center, cliplimit, weightsAreMultiplicative,
435 andMask, calcErrorFromInputVariance,
true, doGetWeighted, maskPropagationThresholds);
437 return processPixels<ChkFin, AlwaysF, AlwaysF, ChkClip, true>(
438 img, msk, var, weights, flags, nCrude, stride, center, cliplimit, weightsAreMultiplicative,
439 andMask, calcErrorFromInputVariance, doCheckFinite, doGetWeighted, maskPropagationThresholds);
451 template <
typename Pixel>
454 assert(fraction >= 0.0 && fraction <= 1.0);
456 int const n = img.
size();
459 double const idx = fraction * (n - 1);
467 int const q1 =
static_cast<int>(idx);
468 int const q2 = q1 + 1;
470 auto mid1 = img.
begin() + q1;
471 auto mid2 = img.
begin() + q2;
472 if (fraction > 0.5) {
480 double val1 =
static_cast<double>(*mid1);
481 double val2 =
static_cast<double>(*mid2);
482 double w1 = (
static_cast<double>(q2) - idx);
483 double w2 = (idx -
static_cast<double>(q1));
484 return w1 * val1 + w2 * val2;
517 for (
auto ptr =
begin; ptr !=
end; ++ptr) {
518 auto const val = *ptr;
521 }
else if (val == naive) {
537 template <
typename Pixel>
540 assert(fraction >= 0.0 && fraction <= 1.0);
542 auto const n = img.
size();
556 double const idx = fraction*(n - 1);
558 auto midP = img.
begin() +
static_cast<int>(idx);
560 auto const naiveP = *midP;
562 return computeQuantile(img.
begin(), img.
end(), naiveP, fraction*n);
576 template <
typename Pixel>
579 int const n = img.
size();
582 double const idx50 = 0.50 * (n - 1);
583 double const idx25 = 0.25 * (n - 1);
584 double const idx75 = 0.75 * (n - 1);
591 int const q50a =
static_cast<int>(idx50);
592 int const q50b = q50a + 1;
593 int const q25a =
static_cast<int>(idx25);
594 int const q25b = q25a + 1;
595 int const q75a =
static_cast<int>(idx75);
596 int const q75b = q75a + 1;
598 auto mid50a = img.
begin() + q50a;
599 auto mid50b = img.
begin() + q50b;
600 auto mid25a = img.
begin() + q25a;
601 auto mid25b = img.
begin() + q25b;
602 auto mid75a = img.
begin() + q75a;
603 auto mid75b = img.
begin() + q75b;
616 double val50a =
static_cast<double>(*mid50a);
617 double val50b =
static_cast<double>(*mid50b);
618 double w50a = (
static_cast<double>(q50b) - idx50);
619 double w50b = (idx50 -
static_cast<double>(q50a));
620 double median = w50a * val50a + w50b * val50b;
622 double val25a =
static_cast<double>(*mid25a);
623 double val25b =
static_cast<double>(*mid25b);
624 double w25a = (
static_cast<double>(q25b) - idx25);
625 double w25b = (idx25 -
static_cast<double>(q25a));
626 double q1 = w25a * val25a + w25b * val25b;
628 double val75a =
static_cast<double>(*mid75a);
629 double val75b =
static_cast<double>(*mid75b);
630 double w75a = (
static_cast<double>(q75b) - idx75);
631 double w75b = (idx75 -
static_cast<double>(q75a));
632 double q3 = w75a * val75a + w75b * val75b;
634 return MedianQuartileReturn(median, q1, q3);
636 return MedianQuartileReturn(img[0], img[0], img[0]);
638 return MedianQuartileReturn(NaN, NaN, NaN);
649 template <
typename Pixel>
652 auto const n = img.
size();
655 return MedianQuartileReturn(NaN, NaN, NaN);
657 return MedianQuartileReturn(img[0], img[0], img[0]);
669 auto mid25 = img.
begin() +
static_cast<int>(0.25*(n - 1));
670 auto mid50 = img.
begin() +
static_cast<int>(0.50*(n - 1));
671 auto mid75 = img.
begin() +
static_cast<int>(0.75*(n - 1));
678 double const q1 = computeQuantile(img.
begin(), mid50, *mid25,
680 double const median = computeQuantile(mid25, mid75, *mid50,
681 0.50*n - (mid25 - img.
begin()));
682 double const q3 = computeQuantile(mid50, img.
end(), *mid75,
683 0.75*n - (mid50 - img.
begin()));
685 return MedianQuartileReturn(median, q1, q3);
697 template <
typename IsFinite,
typename ImageT,
typename MaskT,
typename VarianceT>
699 VarianceT
const &,
int const andMask) {
704 for (
int i_y = 0; i_y < img.getHeight(); ++i_y) {
705 typename MaskT::x_iterator mptr = msk.row_begin(i_y);
706 for (
typename ImageT::x_iterator ptr = img.row_begin(i_y),
end = img.row_end(i_y); ptr !=
end;
708 if (IsFinite()(*ptr) && !(*mptr & andMask)) {
709 imgcp->push_back(*ptr);
719 double StatisticsControl::getMaskPropagationThreshold(
int bit)
const {
720 int oldSize = _maskPropagationThresholds.size();
721 if (oldSize <= bit) {
724 return _maskPropagationThresholds[bit];
727 void StatisticsControl::setMaskPropagationThreshold(
int bit,
double threshold) {
728 int oldSize = _maskPropagationThresholds.size();
729 if (oldSize <= bit) {
730 int newSize = bit + 1;
731 _maskPropagationThresholds.resize(newSize);
732 for (
int i = oldSize; i < bit; ++i) {
733 _maskPropagationThresholds[i] = 1.0;
736 _maskPropagationThresholds[bit] = threshold;
741 if (statisticsProperty.
size() == 0) {
742 statisticsProperty[
"NOTHING"] =
NOTHING;
743 statisticsProperty[
"ERRORS"] =
ERRORS;
744 statisticsProperty[
"NPOINT"] =
NPOINT;
745 statisticsProperty[
"MEAN"] =
MEAN;
746 statisticsProperty[
"STDEV"] =
STDEV;
747 statisticsProperty[
"VARIANCE"] =
VARIANCE;
748 statisticsProperty[
"MEDIAN"] =
MEDIAN;
749 statisticsProperty[
"IQRANGE"] =
IQRANGE;
750 statisticsProperty[
"MEANCLIP"] =
MEANCLIP;
751 statisticsProperty[
"STDEVCLIP"] =
STDEVCLIP;
753 statisticsProperty[
"MIN"] =
MIN;
754 statisticsProperty[
"MAX"] =
MAX;
755 statisticsProperty[
"SUM"] =
SUM;
756 statisticsProperty[
"MEANSQUARE"] =
MEANSQUARE;
757 statisticsProperty[
"ORMASK"] =
ORMASK;
758 statisticsProperty[
"NCLIPPED"] =
NCLIPPED;
759 statisticsProperty[
"NMASKED"] =
NMASKED;
761 return statisticsProperty[property];
764 template <
typename ImageT,
typename MaskT,
typename VarianceT>
765 Statistics::Statistics(ImageT
const &img, MaskT
const &msk, VarianceT
const &var,
int const flags,
774 _varianceclip(NaN, NaN),
780 _weightsAreMultiplicative(false) {
781 doStatistics(img, msk, var, var, _flags, _sctrl);
785 template <
typename T>
786 bool isEmpty(T
const &t) {
790 template <
typename T>
796 template <
typename ImageT1,
typename ImageT2>
797 void checkDimensions(ImageT1
const &image1, ImageT2
const &image2) {
798 if (image1.getDimensions() != image2.getDimensions()) {
800 (boost::format(
"Image sizes don't match: %s vs %s") % image1.getDimensions() %
801 image2.getDimensions())
807 template <
typename ImageT,
typename PixelT>
808 void checkDimensions(ImageT
const &image1, MaskImposter<PixelT>
const &image2) {}
809 template <
typename ImageT,
typename PixelT>
810 void checkDimensions(MaskImposter<PixelT>
const &image1, ImageT
const &image2) {}
813 template <
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
823 _varianceclip(NaN, NaN),
829 _weightsAreMultiplicative(true) {
830 if (!isEmpty(weights)) {
833 "You must use the weights if you provide them");
838 doStatistics(img, msk, var, weights, _flags, _sctrl);
841 template <
typename ImageT,
typename MaskT,
typename VarianceT,
typename WeightT>
842 void Statistics::doStatistics(ImageT
const &img, MaskT
const &msk, VarianceT
const &var,
844 int const num = img.getWidth() * img.getHeight();
849 checkDimensions(img, msk);
850 checkDimensions(img, var);
852 checkDimensions(img, weights);
859 StandardReturn standard =
860 getStandard(img, msk, var, weights, flags, _weightsAreMultiplicative, _sctrl.
getAndMask(),
862 _sctrl._maskPropagationThresholds);
864 _n = std::get<0>(standard);
865 _sum = std::get<1>(standard);
866 _mean = std::get<2>(standard);
867 _variance = std::get<3>(standard);
868 _min = std::get<4>(standard);
869 _max = std::get<5>(standard);
870 _allPixelOrMask = std::get<6>(standard);
884 imgcp = makeVectorCopy<ChkFin>(img, msk, var, _sctrl.
getAndMask());
886 imgcp = makeVectorCopy<AlwaysT>(img, msk, var, _sctrl.
getAndMask());
891 _median =
Value(percentile(*imgcp, 0.5), NaN);
893 MedianQuartileReturn mq = medianAndQuartiles(*imgcp);
894 _median =
Value(std::get<0>(mq), NaN);
895 _iqrange = std::get<2>(mq) - std::get<1>(mq);
899 for (
int i_i = 0; i_i < _sctrl.
getNumIter(); ++i_i) {
900 double const center = ((i_i > 0) ? _meanclip : _median).first;
901 double const hwidth = (i_i > 0 && _n > 1)
903 : _sctrl.getNumSigmaClip() * IQ_TO_STDEV * _iqrange;
906 StandardReturn clipped = getStandard(
907 img, msk, var, weights, flags, clipinfo, _weightsAreMultiplicative,
909 _sctrl.
getWeighted(), _sctrl._maskPropagationThresholds);
911 int const nClip = std::get<0>(clipped);
912 _nClipped = _n - nClip;
913 _meanclip = std::get<2>(clipped);
914 double const varClip = std::get<3>(clipped).first;
916 _varianceclip =
Value(varClip, varianceError(varClip, nClip));
927 if (!(prop & _flags)) {
929 (boost::format(
"You didn't ask me to calculate %d") % prop).str());
935 ret.first =
static_cast<double>(_n);
942 ret.first =
static_cast<double>(_nClipped);
949 ret.first =
static_cast<double>(_nMasked);
956 ret.first =
static_cast<double>(_sum);
964 ret.first = _mean.first;
966 ret.second = ::sqrt(_mean.second);
970 ret.first = _meanclip.first;
972 ret.second = ::sqrt(_meanclip.second);
978 ret.first = _variance.first;
980 ret.second = ::sqrt(_variance.second);
984 ret.first =
sqrt(_variance.first);
986 ret.second = 0.5 * ::sqrt(_variance.second) / ret.first;
990 ret.first = _varianceclip.first;
992 ret.second = ret.second;
996 ret.first =
sqrt(_varianceclip.first);
998 ret.second = 0.5 * ::sqrt(_varianceclip.second) / ret.first;
1003 ret.first = (_n - 1) /
static_cast<double>(_n) * _variance.first + ::pow(_mean.first, 2);
1005 ret.second = ::sqrt(2 * ::
pow(ret.first / _n, 2));
1023 ret.first = _median.first;
1029 ret.first = _iqrange;
1042 "getValue() may only be called without a parameter"
1043 " if you asked for only one statistic");
1067 _variance(NaN, NaN),
1070 _meanclip(NaN, NaN),
1071 _varianceclip(NaN, NaN),
1078 "Statistics<Mask> only supports NPOINT and SUM");
1107 return Statistics(msk, msk, msk, flags, sctrl);
1118 #define STAT Statistics
1122 #define INSTANTIATE_MASKEDIMAGE_STATISTICS(TYPE) \
1123 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1124 image::Image<VPixel> const &var, int const flags, \
1125 StatisticsControl const &sctrl); \
1126 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1127 image::Image<VPixel> const &var, image::Image<VPixel> const &weights, \
1128 int const flags, StatisticsControl const &sctrl); \
1129 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1130 image::Image<VPixel> const &var, ImageImposter<VPixel> const &weights, \
1131 int const flags, StatisticsControl const &sctrl)
1133 #define INSTANTIATE_MASKEDIMAGE_STATISTICS_NO_MASK(TYPE) \
1134 template STAT::Statistics(image::Image<TYPE> const &img, MaskImposter<image::MaskPixel> const &msk, \
1135 image::Image<VPixel> const &var, int const flags, \
1136 StatisticsControl const &sctrl); \
1137 template STAT::Statistics(image::Image<TYPE> const &img, MaskImposter<image::MaskPixel> const &msk, \
1138 image::Image<VPixel> const &var, image::Image<VPixel> const &weights, \
1139 int const flags, StatisticsControl const &sctrl)
1141 #define INSTANTIATE_MASKEDIMAGE_STATISTICS_NO_VAR(TYPE) \
1142 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1143 MaskImposter<VPixel> const &var, int const flags, \
1144 StatisticsControl const &sctrl); \
1145 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1146 MaskImposter<VPixel> const &var, image::Image<VPixel> const &weights, \
1147 int const flags, StatisticsControl const &sctrl); \
1148 template STAT::Statistics(image::Image<TYPE> const &img, image::Mask<image::MaskPixel> const &msk, \
1149 MaskImposter<VPixel> const &var, ImageImposter<VPixel> const &weights, \
1150 int const flags, StatisticsControl const &sctrl)
1152 #define INSTANTIATE_REGULARIMAGE_STATISTICS(TYPE) \
1153 template STAT::Statistics(image::Image<TYPE> const &img, MaskImposter<image::MaskPixel> const &msk, \
1154 MaskImposter<VPixel> const &var, int const flags, \
1155 StatisticsControl const &sctrl)
1157 #define INSTANTIATE_VECTOR_STATISTICS(TYPE) \
1158 template STAT::Statistics(ImageImposter<TYPE> const &img, MaskImposter<image::MaskPixel> const &msk, \
1159 MaskImposter<VPixel> const &var, int const flags, \
1160 StatisticsControl const &sctrl); \
1161 template STAT::Statistics(ImageImposter<TYPE> const &img, MaskImposter<image::MaskPixel> const &msk, \
1162 MaskImposter<VPixel> const &var, ImageImposter<VPixel> const &weights, \
1163 int const flags, StatisticsControl const &sctrl)
1165 #define INSTANTIATE_IMAGE_STATISTICS(T) \
1166 INSTANTIATE_MASKEDIMAGE_STATISTICS(T); \
1167 INSTANTIATE_MASKEDIMAGE_STATISTICS_NO_VAR(T); \
1168 INSTANTIATE_MASKEDIMAGE_STATISTICS_NO_MASK(T); \
1169 INSTANTIATE_REGULARIMAGE_STATISTICS(T); \
1170 INSTANTIATE_VECTOR_STATISTICS(T)
1172 INSTANTIATE_IMAGE_STATISTICS(
double);
1173 INSTANTIATE_IMAGE_STATISTICS(
float);
1174 INSTANTIATE_IMAGE_STATISTICS(
int);
Key< Flag > const & target
#define LSST_EXCEPT(type,...)
int getWidth() const
Return the number of columns in the image.
int getHeight() const
Return the number of rows in the image.
x_iterator row_begin(int y) const
Return an x_iterator to the start of the y'th row.
x_iterator row_end(int y) const
Return an x_iterator to the end of the y'th row.
A class to represent a 2-dimensional array of pixels.
Represent a 2-dimensional array of bitmask pixels.
Pass parameters to a Statistics object.
bool getCalcErrorFromInputVariance() const noexcept
int getAndMask() const noexcept
bool getWeightedIsSet() const noexcept
void setWeighted(bool useWeights) noexcept
double getNumSigmaClip() const noexcept
bool getWeighted() const noexcept
int getNumIter() const noexcept
bool getNanSafe() const noexcept
A class to evaluate image statistics.
Value getResult(Property const prop=NOTHING) const
Return the value and error in the specified statistic (e.g.
double getError(Property const prop=NOTHING) const
Return the error in the desired property (if specified in the constructor)
Statistics(ImageT const &img, MaskT const &msk, VarianceT const &var, int const flags, StatisticsControl const &sctrl=StatisticsControl())
Constructor for Statistics object.
double getValue(Property const prop=NOTHING) const
Return the value of the desired property (if specified in the constructor)
std::pair< double, double > Value
The type used to report (value, error) for desired statistics.
float VariancePixel
default type for MaskedImage variance images
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)
Property
control what is calculated
@ ORMASK
get the or-mask of all pixels used.
@ ERRORS
Include errors of requested quantities.
@ VARIANCECLIP
estimate sample N-sigma clipped variance (N set in StatisticsControl, default=3)
@ MEANSQUARE
find mean value of square of pixel values
@ MIN
estimate sample minimum
@ NCLIPPED
number of clipped points
@ NOTHING
We don't want anything.
@ STDEV
estimate sample standard deviation
@ NMASKED
number of masked points
@ STDEVCLIP
estimate sample N-sigma clipped stdev (N set in StatisticsControl, default=3)
@ VARIANCE
estimate sample variance
@ MEDIAN
estimate sample median
@ MAX
estimate sample maximum
@ SUM
find sum of pixels in the image
@ IQRANGE
estimate sample inter-quartile range
@ MEAN
estimate sample mean
@ MEANCLIP
estimate sample N-sigma clipped mean (N set in StatisticsControl, default=3)
@ NPOINT
number of sample points
Property stringToStatisticsProperty(std::string const property)
Conversion function to switch a string to a Property (see Statistics.h)
A base class for image defects.