BundleObservation.h

#ifndef BundleObservation_h
#define BundleObservation_h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <QStringList>
#include <QVector>
 
#include "BundleImage.h"
#include "BundleObservationSolveSettings.h"
#include "BundleSettings.h"
#include "BundleTargetBody.h"
#include "LinearAlgebra.h"
#include "BundleMeasure.h"
#include "SurfacePoint.h"
 
namespace Isis {

  class BundleObservation : public QVector<BundleImageQsp> {
 
    public:
      // default constructor
      BundleObservation();
 
      // constructor
      BundleObservation(BundleImageQsp image, QString observationNumber, QString instrumentId,
                        BundleTargetBodyQsp bundleTargetBody);
 
      // copy constructor
      BundleObservation(const BundleObservation &src);
 
      // destructor
      virtual ~BundleObservation();
 
      // equals operator
      virtual BundleObservation &operator=(const BundleObservation &src);
 
      // copy method
 
      void copy(const BundleObservation &src);
 
      virtual bool setSolveSettings(BundleObservationSolveSettings solveSettings) = 0;
 
      virtual void append(const BundleImageQsp &value);
 
      BundleImageQsp imageByCubeSerialNumber(QString cubeSerialNumber);
 
      void setIndex(int n);
      int index();
 
      QString instrumentId();
 
      double vtpv();
 
      virtual LinearAlgebra::Vector &parameterWeights();
      virtual LinearAlgebra::Vector &parameterCorrections();
      virtual LinearAlgebra::Vector &aprioriSigmas();
      virtual LinearAlgebra::Vector &adjustedSigmas();
 
 
      virtual const BundleObservationSolveSettingsQsp solveSettings() = 0;
      virtual int numberParameters() = 0;
      virtual bool applyParameterCorrections(LinearAlgebra::Vector corrections) = 0;
 
      virtual void bundleOutputString(std::ostream &fpOut,bool errorPropagation) = 0;
      virtual QString bundleOutputCSV(bool errorPropagation) = 0;
 
      virtual QStringList parameterList() = 0;
      virtual QStringList imageNames();
 
      virtual bool computeTargetPartials(LinearAlgebra::Matrix &coeffTarget, BundleMeasure &measure,
                                         BundleSettingsQsp &bundleSettings, BundleTargetBodyQsp &bundleTargetBody) = 0;
      virtual bool computeImagePartials(LinearAlgebra::Matrix &coeffImage, BundleMeasure &measure) = 0;
      virtual bool computePoint3DPartials(LinearAlgebra::Matrix &coeffPoint3D, BundleMeasure &measure, SurfacePoint::CoordinateType coordType = SurfacePoint::Rectangular) = 0;
      virtual bool computeRHSPartials(LinearAlgebra::Vector &coeffRHS, BundleMeasure &measure) = 0;
      virtual double computeObservationValue(BundleMeasure &measure, double deltaVal) = 0;
 
    protected:
      QString m_observationNumber; 
      int m_index; 
      QMap<QString, BundleImageQsp> m_cubeSerialNumberToBundleImageMap;
      QStringList m_serialNumbers;      
      QStringList m_imageNames;         
      QString m_instrumentId;           
 
      LinearAlgebra::Vector m_weights;     
      LinearAlgebra::Vector m_corrections;
      LinearAlgebra::Vector m_aprioriSigmas;
      LinearAlgebra::Vector m_adjustedSigmas;
  };
  class BundleObservation : public QVector<BundleImageQsp> {…};

  typedef QSharedPointer<BundleObservation> BundleObservationQsp;
}
 
#endif // BundleObservation_h