ControlNetDiff.cpp

#include "IsisDebug.h"

#include "ControlNetDiff.h"

#include <QMap>
#include <QSet>
#include <QString>

#include "ControlMeasure.h"
#include "ControlNet.h"
#include "ControlNetFile.h"
#include "ControlNetVersioner.h"
#include "ControlPoint.h"
#include "FileName.h"
#include "Pvl.h"
#include "PvlContainer.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "PvlObject.h"


using std::cerr;
using std::cout;
using std::endl;

namespace Isis {

  ControlNetDiff::ControlNetDiff() {
    init();
  }


  ControlNetDiff::ControlNetDiff(Pvl &diffFile) {
    init();
    addTolerances(diffFile);
  }


  ControlNetDiff::~ControlNetDiff() {
    delete m_tolerances;
    m_tolerances = NULL;

    delete m_ignoreKeys;
    m_ignoreKeys = NULL;
  }


  void ControlNetDiff::addTolerances(Pvl &diffFile) {
    if (diffFile.HasGroup("Tolerances")) {
      PvlGroup tolerances = diffFile.FindGroup("Tolerances");
      for (int i = 0; i < tolerances.Keywords(); i++)
        m_tolerances->insert(tolerances[i].Name(),
            toDouble(tolerances[i][0]));
    }

    if (diffFile.HasGroup("IgnoreKeys")) {
      PvlGroup ignoreKeys = diffFile.FindGroup("IgnoreKeys");
      for (int i = 0; i < ignoreKeys.Keywords(); i++)
        m_ignoreKeys->insert(ignoreKeys[i].Name());
    }
  }


  Pvl ControlNetDiff::compare(FileName &net1Name, FileName &net2Name) {
    Pvl results;
    PvlObject report("Differences");

    LatestControlNetFile *net1 = ControlNetVersioner::Read(net1Name.expanded());
    LatestControlNetFile *net2 = ControlNetVersioner::Read(net2Name.expanded());
    diff("Filename", net1Name.name(), net2Name.name(), report);

    Pvl net1Pvl(net1->ToPvl());
    Pvl net2Pvl(net2->ToPvl());

    PvlObject &net1Obj = net1Pvl.FindObject("ControlNetwork");
    PvlObject &net2Obj = net2Pvl.FindObject("ControlNetwork");

    BigInt net1NumPts = net1Obj.Objects();
    BigInt net2NumPts = net2Obj.Objects();
    diff("Points", toString(net1NumPts), toString(net2NumPts), report);

    diff("NetworkId", net1Obj, net2Obj, report);
    diff("TargetName", net1Obj, net2Obj, report);

    QMap< QString, QMap<int, PvlObject> > pointMap;
    for (int p = 0; p < net1NumPts; p++) {
      PvlObject &point = net1Obj.Object(p);
      pointMap[point.FindKeyword("PointId")[0]].insert(
          0, point);
    }

    for (int p = 0; p < net2NumPts; p++) {
      PvlObject &point = net2Obj.Object(p);
      pointMap[point.FindKeyword("PointId")[0]].insert(
          1, point);
    }

    QList<QString> pointNames = pointMap.keys();
    for (int i = 0; i < pointNames.size(); i++) {
      QMap<int, PvlObject> idMap = pointMap[pointNames[i]];
      if (idMap.size() == 2) {
        compare(idMap[0], idMap[1], report);
      }
      else if (idMap.contains(0)) {
        addUniquePoint("PointId", idMap[0].FindKeyword("PointId")[0], "N/A", report);
      }
      else if (idMap.contains(1)) {
        addUniquePoint("PointId", "N/A", idMap[1].FindKeyword("PointId")[0], report);
      }
    }

    delete net1;
    delete net2;

    results.AddObject(report);
    return results;
  }


  void ControlNetDiff::compare(PvlObject &point1Pvl, PvlObject &point2Pvl, PvlObject &report) {
    PvlObject pointReport("Point");

    QString id1 = point1Pvl.FindKeyword("PointId")[0];
    QString id2 = point2Pvl.FindKeyword("PointId")[0];
    pointReport.AddKeyword(makeKeyword("PointId", id1, id2));

    int p1Measures = point1Pvl.Groups();
    int p2Measures = point2Pvl.Groups();
    diff("Measures", toString(p1Measures), toString(p2Measures), pointReport);

    compareGroups(point1Pvl, point2Pvl, pointReport);

    QMap< QString, QMap<int, PvlGroup> > measureMap;
    for (int m = 0; m < p1Measures; m++) {
      PvlGroup &measure = point1Pvl.Group(m);
      measureMap[measure.FindKeyword("SerialNumber")[0]].insert(
          0, measure);
    }

    for (int m = 0; m < p2Measures; m++) {
      PvlGroup &measure = point2Pvl.Group(m);
      measureMap[measure.FindKeyword("SerialNumber")[0]].insert(
          1, measure);
    }

    QList<QString> measureNames = measureMap.keys();
    for (int i = 0; i < measureNames.size(); i++) {
      QMap<int, PvlGroup> idMap = measureMap[measureNames[i]];
      if (idMap.size() == 2) {
        compareGroups(idMap[0], idMap[1], pointReport);
      }
      else if (idMap.contains(0)) {
        addUniqueMeasure("SerialNumber", idMap[0].FindKeyword("SerialNumber")[0], "N/A", pointReport);
      }
      else if (idMap.contains(1)) {
        addUniqueMeasure("SerialNumber", "N/A", idMap[1].FindKeyword("SerialNumber")[0], pointReport);
      }
    }

    if (pointReport.Keywords() > 2 || pointReport.Groups() > 0)
      report.AddObject(pointReport);
  }


  void ControlNetDiff::compareGroups(PvlContainer &g1, PvlContainer &g2, PvlObject &report) {
    PvlGroup measureReport("Measure");
    if (g1.HasKeyword("SerialNumber")) {
      QString sn1 = g1.FindKeyword("SerialNumber")[0];
      QString sn2 = g1.FindKeyword("SerialNumber")[0];
      measureReport.AddKeyword(makeKeyword("SerialNumber", sn1, sn2));
    }
    PvlContainer &groupReport = g1.HasKeyword("SerialNumber") ?
        (PvlContainer &) measureReport : (PvlContainer &) report;

    QMap< QString, QMap<int, PvlKeyword> > keywordMap;
    for (int k = 0; k < g1.Keywords(); k++)
      keywordMap[g1[k].Name()].insert(0, g1[k]);
    for (int k = 0; k < g2.Keywords(); k++)
      keywordMap[g2[k].Name()].insert(1, g2[k]);

    QList<QString> keywordNames = keywordMap.keys();
    for (int i = 0; i < keywordNames.size(); i++) {
      QMap<int, PvlKeyword> idMap = keywordMap[keywordNames[i]];
      if (idMap.size() == 2) {
        compare(idMap[0], idMap[1], groupReport);
      }
      else if (idMap.contains(0)) {
        QString name = idMap[0].Name();
        if (!m_ignoreKeys->contains(name))
          diff(name, idMap[0][0], "N/A", groupReport);
      }
      else if (idMap.contains(1)) {
        QString name = idMap[1].Name();
        if (!m_ignoreKeys->contains(name))
          diff(name, "N/A", idMap[1][0], groupReport);
      }
    }

    if (measureReport.Keywords() > 1) report.AddGroup(measureReport);
  }


  void ControlNetDiff::compare(PvlKeyword &k1, PvlKeyword &k2, PvlContainer &report) {
    QString name = k1.Name();
    if (m_tolerances->contains(name))
      diff(name, toDouble(k1[0]), toDouble(k2[0]), (*m_tolerances)[name], report);
    else
      diff(name, k1[0], k2[0], report);
  }


  void ControlNetDiff::diff(QString name, PvlObject &o1, PvlObject &o2, PvlContainer &report) {
    QString v1 = o1[name][0];
    QString v2 = o2[name][0];
    diff(name, v1, v2, report);
  }


  void ControlNetDiff::diff(QString name, QString v1, QString v2, PvlContainer &report) {
    if (!m_ignoreKeys->contains(name)) {
      if (v1 != v2) report.AddKeyword(makeKeyword(name, v1, v2));
    }
  }


  PvlKeyword ControlNetDiff::makeKeyword(QString name, QString v1, QString v2) {
    PvlKeyword keyword(name);
    keyword.AddValue(v1);
    if (v1 != v2) keyword.AddValue(v2);
    return keyword;
  }


  void ControlNetDiff::diff(QString name, double v1, double v2, double tol, PvlContainer &report) {
    if (!m_ignoreKeys->contains(name)) {
      if (fabs(v1 - v2) > tol) report.AddKeyword(makeKeyword(name, v1, v2, tol));
    }
  }


  PvlKeyword ControlNetDiff::makeKeyword(QString name, double v1, double v2, double tol) {
    PvlKeyword keyword(name);
    keyword.AddValue(toString(v1));
    if (fabs(v1 - v2) > tol) {
      keyword.AddValue(toString(v2));
      keyword.AddValue(toString(tol));
    }
    return keyword;
  }


  void ControlNetDiff::addUniquePoint(QString label, QString v1, QString v2, PvlObject &parent) {
    PvlObject point("Point");

    PvlKeyword keyword(label);
    keyword.AddValue(v1);
    keyword.AddValue(v2);
    point.AddKeyword(keyword);

    parent.AddObject(point);
  }


  void ControlNetDiff::addUniqueMeasure(QString label, QString v1, QString v2, PvlObject &parent) {
    PvlGroup measure("Measure");

    PvlKeyword keyword(label);
    keyword.AddValue(v1);
    keyword.AddValue(v2);
    measure.AddKeyword(keyword);

    parent.AddGroup(measure);
  }


  void ControlNetDiff::init() {
    m_tolerances = NULL;
    m_ignoreKeys = NULL;

    m_tolerances = new QMap<QString, double>;
    m_ignoreKeys = new QSet<QString>;

    m_ignoreKeys->insert("DateTime");
  }
}