casacore
LatticeStatistics.h
Go to the documentation of this file.
1 //# LatticeStatistics.h: generate statistics from a Lattice
2 //# Copyright (C) 1996,1997,1998,1999,2000,2001,2002,2003
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id$
27 
28 #ifndef LATTICES_LATTICESTATISTICS_H
29 #define LATTICES_LATTICESTATISTICS_H
30 
31 #include <casacore/casa/aips.h>
32 #include <casacore/casa/Arrays/Array.h>
33 #include <casacore/casa/Containers/Block.h>
34 #include <casacore/casa/Arrays/Vector.h>
35 #include <casacore/casa/Containers/Record.h>
36 #include <casacore/lattices/LatticeMath/LatticeStatsBase.h>
37 #include <casacore/lattices/LatticeMath/TiledCollapser.h>
38 #include <casacore/lattices/LatticeMath/TiledCollapser.h>
39 #include <casacore/lattices/LEL/LatticeExprNode.h>
40 #include <casacore/lattices/LatticeMath/LatticeStatsDataProvider.h>
41 #include <casacore/lattices/LatticeMath/MaskedLatticeStatsDataProvider.h>
42 #include <casacore/scimath/Mathematics/NumericTraits.h>
43 #include <casacore/casa/Utilities/DataType.h>
44 #include <casacore/casa/BasicSL/String.h>
45 #include <casacore/casa/Logging/LogIO.h>
46 #include <casacore/scimath/Mathematics/FitToHalfStatisticsData.h>
47 #include <casacore/scimath/Mathematics/StatisticsData.h>
48 #include <casacore/scimath/Mathematics/StatisticsAlgorithm.h>
49 #include <vector>
50 #include <list>
51 
52 namespace casacore { //# NAMESPACE CASACORE - BEGIN
53 
54 //# Forward Declarations
55 template <class T> class MaskedLattice;
56 template <class T> class TempLattice;
57 class IPosition;
58 
59 #include <casacore/casa/iosstrfwd.h>
60 
61 
62 // <summary>
63 // Compute and display various statistics from a lattice
64 // </summary>
65 // <use visibility=export>
66 // <reviewed reviewer="" date="yyyy/mm/dd" tests="" demos="">
67 // </reviewed>
68 // <prerequisite>
69 // <li> <linkto class=LatticeStatsBase>LatticeStatsBase</linkto>
70 // <li> <linkto class=MaskedLattice>MaskedLattice</linkto>
71 // </prerequisite>
72 
73 // <etymology>
74 // This is a class designed to display and retrieve statistics from lattices
75 // </etymology>
76 
77 // <synopsis>
78 // This class enable you to display and/or retrieve statistics evaluated over
79 // specified regions of a lattice. The dimension of the region is arbitrary, but
80 // the size of each dimension is always the shape of the corresponding lattice axis.
81 // The statistics are displayed as a function of location of the axes not
82 // used to evaluate the statistics over. The axes which you evaluate the statistics
83 // over are called the cursor axes, the others are called the display axes.
84 //
85 // For example, consider a lattice cube (call the axes xyz or [0,1,2]). You could
86 // display statistics from xy planes (cursor axes [0,1]) as a function of z (display
87 // axes [2]). Or you could retrieve statistics from the z axis (cursor axes [2])
88 // for each [x,y] location (display axes [0,1]).
89 //
90 // This class inherits from <linkto class="LatticeStatsBase">LatticeStatsBase</linkto>
91 // This base class provides an <src>enum</src> defining allowed statistics types and a
92 // helper function to convert between a <src>String</src> and a
93 // <src>Vector<Int></src> describing the desired statistics to plot.
94 // An example is shown below.
95 //
96 // This class can list, plot and retrieve statistics. When it lists statistics,
97 // it always lists all the available statistics. When you plot statistics,
98 // you must specify which ones you would like to see.
99 //
100 // This class generates a "storage lattice" into which it writes the accumulated
101 // statistical sums. It is from this storage lattice that the plotting and retrieval
102 // arrays are drawn. The storage lattice is either in core or on disk
103 // depending upon its size (if > 10% of memory given by .aipsrc system.resources.memory
104 // then it goes into a disk-based PagedArray). If on disk, the
105 // storage lattice is deleted when the <src>LatticeStatistics</src> class
106 // object destructs. However, currently, if the process is terminated ungracefully,
107 // the storage lattice will be left over.
108 // </synopsis>
109 //
110 // <note role=tip>
111 // This class has a few virtual functions; they are not part of a nice general
112 // polymorphic interface; rather they have specialized functionality. The idea
113 // of these is that you can derive a class from LatticeStatistics, such as
114 // <linkto class="ImageStatistics">ImageStatistics</linkto> which provides
115 // you with a little more information when displaying/logging the
116 // statistics (such as world coordinates)
117 // The virtual functions are
118 // <ul>
119 // <li> <src>getBeamArea</src> can be used to return the synthesized beam
120 // area so that the FLUX statistic can be computed
121 // <li> <src>listStats</src> is used to list the statistics to the logger
122 // <li> <src>getLabelsM</src> find the X-axis label and the title label
123 // for the plotting.
124 // </ul>
125 // </note>
126 //
127 // <note role=tip>
128 // If you ignore return error statuses from the functions that set the
129 // state of the class, the internal status of the class is set to bad.
130 // This means it will just keep on returning error conditions until you
131 // explicitly recover the situation. A message describing the last
132 // error condition can be recovered with function errorMessage.
133 // </note>
134 
135 
136 // <example>
137 // <srcBlock>
139 //
140 // PagedImage<Float> inImage(inName);
141 //
143 //
144 // LogOrigin or("myClass", "myFunction(...)", WHERE);
145 // LogIO os(or);
146 // LatticeStatistics<Float> stats(SubImage<FLoat>(inImage), os);
147 //
149 //
150 // Vector<Int> cursorAxes(2)
151 // cursorAxes(0) = 1;
152 // cursorAxes(1) = 2;
153 // if (!stats.setAxes(cursorAxes)) return 1;
154 //
156 //
157 // if (!stats.setList(True)) return 1;
158 // String device = "/xs";
159 // Vector<Int> nxy(2);
160 // nxy(0) = 1;
161 // nxy(1) = 1;
162 // Vector<Int> statsToPlot = LatticeStatsBase::toStatisticTypes("mean,rms,sigma");
163 // if (!stats.setPlotting(statsToPlot, device, nxy)) return 1;
164 //
166 //
167 // if (!stats.display ()) return 1;
168 //
170 //
171 // Array<Double> sum;
172 // if (!stats.getStatistic(sum, LatticeStatsBase::SUM)) return 1;
173 //
174 // </srcBlock>
175 // In this example, a <src>PagedImage</src> is constructed (which isA
176 // MaskedLattice) with . We set the cursor axes
177 // to be the y and z axes, we specify to list the statistics if we plot them,
178 // and we ask to plot the mean, standard deviation, and root mean square of each
179 // yz plane as a function of x location on the PGPLOT device "/xs" with
180 // 1 subplot per page (there will be only one in this case). After the
181 // plotting and listing, we also retrieve the sum of the selected pixels
182 // as a function of x location into an array.
183 // </example>
184 
185 // <motivation>
186 // The generation of statistical information from a lattice is a basic
187 // and necessary capability.
188 // </motivation>
189 
190 // <todo asof="1996/11/26">
191 // <li> Implement plotting for complex lattices
192 // <li> Retrieve statistics at specified location of display axes
193 // </todo>
194 
195 
196 template <class T> class LatticeStatistics : public LatticeStatsBase
197 {
198 
199 public:
200 
201 
203 
204  struct AlgConf {
206  // hinges-fences f factor
208  // fit to have center type
210  // fit to half data portion to use
212  // fit to half center value
213  AccumType cv;
214  // Chauvenet zscore
216  // Chauvenet max iterations
218  };
219 
220 // Constructor takes the lattice and a <src>LogIO</src> object for logging.
221 // You can specify whether you want to see progress meters or not.
222 // You can force the storage lattice to be disk based, otherwise
223 // the decision for core or disk is taken for you.
224 // If <src>clone</src> is True, the input lattice will be cloned, so the caller
225 // can make changes to the input lattice, but the statistics will reflect the
226 // lattice as it was at construction. If False, a reference to the input lattice
227 // is used, and so the caller shouldn't make changes to the input lattice between
228 // construction and calling statistics computation methods, unless it calls setNewLattice()
229 // to update the changed lattice. Obviously, cloning the lattice impacts performance
230 // and memory usage.
231  LatticeStatistics (const MaskedLattice<T>& lattice,
232  LogIO& os,
233  Bool showProgress=True,
234  Bool forceDisk=False,
235  Bool clone=True);
236 
237 // Constructor takes the lattice only. In the absence of a logger you get no messages.
238 // This includes error messages and potential listing of the statistics.
239 // You can specify whether you want to see progress meters or not.
240 // You can force the storage lattice to be disk based, otherwise
241 // the decision for core or disk is taken for you.
242  LatticeStatistics (const MaskedLattice<T>& lattice,
243  Bool showProgress=True,
244  Bool forceDisk=False,
245  Bool clone=True);
246 
247 // Copy constructor. Copy semantics are followed. Therefore any storage lattice
248 // that has already been created for <src>other</src> is copied to <src>*this</src>
250 
251 // Destructor
252  virtual ~LatticeStatistics ();
253 
254 // Assignment operator. Deletes any storage lattice associated with
255 // the object being assigned to and copies any storage lattice that has
256 // already been created for "other".
258 
259 // Set the cursor axes (0 relative). A return value of <src>False</src>
260 // indicates you have asked for an invalid axis. The default state of the class
261 // is to set the cursor axes to all axes in the lattice.
262  Bool setAxes (const Vector<Int>& cursorAxes);
263 
264 // You may specify a pixel intensity range as either one for which
265 // all pixels in that range are included or one for which all pixels
266 // in that range are excluded. One or the other of <src>include</src>
267 // and <src>exclude</src> must therefore be a zero length vector if you
268 // call this function. If you are setting an <src>include</src>
269 // range, then if you set <src>setMinMaxToInclude=True</src>, the
270 // minimum and maximum values that this class returns will always be
271 // the minimum and maximum of the <src>include</src> range, respectively.
272 // A return value of <src>False</src> indicates that
273 // you have given both an <src>include</src> and an <src>exclude</src>
274 // range. A vector of length 1 for <src>include</src> and/or <src>exclude</src>
275 // means that the range will be set to (say for <src>include</src>)
276 // <src>-abs(include(0))</src> to <src>abs(include(0))</src>. A return value
277 // of <src>False</src> indicates that both an inclusion and exclusion
278 // range were given or that the internal state of the class is bad. If you don't
279 // call this function, the default state of the class is to include all pixels.
280  Bool setInExCludeRange(const Vector<T>& include,
281  const Vector<T>& exclude,
282  Bool setMinMaxToInclude=False);
283 
284 // This function allows you to control whether the statistics are written to
285 // the output stream if you are also making a plot. A return value of
286 // <src>False</src> indicates that the internal state of the class is bad.
287 // If you have created the <src>LatticeStatistics</src> object without
288 // a <src>LogIO</src> object, you won't see any listings, but no error
289 // conditions will be generated. The default state of the class is to
290 // not list the output when making a plot.
291  Bool setList(const Bool& doList);
292 
293 // Display the statistics by listing and/or plotting them. If you don't call
294 // this function then you won't see anything ! A return value of <src>False</src>
295 // indicates an invalid plotting device, or that the internal state of the class is bad.
296 
297  Bool display();
298 
299  Bool getLayerStats(String& stats, Double area,
300  Int zAxis=-1, Int zLayer=-1,
301  Int hAxis=-1, Int hLayer=-1);
302 
303  typedef std::pair<String,String> stat_element;
304  typedef std::list<stat_element> stat_list;
305  Bool getLayerStats( stat_list &stats, Double area,
306  Int zAxis=-1, Int zLayer=-1,
307  Int hAxis=-1, Int hLayer=-1);
308 
309 // Return the display axes. The returned vector will be valid only if <src>setAxes</src>
310 // has been called, or if one of the active "display" or "get*" methods has been called.
312 
313 // Recover the desired Statistic into an array. If you choose to use
314 // the T version, be aware that the values in the AccumType version of the
315 // Array may not be representable in the T version (e.g. large values for
316 // SumSq). The shape of the
317 // array is the shape of the display axes (e.g. if the shape of the lattice is
318 // [nx,ny,nz] and you ask for the mean of the y axis the shape of the returned
319 // array would be [nx,nz]. A returned array of zero shape indicates that there
320 // were no good values. A return value of <src>False</src>
321 // indicates that the internal state of the class is bad.
322 // <group>
325 // </group>
326 
327 // Recover position of min and max. Only works if there are no
328 // display axes (i.e. statistics found over entire image), otherwise,
329 // the returned values are resized to 0 shape. A return
330 // value of <src>False</src> indicates that the internal state of
331 // the class is bad.
332  Bool getMinMaxPos(IPosition& minPos, IPosition& maxPos);
333 
334 // This function gets a vector containing all the statistics
335 // for a given location. If <src>posInLattice=True</src> then
336 // the location is a location in the input lattice. Any
337 // positions on the display axes are ignored. Otherwise, you
338 // should just give locations for the display axes only.
339 // Use can use the enum in class LatticeStatsBase to find out
340 // which locations in the vector contain which statistics.
341 // A returned vector of zero shape indicates that there
342 // were no good values. A return value of <src>False</src>
343 // indicates that the internal state of the class is bad.
345  const IPosition& pos,
346  const Bool posInLattice=False);
347 
348 // Reset argument error condition. If you specify invalid arguments to
349 // one of the above <src>set</src> functions, an internal flag will be set which will
350 // prevent the work functions from doing anything (should you have chosen
351 // to ignore the Boolean return values of the <src>set</src> functions).
352 // This function allows you to reset that internal state to good.
354 
355 // Get full lattice min and max only. Returns False if no unmasked data, else returns True.
356 // Honours any include or exclude range if set.
357  Bool getFullMinMax (T& dataMin, T& dataMax);
358 
359 // Recover last error message
360  String errorMessage() const {return error_p;};
361 
362 // Set a new MaskedLattice object. A return value of <src>False</src> indicates the
363 // lattice had an invalid type or that the internal state of the class is bad.
364 // If <src>clone</src> is True, the input lattice will be cloned, so the caller
365 // can make changes to the input lattice, but the statistics will reflect the
366 // lattice as it was at construction. If False, a reference to the input lattice
367 // is used, and so the caller shouldn't make changes to the input lattice between
368 // construction and calling statistics computation methods, unless it calls setNewLattice()
369 // to update the changed lattice. Obviously, cloning the lattice impacts performance
370 // and memory usage.
371  Bool setNewLattice(const MaskedLattice<T>& lattice, Bool clone=True);
372 
373 // Did we construct with a logger ?
374  Bool hasLogger () const {return haveLogger_p;};
375 
376  // configure object to use Classical Statistics
377  // The time, t_x, it takes to compute classical statistics using algorithm x, can
378  // be modeled by
379  // t_x = n_sets*(a_x + b_x*n_el)
380  // where n_sets is the number of independent sets of data to compute stats on,
381  // each containing n_el number of elements. a_x is the time it takes to compute
382  // stats a a single set of data, and b_x is the time it takes to accumulate
383  // a single point.
384  // The old algorithm was developed in the early history of the project, I'm guessing
385  // by Neil Kileen, while the new algorithm was developed in 2015 by Dave Mehringer
386  // as part of the stats framework project. The old algorithm is faster in the regime
387  // of large n_sets and small n_el, while the new algorithm is faster in the
388  // regime of small n_sets and large n_el.
389  // If one always wants to use one of these algorithms, that algorithm's coefficients
390  // should be set to 0, while setting the other algorithm's coefficients to positive
391  // values. Note that it's the relative, not the absolute, values of these
392  // coeffecients that is important
393  // The version that takes no parameters uses the default values of the coefficients;
394  // <group>
395  void configureClassical();
396 
397  void configureClassical(Double aOld, Double bOld, Double aNew, Double bNew);
398  // </group>
399 
400  // configure to use fit to half algorithm.
401  void configureFitToHalf(
404  AccumType centerValue=0
405  );
406 
407  // configure to use hinges-fences algorithm
409 
410  // configure to use Chauvenet's criterion
411  void configureChauvenet(
412  Double zscore=-1, Int maxIterations=-1
413  );
414 
415  // get number of iterations associated with Chauvenet criterion algorithm
416  std::map<String, uInt> getChauvenetNiter() const { return _chauvIters; }
417 
418 protected:
419 
424 
425 // doRobust means that when the storage lattice is generated, the
426 // robust statistics are generated as well
427 
432 //
433 // Virtual Functions. See implementation to figure it all out !
434 
435  // FIXME The indirect dependence of this class on ImageInterface related
436  // issues (eg flux density) breaks encapsulation. All the ImageInterface related code should be
437  // encapsulated in ImageStatistics. Unfortunately, that requires significantly
438  // more time than I have atm. A return value of False means that the object in
439  // question cannot compute flux density values. The default implementation returns False.
440  virtual Bool _canDoFlux() const { return False; }
441 
442  virtual Quantum<AccumType> _flux(Bool&, AccumType, Double) const {
443  ThrowCc("Logic Error: This object cannot compute flux density");
444  }
445 
446  virtual void listMinMax (ostringstream& osMin,
447  ostringstream& osMax,
448  Int oWidth, DataType type);
449 
450  //
451 
452 // List the statistics to the logger. The implementation here
453 // is adequate for all lattices. See ImageStatistics for an
454 // example of where extra information is provided. hasBeam is
455 // the return value of getBeamArea. If it is true, that means
456 // that the FLUX statistics will be available in the storage
457 // lattice. dPos is the location of the start of the cursor in the
458 // storage image for this row. stats(j,i) is the statistics matrix.
459 // for the jth point and the ith statistic.
460 // The return value is False if something goes wrong !
461 // Have a look at the implementation to see what you really
462 // have to do.
463  virtual Bool listStats (Bool hasBeam, const IPosition& dPos,
464  const Matrix<AccumType>& ord);
465  virtual Bool listLayerStats (
466  const Matrix<AccumType>& ord,
467  ostringstream& rslt, Int zLayer);
468 /*
469 // Gets labels for higher order axes and x axis.
470 // dPos is the location of the start of the cursor in the
471 // storage image for this row.
472  virtual void getLabels(String& higherOrderLabel, String& xAxisLabel,
473  const IPosition& dPos) const;
474 */
475 // Given a location in the storage lattice, convert those locations on the
476 // non-statistics axis (the last one) and optionally account for the
477 // lattice subsectioning
478  IPosition locInLattice (const IPosition& storagePosition,
479  Bool relativeToParent=True) const;
480 
481 // Non-virtual functions
482 //
483 // set stream manipulators
484  void setStream (ostream& os, Int oPrec);
485 
486  // get the storage lattice shape
487  inline IPosition _storageLatticeShape() const { return pStoreLattice_p->shape(); }
488 
489  virtual Bool _computeFlux(
490  Array<AccumType>& flux, const Array<AccumType>& npts, const Array<AccumType>& sum
491  );
492 
493  virtual Bool _computeFlux(
494  Quantum<AccumType>& flux, AccumType sum, const IPosition& pos,
495  Bool posInLattice
496  );
497 
498  // convert a position in the input lattice to the corresponding
499  // position in the stats storage lattice. The number of elements
500  // in storagePos will not be changed and only the first N elements
501  // will be modified where N = the number of elements in latticePos.
502  // <src>storagePos</src> must therefore have at least as many elements
503  // as <src>latticePos</src>. Returns False if
504  //<src>latticePos</src> is inconsistent with the input lattice.
506  IPosition& storagePos, const IPosition& latticePos
507  );
508 
509 private:
510 
512  SHARED_PTR<const MaskedLattice<T> > _inLatPtrMgr;
513 
518 
521 
524 
526  std::map<String, uInt> _chauvIters;
527 
529 
531  // coefficients from timings run on PagedImages on
532  // etacarinae.cv.nrao.edu (dmehring's development
533  // machine)
534  _aOld = 4.7e-7;
535  _bOld = 2.3e-8;
536  _aNew = 1.6e-5;
537  _bNew = 1.5e-8;
538  }
539 
540 // Summarize the statistics found over the entire lattice
541  virtual void summStats();
542 
543  virtual void displayStats(
544  AccumType nPts, AccumType sum, AccumType median,
545  AccumType medAbsDevMed, AccumType quartile, AccumType sumSq, AccumType mean,
546  AccumType var, AccumType rms, AccumType sigma, AccumType dMin, AccumType dMax,
547  AccumType q1, AccumType q3
548  );
549 
550 // Calculate statistic from storage lattice and return in an array
553  Bool dropDeg);
554 
555 // Find the median per cursorAxes chunk
556  void generateRobust ();
557 
558 // Create a new storage lattice
560 
561 // Given a location in the lattice and a statistic type, work
562 // out where to put it in the storage lattice
563  IPosition locInStorageLattice(const IPosition& latticePosition,
565 
566 // Find min and max of good data in arrays specified by pointers
567  void minMax (Bool& none, AccumType& dMin, AccumType& dMax,
568  const Vector<AccumType>& d,
569  const Vector<AccumType>& n) const;
570 
571 // Retrieve a statistic from the storage lattice and return in an array
574  const Bool dropDeg);
575 
576 // Retrieve a statistic from the storage lattice at the specified
577 // location and return in an array
579  const IPosition& pos,
580  const Bool posInLattice);
581 
582 // Find the shape of slice from the statistics lattice at one
583 // spatial pixel
584  IPosition statsSliceShape () const;
585 
586 // See if there were some valid points found in the storage lattice
587  Bool someGoodPoints ();
588 
589 // Stretch min and max by 5%
590  void stretchMinMax (AccumType& dMin, AccumType& dMax) const;
591 
593 
597  ) const;
598 
599  void _doStatsLoop(uInt nsets, CountedPtr<LattStatsProgress> progressMeter);
600 
601  inline static AccumType _mean(const AccumType& sum, const AccumType& npts) {
602  return npts <= 0 ? 0 : sum/npts;
603  }
604 
605  inline static AccumType _rms(const AccumType& sumsq, const AccumType& npts) {
606  return npts <= 0 ? 0 : sqrt(sumsq/npts);
607  }
608 
609 };
610 
611 //# Declare extern templates for often used types.
612 #ifdef AIPS_CXX11
613  extern template class LatticeStatistics<Float>;
614 #endif
615 
616 
617 } //# NAMESPACE CASA - END
618 
619 #ifndef CASACORE_NO_AUTO_TEMPLATES
620 #include <casacore/lattices/LatticeMath/LatticeStatistics.tcc>
621 #endif //# CASACORE_NO_AUTO_TEMPLATES
622 #endif
A Vector of integers, for indexing into Array<T> objects.
Definition: IPosition.h:119
virtual Bool listLayerStats(const Matrix< AccumType > &ord, ostringstream &rslt, Int zLayer)
A Lattice that can be used for temporary storage.
int Int
Definition: aipstype.h:50
void configureClassical()
configure object to use Classical Statistics The time, t_x, it takes to compute classical statistics ...
Vector< Int > displayAxes() const
Return the display axes.
LatticeExprNode median(const LatticeExprNode &expr)
Bool retrieveStorageStatistic(Array< AccumType > &slice, const LatticeStatsBase::StatisticsTypes type, const Bool dropDeg)
Retrieve a statistic from the storage lattice and return in an array.
Int mi
Chauvenet max iterations.
std::map< String, uInt > _chauvIters
Bool getMinMaxPos(IPosition &minPos, IPosition &maxPos)
Recover position of min and max.
const MaskedLattice< T > * pInLattice_p
LatticeExprNode sum(const LatticeExprNode &expr)
void configureChauvenet(Double zscore=-1, Int maxIterations=-1)
configure to use Chauvenet&#39;s criterion
void configureFitToHalf(FitToHalfStatisticsData::CENTER centerType=FitToHalfStatisticsData::CMEAN, FitToHalfStatisticsData::USE_DATA useData=FitToHalfStatisticsData::LE_CENTER, AccumType centerValue=0)
configure to use fit to half algorithm.
void configureHingesFences(Double f)
configure to use hinges-fences algorithm
Base class for LatticeStatistics class.
Double hf
hinges-fences f factor
Bool someGoodPoints()
See if there were some valid points found in the storage lattice.
A templated, abstract base class for array-like objects with masks.
Definition: ImageConcat.h:46
Bool setList(const Bool &doList)
This function allows you to control whether the statistics are written to the output stream if you ar...
Data provider which allows stats framework to iterate through an unmasked lattice.
virtual ~LatticeStatistics()
Destructor.
A 2-D Specialization of the Array class.
Definition: Array.h:53
ostream-like interface to creating log messages.
Definition: LogIO.h:167
Bool getStatistic(Array< AccumType > &stat, LatticeStatsBase::StatisticsTypes type, Bool dropDeg=True)
Recover the desired Statistic into an array.
std::list< stat_element > stat_list
USE_DATA
which section of data to use, greater than or less than the center value
void _doStatsLoop(uInt nsets, CountedPtr< LattStatsProgress > progressMeter)
std::pair< String, String > stat_element
Bool hasLogger() const
Did we construct with a logger ?
Bool calculateStatistic(Array< AccumType > &slice, LatticeStatsBase::StatisticsTypes type, Bool dropDeg)
Calculate statistic from storage lattice and return in an array.
Bool doRobust_p
doRobust means that when the storage lattice is generated, the robust statistics are generated as wel...
LatticeStatistics< T > & operator=(const LatticeStatistics< T > &other)
Assignment operator.
Bool display()
Display the statistics by listing and/or plotting them.
ALGORITHM
implemented algorithms
Bool getFullMinMax(T &dataMin, T &dataMax)
Get full lattice min and max only.
Bool setNewLattice(const MaskedLattice< T > &lattice, Bool clone=True)
Set a new MaskedLattice object.
virtual Bool _canDoFlux() const
Virtual Functions.
void generateRobust()
Find the median per cursorAxes chunk.
std::map< String, uInt > getChauvenetNiter() const
get number of iterations associated with Chauvenet criterion algorithm
IPosition statsSliceShape() const
Find the shape of slice from the statistics lattice at one spatial pixel.
virtual void summStats()
Summarize the statistics found over the entire lattice.
CENTER
choice of center point based on the corresponding statistics from the entire distribution of data...
Bool getLayerStats(String &stats, Double area, Int zAxis=-1, Int zLayer=-1, Int hAxis=-1, Int hLayer=-1)
Char PrecisionType
Higher precision type (Float->Double)
Data provider which allows stats framework to iterate through a masked lattice.
IPosition _storageLatticeShape() const
get the storage lattice shape
Referenced counted pointer for constant data.
Definition: CountedPtr.h:86
LatticeStatistics(const MaskedLattice< T > &lattice, LogIO &os, Bool showProgress=True, Bool forceDisk=False, Bool clone=True)
Constructor takes the lattice and a LogIO object for logging.
virtual Quantum< AccumType > _flux(Bool &, AccumType, Double) const
void minMax(Bool &none, AccumType &dMin, AccumType &dMax, const Vector< AccumType > &d, const Vector< AccumType > &n) const
Find min and max of good data in arrays specified by pointers.
double Double
Definition: aipstype.h:55
AccumType cv
fit to half center value
CountedPtr< StatisticsAlgorithm< AccumType, const T *, const Bool * > > _createStatsAlgorithm() const
Compute and display various statistics from a lattice.
FitToHalfStatisticsData::CENTER ct
fit to have center type
LatticeExprNode sqrt(const LatticeExprNode &expr)
virtual Bool _computeFlux(Array< AccumType > &flux, const Array< AccumType > &npts, const Array< AccumType > &sum)
Bool getConvertedStatistic(Array< T > &stat, LatticeStatsBase::StatisticsTypes type, Bool dropDeg=True)
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
void setStream(ostream &os, Int oPrec)
Non-virtual functions.
void _latticePosToStoragePos(IPosition &storagePos, const IPosition &latticePos)
convert a position in the input lattice to the corresponding position in the stats storage lattice...
StatisticsTypes
This enum StatisticTypes is provided for use with the LatticeStatistics<T>::setPlotting function...
Bool setInExCludeRange(const Vector< T > &include, const Vector< T > &exclude, Bool setMinMaxToInclude=False)
You may specify a pixel intensity range as either one for which all pixels in that range are included...
void stretchMinMax(AccumType &dMin, AccumType &dMax) const
Stretch min and max by 5%.
IPosition locInStorageLattice(const IPosition &latticePosition, LatticeStatsBase::StatisticsTypes type) const
Given a location in the lattice and a statistic type, work out where to put it in the storage lattice...
Quantities (i.e. dimensioned values)
Definition: MeasValue.h:40
Bool setAxes(const Vector< Int > &cursorAxes)
Set the cursor axes (0 relative).
virtual void listMinMax(ostringstream &osMin, ostringstream &osMax, Int oWidth, DataType type)
const Bool False
Definition: aipstype.h:44
template <class T, class U> class vector;
Definition: Array.h:169
Bool getStats(Vector< AccumType > &, const IPosition &pos, const Bool posInLattice=False)
This function gets a vector containing all the statistics for a given location.
*IPosition locInLattice(const IPosition &storagePosition, Bool relativeToParent=True) const
Given a location in the storage lattice, convert those locations on the non-statistics axis (the last...
Bool generateStorageLattice()
Create a new storage lattice.
String errorMessage() const
Recover last error message.
SHARED_PTR< const MaskedLattice< T > > _inLatPtrMgr
FitToHalfStatisticsData::USE_DATA ud
fit to half data portion to use
LatticeExprNode mean(const LatticeExprNode &expr)
CountedPtr< TempLattice< AccumType > > pStoreLattice_p
TableExprNode rms(const TableExprNode &array)
Definition: ExprNode.h:1844
String: the storage and methods of handling collections of characters.
Definition: String.h:223
virtual Bool listStats(Bool hasBeam, const IPosition &dPos, const Matrix< AccumType > &ord)
List the statistics to the logger.
StatisticsData::ALGORITHM algorithm
#define ThrowCc(m)
Definition: Error.h:86
NumericTraits< T >::PrecisionType AccumType
virtual void displayStats(AccumType nPts, AccumType sum, AccumType median, AccumType medAbsDevMed, AccumType quartile, AccumType sumSq, AccumType mean, AccumType var, AccumType rms, AccumType sigma, AccumType dMin, AccumType dMax, AccumType q1, AccumType q3)
const Bool True
Definition: aipstype.h:43
void _configureDataProviders(LatticeStatsDataProvider< T > &lattDP, MaskedLatticeStatsDataProvider< T > &maskedLattDP) const
this file contains all the compiler specific defines
Definition: mainpage.dox:28
static AccumType _rms(const AccumType &sumsq, const AccumType &npts)
void resetError()
Reset argument error condition.
static AccumType _mean(const AccumType &sum, const AccumType &npts)
unsigned int uInt
Definition: aipstype.h:51