ControlNet.h

#ifndef ControlNet_h
#define ControlNet_h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
// This is needed for the QVariant macro
#include <QMetaType>
#include <QObject> // parent class
#include <QSharedPointer>
#include "SurfacePoint.h"
#include <QString>
#include <QMap>
#include <QVariant>
#include <QVector>
#include <QVariant>
 
 
// Boost includes
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/connected_components.hpp>
 
#include "ControlMeasure.h"
#include "ControlPoint.h"
 
template< typename A, typename B > class QHash;
template< typename T > class QList;
template< typename T > class QSet;
 
class QMutex;
class QString;
 
namespace Isis {
  class Camera;
  class ControlMeasure;
  class ControlPoint;
  class Distance;
  class Progress;
  class Pvl;
  class SerialNumberList;

  class ControlNet : public QObject {
      Q_OBJECT
 
      friend class ControlMeasure;
      friend class ControlPoint;
 
    public:

      enum ModType {
        Swapped,
        GraphModified
      };
 
      ControlNet(SurfacePoint::CoordinateType = SurfacePoint::Latitudinal);
      ControlNet(const ControlNet &other);
      ControlNet(const QString &filename, Progress *progress = 0,
                 SurfacePoint::CoordinateType = SurfacePoint::Latitudinal);
 
      ~ControlNet();
 
      void clear();
      QList< ControlPoint * > take();
 
      void ReadControl(const QString &filename, Progress *progress = 0);
      void Write(const QString &filename, bool pvl = false);
 
      void AddPoint(ControlPoint *point);
      int DeletePoint(ControlPoint *point);
      int DeletePoint(QString pointId);
      int DeletePoint(int index);
      bool ContainsPoint(QString pointId) const;
 
      QList< QString > GetCubeSerials() const;
      QString GraphToString() const;
      QList< QList< QString > > GetSerialConnections() const;
      int getEdgeCount() const;
      QList< QString > getAdjacentImages(QString serialNumber) const;
      QList< ControlMeasure * > GetMeasuresInCube(QString serialNumber);
      QList< ControlMeasure * > GetValidMeasuresInCube(QString serialNumber);
      QList< ControlMeasure * > sortedMeasureList(double(ControlMeasure::*statFunc)() const,
                                                  double min,double max);
 
      void ComputeResiduals();
      void ComputeApriori();
 
      const ControlPoint *GetPoint(QString pointId) const;
      ControlPoint *GetPoint(QString pointId);
      const ControlPoint *GetPoint(int index) const;
      ControlPoint *GetPoint(int index);
 
      double AverageResidual();
      Isis::Camera *Camera(int index);
      Isis::Camera *Camera(QString serialNumber);                                                                       
      QString CreatedDate() const;
      QString Description() const;
      ControlPoint *FindClosest(QString serialNumber,
          double sample, double line);
      //bool IsValid() const;
      double GetMaximumResidual();
      QString GetNetworkId() const;
      int GetNumEditLockMeasures();
      int GetNumEditLockPoints();
      int GetNumIgnoredMeasures();
      int GetNumberOfValidMeasuresInImage(const QString &serialNumber);
      int GetNumberOfJigsawRejectedMeasuresInImage(const QString &serialNumber);
      void ClearJigsawRejected();
      void IncrementNumberOfRejectedMeasuresInImage(const QString &serialNumber);
      void DecrementNumberOfRejectedMeasuresInImage(const QString &serialNumber);
      int GetNumMeasures() const;
      int GetNumPoints() const;
      int GetNumValidMeasures();
      int GetNumValidPoints();
      QString GetTarget() const;
      QString GetUserName() const;
      QString GetLastModified() const;
      QList< ControlPoint * > GetPoints();
      QList< QString > GetPointIds() const;
      SurfacePoint::CoordinateType GetCoordType();
 
      void SetCreatedDate(const QString &date);
      void SetDescription(const QString &newDescription);
      void SetImages(const QString &imageListFile);
      void SetImages(SerialNumberList &list, Progress *progress = 0);
 
      void SetModifiedDate(const QString &date);
      void SetMutex(QMutex *mutex);
      void SetNetworkId(const QString &id);
      void SetTarget(const QString &target);
      void SetTarget(Pvl label);
      void SetTarget(const ControlNet &other);
      void SetUserName(const QString &name);
      void SetCoordType(SurfacePoint::CoordinateType coordType);
 
      void swap(ControlNet &other);
      ControlNet &operator=(const ControlNet &other);
 
      const ControlPoint *operator[](QString id) const;
      ControlPoint *operator[](QString id);
      const ControlPoint *operator[](int id) const;
      ControlPoint *operator[](int id);
 
 
    signals:
      void networkStructureModified();
      void networkModified(ControlNet::ModType type);
      void pointModified(ControlPoint *point, ControlPoint::ModType type, QVariant oldValue, QVariant newValue);
      void measureModified(ControlMeasure *measure, ControlMeasure::ModType type, QVariant oldValue, QVariant newValue);
      void pointDeleted(ControlPoint *point);
      void newPoint(ControlPoint *);
      void newMeasure(ControlMeasure *);
      void measureRemoved(ControlMeasure *);
 
 
 
    private:
      void nullify();
      bool ValidateSerialNumber(QString serialNumber) const;
      void measureAdded(ControlMeasure *measure);
      void measureDeleted(ControlMeasure *measure);
      void measureIgnored(ControlMeasure *measure);
      void measureUnIgnored(ControlMeasure *measure);
      void pointIgnored(ControlPoint *point);
      void pointUnIgnored(ControlPoint *point);
      void UpdatePointReference(ControlPoint *point, QString oldId);
      void emitNetworkStructureModified();
      void emitMeasureModified(ControlMeasure *measure, ControlMeasure::ModType type, QVariant oldValue, QVariant newValue);
      void emitPointModified(ControlPoint *point, ControlPoint::ModType type, QVariant oldValue, QVariant newValue);
      void pointAdded(ControlPoint *point);
      bool addEdge(QString sourceSerial, QString targetSerial);
      bool removeEdge(QString sourceSerial, QString targetSerial);
 
    private: // graphing functions
      class ControlMeasureLessThanFunctor :
          public std::function<bool(ControlMeasure* const &,
          ControlMeasure * const &)> {
        public:
          ControlMeasureLessThanFunctor(double(ControlMeasure::*accessorMethod)() const) {
            m_accessor = accessorMethod;
          }
          ControlMeasureLessThanFunctor(ControlMeasureLessThanFunctor const &other) {
            this->m_accessor = other.m_accessor;
          }
          ~ControlMeasureLessThanFunctor() {}
 
          bool operator()(ControlMeasure* const &, ControlMeasure* const &);
          ControlMeasureLessThanFunctor & operator=(ControlMeasureLessThanFunctor const &other);
 
        private:
          double(ControlMeasure::*m_accessor)() const;
      };
 
    private: // data
      QHash< QString, ControlPoint * > * points;

      struct Image {
        QString serial; 
        QHash< ControlPoint *, ControlMeasure * > measures;
      };

      struct Connection {
        Connection() : strength(0) {}
        int strength;
      };

      typedef boost::adjacency_list<boost::setS,
                                    boost::listS,
                                    boost::undirectedS,
                                    Image,
                                    Connection> Network;
 
      typedef Network::vertex_descriptor ImageVertex; 
      typedef Network::edge_descriptor ImageConnection; 

      typedef std::map<ImageVertex, size_t> VertexIndexMap;

      typedef boost::associative_property_map<VertexIndexMap> VertexIndexMapAdaptor;

      typedef boost::graph_traits<Network>::adjacency_iterator AdjacencyIterator;
      typedef boost::graph_traits<Network>::vertex_iterator VertexIterator;
 
      QHash<QString, ImageVertex> m_vertexMap; 
      Network m_controlGraph; 
      QStringList *pointIds;
      QMutex *m_mutex;
 
      QString p_targetName;            
      QString p_networkId;             
      QString p_created;               
      QString p_modified;              
      QString p_description;           
      QString p_userName;              
      QMap<QString, Isis::Camera *> p_cameraMap; 
      QMap<QString, int> p_cameraValidMeasuresMap; 
      QMap<QString, int> p_cameraRejectedMeasuresMap; 
      QVector<Isis::Camera *> p_cameraList; 
 
      bool m_ownPoints; 
      SurfacePoint::CoordinateType m_coordType; 
  };

  typedef QSharedPointer<ControlNet> ControlNetQsp;
}

Q_DECLARE_METATYPE(Isis::ControlNet *);
 
#endif