BundleResults.h

Go to the documentation of this file.

#ifndef BundleResults_h
#define BundleResults_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
// Qt Library
#include <QList>
#include <QObject>
#include <QPair>
#include <QString>
#include <QVector>
 
// Isis Library
#include "BundleControlPoint.h"
#include "BundleLidarControlPoint.h"
#include "BundleObservationVector.h"
#include "BundleSettings.h"
#include "ControlNet.h"
#include "Distance.h"
#include "LidarData.h"
#include "MaximumLikelihoodWFunctions.h"
#include "PvlObject.h"
#include "Statistics.h" // ???
#include "SurfacePoint.h"
#include "XmlStackedHandler.h"
 
// Qt Library
class QDataStream;
class QUuid;
class QXmlStreamWriter;
 
namespace Isis {
  // Isis Library
  class ControlNet;
  class CorrelationMatrix;
  class FileName;
  class Project;// ??? does xml stuff need project???
  class PvlObject;
  class SerialNumberList;
  class StatCumProbDistDynCalc;
  class XmlStackedHandlerReader;
 
  class BundleResults : public QObject {
    Q_OBJECT
    public:
      BundleResults(QObject *parent = 0);
      // TODO: does xml stuff need project???
      BundleResults(Project *project, XmlStackedHandlerReader *xmlReader, QObject *parent = 0);
      BundleResults(const BundleResults &src);
      ~BundleResults();
      BundleResults &operator=(const BundleResults &src);
      void initialize();
 
      // mutators and computation methods
      void resizeSigmaStatisticsVectors(int numberImages);
      void setRmsImageResidualLists(QList<Statistics> rmsImageLineResiduals,
                                    QList<Statistics> rmsImageSampleResiduals,
                                    QList<Statistics> rmsImageResiduals);
      void setRmsImageResidualLists(QVector<Statistics> rmsImageLineResiduals,
                                    QVector<Statistics> rmsImageSampleResiduals,
                                    QVector<Statistics> rmsImageResiduals);
      void setRmsLidarImageResidualLists(QList<Statistics> rmsLidarImageLineResiduals,
                                    QList<Statistics> rmsLidarImageSampleResiduals,
                                    QList<Statistics> rmsLidarImageResiduals);
      void setSigmaCoord1Range(Distance minCoord1Dist, Distance maxCoord1Dist,
                                 QString minCoord1PointId, QString maxCoord1PointId);
      void setSigmaCoord2Range(Distance minCoord2Dist, Distance maxCoord2Dist,
                                  QString minCoord2PointId, QString maxCoord2PointId);
      void setSigmaCoord3Range(Distance minCoord3Dist, Distance maxCoord3Dist,
                               QString minCoord3PointId, QString maxCoord3PointId);
      void setRmsFromSigmaStatistics(double rmsFromSigmaCoord1Stats,
                                     double rmsFromSigmaCoord2Stats,
                                     double rmsFromSigmaCoord3Stats);
      void maximumLikelihoodSetUp(
          QList< QPair< MaximumLikelihoodWFunctions::Model, double > > modelsWithQuantiles);
      void printMaximumLikelihoodTierInformation();
      void initializeResidualsProbabilityDistribution(unsigned int nodes = 20);
      void initializeProbabilityDistribution(unsigned int nodes = 20);
      void addResidualsProbabilityDistributionObservation(double obsValue);
      void addProbabilityDistributionObservation(double obsValue);
      void addProbabilityDistributionObservation(double obsValue, bool residuals);
      void incrementMaximumLikelihoodModelIndex();
 
      void incrementFixedPoints();
      int numberFixedPoints() const;
      void incrementHeldImages();
      int numberHeldImages() const;
      void incrementIgnoredPoints();
      int numberIgnoredPoints() const; // currently unused ???
#if 0
      double computeRejectionLimit(ControlNet *p_Cnet,
                                   double outlierRejectionMultiplier,
                                   int numObservations);
#endif
      void setRejectionLimit(double rejectionLimit);
#if 0
      double computeResiduals(
               ControlNet *pCnet,
               std::vector< boost::numeric::ublas::bounded_vector< double, 3 > > pointWeights,
               std::vector< boost::numeric::ublas::bounded_vector< double, 3 > > pointCorrections,
               LinearAlgebra::Vector image_Corrections,
               std::vector< double > imageParameterWeights,
               int numImagePartials,
               int rank);
#endif
      void setRmsXYResiduals(double rx, double ry, double rxy);
#if 0
      bool flagOutliers(ControlNet *pCnet);
#endif
      void setNumberRejectedObservations(int numberObservations);
      void setNumberImageObservations(int numberObservations);
      void setNumberLidarImageObservations(int numberLidarObservations);
      void setNumberObservations(int numberObservations);
      void setNumberImageParameters(int numberParameters); // ??? this is the same value an m_nRank
      void setNumberConstrainedPointParameters(int numberParameters);
      void setNumberConstrainedLidarPointParameters(int numberParameters);
      void resetNumberConstrainedPointParameters();
      void incrementNumberConstrainedPointParameters(int incrementAmount);
      void resetNumberConstrainedImageParameters();
      void incrementNumberConstrainedImageParameters(int incrementAmount);
      void resetNumberConstrainedTargetParameters();
      void incrementNumberConstrainedTargetParameters(int incrementAmount);
      void setNumberLidarRangeConstraints(int numberLidarRangeConstraints);
      void setNumberUnknownParameters(int numberParameters);
      void computeDegreesOfFreedom();
      void computeSigma0(double dvtpv, BundleSettings::ConvergenceCriteria criteria);
      void setDegreesOfFreedom(double degreesOfFreedom);
      void setSigma0(double sigma0);
      void setElapsedTime(double time);
      void setElapsedTimeErrorProp(double time);
      void setConverged(bool converged); // or initialze method
      void setBundleControlPoints(QVector<BundleControlPointQsp> controlPoints);
      void setBundleLidarPoints(QVector<BundleLidarControlPointQsp> lidarPoints);
      void setOutputControlNet(ControlNetQsp outNet);
      void setOutputLidarData(LidarDataQsp outLidarData);
      void setIterations(int iterations);
      void setObservations(BundleObservationVector observations);
 
      // Accessors...
      QList<Statistics> rmsImageSampleResiduals() const;
      QList<Statistics> rmsImageLineResiduals() const;
      QList<Statistics> rmsImageResiduals() const;
      QList<Statistics> rmsLidarImageSampleResiduals() const;
      QList<Statistics> rmsLidarImageLineResiduals() const;
      QList<Statistics> rmsLidarImageResiduals() const;
      QVector<Statistics> rmsImageXSigmas() const;       // currently unused ???
      QVector<Statistics> rmsImageYSigmas() const;       // currently unused ???
      QVector<Statistics> rmsImageZSigmas() const;       // currently unused ???
      QVector<Statistics> rmsImageRASigmas() const;      // currently unused ???
      QVector<Statistics> rmsImageDECSigmas() const;     // currently unused ???
      QVector<Statistics> rmsImageTWISTSigmas() const;   // currently unused ???
      // *** TODO *** Will we ever want to request a specific coordinate type?
      //   (Lat or X) or just whatever is the designated type?
      SurfacePoint::CoordinateType coordTypeReports();
 
      Distance minSigmaCoord1Distance() const;
      Distance maxSigmaCoord1Distance() const;
      Distance minSigmaCoord2Distance() const;
      Distance maxSigmaCoord2Distance() const;
      Distance minSigmaCoord3Distance() const;
      Distance maxSigmaCoord3Distance() const;
      QString maxSigmaCoord1PointId() const;
      QString minSigmaCoord1PointId() const;
      QString minSigmaCoord2PointId() const;
      QString maxSigmaCoord2PointId() const;
      QString minSigmaCoord3PointId() const;
      QString maxSigmaCoord3PointId() const;
      double sigmaCoord1StatisticsRms() const;
      double sigmaCoord2StatisticsRms() const;
      double sigmaCoord3StatisticsRms() const;
 
      double rmsRx() const;  // currently unused ???
      double rmsRy() const;  // currently unused ???
      double rmsRxy() const; // currently unused ???
      double rejectionLimit() const;
      int numberRejectedObservations() const;
      int numberObservations() const;
      int numberImageObservations() const;
      int numberLidarImageObservations() const;
 
      int numberImageParameters() const; // ??? this is the same value an m_nRank
      int numberConstrainedPointParameters() const;
      int numberConstrainedImageParameters() const;
      int numberConstrainedTargetParameters() const;
      int numberLidarRangeConstraintEquations() const;
      int numberUnknownParameters() const;
      int degreesOfFreedom() const;
      double sigma0() const;
      double elapsedTime() const;
      double elapsedTimeErrorProp() const;
      bool converged() const; // or initialze method
      QVector<BundleControlPointQsp> &bundleControlPoints();
      QVector<BundleLidarControlPointQsp> &bundleLidarControlPoints();
      ControlNetQsp outputControlNet() const;
      LidarDataQsp outputLidarData() const;
      int iterations() const;
      const BundleObservationVector &observations() const;
 
      int numberMaximumLikelihoodModels() const;
      int maximumLikelihoodModelIndex() const;
      StatCumProbDistDynCalc cumulativeProbabilityDistribution() const;
      StatCumProbDistDynCalc residualsCumulativeProbabilityDistribution() const;
      double maximumLikelihoodMedianR2Residuals() const;
      MaximumLikelihoodWFunctions maximumLikelihoodModelWFunc(int modelIndex) const;
      double maximumLikelihoodModelQuantile(int modelIndex) const;
 
      QList< QPair< MaximumLikelihoodWFunctions, double > > maximumLikelihoodModels() const;
 
      bool setNumberHeldImages(SerialNumberList pHeldSnList,
                               SerialNumberList *pSnList);
 
      // Correlation Matrix accessors for ipce and mutators for bundle adjust.
      CorrelationMatrix correlationMatrix() const;
      void setCorrMatCovFileName(FileName name);
      void setCorrMatImgsAndParams(QMap<QString, QStringList> imgsAndParams);
 
      // TODO: does xml stuff need project???
      void save(QXmlStreamWriter &stream, const Project *project) const;
 
 
    private:
      class XmlHandler : public XmlStackedHandler {
        public:
          // TODO: does xml stuff need project???
          XmlHandler(BundleResults *statistics, Project *project);
          ~XmlHandler();
 
          virtual bool startElement(const QString &namespaceURI, const QString &localName,
                                    const QString &qName, const QXmlAttributes &atts);
          virtual bool characters(const QString &ch);
          virtual bool endElement(const QString &namespaceURI, const QString &localName,
                                  const QString &qName);
 
        private:
          Q_DISABLE_COPY(XmlHandler);
 
          BundleResults *m_xmlHandlerBundleResults;
          Project *m_xmlHandlerProject;   // TODO: does xml stuff need project???
          QString m_xmlHandlerCharacters;
          int m_xmlHandlerResidualsListSize;
          int m_xmlHandlerSampleResidualsListSize;
          int m_xmlHandlerLineResidualsListSize;
          int m_xmlHandlerXSigmasListSize;
          int m_xmlHandlerYSigmasListSize;
          int m_xmlHandlerZSigmasListSize;
          int m_xmlHandlerRASigmasListSize;
          int m_xmlHandlerDECSigmasListSize;
          int m_xmlHandlerTWISTSigmasListSize;
          QList<Statistics *> m_xmlHandlerStatisticsList;
          StatCumProbDistDynCalc *m_xmlHandlerCumProCalc;
 
          QString m_xmlHandlerCorrelationImageId;
          QStringList m_xmlHandlerCorrelationParameterList;
          QMap<QString, QStringList> m_xmlHandlerCorrelationMap;
      };
 
      CorrelationMatrix *m_correlationMatrix; 
 
      int m_numberFixedPoints;                
      // Currently set but unused
      int m_numberIgnoredPoints;              
      int m_numberHeldImages;                 
 
      // The following three members are set but unused.
      double m_rmsXResiduals;                 
      double m_rmsYResiduals;                 
      double m_rmsXYResiduals;                
 
      double m_rejectionLimit;                
      // TODO:??? reorder read/write data stream, init, copy constructor, operator=
      int m_numberObservations;                
      int m_numberImageObservations;               
      int m_numberLidarImageObservations;          
      int m_numberRejectedObservations;        
      int m_numberLidarRangeConstraintEquations;   
      int m_numberUnknownParameters;           
      int m_numberImageParameters;             
      int m_numberConstrainedImageParameters;  
      int m_numberConstrainedPointParameters;  
      int m_numberConstrainedLidarPointParameters; 
      int m_numberConstrainedTargetParameters; 
      int m_degreesOfFreedom;                  
      double m_sigma0;                         
      double m_elapsedTime;                    
      double m_elapsedTimeErrorProp;           
      bool m_converged;
 
      // Variables for output methods in BundleSolutionInfo
 
      QVector<BundleControlPointQsp> m_bundleControlPoints; 
      QVector<BundleLidarControlPointQsp> m_bundleLidarPoints;
      ControlNetQsp m_outNet;                               
      LidarDataQsp m_outLidarData;                          
      int m_iterations;                                     
      BundleObservationVector m_observations;               
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // variables set in computeBundleResults()
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // QList??? jigsaw apptest gives - ASSERT failure in QList<T>::operator[]: "index out of range",
      QList<Statistics> m_rmsImageSampleResiduals;
      QList<Statistics> m_rmsImageLineResiduals;  
      QList<Statistics> m_rmsImageResiduals;      
      QList<Statistics> m_rmsLidarImageSampleResiduals; 
      QList<Statistics> m_rmsLidarImageLineResiduals;   
      QList<Statistics> m_rmsLidarImageResiduals;       
      QVector<Statistics> m_rmsImageXSigmas;     // unset and unused ???
      QVector<Statistics> m_rmsImageYSigmas;     // unset and unused ???
      QVector<Statistics> m_rmsImageZSigmas;     // unset and unused ???
      QVector<Statistics> m_rmsImageRASigmas;    // unset and unused ???
      QVector<Statistics> m_rmsImageDECSigmas;   // unset and unused ???
      QVector<Statistics> m_rmsImageTWISTSigmas; // unset and unused ???
 
      Distance m_minSigmaCoord1Distance;  
      Distance m_maxSigmaCoord1Distance;  
      Distance m_minSigmaCoord2Distance; 
      Distance m_maxSigmaCoord2Distance; 
      Distance m_minSigmaCoord3Distance;    
      Distance m_maxSigmaCoord3Distance;    
 
      QString m_minSigmaCoord1PointId;    
      QString m_maxSigmaCoord1PointId;    
      QString m_minSigmaCoord2PointId;   
      QString m_maxSigmaCoord2PointId;   
      QString m_minSigmaCoord3PointId;      
      QString m_maxSigmaCoord3PointId;      
 
      double m_rmsSigmaCoord1Stats;       
      double m_rmsSigmaCoord2Stats;      
      double m_rmsSigmaCoord3Stats;         
 
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // variables for maximum likelihood estimation
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
      QList< QPair< MaximumLikelihoodWFunctions, double > > m_maximumLikelihoodFunctions;
 
      int m_maximumLikelihoodIndex;            
      StatCumProbDistDynCalc *m_cumPro;        
      StatCumProbDistDynCalc *m_cumProRes;     
      double m_maximumLikelihoodMedianR2Residuals; 
  };
 
};
 
Q_DECLARE_METATYPE(Isis::BundleResults);
 
#endif // BundleResults_h