TargetBody.h

#ifndef TargetBody_h
#define TargetBody_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <vector>
 
#include <QList>
#include <QObject>
#include <QSharedPointer>
#include <QString>
 
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>
 
#include "Angle.h"
//#include "BundleTargetBody.h"
#include "Distance.h"
#include "Target.h"
#include "XmlStackedHandler.h"
 
 
class QDataStream;
class QUuid;
class QXmlStreamWriter;
 
namespace Isis {
  //class Distance;
  class FileName;
  class Project;  // TODO: does xml stuff need project???
  class PvlObject;
  class TargetBodyDisplayProperties;
  class XmlStackedHandlerReader;
 
  class TargetBody : public QObject {
 
    Q_OBJECT
 
    public:
      TargetBody(Target *target, QObject *parent = 0);
      //TargetBody(BundleTargetBodyQsp bundleTargetBody, QObject *parent = 0);
//      TargetBody(Project *project, XmlStackedHandlerReader *xmlReader,
//                 QObject *parent = 0);  // TODO: does xml stuff need project???
      ~TargetBody();
 
      bool operator==(const TargetBody &src) const;
 
      TargetBodyDisplayProperties *displayProperties();
      const TargetBodyDisplayProperties *displayProperties() const;
 
      QString id() const;
      QString targetName();
//    void deleteFromDisk();
 
      int frameType();
 
      std::vector<Angle> poleRaCoefs();
      std::vector<Angle> poleDecCoefs();
      std::vector<Angle> pmCoefs();
 
      std::vector<double> poleRaNutPrecCoefs();
      std::vector<double> poleDecNutPrecCoefs();
 
      std::vector<double> pmNutPrecCoefs();
 
      std::vector<Angle> sysNutPrecConstants();
      std::vector<Angle> sysNutPrecCoefs();
 
      SpiceInt naifBodyCode() const;
      SpiceInt naifPlanetSystemCode() const;
      QString naifPlanetSystemName() const;
      Distance radiusA() const;
      Distance radiusB() const;
      Distance radiusC() const;
      Distance meanRadius() const;
      Distance sigmaRadiusA() const;
      Distance sigmaRadiusB() const;
      Distance sigmaRadiusC() const;
      Distance sigmaMeanRadius() const;
 
//      void save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot) const;
//      TODO: does xml stuff need project and newRoot???
//      void save(QXmlStreamWriter &stream, const Project *project) const;
//      TODO: does xml stuff need project???
//
//      QDataStream &write(QDataStream &stream) const;
//      QDataStream &read(QDataStream &stream);
 
    private:
//      class XmlHandler : public XmlStackedHandler {
//        public:
//          XmlHandler(TargetBody *TargetBody, Project *project);
//      TODO: does xml stuff need 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);
//
//          TargetBody *m_xmlHandlerTargetBody;
//          Project *m_xmlHandlerProject;  // TODO: does xml stuff need project???
//          QString m_xmlHandlerCharacters;
//      };
 
    private:
      TargetBody(const TargetBody &other);          // NOTE: copy constructor & assignment operators
      TargetBody &operator=(const TargetBody &rhs); // are private so compiler will generate error
                                                    // if trying to use them (because parent is
                                                    // QObject which uses Q_DISABLE_COPY macro
      //testing
      TargetQsp m_isisTarget;
 
      QUuid *m_id;
 
      QString m_targetName;
 
      SpiceInt *m_bodyCode;
 
      SpiceInt *m_systemCode;
 
      QString m_systemName;
 
      std::vector<Distance> m_radii;
 
      std::vector<Distance> m_sigmaRadii;
 
      TargetBodyDisplayProperties *m_displayProperties;
 
      int m_frametype;  
 
      // The next three vectors will have length 3 (for a quadratic polynomial) if used.
      std::vector<Angle> m_raPole;      
      std::vector<Angle> m_decPole;     
      std::vector<Angle> m_pm ;         
      //
      // Currently multiples (terms with periods matching other terms but varying amplitudes)
      // are handled as additional terms added to the end of the vector as Naif does (see
      // comments in any of the standard Naif PCK.
      std::vector<double> m_raNutPrec;   
      std::vector<double> m_decNutPrec;  
      std::vector<double> m_pmNutPrec;   
 
      // The periods of bodies in the same system are modeled with a linear equation
      std::vector<Angle> m_sysNutPrec0; 
      std::vector<Angle> m_sysNutPrec1; 
  };
 
  typedef QSharedPointer<TargetBody> TargetBodyQsp;
 
  //
 
  // operators to read/write TargetBody to/from binary data
  QDataStream &operator<<(QDataStream &stream, const TargetBody &TargetBody);
  QDataStream &operator>>(QDataStream &stream, TargetBody &TargetBody);
};
 
Q_DECLARE_METATYPE(Isis::TargetBodyQsp);
 
#endif // TargetBody_h