Object/Developer/_control_net_8h_source.html

#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 A, typename B > struct QPair;

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);

      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::binary_function<ControlMeasure* const &,

          ControlMeasure * const &, bool > {

        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