ControlNetVitals.cpp

#include "ControlNetVitals.h"

#include <QDateTime>
#include <QList>
#include <QPair>
#include <QVariant>

#include "IException.h"
#include "IString.h"
#include "ControlNet.h"
#include "ControlPoint.h"
#include "ControlMeasure.h"

namespace Isis {


  ControlNetVitals::ControlNetVitals(ControlNet *cnet) {
    m_controlNet = cnet;

    initializeVitals();

    connect(cnet, SIGNAL(networkModified(ControlNet::ModType)),
            this, SLOT(validateNetwork(ControlNet::ModType)));

    connect(cnet, SIGNAL(newPoint(ControlPoint*)),
            this, SLOT(addPoint(ControlPoint*)));
    connect(cnet, SIGNAL(pointModified(ControlPoint *, ControlPoint::ModType, QVariant, QVariant)),
            this, SLOT(pointModified(ControlPoint *, ControlPoint::ModType, QVariant, QVariant)));
    connect(cnet, SIGNAL(pointDeleted(ControlPoint*)),
            this, SLOT(deletePoint(ControlPoint*)));

    connect(cnet, SIGNAL(newMeasure(ControlMeasure*)),
            this, SLOT(addMeasure(ControlMeasure*)));
    connect(cnet, SIGNAL(measureModified(ControlMeasure *, ControlMeasure::ModType, QVariant, QVariant)),
            this, SLOT(measureModified(ControlMeasure *, ControlMeasure::ModType, QVariant, QVariant)));
    connect(cnet, SIGNAL(measureRemoved(ControlMeasure*)),
            this, SLOT(deleteMeasure(ControlMeasure*)));

    validate();
  }


  void ControlNetVitals::initializeVitals() {

    m_islandList = m_controlNet->GetSerialConnections();

    m_numPoints = 0;
    m_numPointsIgnored = 0;
    m_numPointsLocked = 0;
    m_numMeasures = m_controlNet->GetNumMeasures();

    m_pointMeasureCounts.clear();
    m_imageMeasureCounts.clear();
    m_pointTypeCounts.clear();

    m_pointTypeCounts.insert(ControlPoint::Free, 0);
    m_pointTypeCounts.insert(ControlPoint::Constrained, 0);
    m_pointTypeCounts.insert(ControlPoint::Fixed, 0);

    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      addPoint(point);
    }

    foreach(QString serial, m_controlNet->GetCubeSerials()) {
      int numValidMeasures = m_controlNet->GetNumberOfValidMeasuresInImage(serial);
      if ( !m_imageMeasureCounts.contains(numValidMeasures) ) {
        m_imageMeasureCounts.insert(numValidMeasures, 1);
      }
      else {
        m_imageMeasureCounts[numValidMeasures]++;
      }
    }
  }


  void ControlNetVitals::emitHistoryEntry(QString entry, QString id, QVariant oldValue, QVariant newValue) {
    emit historyEntry(entry, id, oldValue, newValue, QDateTime::currentDateTime().toString());
  }


  void ControlNetVitals::addPoint(ControlPoint *point) {

    emitHistoryEntry("Control Point Added", point->GetId(), "", "");
    m_numPoints++;

    if (point->IsIgnored()) {
      m_numPointsIgnored++;
      return;
    }

    if (point->IsEditLocked()) {
      m_numPointsLocked++;
    }

    m_pointTypeCounts[point->GetType()]++;

    int numValidMeasures = point->GetNumValidMeasures();
    if ( !m_pointMeasureCounts.contains(numValidMeasures) ) {
      m_pointMeasureCounts.insert(numValidMeasures, 1);
    }

    else {
      m_pointMeasureCounts[numValidMeasures]++;
    }

    m_numMeasures = m_controlNet->GetNumMeasures();
    validate();
  }


  void ControlNetVitals::pointModified(ControlPoint *point, ControlPoint::ModType type,
                                       QVariant oldValue, QVariant newValue) {

    QString historyEntry;

    switch(type) {
      case ControlPoint::EditLockModified:

        historyEntry = "Point Edit Lock Modified";

        if (oldValue.toBool()) {
          m_numPointsLocked--;
        }

        if (newValue.toBool()) {
          m_numPointsLocked++;
        }

        emitHistoryEntry( historyEntry, point->GetId(),
                          oldValue, newValue );

        break;

      case ControlPoint::IgnoredModified:

        historyEntry = "Point Ignored Modified";

        if (oldValue.toBool()) {
          m_numPointsIgnored--;
          if (point->IsEditLocked()) {
            m_numPointsLocked++;
          }
          m_pointTypeCounts[point->GetType()]++;
          int numValidMeasures = point->GetNumValidMeasures();
          if ( !m_pointMeasureCounts.contains(numValidMeasures) ) {
            m_pointMeasureCounts.insert(numValidMeasures, 1);
          }
          else {
            m_pointMeasureCounts[numValidMeasures]++;
          }
        }

        if (newValue.toBool()) {
          m_numPointsIgnored++;
          if (point->IsEditLocked()) {
            m_numPointsLocked--;
          }
          m_pointTypeCounts[point->GetType()]--;
          int numValidMeasures = point->GetNumValidMeasures();
          if ( --m_pointMeasureCounts[numValidMeasures] < 1 ) {
            m_pointMeasureCounts.remove(numValidMeasures);
          }
        }

        emitHistoryEntry( historyEntry, point->GetId(),
                          oldValue, newValue );

        break;

      case ControlPoint::TypeModified:

        historyEntry = "Point Type Modified";

        m_pointTypeCounts[ControlPoint::PointType(oldValue.toInt())]--;
        m_pointTypeCounts[ControlPoint::PointType(newValue.toInt())]++;

        emitHistoryEntry( historyEntry, point->GetId(),
                          ControlPoint::PointTypeToString(ControlPoint::PointType(oldValue.toInt())),
                          ControlPoint::PointTypeToString(ControlPoint::PointType(newValue.toInt())) );

        break;

      default:
        // no operation
        break;
    }

    validate();

  }


  ControlPoint* ControlNetVitals::getPoint(QString id) {
    return m_controlNet->GetPoint(id);
  }


  void ControlNetVitals::deletePoint(ControlPoint *point) {

    emitHistoryEntry("Control Point Deleted", point->GetId(), "", "");
    m_numPoints--;

    if (point->IsIgnored()) {
      m_numPointsIgnored--;
      validate();
      return;
    }
    if (point->IsEditLocked()) {
      m_numPointsLocked--;
    }

    m_pointTypeCounts[point->GetType()]--;

    int numValidMeasures= point->GetNumValidMeasures();
    if ( --m_pointMeasureCounts[numValidMeasures] < 1 ) {
      m_pointMeasureCounts.remove(numValidMeasures);
    }

    validate();
  }


  void ControlNetVitals::addMeasure(ControlMeasure *measure) {
    emitHistoryEntry("Control Measure Added", measure->GetCubeSerialNumber(), "", "");

    m_numMeasures++;

    addMeasureToCounts(measure);

    validate();
  }


  void ControlNetVitals::measureModified(ControlMeasure *measure, ControlMeasure::ModType type, QVariant oldValue, QVariant newValue) {

    QString historyEntry;

    switch (type) {
      case ControlMeasure::IgnoredModified:

        historyEntry = "Measure Ignored Modified";

        if ( !oldValue.toBool() && newValue.toBool() ) {
          return removeMeasureFromCounts(measure);
        }
        else if ( oldValue.toBool() && !newValue.toBool() ) {
          return addMeasureToCounts(measure);
        }
        break;

      default:
        // No operation.
        break;
    }

    ControlNetVitals::emitHistoryEntry(historyEntry, measure->GetCubeSerialNumber(), "", "");
    validate();
  }


  void ControlNetVitals::deleteMeasure(ControlMeasure *measure) {

    emitHistoryEntry("Control Measure Deleted", measure->GetCubeSerialNumber(), "", "");

    m_numMeasures--;

    removeMeasureFromCounts(measure);

    validate();
  }


   void ControlNetVitals::addMeasureToCounts(ControlMeasure *measure) {
     ControlPoint *point = measure->Parent();
     if (point) {
       // By this time, the measure has been added to its parent point, so the
       // old count is the current count minus one.
       int numValidMeasures = point->GetNumValidMeasures();
       if ( --m_pointMeasureCounts[numValidMeasures] < 1 ) {
         m_pointMeasureCounts.remove(numValidMeasures);
       }
       if ( !m_pointMeasureCounts.contains(numValidMeasures + 1) ) {
         m_pointMeasureCounts.insert(numValidMeasures + 1, 1);
       }
       else {
         m_pointMeasureCounts[numValidMeasures + 1]++;
       }
     }

     QString serial = measure->GetCubeSerialNumber();
     int numValidMeasures = m_controlNet->GetNumberOfValidMeasuresInImage(serial);
     if ( --m_imageMeasureCounts[numValidMeasures - 1] < 1 ) {
       m_imageMeasureCounts.remove(numValidMeasures);
     }
     if ( !m_imageMeasureCounts.contains(numValidMeasures) ) {
       m_imageMeasureCounts.insert(numValidMeasures, 1);
     }
     else {
       m_imageMeasureCounts[numValidMeasures]++;
     }
   }


    void ControlNetVitals::removeMeasureFromCounts(ControlMeasure *measure) {
      ControlPoint *point = measure->Parent();
      if (point) {
        // By this time, the measure is still a valid measure in the parent control point.
        int numValidMeasures = point->GetNumValidMeasures();

        if ( --m_pointMeasureCounts[numValidMeasures] < 1 ) {
          m_pointMeasureCounts.remove(numValidMeasures);
        }
        if ( !m_pointMeasureCounts.contains(numValidMeasures - 1) ) {
          m_pointMeasureCounts.insert(numValidMeasures - 1, 1);
        }
        else {
          m_pointMeasureCounts[numValidMeasures - 1]++;
        }
      }

      QString serial = measure->GetCubeSerialNumber();
      int numValidMeasures = m_controlNet->GetNumberOfValidMeasuresInImage(serial);

      if ( --m_imageMeasureCounts[numValidMeasures] < 1 ) {
        m_imageMeasureCounts.remove(numValidMeasures);
      }

      if ( !m_imageMeasureCounts.contains(numValidMeasures - 1) ) {
        m_imageMeasureCounts.insert(numValidMeasures - 1, 1);
      }
      else {
        m_imageMeasureCounts[numValidMeasures - 1]++;
      }
    }


  void ControlNetVitals::validateNetwork(ControlNet::ModType type) {

    QString historyEntry;

    switch (type) {
      case ControlNet::Swapped:
        emitHistoryEntry("Control Net Swapped", m_controlNet->GetNetworkId(), "", "");
        initializeVitals();
        break;
      case ControlNet::GraphModified:
        emitHistoryEntry("Control Net Graph Modified", m_controlNet->GetNetworkId(), "", "");
        m_islandList = m_controlNet->GetSerialConnections();
        break;
      default:
        // No operation.
        break;
    }
    validate();
  }


  ControlNetVitals::~ControlNetVitals() {
  }


  bool ControlNetVitals::hasIslands() {
    return numIslands() > 1;
  }


  int ControlNetVitals::numIslands() {
    return m_islandList.size();
  }


  const QList< QList<QString> > &ControlNetVitals::getIslands() {
    return m_islandList;
  }


  int ControlNetVitals::numPoints() {
    return m_numPoints;
  }


  int ControlNetVitals::numIgnoredPoints() {
    return m_numPointsIgnored;
  }


  int ControlNetVitals::numLockedPoints() {
    return m_numPointsLocked;
  }


  int ControlNetVitals::numFixedPoints() {
    return m_pointTypeCounts[ControlPoint::Fixed];
  }


  int ControlNetVitals::numConstrainedPoints() {
    return m_pointTypeCounts[ControlPoint::Constrained];
  }


  int ControlNetVitals::numFreePoints() {
    return m_pointTypeCounts[ControlPoint::Free];
  }


  int ControlNetVitals::numPointsBelowMeasureThreshold(int num) {
    int count = 0;

    QMap<int, int>::const_iterator i = m_pointMeasureCounts.constBegin();
    while (i != m_pointMeasureCounts.constEnd()) {
      if (i.key() >= num ) {
        break;
      }
      count += i.value();
      ++i;
    }

    return count;
  }


  int ControlNetVitals::numImages() {
    return m_controlNet->GetCubeSerials().size();
  }


  int ControlNetVitals::numMeasures() {
    return m_numMeasures;
  }


  int ControlNetVitals::numImagesBelowMeasureThreshold(int num) {
    int count = 0;

    QMap<int, int>::const_iterator i = m_imageMeasureCounts.constBegin();
    while (i != m_imageMeasureCounts.constEnd()) {
      if (i.key() >= num ) {
        break;
      }
      count += i.value();
      ++i;
    }
    return count;
  }


  // REFACTOR
  int ControlNetVitals::numImagesBelowHullTolerance(int tolerance) {
    return 0;
  }


  QList<QString> ControlNetVitals::getCubeSerials() {
    return m_controlNet->GetCubeSerials();
  }


  QList<ControlPoint*> ControlNetVitals::getAllPoints() {
    return m_controlNet->GetPoints();
  }


  QList<ControlPoint*> ControlNetVitals::getIgnoredPoints() {
    QList<ControlPoint*> ignoredPoints;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (point->IsIgnored()) ignoredPoints.append(point);
    }
    return ignoredPoints;
  }


  QList<ControlPoint*> ControlNetVitals::getLockedPoints() {
    QList<ControlPoint*> lockedPoints;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (!point->IsIgnored() && point->IsEditLocked()) lockedPoints.append(point);
    }
    return lockedPoints;
  }


  QList<ControlPoint*> ControlNetVitals::getFixedPoints() {
    QList<ControlPoint*> fixedPoints;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (!point->IsIgnored() && point->GetType() == ControlPoint::Fixed) fixedPoints.append(point);
    }
    return fixedPoints;
  }


  QList<ControlPoint*> ControlNetVitals::getConstrainedPoints() {
    QList<ControlPoint*> constrainedPoints;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (!point->IsIgnored() && point->GetType() == ControlPoint::Constrained) constrainedPoints.append(point);
    }
    return constrainedPoints;
  }


  QList<ControlPoint*> ControlNetVitals::getFreePoints() {
    QList<ControlPoint*> freePoints;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (!point->IsIgnored() && point->GetType() == ControlPoint::Free) freePoints.append(point);
    }
    return freePoints;
  }


  QList<ControlPoint*> ControlNetVitals::getPointsBelowMeasureThreshold(int num) {
    QList<ControlPoint*> belowThreshold;
    foreach(ControlPoint* point, m_controlNet->GetPoints()) {
      if (!point->IsIgnored() && point->GetNumMeasures() < num) belowThreshold.append(point);
    }
    return belowThreshold;
  }


  QList<QString> ControlNetVitals::getImagesBelowMeasureThreshold(int num) {
    QList<QString> imagesBelowThreshold;
    foreach(QString serial, m_controlNet->GetCubeSerials()) {
      if (m_controlNet->GetValidMeasuresInCube(serial).size() < num) {
        imagesBelowThreshold.append(serial);
      }
    }
    return imagesBelowThreshold;
  }


  QList<QString> ControlNetVitals::getImagesBelowHullTolerance(int num) {
    QList<QString> list;
    return list;
  }


  QString ControlNetVitals::getStatus() {
    return m_status;
  }


  QString ControlNetVitals::getStatusDetails() {
    return m_statusDetails;
  }


  QString ControlNetVitals::getNetworkId() {
    return m_controlNet->GetNetworkId();
  }


  void ControlNetVitals::validate() {

    QString status = "";
    QString details = "";
    if (hasIslands()) {
      status = "Broken!";
      details = "This network has " + toString(numIslands()) + " islands.";
    }
    else {

      if (numPointsBelowMeasureThreshold() > 0) {
        status = "Weak!";
        details += "This network has " + toString(numPointsBelowMeasureThreshold()) + " point(s) with less than 3 measures\n";
      }

      if (numImagesBelowMeasureThreshold() > 0) {
        status = "Weak!";
        details += "This network has " + toString(numImagesBelowMeasureThreshold()) + " image(s) with less than 3 measures\n";
      }

      if (numImagesBelowHullTolerance() > 0) {
        status = "Weak!";
        details += "This network has " + toString(numImagesBelowHullTolerance()) + " image(s) below the Convex Hull Tolerance of 75%\n";
      }

      if (status.isEmpty()) {
        status = "Healthy!";
        details = "This network is healthy.";
      }
    }
    m_status = status;
    m_statusDetails = details;
    emit networkChanged();
  }

}