ControlNet.h

Go to the documentation of this file.

#ifndef ControlNet_h
#define ControlNet_h

// 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