LCOV - code coverage report
Current view: top level - imageanalysis/IO - ImageProfileFitterResults.h (source / functions) Hit Total Coverage
Test: casacpp_coverage.info Lines: 13 13 100.0 %
Date: 2024-11-06 17:42:47 Functions: 13 13 100.0 %

          Line data    Source code
       1             : //# tSubImage.cc: Test program for class SubImage
       2             : //# Copyright (C) 1998,1999,2000,2001,2003
       3             : //# Associated Universities, Inc. Washington DC, USA.
       4             : //#
       5             : //# This program is free software; you can redistribute it and/or modify it
       6             : //# under the terms of the GNU General Public License as published by the Free
       7             : //# Software Foundation; either version 2 of the License, or (at your option)
       8             : //# any later version.
       9             : //#
      10             : //# This program 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 General Public License for
      13             : //# more details.
      14             : //#
      15             : //# You should have received a copy of the GNU General Public License along
      16             : //# with this program; if not, write to the Free Software Foundation, Inc.,
      17             : //# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
      18             : //#
      19             : //# Correspondence concerning AIPS++ should be addressed as follows:
      20             : //#        Internet email: casa-feedback@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             : 
      27             : 
      28             : #ifndef IMAGEANALYSIS_IMAGEPROFILEFITTERRESULTS_H
      29             : #define IMAGEANALYSIS_IMAGEPROFILEFITTERRESULTS_H
      30             : 
      31             : #include <components/SpectralComponents/GaussianMultipletSpectralElement.h>
      32             : #include <imageanalysis/ImageAnalysis/ImageFit1D.h>
      33             : #include <casacore/images/Images/TempImage.h>
      34             : 
      35             : #include <casacore/casa/namespace.h>
      36             : 
      37             : namespace casa {
      38             : 
      39             : class LogFile;
      40             : class ProfileFitResults;
      41             : 
      42             : class ImageProfileFitterResults {
      43             :     // <summary>
      44             :     // </summary>
      45             : 
      46             :     // <reviewed reviewer="" date="" tests="" demos="">
      47             :     // </reviewed>
      48             : 
      49             :     // <prerequisite>
      50             :     // </prerequisite>
      51             : 
      52             :     // <etymology>
      53             :     // </etymology>
      54             : 
      55             :     // <synopsis>
      56             :     // This class is the encapsulated IO portion of ImageProfileFitter. It is meant to be
      57             :     // used only by that class. It is seperate from ImageProfileFitter for maintenence
      58             :     // and compile convenience.
      59             :     // </synopsis>
      60             : 
      61             :     // <example>
      62             :     // <srcblock>
      63             :     // </srcblock>
      64             :     // </example>
      65             : 
      66             : public:
      67             :     ImageProfileFitterResults(
      68             :                 const std::shared_ptr<casacore::LogIO> log, const casacore::CoordinateSystem& csysIm,
      69             :                 const casacore::Array<std::shared_ptr<ProfileFitResults> >* const &fitters,
      70             :         const SpectralList& nonPolyEstimates,
      71             :                 const std::shared_ptr<const casacore::SubImage<casacore::Float> > subImage, casacore::Int fitAxis, casacore::Int polyOrder,
      72             :                 casacore::uInt nGaussSinglets, casacore::uInt nGaussMultiplets, casacore::uInt nLorentzSinglets,
      73             :                 casacore::uInt nPLPCoeffs, casacore::uInt nLTPCoeffs, casacore::Bool logResults, casacore::Bool multiFit,
      74             :                 const std::shared_ptr<LogFile> logfile, const casacore::String& xUnit,
      75             :                 const casacore::String& summaryHeader
      76             :     );
      77             : 
      78             :     ~ImageProfileFitterResults();
      79             : 
      80             :     // create all the products. Should be run after the object has been entirely configured
      81             :     void createResults();
      82             : 
      83             :     // get the result Record
      84             :         casacore::Record getResults() const;
      85             : 
      86             :     inline casacore::String getClass() const { return _class; };
      87             : 
      88             :     // stream results to logger? This can be a lot of output.
      89             :     inline void setLogResults(const casacore::Bool logResults) { _logResults = logResults; }
      90             : 
      91             :     // <group>
      92             :     // gaussian amplitude image name
      93          67 :     inline void setAmpName(const casacore::String& s) { _ampName = s; }
      94             :     // gaussian amplitude error image name
      95          67 :     inline void setAmpErrName(const casacore::String& s) { _ampErrName = s; }
      96             :     // gaussian center image name
      97          67 :     inline void setCenterName(const casacore::String& s) { _centerName = s; }
      98             :     // gaussian center error image name
      99          67 :     inline void setCenterErrName(const casacore::String& s) { _centerErrName = s; }
     100             :     // gaussian fwhm image name
     101          67 :     inline void setFWHMName(const casacore::String& s) { _fwhmName = s; }
     102             :     // gaussian fwhm error image name
     103          67 :     inline void setFWHMErrName(const casacore::String& s) { _fwhmErrName = s; }
     104             :     // gaussian integral image name
     105          67 :     inline void setIntegralName(const casacore::String& s) { _integralName = s; }
     106             :     // gaussian integral error image name
     107          67 :     inline void setIntegralErrName(const casacore::String& s) { _integralErrName = s; }
     108             :     // </group>
     109             : 
     110             :     // set the name of the power logarithmic polynomial image.
     111          11 :     inline void setPLPName(const casacore::String& s) { _plpName = s; }
     112             : 
     113             :     // set the name of the power logarithmic polynomial image.
     114          11 :     inline void setPLPErrName(const casacore::String& s) { _plpErrName = s; }
     115             : 
     116             :     // set the name of the power logarithmic polynomial image.
     117           5 :     inline void setLTPName(const casacore::String& s) { _ltpName = s; }
     118             : 
     119             :     // set the name of the power logarithmic polynomial image.
     120           5 :     inline void setLTPErrName(const casacore::String& s) { _ltpErrName = s; }
     121             : 
     122             : 
     123             :     //inline void setOutputSigmaImage(const casacore::String& s) { _sigmaName = s; }
     124             :     // </group>
     125             : 
     126             : 
     127             :     const static casacore::String _CONVERGED;
     128             :     const static casacore::String _SUCCEEDED;
     129             :     const static casacore::String _VALID;
     130             : 
     131             :     const casacore::Array<ImageFit1D<casacore::Float> >& getFitters() const;
     132             :     // Returns the center, in pixels of the indexth fit.
     133             :     const casacore::Vector<casacore::Double> getPixelCenter( uint index ) const;
     134             :     //Converts a pixel value into a world value either in velocity, wavelength, or
     135             :     //frequency units.
     136             :     casacore::Double getWorldValue(
     137             :         double pixelVal, const casacore::IPosition& imPos, const casacore::String& units,
     138             :         bool velocity, bool wavelength
     139             :     ) const;
     140             : 
     141          16 :     void setPLPDivisor(const casacore::String& x) { _plpDivisor = x; }
     142             : 
     143             :     std::vector<String> logSummary(
     144             :         casacore::uInt nProfiles, casacore::uInt nAttempted, casacore::uInt nSucceeded,
     145             :         casacore::uInt nConverged, casacore::uInt nValid
     146             :     );
     147             : 
     148             :     void writeImages(casacore::Bool someConverged) const;
     149             : 
     150             : private:
     151             :     enum gaussSols {
     152             :         AMP, CENTER, FWHM, INTEGRAL, AMPERR, CENTERERR,
     153             :         FWHMERR, INTEGRALERR, NGSOLMATRICES
     154             :     };
     155             : 
     156             :     enum spxSols {
     157             :         SPXSOL, SPXERR, NSPXSOLMATRICES
     158             :     };
     159             : 
     160             :     enum axisType {
     161             :         LONGITUDE, LATITUDE, FREQUENCY, POLARIZATION, NAXISTYPES
     162             :     };
     163             :     
     164             :     const static casacore::String _class;
     165             :     casacore::Bool _logResults, _multiFit, _doVelocity;
     166             :         casacore::String _xUnit, _centerName, _centerErrName, _fwhmName,
     167             :         _fwhmErrName, _ampName, _ampErrName,
     168             :         _integralName, _integralErrName, _plpName, _plpErrName,
     169             :         _ltpName, _ltpErrName, /*_sigmaName, */ _summaryHeader;
     170             :     casacore::uInt _nGaussSinglets, _nGaussMultiplets, _nLorentzSinglets,
     171             :         _nPLPCoeffs, _nLTPCoeffs;
     172             :     const casacore::Array<std::shared_ptr<ProfileFitResults> >* const  _fitters;
     173             :     SpectralList _nonPolyEstimates;
     174             :     // subimage contains the region of the original image
     175             :     // on which the fit is performed.
     176             :         const std::shared_ptr<const casacore::SubImage<casacore::Float> > _subImage;
     177             :         casacore::Int _polyOrder, _fitAxis;
     178             :     std::vector<axisType> _axisTypes;
     179             :         casacore::Array<casacore::String> _worldCoords;
     180             :         casacore::Record _results;
     181             :         const static casacore::uInt _nOthers, _gsPlane, _lsPlane;
     182             :     std::shared_ptr<LogFile> _logfile;
     183             :         std::shared_ptr<casacore::LogIO> _log;
     184             :         casacore::Vector<casacore::Double> _goodAmpRange, _goodCenterRange, _goodFWHMRange;
     185             :         const casacore::CoordinateSystem _csysIm;
     186             :         casacore::String _plpDivisor;
     187             : 
     188             :     void _setResults();
     189             : 
     190             :     void _resultsToLog();
     191             : 
     192             :     casacore::String _getTag(const casacore::uInt i) const;
     193             : 
     194             :     std::unique_ptr<std::vector<vector<casacore::Array<casacore::Double> > > > _createPCFArrays() const;
     195             : 
     196             :     casacore::String _elementToString(
     197             :         const casacore::Double value, const casacore::Double error,
     198             :         const casacore::String& unit, casacore::Bool isFixed
     199             :     ) const;
     200             : 
     201             :     casacore::String _pcfToString(
     202             :         const PCFSpectralElement *const &pcf, const casacore::CoordinateSystem& csys,
     203             :         const casacore::Vector<casacore::Double>& world, const casacore::IPosition& imPos, casacore::Bool showTypeString=true,
     204             :         const casacore::String& indent=""
     205             :     ) const;
     206             : 
     207             :     casacore::String _gaussianMultipletToString(
     208             :         const GaussianMultipletSpectralElement& gm,
     209             :         const casacore::CoordinateSystem& csys, const casacore::Vector<casacore::Double>& world,
     210             :         const casacore::IPosition& imPos
     211             :     ) const;
     212             : 
     213             :     casacore::Bool _setAxisTypes();
     214             : 
     215             :     casacore::String _polynomialToString(
     216             :         const PolynomialSpectralElement& poly, const casacore::CoordinateSystem& csys,
     217             :         const casacore::Vector<casacore::Double>& imPix, const casacore::Vector<casacore::Double>& world
     218             :     ) const;
     219             : 
     220             :     casacore::String _powerLogPolyToString(
     221             :         const PowerLogPolynomialSpectralElement& plp
     222             :     ) const;
     223             : 
     224             :     casacore::String _logTransPolyToString(
     225             :         const LogTransformedPolynomialSpectralElement& ltp
     226             :     ) const;
     227             : 
     228             :     void _marshalFitResults(
     229             :         casacore::Array<casacore::Bool>& attemptedArr, casacore::Array<casacore::Bool>& successArr,
     230             :         casacore::Array<casacore::Bool>& convergedArr, casacore::Array<casacore::Bool>& validArr,
     231             :         casacore::Array<casacore::String>& typeMat, casacore::Array<casacore::Int>& niterArr,
     232             :         casacore::Array<casacore::Int>& nCompArr, std::unique_ptr<std::vector<vector<casacore::Array<casacore::Double> > > >& pcfArrays,
     233             :         std::vector<casacore::Array<casacore::Double> >& plpArrayss, std::vector<casacore::Array<casacore::Double> >& ltpArrays, casacore::Bool returnDirection,
     234             :         casacore::Array<casacore::String>& directionInfo /*, casacore::Array<casacore::Bool>& mask */
     235             :     ); 
     236             : 
     237             :     static void _makeSolutionImages(
     238             :         const casacore::String& name, const casacore::CoordinateSystem& csys,
     239             :                 const casacore::Array<casacore::Double>& values, const casacore::String& unit,
     240             :                 const casacore::Array<casacore::Bool>& mask
     241             :     );
     242             : 
     243             :     void _insertPCF(
     244             :         vector<vector<casacore::Array<casacore::Double> > >& pcfArrays, /*casacore::Bool& isSolutionSane,*/
     245             :         const casacore::IPosition& pixel, const PCFSpectralElement& pcf, 
     246             :         const casacore::uInt row, const casacore::uInt col, 
     247             :         const casacore::Double increment/*, const casacore::uInt npix*/
     248             :     ) const;
     249             : 
     250             :     void _writeImages(
     251             :         const casacore::CoordinateSystem& csys,
     252             :         const casacore::Array<casacore::Bool>& mask, const casacore::String& yUnit
     253             :     ) const;
     254             : 
     255             :     casacore::Double _fitAxisIncrement() const;
     256             : 
     257             :     casacore::Double _centerWorld(
     258             :         const PCFSpectralElement& solution, const casacore::IPosition& imPos
     259             :     ) const;
     260             : 
     261             :     //casacore::Bool _inVelocitySpace() const;
     262             : 
     263             :     casacore::Vector< casacore::Vector<casacore::Double> > _pixelPositions;
     264             : 
     265             :     void _writeLogfile(const casacore::String& str, casacore::Bool open, casacore::Bool close);
     266             : 
     267             :     // the input array must have a degenerate last axis. It will be replicated
     268             :     // along this axis n times to form an array with a last axis laength of n.
     269             :     static casacore::Array<casacore::Bool> _replicateMask(const casacore::Array<casacore::Bool>& array, casacore::Int n);
     270             : 
     271             :     void _doWorldCoords(
     272             :         casacore::Array<casacore::String>& directionInfo, const casacore::CoordinateSystem& csysSub,
     273             :         const casacore::IPosition& pixel, const casacore::DirectionCoordinate* const &dcoord,
     274             :         const casacore::SpectralCoordinate* const &spcoord, const casacore::StokesCoordinate* const &polcoord,
     275             :         casacore::Bool returnDirection, const casacore::String& directionType
     276             :     );
     277             : 
     278             :     void _processSolutions(
     279             :         /* casacore::Array<casacore::Bool>& mask, */ casacore::Array<casacore::String>& typeMat, casacore::Array<casacore::Int>& niterArr,
     280             :         casacore::Array<casacore::Int>& nCompArr, const casacore::IPosition& pixel,
     281             :         std::shared_ptr<const ProfileFitResults> fitter,
     282             :         /* const casacore::RO_MaskedLatticeIterator<casacore::Float>& inIter, */
     283             :         std::unique_ptr<std::vector<vector<casacore::Array<casacore::Double> > > >& pcfArrays,
     284             :         std::vector<casacore::Array<casacore::Double> >& plpArrays, std::vector<casacore::Array<casacore::Double> >& ltpArrays,
     285             :         casacore::Double increment
     286             :     );
     287             : };
     288             : }
     289             : 
     290             : #endif

Generated by: LCOV version 1.16