ControlNetVitals.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#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();
  }
 
}