ControlNet.cpp

#include "IsisDebug.h"

#include "ControlNet.h"

#include <iostream>
#include <cmath>
#include <sstream>

#include <QDebug>
#include <QMutex>
#include <QMutexLocker>
#include <QPair>
#include <QScopedPointer>
#include <QSet>
#include <QStringList>
#include <QTime>
#include <QVariant>
#include <QVector>

#include <boost/numeric/ublas/symmetric.hpp>
#include <boost/numeric/ublas/io.hpp>

#include "Application.h"
#include "CameraFactory.h"
#include "ControlMeasure.h"
#include "ControlNetVersioner.h"
#include "ControlPoint.h"
#include "Distance.h"
#include "FileName.h"
#include "IException.h"
#include "iTime.h"
#include "Progress.h"
#include "SerialNumberList.h"
#include "SpecialPixel.h"
#include "Statistics.h"
#include "Target.h"

using namespace std;
using namespace boost::numeric::ublas;


namespace Isis {

  void ControlNet::nullify() {

    points = NULL;
    pointIds = NULL;
    m_mutex = NULL;
  }

  ControlNet::ControlNet(SurfacePoint::CoordinateType coordType) {
    
  // ControlNet::ControlNet() {
    nullify();

    points = new QHash< QString, ControlPoint * >;
    pointIds = new QStringList;

    m_ownPoints = true;
    p_created = Application::DateTime();
    p_modified = Application::DateTime();
    m_coordType = coordType;
  }

  ControlNet::ControlNet(const ControlNet &other) {

    nullify();

    points = new QHash< QString, ControlPoint * >;
    pointIds = new QStringList;

    for (int cpIndex = 0; cpIndex < other.GetNumPoints(); cpIndex++) {
      ControlPoint *newPoint = new ControlPoint(*other.GetPoint(cpIndex));
      AddPoint(newPoint);
    }

    m_ownPoints = true;

    p_targetName = other.p_targetName;
    p_networkId = other.p_networkId;
    p_created = other.p_created;
    p_modified = other.p_modified;
    p_description = other.p_description;
    p_userName = other.p_userName;
    p_cameraMap = other.p_cameraMap;
    p_cameraList = other.p_cameraList;
    m_coordType = other.m_coordType;
  }


  ControlNet::ControlNet(const QString &ptfile, Progress *progress,
                         SurfacePoint::CoordinateType coordType) {
    
    nullify();

    points = new QHash< QString, ControlPoint * >;
    pointIds = new QStringList;

    m_ownPoints = true;
    m_coordType = coordType;
    
    try {
      ReadControl(ptfile, progress);
    }
    catch (IException &e) {
      QString msg = "Invalid control network [" + ptfile + "]";
      throw IException(e, IException::Io, msg, _FILEINFO_);
    }
  }


  ControlNet::~ControlNet() {

    clear();

    delete points;
    delete pointIds;

    nullify();
  }


  void ControlNet::emitMeasureModified(ControlMeasure *measure, ControlMeasure::ModType type, QVariant oldValue, QVariant newValue) {
    emit measureModified(measure, type, oldValue, newValue);
  }


  void ControlNet::emitPointModified(ControlPoint *point, ControlPoint::ModType type, QVariant oldValue, QVariant newValue) {
    emit pointModified(point, type, oldValue, newValue);
  }


  void ControlNet::clear() {

    // Now must also own points to delete them.
    if (points) {
      if (GetNumPoints() > 0) {
        if (m_ownPoints) {
          QHashIterator<QString, ControlPoint*> i(*points);
          while (i.hasNext()) {
            i.next();
            delete(*points)[i.key()];
            (*points)[i.key()] = NULL;
          }
        }
      }
      points->clear();
    }

    m_vertexMap.clear();
    m_controlGraph.clear();

    if (pointIds) {
      pointIds->clear();
    }

    return;
  }


    QList< ControlPoint * > ControlNet::take() {

      // First check to see if someone else has taken ownership
      if (!m_ownPoints) {
        throw IException(IException::Programmer, "Ownership has already been taken",
                         _FILEINFO_);
      }

      QList<ControlPoint *> points = GetPoints();
      m_ownPoints = false;
      clear();

      // Disconnect the parent network reference
      for (int i = 0; i < points.size(); i++) {
        points[i]->parentNetwork = NULL;
      }
      return (points);
    }


  void ControlNet::ReadControl(const QString &filename, Progress *progress) {

    FileName cnetFileName(filename);
    ControlNetVersioner versionedReader(cnetFileName, progress);
    SetTarget( versionedReader.targetName() );
    p_networkId   = versionedReader.netId();
    p_userName    = versionedReader.userName();
    p_created     = versionedReader.creationDate();
    p_modified    = versionedReader.lastModificationDate();
    p_description = versionedReader.description();

    int numPoints = versionedReader.numPoints();

    if (progress) {
      progress->SetText("Adding Control Points to Network...");
      progress->SetMaximumSteps(numPoints);
      progress->CheckStatus();
    }

    for (int i = 0; i < numPoints; i++) {
      AddPoint( versionedReader.takeFirstPoint() );
      if (progress) {
        progress->CheckStatus();
      }
    }
  }


  void ControlNet::Write(const QString &ptfile, bool pvl) {
    ControlNetVersioner versionedWriter(this);

    if (pvl) {
      Pvl network;
      try {
        network = versionedWriter.toPvl();
      }
      catch (IException &e) {
        QString msg = "Failed to convert control network to Pvl format.";
        throw IException(e, IException::Programmer, msg, _FILEINFO_);
      }

      try {
        network.write(ptfile);
      }
      catch (IException &e) {
        QString msg = "Failed writing control network to file [" + ptfile + "]";
        throw IException(e, IException::Io, msg, _FILEINFO_);
      }
    }
    else {
      try {
        versionedWriter.write(FileName(ptfile));
      }
      catch (IException &e) {
        QString msg = "Failed writing control network to file [" + ptfile + "]";
        throw IException(e, IException::Io, msg, _FILEINFO_);
      }
    }
  }


  void ControlNet::AddPoint(ControlPoint *point) {
    if (!point) {
      IString msg = "Null pointer passed to ControlNet::AddPoint!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    if (ContainsPoint(point->GetId())) {
      IString msg = "ControlPoint must have unique Id";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    QString pointId = point->GetId();
    points->insert(pointId, point);
    pointIds->append(pointId);

    point->parentNetwork = this;

    // notify control network of new point
    pointAdded(point);

    emit networkStructureModified();
  }


  void ControlNet::pointAdded(ControlPoint *point) {
    if (!point) {
      IString msg = "NULL point passed to "
          "ControlNet::pointAdded!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    if (!ContainsPoint(point->GetId())) {
      QString msg = "ControlNet does not contain the point [";
      msg += point->GetId() + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Make sure there is a node for every measure
    for (int i = 0; i < point->GetNumMeasures(); i++) {
      QString sn = point->GetMeasure(i)->GetCubeSerialNumber();
      // If the graph doesn't have the sn, add a node for it
      if (!m_vertexMap.contains(sn)) {
        Image newImage;
        newImage.serial = sn;
        ImageVertex newVertex = boost::add_vertex(newImage, m_controlGraph);
        m_vertexMap.insert(sn, newVertex);
        emit networkModified(GraphModified);
      }
    }

    QList< ControlMeasure * > measures = point->getMeasures();
    for(int i = 0; i < measures.size(); i++) {
      ControlMeasure* measure = measures[i];
      // Add the measure to the corresponding node
      QString serial = measure->GetCubeSerialNumber();
      m_controlGraph[m_vertexMap[serial]].measures[measure->Parent()] = measure;

      // In this measure's node add connections to the other nodes reachable from
      // its point
      if (!point->IsIgnored() && !measure->IsIgnored()) {
        for (int j = i + 1; j < measures.size(); j++) {
          ControlMeasure *cm = measures[j];
          if (!cm->IsIgnored()) {
            QString sn = cm->GetCubeSerialNumber();
            addEdge(serial, sn);
          }
        }
      }
    }
    emit newPoint(point);
  }


  bool ControlNet::addEdge(QString sourceSerial, QString targetSerial) {
    // If the edge doesn't already exist, this adds and returns the edge.
    // If the edge already exists, this just returns it. (The use of a set
    // forces the edges to be unique.)
    ImageConnection connection;
    bool edgeAdded;

    boost::tie(connection, edgeAdded) = boost::add_edge(m_vertexMap[sourceSerial],
                                                        m_vertexMap[targetSerial],
                                                        m_controlGraph);
    m_controlGraph[connection].strength++;
    if (edgeAdded) {
      emit networkModified(GraphModified);
    }
    return edgeAdded;
  }


  bool ControlNet::removeEdge(QString sourceSerial, QString targetSerial) {
    ImageConnection connection;
    bool edgeExists;
    boost::tie(connection, edgeExists) = boost::edge(m_vertexMap[sourceSerial],
                                                     m_vertexMap[targetSerial],
                                                     m_controlGraph);
    if (edgeExists) {
      m_controlGraph[connection].strength--;
      if (m_controlGraph[connection].strength <= 0) {
        boost::remove_edge(m_vertexMap[sourceSerial],
                           m_vertexMap[targetSerial],
                           m_controlGraph);
        emit networkModified(GraphModified);

        return true;
      }
    }
    return false;
  }


  QString ControlNet::GraphToString() const {
    QString graphString;

    QStringList images = GetCubeSerials();
    images.sort();

    QHash<QString, QStringList> imagePointIds;

    foreach(QString imageSerial, images) {
      QList<ControlPoint *> imagePoints = m_controlGraph[m_vertexMap[imageSerial]].measures.keys();
      QStringList pointIds;
      foreach(ControlPoint *point, imagePoints) {
        if (!point->IsIgnored()) {
          pointIds.append(point->GetId());
        }
      }
      pointIds.sort();
      imagePointIds.insert(imageSerial, pointIds);
    }

    foreach(QString imageSerial, images) {
      QStringList adjacentImages = getAdjacentImages(imageSerial);
      adjacentImages.sort();
      foreach(QString adjacentSerial, adjacentImages) {
        if (QString::compare(adjacentSerial, imageSerial) < 0) {
          continue;
        }

        QStringList commonPoints;
        QList<QString>::const_iterator imageIt = imagePointIds[imageSerial].cbegin();
        QList<QString>::const_iterator adjacentIt = imagePointIds[adjacentSerial].cbegin();
        while (imageIt != imagePointIds[imageSerial].cend() &&
               adjacentIt != imagePointIds[adjacentSerial].cend()) {
          int stringDiff = QString::compare(*imageIt, *adjacentIt);
          if (stringDiff < 0) {
            imageIt++;
          }
          else if(stringDiff == 0) {
            commonPoints.append(*imageIt);
            imageIt++;
            adjacentIt++;
          }
          else {
            adjacentIt++;
          }
        }

        std::pair<ImageConnection, bool> result = boost::edge(m_vertexMap[imageSerial],
                                                              m_vertexMap[adjacentSerial],
                                                              m_controlGraph);
        QString edgeStrength = "UNKNOWN";
        if (result.second) {
          edgeStrength = toString(m_controlGraph[result.first].strength);
        }

        graphString.append(imageSerial);
        graphString.append(" ----(");
        graphString.append(edgeStrength);
        graphString.append(") [");
        graphString.append(commonPoints.join(","));
        graphString.append("]---- ");
        graphString.append(adjacentSerial);
        graphString.append("\n");
      }
    }

    return graphString;
   }


  void ControlNet::measureAdded(ControlMeasure *measure) {
    if (!measure) {
      IString msg = "NULL measure passed to "
          "ControlNet::measureAdded!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    ControlPoint *point = measure->Parent();
    if (!point) {
      IString msg = "Control measure with NULL parent passed to "
          "ControlNet::measureAdded!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    if (!ContainsPoint(point->GetId())) {
      QString msg = "ControlNet does not contain the point [";
      msg += point->GetId() + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    // Add the measure to the corresponding node
    QString serial = measure->GetCubeSerialNumber();

    // If the graph doesn't have the sn, add a node for it
    if (!m_vertexMap.contains(serial)) {
      Image newImage;
      newImage.serial = serial;
      ImageVertex newVertex = boost::add_vertex(newImage, m_controlGraph);
      m_vertexMap.insert(serial, newVertex);
      emit networkModified(GraphModified);
    }

    m_controlGraph[m_vertexMap[serial]].measures[measure->Parent()] = measure;

    // in this measure's node add connections to the other nodes reachable from
    // its point
    if (!point->IsIgnored() && !measure->IsIgnored()) {
      for (int i = 0; i < point->GetNumMeasures(); i++) {
        ControlMeasure *cm = point->GetMeasure(i);
        if (!cm->IsIgnored()) {
          QString sn = cm->GetCubeSerialNumber();


          if (QString::compare(sn, serial) != 0) {
            addEdge(serial, sn);
          }
        }
      }
    }
    emit newMeasure(measure);
  }


  void ControlNet::pointUnIgnored(ControlPoint *point) {
    if (!point) {
      IString msg = "NULL point passed to "
          "ControlNet::pointUnIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    QList< ControlMeasure * > validMeasures = point->getMeasures(true);

    for (int i = 0; i < validMeasures.size(); i++) {
      ControlMeasure *sourceMeasure = validMeasures[i];
      QString sourceSerial = sourceMeasure->GetCubeSerialNumber();

      if (!ValidateSerialNumber(sourceSerial)) {
        QString msg = "Node does not exist for [";
        msg += sourceSerial + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }

      for(int j = i+1; j < validMeasures.size(); j++) {
        ControlMeasure *targetMeasure = validMeasures[j];
        QString targetSerial = targetMeasure->GetCubeSerialNumber();

        if (!ValidateSerialNumber(targetSerial)) {
          QString msg = "Node does not exist for [";
          msg += targetSerial + "]";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }
        addEdge(sourceSerial, targetSerial);
      }
    }
  }


  void ControlNet::measureUnIgnored(ControlMeasure *measure) {
    if (!measure) {
      IString msg = "NULL measure passed to "
          "ControlNet::measureUnIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    ControlPoint *point = measure->Parent();
    if (!point) {
      IString msg = "Control measure with NULL parent passed to "
          "ControlNet::measureUnIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    if (!ContainsPoint(point->GetId())) {
      QString msg = "ControlNet does not contain the point [";
      msg += point->GetId() + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Make sure there is a node for every measure in this measure's parent
    for (int i = 0; i < point->GetNumMeasures(); i++) {
      ControlMeasure *adjacentMeasure = point->GetMeasure(i);
      QString sn = adjacentMeasure->GetCubeSerialNumber();
      if (!adjacentMeasure->IsIgnored() && !m_vertexMap.contains(sn)) {
        QString msg = "Node does not exist for [";
        msg += measure->GetCubeSerialNumber() + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
    }

    if (!point->IsIgnored()) {
      QString serial = measure->GetCubeSerialNumber();

      // In this measure's node add connections to the other nodes reachable
      // from its point
      for (int i = 0; i < point->GetNumMeasures(); i++) {
        ControlMeasure *cm = point->GetMeasure(i);
        if (!cm->IsIgnored()) {
          QString sn = cm->GetCubeSerialNumber();

          if (QString::compare(sn, serial) != 0) {
            addEdge(serial, sn);
          }
        }
      }
    }
  }


  void ControlNet::UpdatePointReference(ControlPoint *point, QString oldId) {
    points->remove(oldId);
    (*points)[point->GetId()] = point;
    (*pointIds)[pointIds->indexOf((QString) oldId)] = (QString)point->GetId();
  }


  void ControlNet::measureDeleted(ControlMeasure *measure) {
    ASSERT(measure);
    QString serial = measure->GetCubeSerialNumber();
    ASSERT(m_vertexMap.contains(serial));

    emit measureRemoved(measure);

    // Remove connections to and from this node
    if (!measure->IsIgnored() && !measure->Parent()->IsIgnored()) {
      // Break connections
      measureIgnored(measure);
    }

    // Remove the measure from the associated node.
    // Conceptually, I think this belongs in measureIgnored, but it isn't done
    // for the old graph.
    m_controlGraph[m_vertexMap[serial]].measures.remove(measure->Parent());
  }


  void ControlNet::pointIgnored(ControlPoint *point) {
    if (!point) {
      IString msg = "NULL point passed to "
          "ControlNet::pointIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    QList< ControlMeasure * > validMeasures = point->getMeasures(true);

    for (int i = 0; i < validMeasures.size(); i++) {
      ControlMeasure *sourceMeasure = validMeasures[i];
      QString sourceSerial = sourceMeasure->GetCubeSerialNumber();

      if (!ValidateSerialNumber(sourceSerial)) {
        QString msg = "Node does not exist for [";
        msg += sourceSerial + "]";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }

      for(int j = i+1; j < validMeasures.size(); j++) {
        ControlMeasure *targetMeasure = validMeasures[j];
        QString targetSerial = targetMeasure->GetCubeSerialNumber();

        if (!ValidateSerialNumber(targetSerial)) {
          QString msg = "Node does not exist for [";
          msg += targetSerial + "]";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }
        removeEdge(sourceSerial, targetSerial);
      }
    }
  }



  void ControlNet::measureIgnored(ControlMeasure *measure) {
    if (!measure) {
      IString msg = "NULL measure passed to "
          "ControlNet::measureIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    ControlPoint *point = measure->Parent();
    if (!point) {
      IString msg = "Control measure with NULL parent passed to "
          "ControlNet::measureIgnored!";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    QString serial = measure->GetCubeSerialNumber();
    if (!ValidateSerialNumber(serial)) {
      QString msg = "Node does not exist for [";
      msg += serial + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Decrement the edge strength for edges from this node
    // Remove edge if the strength becomes 0.
    for (int i = 0; i < point->GetNumMeasures(); i++) {
      ControlMeasure *adjacentMeasure = point->GetMeasure(i);
      QString sn = adjacentMeasure->GetCubeSerialNumber();
      if (!adjacentMeasure->IsIgnored() && m_vertexMap.contains(sn)) {
        if (QString::compare(serial, sn) !=0) {
          removeEdge(serial, sn);
        }
      }
    }
  }


  void ControlNet::SetCoordType(SurfacePoint::CoordinateType coordType)  {
    m_coordType = coordType;
  }


  void ControlNet::emitNetworkStructureModified() {
    emit networkStructureModified();
  }


  int ControlNet::DeletePoint(ControlPoint *point) {
    if (points->values().contains(point)) {
      return DeletePoint(point->GetId());
    }
    else {
      IString msg = "point [";
      msg += (long) point;
      msg += "] does not exist in the network";
      throw IException(IException::User, msg, _FILEINFO_);
    }
  }


  int ControlNet::DeletePoint(QString pointId) {
    if (!points->contains(pointId)) {
      IString msg = "point Id [" + pointId + "] does not exist in the network";
      throw IException(IException::User, msg, _FILEINFO_);
    }

    ControlPoint *point = (*points)[pointId];

    if (point->IsEditLocked())
      return ControlPoint::PointLocked;

    bool wasIgnored = point->IsIgnored();

    // notify CubeSerialNumbers of the loss of this point
    foreach(ControlMeasure * measure, point->getMeasures()) {
      point->Delete(measure);
    }

    emit pointDeleted(point);

    // delete point
    points->remove(pointId);
    pointIds->removeAt(pointIds->indexOf(pointId));
    delete point;
    point = NULL;

    if (!wasIgnored)
      emit networkStructureModified();
    return ControlPoint::Success;
  }


  int ControlNet::DeletePoint(int index) {
    if (index < 0 || index >= pointIds->size()) {
      IString msg = "Index [" + IString(index) + "] out of range";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return DeletePoint(pointIds->at(index));
  }


  bool ControlNet::ContainsPoint(QString pointId) const {
    return points->contains(pointId);
  }


  QList< QList< QString > > ControlNet::GetSerialConnections() const {

    VertexIndexMap indexMap;
    VertexIndexMapAdaptor indexMapAdaptor(indexMap);

    // Needed to use connected_componenets
    QList< QString> serials = m_vertexMap.keys();
    for (int i = 0; i < serials.size(); i++) {
      boost::put(indexMapAdaptor, m_vertexMap[serials[i]], i);
    }

    VertexIndexMap componentMap;
    VertexIndexMapAdaptor componentAdaptor(componentMap);
    int numComponents = boost::connected_components(m_controlGraph, componentAdaptor,
                                                      boost::vertex_index_map(indexMapAdaptor));

    QList< QList< QString > > islandStrings;
    for (int i = 0; i < numComponents; i++) {
      QList<QString> tempList;
      islandStrings.append(tempList);
    }
    std::map<ImageVertex, size_t>::iterator it = componentMap.begin();
    while(it != componentMap.end())
    {
      QString serial = m_controlGraph[it->first].serial;
      int group = (int) it->second;
      islandStrings[group].append(serial);
      ++it;
    }
    return islandStrings;
  }


  int ControlNet::getEdgeCount() const {
    return boost::num_edges(m_controlGraph);
  }


  QList< QString > ControlNet::GetCubeSerials() const {
    return m_vertexMap.keys();
  }


  bool ControlNet::ValidateSerialNumber(QString serialNumber) const {
    return m_vertexMap.contains(serialNumber);
  }


  QList< QString > ControlNet::getAdjacentImages(QString serialNumber) const {
    if (!ValidateSerialNumber(serialNumber)) {
      QString msg = "Cube Serial Number [" + serialNumber + "] not found in "
          "the network";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    QList< QString > adjacentSerials;

    AdjacencyIterator adjIt, adjEnd;
    boost::tie(adjIt, adjEnd) = boost::adjacent_vertices(m_vertexMap[serialNumber], m_controlGraph);
    for( ; adjIt != adjEnd; adjIt++) {
      adjacentSerials.append(m_controlGraph[*adjIt].serial);
    }

    return adjacentSerials;
  }


  QList< ControlMeasure * > ControlNet::GetMeasuresInCube(QString serialNumber) {
    if( !ValidateSerialNumber(serialNumber) ) {
      IString msg = "Cube Serial Number [" + serialNumber + "] not found in "
          "the network";
      throw IException(IException::Programmer, msg, _FILEINFO_);

    }
    return m_controlGraph[m_vertexMap[serialNumber]].measures.values();
  }


  QList< ControlMeasure * > ControlNet::GetValidMeasuresInCube(QString serialNumber) {
    QList< ControlMeasure * > validMeasures;

    // Get measures in cube will validate this for us, so we don't need to re-check
    QList< ControlMeasure * > measureList = GetMeasuresInCube(serialNumber);

    foreach(ControlMeasure * measure, measureList) {
      if (!measure->IsIgnored())
        validMeasures.append(measure);
    }

    return validMeasures;
  }


  ControlNet::ControlMeasureLessThanFunctor &
    ControlNet::ControlMeasureLessThanFunctor::operator=(ControlMeasureLessThanFunctor const &other) {

    if (this != &other) {
      this->m_accessor = other.m_accessor;
    }

    return *this;
  }


  bool ControlNet::ControlMeasureLessThanFunctor::operator()
    (ControlMeasure* const &a, ControlMeasure* const &b) {

    return (a->*this->m_accessor)() < (b->*this->m_accessor)();

  }


  QList< ControlMeasure * > ControlNet::sortedMeasureList(double(ControlMeasure::*statFunc)() const,
                                                          double min,double max) {

    QList< ControlMeasure * >measures;

    //build a list of all the pointers to the relevant measures
      //get the number of object points
    int nObjPts =  this->GetNumPoints();
    for (int i=0;i<nObjPts;i++) { //for each Object point
      ControlPoint *point = this->GetPoint(i);
      if (point->IsIgnored()) continue;  //if the point is ignored then continue

      // Get the number of measures
      int nObs = point->GetNumMeasures();
      for (int j=0;j<nObs;j++) {  //for every measure
        ControlMeasure *measure = point->GetMeasure(j);
        if (measure->IsIgnored())  continue;
        double temp = (measure->*statFunc)();
        if (temp > min)
        if (min <= temp && temp <= max) measures.push_back(measure);
      }
    }

    // Sort the measures
    ControlMeasureLessThanFunctor lessThan(statFunc);
    qSort(measures.begin(),measures.end(),lessThan);

    return measures;
  }


  void ControlNet::ComputeResiduals() {
    // TODO:  Make sure the cameras have been initialized

    QHashIterator< QString, ControlPoint * > i(*points);
    while (i.hasNext()) {
      i.next();
      i.value()->ComputeResiduals();
    }
  }


  void ControlNet::ComputeApriori() {
    // TODO:  Make sure the cameras have been initialized
    QHashIterator< QString, ControlPoint * > i(*points);
    while (i.hasNext()) {
      i.next();
      ControlPoint *point = i.value();
      if ( !point->IsIgnored() )
        point->ComputeApriori();
    }
  }


  double ControlNet::AverageResidual() {
    // TODO:  Make sure the cameras have been initialized
    double avgResidual = 0.0;
    int count = 0;
    QHashIterator< QString, ControlPoint * > i(*points);
    while (i.hasNext()) {
      i.next();
      ControlPoint *point = i.value();
      if (!point->IsIgnored()) {
        avgResidual += point->GetStatistic(
            &ControlMeasure::GetResidualMagnitude).Average();
        count++;
      }
    }

    if (count != 0)
      avgResidual /= count;

    return avgResidual;
  }


  Isis::Camera *ControlNet::Camera(int index) {
    return p_cameraList[index];
  }


  QString ControlNet::CreatedDate() const {
    return p_created;
  }


  QString ControlNet::Description() const {
    return p_description;
  }


  ControlPoint *ControlNet::FindClosest(QString serialNumber,
      double sample, double line) {

    if (!ValidateSerialNumber(serialNumber)) {
      QString msg = "serialNumber [";
      msg += serialNumber;
      msg += "] not found in ControlNet";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    const double SEARCH_DISTANCE = 99999999.0;
    double minDist = SEARCH_DISTANCE;
    ControlPoint *closestPoint = NULL;

    QList < ControlMeasure * > measures = m_controlGraph[m_vertexMap[serialNumber]].measures.values();

    for (int i = 0; i < measures.size(); i++) {
      ControlMeasure *measureToCheck = measures[i];

      // Find closest line sample & return that controlpoint
      double dx = fabs(sample - measureToCheck->GetSample());
      double dy = fabs(line - measureToCheck->GetLine());

      double dist = sqrt((dx * dx) + (dy * dy));

      if (dist < minDist) {
        minDist = dist;
        closestPoint = measureToCheck->Parent();
      }
    }

    if (!closestPoint) {
      IString msg = "No point found within ";
      msg += IString(SEARCH_DISTANCE);
      msg += "pixels of sample/line [";
      msg += IString(sample);
      msg += ", ";
      msg += IString(line);
      msg += "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return closestPoint;
  }


  double ControlNet::GetMaximumResidual() {
    // TODO:  Make sure the cameras have been initialized

    double maxResidual = 0.0;
    foreach(ControlPoint * p, *points) {
      double residual = p->GetStatistic(
          &ControlMeasure::GetResidualMagnitude).Maximum();
      if (residual > maxResidual)
        maxResidual = residual;
    }

    return maxResidual;
  }


  QString ControlNet::GetNetworkId() const {
    return p_networkId;
  }


  int ControlNet::GetNumEditLockMeasures() {
    int numLockedMeasures = 0;
    foreach(ControlPoint * p, *points) {
      numLockedMeasures += p->GetNumLockedMeasures();
    }

    return numLockedMeasures;
  }


  int ControlNet::GetNumEditLockPoints() {
    int editLockPoints = 0;
    foreach(ControlPoint * p, *points) {
      if (p->IsEditLocked())
        editLockPoints++;
    }

    return editLockPoints;
  }


  int ControlNet::GetNumIgnoredMeasures() {
    int numIgnoredMeasures = 0;
    foreach(ControlPoint * p, *points) {
      numIgnoredMeasures += p->GetNumMeasures() - p->GetNumValidMeasures();
    }

    return numIgnoredMeasures;
  }


  int ControlNet::GetNumberOfValidMeasuresInImage(const QString &serialNumber) {
    // If SetImage was called, use the map that has been populated with valid measures
    if (p_cameraList.size() > 0) {
      return p_cameraValidMeasuresMap[serialNumber];
    }
    return GetValidMeasuresInCube(serialNumber).size();
  }


  int ControlNet::GetNumberOfJigsawRejectedMeasuresInImage(const QString &serialNumber) {
    return p_cameraRejectedMeasuresMap[serialNumber];
  }


  void ControlNet::ClearJigsawRejected() {
    foreach(ControlPoint * p, *points) {
      p->ClearJigsawRejected();
    }
  }


  void ControlNet::IncrementNumberOfRejectedMeasuresInImage(const QString &serialNumber) {
    p_cameraRejectedMeasuresMap[serialNumber]++;
  }


  void ControlNet::DecrementNumberOfRejectedMeasuresInImage(const QString &serialNumber) {
    if (p_cameraRejectedMeasuresMap[serialNumber] > 0)
      p_cameraRejectedMeasuresMap[serialNumber]--;
  }


  int ControlNet::GetNumMeasures() const {
    int numMeasures = 0;
    foreach(ControlPoint * p, *points) {
      numMeasures += p->GetNumMeasures();
    }

    return numMeasures;
  }


  int ControlNet::GetNumPoints() const {
    return points->size();
  }


  int ControlNet::GetNumValidMeasures() {
    int numValidMeasures = 0;
    foreach(ControlPoint * p, *points) {
      if (!p->IsIgnored())
        numValidMeasures += p->GetNumValidMeasures();
    }

    return numValidMeasures;
  }


  int ControlNet::GetNumValidPoints() {
    int validPoints = 0;
    foreach(ControlPoint * p, *points) {
      if (!p->IsIgnored())
        validPoints++;
    }

    return validPoints;
  }


  QString ControlNet::GetTarget() const {
    return p_targetName;
  }


  QString ControlNet::GetUserName() const {
    return p_userName;
  }

  QString ControlNet::GetLastModified() const {
    return p_modified;
  }


  QList< ControlPoint * > ControlNet::GetPoints() {
    QList< ControlPoint * > pointsList;

    for (int i = 0; i < pointIds->size(); i++) {
      pointsList.append(GetPoint(i));
    }

    return pointsList;
  }


  QList< QString > ControlNet::GetPointIds() const {
    return *pointIds;
  }


  void ControlNet::SetCreatedDate(const QString &date) {
    p_created = date;
  }


  void ControlNet::SetDescription(const QString &newDescription) {
    p_description = newDescription;
  }


  void ControlNet::SetImages(const QString &imageListFile) {
    SerialNumberList list(imageListFile);
    SetImages(list);
  }


  void ControlNet::SetImages(SerialNumberList &list, Progress *progress) {
    // First check if cameras have already been setup via another SetImages call
    if (p_cameraList.size() > 0) {
      return;
    }
    // Prep for reporting progress
    if (progress != NULL) {
      progress->SetText("Setting input images...");
      progress->SetMaximumSteps(list.size());
      progress->CheckStatus();
    }
    // Open the camera for all the images in the serial number list
    for (int i = 0; i < list.size(); i++) {
      QString serialNumber = list.serialNumber(i);
      QString filename = list.fileName(i);
      Cube cube(filename, "r");

      try {
        Isis::Camera *cam = CameraFactory::Create(cube);
        p_cameraMap[serialNumber] = cam;
        p_cameraValidMeasuresMap[serialNumber] = 0;
        p_cameraRejectedMeasuresMap[serialNumber] = 0;
        p_cameraList.push_back(cam);
      }
      catch (IException &e) {
        QString msg = "Unable to create camera for cube file ";
        msg += filename;
        throw IException(e, IException::Unknown, msg, _FILEINFO_);
      }

      if (progress != NULL)
        progress->CheckStatus();
    }

    // Loop through all measures and set the camera
    QHashIterator< QString, ControlPoint * > p(*points);
    while (p.hasNext()) {
      p.next();
      ControlPoint *curPoint = p.value();

      QList< QString > serialNums = curPoint->getCubeSerialNumbers();
      for (int m = 0; m < serialNums.size(); m++) {
        ControlMeasure *curMeasure = (*curPoint)[serialNums[m]];

        QString serialNumber = curMeasure->GetCubeSerialNumber();
        if (list.hasSerialNumber(serialNumber)) {
          curMeasure->SetCamera(p_cameraMap[serialNumber]);

          // increment number of measures for this image (camera)
          if (!curMeasure->IsIgnored()) p_cameraValidMeasuresMap[serialNumber]++;
        }
        else {
          IString msg = "Control point [" + curPoint->GetId() +
              "], measure [" + curMeasure->GetCubeSerialNumber() +
              "] does not have a cube with a matching serial number";
          throw IException(IException::User, msg, _FILEINFO_);
        }
      }
    }
  }


  void ControlNet::SetModifiedDate(const QString &date) {
    p_modified = date;
  }


  void ControlNet::SetMutex(QMutex *mutex) {
    m_mutex = mutex;
  }


  void ControlNet::SetNetworkId(const QString &id) {
    p_networkId = id;
  }


  void ControlNet::SetTarget(const QString &target) {
    p_targetName = target;
  }


  void ControlNet::SetTarget(Pvl label) {
    PvlGroup mapping;
    if ( (label.hasObject("IsisCube") && label.findObject("IsisCube").hasGroup("Mapping"))
         || label.hasGroup("Mapping") ) {
      mapping = label.findGroup("Mapping", Pvl::Traverse);
    }

    if (mapping.hasKeyword("TargetName")) {
      p_targetName = mapping["TargetName"][0];
    }
    else if (label.hasObject("IsisCube")
             && label.findObject("IsisCube").hasGroup("Instrument")
             && label.findObject("IsisCube").findGroup("Instrument").hasKeyword("TargetName")) {
      p_targetName = label.findObject("IsisCube").findGroup("Instrument").findKeyword("TargetName")[0];
    }
    else {
      p_targetName = "";
    }
  }


  void ControlNet::SetUserName(const QString &name) {
    p_userName = name;
  }


  void ControlNet::swap(ControlNet &other) {
    std::swap(points, other.points);
    std::swap(pointIds, other.pointIds);
    m_controlGraph.swap(other.m_controlGraph);
    std::swap(m_mutex, other.m_mutex);
    std::swap(p_targetName, other.p_targetName);
    std::swap(p_networkId, other.p_networkId);
    std::swap(p_created, other.p_created);
    std::swap(p_modified, other.p_modified);
    std::swap(p_description, other.p_description);
    std::swap(p_userName, other.p_userName);
    std::swap(p_cameraMap, other.p_cameraMap);
    std::swap(p_cameraValidMeasuresMap, other.p_cameraValidMeasuresMap);
    std::swap(p_cameraRejectedMeasuresMap, other.p_cameraRejectedMeasuresMap);
    std::swap(p_cameraList, other.p_cameraList);

    // points have parent pointers that need to be updated too...
    QHashIterator< QString, ControlPoint * > i(*points);
    while (i.hasNext()) {
      i.next().value()->parentNetwork = this;
    }

    QHashIterator< QString, ControlPoint * > i2(*other.points);
    while (i2.hasNext()) {
      i2.next().value()->parentNetwork = &other;
    }

    m_vertexMap.clear();
    VertexIterator v, vend;
    for (boost::tie(v, vend) = vertices(m_controlGraph); v != vend; ++v) {
      ImageVertex imVertex = *v;
      QString serialNum = m_controlGraph[*v].serial;
      m_vertexMap[serialNum] = imVertex;
    }

    other.m_vertexMap.clear();
    VertexIterator v2, vend2;
    for (boost::tie(v2, vend2) = vertices(other.m_controlGraph); v2 != vend2; ++v2) {
      ImageVertex imVertex = *v2;
      QString serialNum = other.m_controlGraph[*v2].serial;
      other.m_vertexMap[serialNum] = imVertex;
    }

    emit networkModified(ControlNet::Swapped);
  }


  ControlNet &ControlNet::operator=(const ControlNet &other) {
    // Optimization: if this == other do nothing.
    if (this != &other) {
      // copy & swap
      ControlNet copy(other);
      swap(copy);
    }

    return *this;
  }


  const ControlPoint *ControlNet::GetPoint(QString id) const {
    if (!points->contains(id)) {
      IString msg = "The control network has no control points with an ID "
          "equal to [" + id + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return points->value(id);
  }


  ControlPoint *ControlNet::GetPoint(QString id) {
    if (!points->contains(id)) {
      IString msg = "The control network has no control points with an ID "
          "equal to [" + id + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return (*points)[id];
  }


  const ControlPoint *ControlNet::GetPoint(int index) const {
    if (index < 0 || index >= pointIds->size()) {
      IString msg = "Index [" + IString(index) + "] out of range";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return GetPoint(pointIds->at(index));
  }


  ControlPoint *ControlNet::GetPoint(int index) {
    if (index < 0 || index >= pointIds->size()) {
      IString msg = "Index [" + IString(index) + "] out of range";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    return GetPoint(pointIds->at(index));
  }


  SurfacePoint::CoordinateType ControlNet::GetCoordType() {
    return m_coordType;
  }

  const ControlPoint *ControlNet::operator[](QString id) const {
    return GetPoint(id);
  }


  ControlPoint *ControlNet::operator[](QString id) {
    return GetPoint(id);
  }


  const ControlPoint *ControlNet::operator[](int index) const {
    return GetPoint(index);
  }


  ControlPoint *ControlNet::operator[](int index) {
    return GetPoint(index);
  }
}