BundleObservationSolveSettings.h

#ifndef BundleObservationSolveSettings_h
#define BundleObservationSolveSettings_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <QList>
#include <QSet>
#include <QString>
#include <QStringList>
 
#include <csm.h>
 
#include "SpicePosition.h"
#include "SpiceRotation.h"
#include "XmlStackedHandler.h"
 
class QDataStream;
class QUuid;
class QXmlStreamWriter;
 
namespace Isis {
  class FileName;
  class Project;  // TODO: does xml stuff need project???
  class PvlObject;
  class XmlStackedHandlerReader;
class BundleObservationSolveSettings {
 
    public:
      BundleObservationSolveSettings();
      BundleObservationSolveSettings(Project *project,
                                     XmlStackedHandlerReader *xmlReader);  // TODO: does xml stuff need project???
      BundleObservationSolveSettings(FileName xmlFile,
                                     Project *project,
                                     XmlStackedHandlerReader *xmlReader);  // TODO: does xml stuff need project???
      BundleObservationSolveSettings(const BundleObservationSolveSettings &src);
      BundleObservationSolveSettings(const PvlGroup &scParameterGroup);
      ~BundleObservationSolveSettings();
      BundleObservationSolveSettings &operator=(const BundleObservationSolveSettings &src);
      void initialize();
 
      void setInstrumentId(QString instrumentId);
      QString instrumentId() const;
      void addObservationNumber(QString observationNumber);
      bool removeObservationNumber(QString observationNumber);
      QSet<QString> observationNumbers() const;
 
      enum CSMSolveOption {
        NoCSMParameters = 0, 
        Set             = 1, 
        Type            = 2, 
        List            = 3  
      };
 
      static CSMSolveOption stringToCSMSolveOption(QString option);
      static QString csmSolveOptionToString(CSMSolveOption option);
      static csm::param::Set stringToCSMSolveSet(QString set);
      static QString csmSolveSetToString(csm::param::Set set);
      static csm::param::Type stringToCSMSolveType(QString type);
      static QString csmSolveTypeToString(csm::param::Type type);
      void setCSMSolveSet(csm::param::Set set);
      void setCSMSolveType(csm::param::Type type);
      void setCSMSolveParameterList(QStringList list);
      CSMSolveOption csmSolveOption() const;
      csm::param::Set csmParameterSet() const;
      csm::param::Type csmParameterType() const;
      QStringList csmParameterList() const;
 
      enum InstrumentPointingSolveOption {
        NoPointingFactors          = 0, 
        AnglesOnly                 = 1, 
        AnglesVelocity             = 2, 
        AnglesVelocityAcceleration = 3, 
        AllPointingCoefficients    = 4  
      };
 
      static InstrumentPointingSolveOption stringToInstrumentPointingSolveOption(QString option);
      static QString instrumentPointingSolveOptionToString(InstrumentPointingSolveOption option);
      void setInstrumentPointingSettings(InstrumentPointingSolveOption option,
                                         bool solveTwist,
                                         int ckDegree = 2,
                                         int ckSolveDegree = 2,
                                         bool solvePolynomialOverExisting = false,
                                         double anglesAprioriSigma = -1.0,
                                         double angularVelocityAprioriSigma = -1.0,
                                         double angularAccelerationAprioriSigma = -1.0,
                                         QList<double> * additionalPointingSigmas=nullptr);
      InstrumentPointingSolveOption instrumentPointingSolveOption() const;
      bool solveTwist() const;
      int ckDegree() const;
      int ckSolveDegree() const;
      int numberCameraAngleCoefficientsSolved() const;
      bool solvePolyOverPointing() const;
      QList<double> aprioriPointingSigmas() const;
      SpiceRotation::Source pointingInterpolationType() const;
 
 
 
      enum InstrumentPositionSolveOption {
        NoPositionFactors            = 0, 
        PositionOnly                 = 1, 
        PositionVelocity             = 2, 
        PositionVelocityAcceleration = 3, 
        AllPositionCoefficients      = 4  
      };
 
      static InstrumentPositionSolveOption stringToInstrumentPositionSolveOption(QString option);
      static QString instrumentPositionSolveOptionToString(InstrumentPositionSolveOption option);
      void setInstrumentPositionSettings(InstrumentPositionSolveOption option,
                                         int spkDegree = 2,
                                         int spkSolveDegree = 2,
                                         bool positionOverHermite = false,
                                         double positionAprioriSigma = -1.0,
                                         double velocityAprioriSigma = -1.0,
                                         double accelerationAprioriSigma = -1.0,
                                         QList<double> * additionalPositionSigmas=nullptr);
      InstrumentPositionSolveOption instrumentPositionSolveOption() const;
      int spkDegree() const;
      int spkSolveDegree() const;
      int numberCameraPositionCoefficientsSolved() const;
      bool solvePositionOverHermite() const;
      QList<double> aprioriPositionSigmas() const;
      SpicePosition::Source positionInterpolationType() const;
 
      // 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(BundleObservationSolveSettings *settings, 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);
 
          BundleObservationSolveSettings *m_xmlHandlerObservationSettings;
          Project *m_xmlHandlerProject;  // TODO: does xml stuff need project???
          QString m_xmlHandlerCharacters;
          QStringList m_xmlHandlerAprioriSigmas;
      };
 
      QUuid *m_id;
      QString m_instrumentId;               
      QSet<QString> m_observationNumbers;  
 
      // CSM related parameters
      CSMSolveOption m_csmSolveOption;  
      csm::param::Set m_csmSolveSet;    
      csm::param::Type m_csmSolveType;  
      QStringList m_csmSolveList;       
      // pointing related parameters
      InstrumentPointingSolveOption m_instrumentPointingSolveOption;
      int m_numberCamAngleCoefSolved;             
      int m_ckDegree;                             
      int m_ckSolveDegree;                        
      bool m_solveTwist;                          
      bool m_solvePointingPolynomialOverExisting; 
      QList<double> m_anglesAprioriSigma; 
      SpiceRotation::Source
          m_pointingInterpolationType;    
      // position related parameters
      InstrumentPositionSolveOption m_instrumentPositionSolveOption;
      int m_numberCamPosCoefSolved;          
      int m_spkDegree;                       
      int m_spkSolveDegree;                  
      bool m_solvePositionOverHermiteSpline; 
      QList<double> m_positionAprioriSigma; 
      SpicePosition::Source
          m_positionInterpolationType;      
  };
  typedef QSharedPointer<BundleObservationSolveSettings> BundleObservationSolveSettingsQsp;
};
 
#endif // BundleObservationSolveSettings_h