Project.cpp

Go to the documentation of this file.

#include "IsisDebug.h"
#include "Project.h"

#include <unistd.h>

#include <QApplication>
#include <QDateTime>
#include <QDir>
#include <QDebug>
#include <QFile>
#include <QFileDialog>
#include <QFuture>
#include <QFutureWatcher>
#include <QMessageBox>
#include <QMutex>
#include <QMutexLocker>
#include <QProgressBar>
#include <QRegExp>
#include <QSettings>
#include <QStringList>
#include <QtDebug>
#include <QTextStream>
#include <QWidget>
#include <QXmlStreamWriter>

#include "BundleSettings.h"
#include "BundleSolutionInfo.h"
#include "Camera.h"
#include "Control.h"
#include "ControlList.h"
#include "ControlNet.h"
#include "CorrelationMatrix.h"
#include "Cube.h"
#include "Directory.h"
#include "Environment.h"
#include "FileName.h"
#include "GuiCamera.h"
#include "GuiCameraList.h"
#include "ImageList.h"
#include "ImageReader.h"
#include "IException.h"
#include "ProgressBar.h"
#include "ProjectItem.h"
#include "ProjectItemModel.h"
#include "SerialNumberList.h"
#include "SetActiveControlWorkOrder.h"
#include "SetActiveImageListWorkOrder.h"
#include "Shape.h"
#include "ShapeList.h"
#include "ShapeReader.h"
#include "Target.h"
#include "TargetBodyList.h"
#include "Template.h"
#include "TemplateList.h"
#include "WorkOrder.h"
#include "WorkOrderFactory.h"
#include "XmlStackedHandlerReader.h"

namespace Isis {



  Project::Project(Directory &directory, QObject *parent) :
      QObject(parent) {
    m_bundleSettings = NULL;
    m_clearing = false;
    m_directory = &directory;
    m_projectRoot = NULL;
    m_cnetRoot = NULL;
    m_idToControlMap = NULL;
    m_idToImageMap = NULL;
    m_idToShapeMap = NULL;
    m_idToTargetBodyMap = NULL;
    m_idToGuiCameraMap = NULL;
    m_images = NULL;
    m_imageReader = NULL;
    m_shapeReader = NULL;
    m_shapes = NULL;
    m_mapTemplates = NULL;
    m_regTemplates = NULL;
    m_warnings = NULL;
    m_workOrderHistory = NULL;
    m_isTemporaryProject = true;
    m_isOpen = false;
    m_isClean = true;
    m_activeControl = NULL;
    m_activeImageList = NULL;

    m_numImagesCurrentlyReading = 0;

    m_mutex = NULL;
    m_workOrderMutex = NULL;
    m_imageReadingMutex = NULL;

    m_numShapesCurrentlyReading = 0;
    m_shapeMutex = NULL;
    m_shapeReadingMutex = NULL;

    m_idToControlMap = new QMap<QString, Control *>;
    m_idToImageMap = new QMap<QString, Image *>;
    m_idToShapeMap = new QMap<QString, Shape *>;
    m_idToTargetBodyMap = new QMap<QString, TargetBody *>;
    m_idToGuiCameraMap = new QMap<QString, GuiCamera *>;
    m_idToBundleSolutionInfoMap = new QMap<QString, BundleSolutionInfo *>;

    m_name = "Project";

    // Look for old projects
    QDir tempDir = QDir::temp();
    QStringList nameFilters;
    nameFilters.append(Environment::userName() + "_" +
                       QApplication::applicationName() + "_*");
    tempDir.setNameFilters(nameFilters);

    QStringList existingProjects = tempDir.entryList();
    bool crashedPreviously = false;

    foreach (QString existingProject, existingProjects) {
      FileName existingProjectFileName(tempDir.absolutePath() + "/" + existingProject);
      QString pidString = QString(existingProject).replace(QRegExp(".*_"), "");
      int otherPid = pidString.toInt();

      if (otherPid != 0) {
        if ( !QFile::exists("/proc/" + pidString) ) {
          crashedPreviously = true;
          int status = system( ("rm -rf '" +
                                existingProjectFileName.expanded() + "' &").toLatin1().data() );
          if (status != 0) {
            QString msg = "Executing command [rm -rf" + existingProjectFileName.expanded() +
                          "' &] failed with return status [" + toString(status) + "]";
            throw IException(IException::Programmer, msg, _FILEINFO_);
          }
        }
      }
    }

    if (crashedPreviously && false) {
      QMessageBox::information( NULL,
                                QObject::tr("Crashed"),
                                QObject::tr("It appears %1 crashed. We're sorry.").
                                         arg( QApplication::applicationName() ) );
    }

    QCoreApplication* ipce_app = static_cast<QCoreApplication *>(directory.parent());

    try {
      QString tmpFolder = QDir::temp().absolutePath() + "/"
            + Environment::userName() + "_"
            + QApplication::applicationName() + "_" + QString::number( getpid() );
      QDir temp(tmpFolder + "/tmpProject");
      m_projectRoot = new QDir(temp);

      if (ipce_app->arguments().count() == 1) {
        createFolders();
      }
    }
    catch (IException &e) {
      throw IException(e, IException::Programmer, "Error creating project folders.", _FILEINFO_);
    }
    catch (std::exception &e) {
      //  e.what()
      throw IException(IException::Programmer,
          tr("Error creating project folders [%1]").arg( e.what() ), _FILEINFO_);
    }
    //  TODO TLS 2016-07-13  This seems to only be used by ControlNet when SetTarget is called.
    //     This needs to be better documented, possibly renamed or redesigned??
    m_mutex = new QMutex;
    m_workOrderMutex = new QMutex;
    // image reader
    m_imageReader = new ImageReader(m_mutex, true);

    connect( m_imageReader, SIGNAL( imagesReady(ImageList) ),
             this, SLOT( imagesReady(ImageList) ) );

    // Project will be listening for when both cnets and images have been added.
    // It will emit a signal, controlsAndImagesAvailable, when this occurs.
    // Directory sets up a listener on the JigsawWorkOrder clone to enable itself
    // when it hears this signal.
    connect(this, SIGNAL(imagesAdded(ImageList *)),
            this, SLOT(checkControlsAndImagesAvailable()));
    connect(this, SIGNAL(controlListAdded(ControlList *)),
            this, SLOT(checkControlsAndImagesAvailable()));
    connect(m_directory, SIGNAL(cleanProject(bool)),
            this, SLOT(setClean(bool)));

    m_images = new QList<ImageList *>;

    // Shape reader
    m_shapeMutex = new QMutex;

    m_shapeReader = new ShapeReader(m_shapeMutex, false);

    connect( m_shapeReader, SIGNAL( shapesReady(ShapeList) ),
             this, SLOT( shapesReady(ShapeList) ) );

    m_shapes = new QList<ShapeList *>;

    m_controls = new QList<ControlList *>;

    m_targets = new TargetBodyList;

    m_mapTemplates = new QList<TemplateList *>;

    m_regTemplates = new QList<TemplateList *>;

    m_guiCameras = new GuiCameraList;

    m_bundleSolutionInfo = new QList<BundleSolutionInfo *>;

    m_warnings = new QStringList;
    m_workOrderHistory = new QList< QPointer<WorkOrder> >;

    m_imageReadingMutex = new QMutex;

    m_shapeReadingMutex = new QMutex;

    // Listen for when an active control is set and when an active image list is set.
    // This is used for enabling the JigsawWorkOrder (the Bundle Adjustment menu action).
//  connect(this, &Project::activeControlSet,
//          this, &Project::checkActiveControlAndImageList);
//  connect(this, &Project::activeImageListSet,
//          this, &Project::checkActiveControlAndImageList);
    // TODO: ken testing
//    m_bundleSettings = NULL;
//    m_bundleSettings = new BundleSettings();
  }


  Project::~Project() {


    if (m_images) {
      foreach (ImageList *imageList, *m_images) {
        foreach (Image *image, *imageList) {
          delete image;
        }

        delete imageList;
      }

      delete m_images;
      m_images = NULL;
    }


    if (m_shapes) {
      foreach (ShapeList *shapeList, *m_shapes) {
        foreach (Shape *shape, *shapeList) {
          delete shape;
        }

        delete shapeList;
      }

      delete m_shapes;
      m_shapes = NULL;
    }


    if (m_controls) {
      foreach (ControlList *controlList, *m_controls) {
        foreach (Control *control, *controlList) {
          delete control;
        }

        delete controlList;
      }
      delete m_controls;
      m_controls = NULL;
    }


    if (m_mapTemplates) {
      foreach (TemplateList *templateList, *m_mapTemplates) {
        foreach (Template *templateFile, *templateList) {
          delete templateFile;
        }

        delete templateList;
      }

      delete m_mapTemplates;
      m_mapTemplates = NULL;
    }


    if (m_regTemplates) {
      foreach (TemplateList *templateList, *m_regTemplates) {
        foreach (Template *templateFile, *templateList) {
          delete templateFile;
        }

        delete templateList;
      }

      delete m_regTemplates;
      m_regTemplates = NULL;
    }


    m_activeControl = NULL;
    m_activeImageList = NULL;

    if (m_bundleSolutionInfo) {
      foreach (BundleSolutionInfo *bundleSolutionInfo, *m_bundleSolutionInfo) {
        delete bundleSolutionInfo;
      }

      delete m_bundleSolutionInfo;
      m_bundleSolutionInfo = NULL;
    }

    delete m_idToControlMap;
    m_idToControlMap = NULL;

    delete m_idToImageMap;
    m_idToImageMap = NULL;

    delete m_idToShapeMap;
    m_idToShapeMap = NULL;

    delete m_idToTargetBodyMap;
    m_idToTargetBodyMap = NULL;

    delete m_idToGuiCameraMap;
    m_idToGuiCameraMap = NULL;

    delete m_idToBundleSolutionInfoMap;
    m_idToBundleSolutionInfoMap = NULL;

    m_directory = NULL;

    delete m_projectRoot;
    m_projectRoot = NULL;

    delete m_cnetRoot;
    m_cnetRoot = NULL;

    delete m_imageReader;
    delete m_shapeReader;

    delete m_warnings;
    m_warnings = NULL;

    m_workOrderHistory->removeAll(NULL);
    m_workOrderHistory = NULL;

    delete m_bundleSettings;
    m_bundleSettings = NULL;
  }


  void Project::createFolders() {
    QDir dir;
    if ( !dir.mkpath( m_projectRoot->path() ) ) {
      warn("Cannot create project directory.");
      throw IException(IException::Io,
                       tr("Unable to create folder [%1] when trying to initialize project")
                         .arg(m_projectRoot->path() ),
                       _FILEINFO_);
    }

    try {
      if ( !dir.mkdir( cnetRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( cnetRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      if ( !dir.mkdir( imageDataRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( imageDataRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      if ( !dir.mkdir( shapeDataRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( shapeDataRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      if ( !dir.mkdir( resultsRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( resultsRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      if ( !dir.mkdir( bundleSolutionInfoRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( bundleSolutionInfoRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      if ( !dir.mkdir( templateRoot() ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( templateRoot() );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      if ( !dir.mkdir( templateRoot() + "/maps" ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( templateRoot() + "/maps" );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
      if ( !dir.mkdir( templateRoot() + "/registrations" ) ) {
        QString msg = QString("Unable to create folder [%1] when trying to initialize project")
                        .arg( templateRoot() + "/registrations" );
        warn(msg);
        throw IException(IException::Io, msg, _FILEINFO_);
      }
    }
    catch (...) {
      warn("Failed to create project directory structure");
      throw;
    }
  }


  void Project::clear() {
    m_clearing = true;

    // We need to look through the project.xml and remove every directory not in the project
    QStringList shapeDirList;
    bool shapes = false;
    QStringList imageDirList;
    bool images = false;
    QStringList cnetDirList;
    bool controls = false;
    QStringList mapTemplateDirList;
    bool mapTemplates = false;
    QStringList regTemplateDirList;
    bool regTemplates = false;
    QStringList bundleDirList;
    bool bundles = false;
    QFile projectXml(projectRoot() + "/project.xml");

    if (projectXml.open(QIODevice::ReadOnly)) {
      QTextStream projectXmlInput(&projectXml);

      while (!projectXmlInput.atEnd() ) {

        QString line = projectXmlInput.readLine();

        if (controls || line.contains("<controlNets>") ) {
          controls = true;

          if (line.contains("</controlNets>") ) {
            controls = false;
          }

          else if (!line.contains("<controlNets>") ) {
            cnetDirList.append(line.split('"').at(3));
          }
        }

        else if (images || line.contains("<imageLists>") ) {
          images = true;

          if (line.contains("</imageLists>")) {
            images = false;
          }

          else if (!line.contains("<imageLists>") ) {
            imageDirList.append(line.split('"').at(3).simplified());
          }
        }

        else if (shapes || line.contains("<shapeLists>")) {
          shapes = true;

          if (line.contains("</shapeLists>") ) {
            shapes = false;
          }

          else if (!line.contains("<shapeLists>") ) {
            shapeDirList.append(line.split('"').at(3));
          }
        }

        else if (mapTemplates || line.contains("<mapTemplateLists>") ) {
          mapTemplates = true;

          if (line.contains("</mapTemplateLists>") ) {
            mapTemplates = false;
          }

          else if (!line.contains("<mapTemplateLists>") ) {
            QList<QString> components = line.split('"');
            mapTemplateDirList.append(components.at(5));
          }
        }

        else if (regTemplates || line.contains("<regTemplateLists>") ) {
          regTemplates = true;

          if (line.contains("</regTemplateLists>") ) {
            regTemplates = false;
          }

          else if (!line.contains("<regTemplateLists>") ) {
            QList<QString> components = line.split('"');
            regTemplateDirList.append(components.at(5));
          }
        }

        else if (bundles || line.contains("<bundleSolutionInfo>") ) {
          bundles = true;

          if (line.contains("</bundleSolutionInfo>") ) {
            bundles = false;
          }

          else if (line.contains("<runTime>") ) {
            bundleDirList.append(line.split('>').at(1).split('<').at(0));
          }
        }
      }

      QDir cnetsDir(m_projectRoot->path() + "/cnets/");
      cnetsDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList cnetsList = cnetsDir.entryList();
      foreach (QString dir, cnetsList) {
        dir = dir.simplified();

        if ( !cnetDirList.contains(dir) ) {
          QDir tempDir(cnetsDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      QDir imagesDir(m_projectRoot->path() + "/images/");
      imagesDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList imagesList = imagesDir.entryList();
      foreach (QString dir, imagesList) {
        dir = dir.simplified();

        if ( !imageDirList.contains(dir) ) {
          QDir tempDir(imagesDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      QDir shapesDir(m_projectRoot->path() + "/shapes/");
      shapesDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList shapesList = shapesDir.entryList();
      foreach (QString dir, shapesList) {
        dir = dir.simplified();

        if ( !shapeDirList.contains(dir) ) {
          QDir tempDir(shapesDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      QDir mapTemplatesDir(m_projectRoot->path() + "/templates/maps");
      mapTemplatesDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList mapTemplatesList = mapTemplatesDir.entryList();
      foreach (QString dir, mapTemplatesList) {
        dir = dir.simplified();

        if ( !mapTemplateDirList.contains("maps/" + dir) ) {
          QDir tempDir(mapTemplatesDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      QDir regTemplatesDir(m_projectRoot->path() + "/templates/registrations");
      regTemplatesDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList regTemplatesList = regTemplatesDir.entryList();
      foreach (QString dir, regTemplatesList) {
        dir = dir.simplified();

        if ( !regTemplateDirList.contains("registrations/" + dir)) {
          QDir tempDir(regTemplatesDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      QDir bundlesDir(m_projectRoot->path() + "/results/bundle/");
      bundlesDir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs);
      QStringList bundleList = bundlesDir.entryList();
      foreach (QString dir, bundleList) {
        dir = dir.simplified();

        if ( !bundleDirList.contains(dir) ) {
          QDir tempDir(bundlesDir.path() + "/" + dir);
          tempDir.removeRecursively();
        }
      }

      projectXml.close();
    }

    try {
      QString tmpFolder = QDir::temp().absolutePath() + "/"
            + Environment::userName() + "_"
            + QApplication::applicationName() + "_" + QString::number( getpid() );
      QDir temp(tmpFolder + "/tmpProject");
      m_projectRoot = new QDir(temp);
    }

    catch (IException &e) {
      throw IException(e, IException::Programmer, "Error creating project folders.", _FILEINFO_);
    }

    catch (std::exception &e) {
      throw IException(IException::Programmer,
          tr("Error creating project folders [%1]").arg( e.what() ), _FILEINFO_);
    }

    m_images->clear();
    m_shapes->clear();
    m_controls->clear();
    m_mapTemplates->clear();
    m_regTemplates->clear();
    m_targets->clear();
    m_guiCameras->clear();
    m_bundleSolutionInfo->clear();
    m_workOrderHistory->clear();

    directory()->clean();
    setClean(true);
  }


  bool Project::clearing() {
    return m_clearing;
  }


  ImageList *Project::createOrRetrieveImageList(QString name, QString path) {
    ImageList *result = imageList(name);
    if (!result) {
      result = new ImageList;

      result->setName(name);
      if (path == "") {
        result->setPath(name);
      }
      else {
        result->setPath(path);
      }

      connect( result, SIGNAL( destroyed(QObject *) ),
               this, SLOT( imageListDeleted(QObject *) ) );
      m_images->append(result);
    }
    return result;
  }


  ShapeList *Project::createOrRetrieveShapeList(QString name, QString path) {
    ShapeList *result = shapeList(name);
    if (!result) {
      result = new ShapeList;

      result->setName(name);
      if (path == "") {
        result->setPath(name);
      }
      else {
        result->setPath(path);
      }

      connect( result, SIGNAL( destroyed(QObject *) ),
               this, SLOT( shapeListDeleted(QObject *) ) );
      m_shapes->append(result);
    }
    return result;
  }


  void Project::save(QXmlStreamWriter &stream, FileName newProjectRoot) const {
    stream.writeStartElement("project");

    stream.writeAttribute("name", m_name);

    if ( !m_controls->isEmpty() ) {
      stream.writeStartElement("controlNets");

      for (int i = 0; i < m_controls->count(); i++) {
        m_controls->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    if ( !m_images->isEmpty() ) {
      stream.writeStartElement("imageLists");
      for (int i = 0; i < m_images->count(); i++) {
        m_images->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    if ( !m_shapes->isEmpty() ) {
      stream.writeStartElement("shapeLists");

      for (int i = 0; i < m_shapes->count(); i++) {
        m_shapes->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    if ( !m_mapTemplates->isEmpty() ) {
      stream.writeStartElement("mapTemplateLists");

      for (int i = 0; i < m_mapTemplates->count(); i++) {
        m_mapTemplates->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    if ( !m_regTemplates->isEmpty() ) {
      stream.writeStartElement("regTemplateLists");

      for (int i = 0; i < m_regTemplates->count(); i++) {
        m_regTemplates->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    // TODO:  Finish implementing serialization of TargetBody & GuiCameras
//  if (!m_targets->isEmpty()) {
//    stream.writeStartElement("targets");
//
//    for (int i = 0; i < m_targets->count(); i++) {
//      m_targets->at(i)->save(stream, this, newProjectRoot);
//    }
//
//    stream.writeEndElement();
//  }
//
//  if (!m_guiCameras->isEmpty()) {
//    stream.writeStartElement("cameras");
//
//    for (int i = 0; i < m_guiCameras->count(); i++) {
//      m_guiCameras->at(i)->save(stream, this, newProjectRoot);
//    }
//
//    stream.writeEndElement();
//  }

//  Write general look of gui, including docked widges
//  QVariant geo_data = saveGeometry();
//  QVariant layout_data = saveState();
//
//  stream.writeStartElement("dockRestore");
//  stream.writeAttribute("geometry", geo_data.toString());
//  stream.writeAttribute("state", layout_data.toString());


    if ( !m_bundleSolutionInfo->isEmpty() ) {
      stream.writeStartElement("results");

      for (int i = 0; i < m_bundleSolutionInfo->count(); i++) {
        m_bundleSolutionInfo->at(i)->save(stream, this, newProjectRoot);
      }

      stream.writeEndElement();
    }

    if (m_activeImageList) {
      stream.writeStartElement("activeImageList");
      stream.writeAttribute("displayName", m_activeImageList->name());
      stream.writeEndElement();
    }

    if (m_activeControl) {
      stream.writeStartElement("activeControl");
      stream.writeAttribute("displayName", m_activeControl->displayProperties()->displayName());
      stream.writeEndElement();
    }

    stream.writeEndElement();
  }


  void Project::saveHistory(QXmlStreamWriter &stream) const {
    stream.writeStartElement("history");

    foreach (WorkOrder *workOrder, *m_workOrderHistory) {
      if (workOrder) {
        workOrder->save(stream);
      }
    }

    stream.writeEndElement();
  }

  void Project::saveWarnings(QXmlStreamWriter &stream) const {
    stream.writeStartElement("warnings");

    foreach (QString warning, *m_warnings) {
      stream.writeStartElement("warning");
      stream.writeAttribute("text", warning);
      stream.writeEndElement();
    }

    stream.writeEndElement();
  }


  // TODO: thread via ImageReader
  QStringList Project::images(QStringList fileNames) {

    QStringList result;

    foreach (QString fileName, fileNames) {
      try {
        Cube tmp(fileName);
        result.append(fileName);
      }
      catch (IException &) {
      }
    }

    return result;
  }


  QList<QAction *> Project::userPreferenceActions() {
    return m_imageReader->actions(ImageDisplayProperties::FootprintViewProperties);
  }


  QDir Project::addCnetFolder(QString prefix) {
    QDir cnetFolder = cnetRoot();
    prefix += "%1";
    int prefixCounter = 0;

    QString numberedPrefix;
    do {
      prefixCounter++;
      numberedPrefix = prefix.arg( QString::number(prefixCounter) );
    }
    while ( cnetFolder.exists(numberedPrefix) );

    if ( !cnetFolder.mkpath(numberedPrefix) ) {
      throw IException(IException::Io,
          tr("Could not create control network directory [%1] in [%2].")
            .arg(numberedPrefix).arg( cnetFolder.absolutePath() ),
          _FILEINFO_);
    }

    cnetFolder.cd(numberedPrefix);

    m_currentCnetFolder = cnetFolder;

    return cnetFolder;
  }


  void Project::addControl(Control *control) {

    connect( control, SIGNAL( destroyed(QObject *) ),
             this, SLOT( controlClosed(QObject *) ) );
    connect( this, SIGNAL( projectRelocated(Project *) ),
             control, SLOT( updateFileName(Project *) ) );

    createOrRetrieveControlList( FileName( control->fileName() ).dir().dirName(), "" )->append(control);

    (*m_idToControlMap)[control->id()] = control;

    emit controlAdded(control);
  }


  ControlList *Project::createOrRetrieveControlList(QString name, QString path) {
    ControlList *result = controlList(name);

    if (!result) {
      result = new ControlList;

      result->setName(name);
      if (path == "") {
        result->setPath(name);
      }
      else {
        result->setPath(path);
      }

      connect( result, SIGNAL( destroyed(QObject *) ),
               this, SLOT( controlListDeleted(QObject *) ) );

      m_controls->append(result);
      emit controlListAdded(result);
    }

    return result;
  }


  QDir Project::addImageFolder(QString prefix) {
    QDir imageFolder = imageDataRoot();
    prefix += "%1";
    int prefixCounter = 0;

    QString numberedPrefix;
    do {
      prefixCounter++;
      numberedPrefix = prefix.arg( QString::number(prefixCounter) );
    }
    while ( imageFolder.exists(numberedPrefix) );

    if ( !imageFolder.mkpath(numberedPrefix) ) {
      throw IException(IException::Io,
          tr("Could not create image directory [%1] in [%2].")
            .arg(numberedPrefix).arg( imageFolder.absolutePath() ),
          _FILEINFO_);
    }

    imageFolder.cd(numberedPrefix);

    return imageFolder;
  }


  void Project::addImages(QStringList imageFiles) {
    if (m_numImagesCurrentlyReading == 0) {
      m_imageReadingMutex->lock();
    }

    m_numImagesCurrentlyReading += imageFiles.count();
    m_imageReader->read(imageFiles);
  }


  void Project::addImages(ImageList newImages) {
    imagesReady(newImages);

    //  The each
    emit guiCamerasAdded(m_guiCameras);
    emit targetsAdded(m_targets);
  }


  QDir Project::addShapeFolder(QString prefix) {
    QDir shapeFolder = shapeDataRoot();
    prefix += "%1";
    int prefixCounter = 0;

    QString numberedPrefix;
    do {
      prefixCounter++;
      numberedPrefix = prefix.arg( QString::number(prefixCounter) );
    }
    while ( shapeFolder.exists(numberedPrefix) );

    if ( !shapeFolder.mkpath(numberedPrefix) ) {
      throw IException(IException::Io,
          tr("Could not create shape directory [%1] in [%2].")
            .arg(numberedPrefix).arg( shapeFolder.absolutePath() ),
          _FILEINFO_);
    }

    shapeFolder.cd(numberedPrefix);

    return shapeFolder;
  }


  void Project::addShapes(QStringList shapeFiles) {
    if (m_numShapesCurrentlyReading == 0) {
      m_shapeReadingMutex->lock();
    }

    m_numShapesCurrentlyReading += shapeFiles.count();
    m_shapeReader->read(shapeFiles);
  }


  void Project::addShapes(ShapeList newShapes) {
    shapesReady(newShapes);
  }


  void Project::addTemplates(TemplateList *templateList) {
    foreach (Template *templateFile, *templateList) {
      connect( this, SIGNAL( projectRelocated(Project *) ),
               templateFile, SLOT( updateFileName(Project *) ) );
    }
    if (templateList->type() == "maps") {
      m_mapTemplates->append(templateList);
    }
    else if (templateList->type() == "registrations") {
      m_regTemplates->append(templateList);
    }

    emit templatesAdded(templateList);
  }


  QDir Project::addTemplateFolder(QString prefix) {
    QDir templateFolder = templateRoot();
    prefix += "%1";
    int prefixCounter = 0;
    QString numberedPrefix;

    do {
      prefixCounter++;
      numberedPrefix = prefix.arg( QString::number(prefixCounter) );
    }
    while ( templateFolder.exists(numberedPrefix) );

    if ( !templateFolder.mkpath(numberedPrefix) ) {
      throw IException(IException::Io,
          tr("Could not create template directory [%1] in [%2].")
            .arg(numberedPrefix).arg( templateFolder.absolutePath() ),
          _FILEINFO_);
    }

    templateFolder.cd(numberedPrefix);

    return templateFolder;
  }


  Control *Project::control(QString id) {
    return (*m_idToControlMap)[id];
  }


  QDir Project::addBundleSolutionInfoFolder(QString folder) {
    QDir bundleSolutionInfoFolder(bundleSolutionInfoRoot());

    if (!bundleSolutionInfoFolder.mkpath(folder)) {
      throw IException(IException::Io,
                       tr("Could not create bundle results directory [%1] in [%2].")
                       .arg(folder).arg(bundleSolutionInfoFolder.absolutePath()),
                       _FILEINFO_);
    }

    bundleSolutionInfoFolder.cd(folder);
    return bundleSolutionInfoFolder;
  }


  void Project::addBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo) {
    connect(bundleSolutionInfo, SIGNAL(destroyed(QObject *)),
            this, SLOT(bundleSolutionInfoClosed(QObject *)));//???
    connect(this, SIGNAL(projectRelocated(Project *)),
            bundleSolutionInfo, SLOT(updateFileName(Project *)));//DNE???


    loadBundleSolutionInfo(bundleSolutionInfo);
  }


  void Project::loadBundleSolutionInfo(BundleSolutionInfo *bundleSolutionInfo) {
    m_bundleSolutionInfo->append(bundleSolutionInfo);

    // add BundleSolutionInfo to project's m_idToBundleSolutionInfoMap
    (*m_idToBundleSolutionInfoMap)[bundleSolutionInfo->id()] = bundleSolutionInfo;

    // add BundleSolutionInfo's control to project's m_idToControlMap
    (*m_idToControlMap)[bundleSolutionInfo->control()->id()] = bundleSolutionInfo->control();

    emit bundleSolutionInfoAdded(bundleSolutionInfo);
  }


  Directory *Project::directory() const {
    return m_directory;
  }


  void Project::writeSettings() {

    QString appName = QApplication::applicationName();


    QSettings globalSettings(
        FileName("$HOME/.Isis/" + appName + "/" + appName + "_" + "Project.config")
          .expanded(),
        QSettings::NativeFormat);

    globalSettings.beginGroup("recent_projects");
    QStringList keys = globalSettings.allKeys();
    QMap<QString,QString> recentProjects;

    foreach (QString key,keys) {

      recentProjects[key]=globalSettings.value(key).toString();

    }

    QList<QString> projectPaths = recentProjects.values();

    if (keys.count() >= m_maxRecentProjects) {

      //Clear out the recent projects before repopulating this group
      globalSettings.remove("");



      //If the currently open project is a project that has been saved and is not within the current
      //list of recently open projects, then remove the oldest project from the list.
      if (!this->projectRoot().contains("tmpProject") && !projectPaths.contains(this->projectRoot()) ) {
        QString s=keys.first();
        recentProjects.remove( s );
      }

      //If the currently open project is already contained within the list,
      //then remove the earlier reference.

      if (projectPaths.contains(this->projectRoot())) {
        QString key = recentProjects.key(this->projectRoot());
        recentProjects.remove(key);
      }

      QMap<QString,QString>::iterator i;

      //Iterate through the recentProjects QMap and set the <key,val> pairs.
      for (i=recentProjects.begin();i!=recentProjects.end();i++) {

          globalSettings.setValue(i.key(),i.value());

      }

      //Get a unique time value for generating a key
      long t0 = QDateTime::currentMSecsSinceEpoch();
      QString projName = this->name();

      QString t0String=QString::number(t0);

      //Save the project location
      if (!this->projectRoot().contains("tmpProject") ) {
              globalSettings.setValue(t0String+"%%%%%"+projName,this->projectRoot());

      }

    }

    //The numer of recent open projects is less than m_maxRecentProjects
    else {

      //Clear out the recent projects before repopulating this group
      globalSettings.remove("");
      if (projectPaths.contains(this->projectRoot())) {
        QString key = recentProjects.key(this->projectRoot());
        recentProjects.remove(key);
      }
      QMap<QString,QString>::iterator i;

      //Iterate through the recentProjects QMap and set the <key,val> pairs.
      for ( i=recentProjects.begin(); i!=recentProjects.end(); i++ ) {
          globalSettings.setValue(i.key(),i.value());
      }

      long t0 = QDateTime::currentMSecsSinceEpoch();
      QString projName = this->name();
      QString t0String=QString::number(t0);

      //if (!this->projectRoot().contains("tmpProject") && !projectPaths.contains( this->projectRoot() ) ) {
      if (!this->projectRoot().contains("tmpProject") ) {
        globalSettings.setValue(t0String+"%%%%%"+projName,this->projectRoot());
      }

    }


    globalSettings.endGroup();
  }


  void Project::open(QString projectPathStr) {
    // Expand projectPathStr to contain absolute path
    QString projectAbsolutePathStr = QDir(projectPathStr).absolutePath();

    QString projectXmlPath = projectAbsolutePathStr + "/project.xml";
    QFile file(projectXmlPath);

    if ( !file.open(QFile::ReadOnly) ) {
      throw IException(IException::Io,
                       QString("Unable to open [%1] with read access")
                       .arg(projectXmlPath),
                       _FILEINFO_);
    }

    QString projectXmlHistoryPath = projectAbsolutePathStr + "/history.xml";
    QFile historyFile(projectXmlHistoryPath);

    if ( !historyFile.open(QFile::ReadOnly) ) {
      throw IException(IException::Io,
                       QString("Unable to open [%1] with read access")
                               .arg(projectXmlHistoryPath),
                       _FILEINFO_);
    }

    QString projectXmlWarningsPath = projectAbsolutePathStr + "/warnings.xml";
    QFile warningsFile(projectXmlWarningsPath);

    if (!warningsFile.open(QFile::ReadOnly)) {
      throw IException(IException::Io,
                       QString("Unable to open [%1] with read access")
                       .arg(projectXmlWarningsPath),
                       _FILEINFO_);
    }

    QString directoryXmlPath = projectAbsolutePathStr + "/directory.xml";
    QFile directoryFile(directoryXmlPath);

    if (!directoryFile.open(QFile::ReadOnly)) {
      throw IException(IException::Io,
                       QString("Unable to open [%1] with read access")
                       .arg(directoryXmlPath),
                       _FILEINFO_);
    }

    if (isOpen() || !isClean()) {
      clear();
    }
    m_clearing = false;
    m_isTemporaryProject = false;

    XmlHandler handler(this);

    XmlStackedHandlerReader reader;
    reader.pushContentHandler(&handler);
    reader.setErrorHandler(&handler);

    QDir oldProjectRoot(*m_projectRoot);
    *m_projectRoot =  QDir(projectAbsolutePathStr);

    QXmlInputSource xmlInputSource(&file);

    //This prevents the project from not loading if everything
    //can't be loaded, and outputs the warnings/errors to the
    //Warnings Tab
    try {
      reader.parse(xmlInputSource);
        }
    catch (IException &e) {
      directory()->showWarning(QString("Failed to open project completely [%1]")
                               .arg(projectAbsolutePathStr));
      directory()->showWarning(e.toString());
      }
    catch (std::exception &e) {
      directory()->showWarning(QString("Failed to open project completely[%1]")
                               .arg(projectAbsolutePathStr));
      directory()->showWarning(e.what());
    }

    reader.pushContentHandler(&handler);
    QXmlInputSource xmlHistoryInputSource(&historyFile);

    try {
      reader.parse(xmlHistoryInputSource);
      }

    catch (IException &e) {
      directory()->showWarning(QString("Failed to read history from project[%1]")
                               .arg(projectAbsolutePathStr));
      directory()->showWarning(e.toString());
      }
    catch (std::exception &e) {
      directory()->showWarning(QString("Failed to read history from project[%1]")
                                .arg(projectAbsolutePathStr));
      directory()->showWarning(e.what());
    }

    reader.pushContentHandler(&handler);

    QXmlInputSource xmlWarningsInputSource(&warningsFile);

    if (!reader.parse(xmlWarningsInputSource)) {
      warn(tr("Failed to read warnings from project [%1]").arg(projectAbsolutePathStr));
    }

    reader.pushContentHandler(&handler);

    QXmlInputSource xmlDirectoryInputSource(&directoryFile);

    try {
      reader.parse(xmlDirectoryInputSource);
         }
    catch (IException &e) {
      directory()->showWarning(QString("Failed to read GUI state from project[%1]")
                               .arg(projectAbsolutePathStr));
      directory()->showWarning(e.toString());

      }
    catch (std::exception &e) {
      directory()->showWarning(QString("Failed to read GUI state from project[%1]")
                               .arg(projectAbsolutePathStr));
      directory()->showWarning(e.what());
    }

    QDir bundleRoot(bundleSolutionInfoRoot());
    if (bundleRoot.exists()) {
      // get QFileInfo for each directory in the bundle root
      bundleRoot.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot | QDir::NoSymLinks); // sym links ok???

      QFileInfoList bundleDirs = bundleRoot.entryInfoList();

      for (int dirListIndex = 0; dirListIndex < bundleDirs.size(); dirListIndex++) {

        // get QFileInfo for each file in this directory
        QDir bundleSolutionDir(bundleDirs[dirListIndex].absoluteFilePath());
        bundleSolutionDir.setFilter(QDir::Files | QDir::NoSymLinks); // sym links ok???

//         QFileInfoList bundleSolutionFiles = bundleSolutionDir.entryInfoList();
//         for (int fileListIndex = 0; fileListIndex < bundleSolutionFiles.size(); fileListIndex++) {
//           // if the file is an hdf file with BundleSolutionInfo object, add it to the project tree
//           if (bundleSolutionFiles[fileListIndex].fileName().contains("_BundleSolutionInfo.hdf")) {
//             QString  absoluteFileName = bundleSolutionFiles[fileListIndex].absoluteFilePath();
//             FileName solutionFile(bundleSolutionFiles[fileListIndex].absoluteFilePath());
//             loadBundleSolutionInfo(new BundleSolutionInfo(solutionFile));
//           }
//         }
      }
    }
    m_isOpen = true;

    setClean(true);
    emit projectLoaded(this);
  }


  QProgressBar *Project::progress() {
    return m_imageReader->progress();
  }


  Image *Project::image(QString id) {

    return (*m_idToImageMap)[id];
  }


  ImageList *Project::imageList(QString name) {
    QListIterator<ImageList *> it(*m_images);

    ImageList *result = NULL;
    while (it.hasNext() && !result) {
      ImageList *list = it.next();

      if (list->name() == name) result = list;
    }

    return result;
  }


  Shape *Project::shape(QString id) {
    return (*m_idToShapeMap)[id];
  }


  ShapeList *Project::shapeList(QString name) {
    QListIterator<ShapeList *> it(*m_shapes);

    ShapeList *result = NULL;
    while (it.hasNext() && !result) {
      ShapeList *list = it.next();

      if (list->name() == name) result = list;
    }

    return result;
  }


  bool Project::isTemporaryProject() const {
    return m_isTemporaryProject;
  }


  bool Project::isOpen() {
    return m_isOpen;
  }


  bool Project::isClean() {
    return m_isClean;
  }


  void Project::setClean(bool value) {
    m_isClean = value;
    m_undoStack.cleanChanged(value);
  }


  WorkOrder *Project::lastNotUndoneWorkOrder() {
    WorkOrder *result = NULL;
    QListIterator< QPointer<WorkOrder> > it(*m_workOrderHistory);
    it.toBack();

    while ( !result && it.hasPrevious() ) {
      WorkOrder *workOrder = it.previous();

      if ( !workOrder->isUndone() && !workOrder->isUndoing() ) {
        result = workOrder;
      }
    }

    return result;
  }


  QString Project::name() const {
    return m_name;
  }


  const WorkOrder *Project::lastNotUndoneWorkOrder() const {
    const WorkOrder *result = NULL;
    QListIterator< QPointer<WorkOrder> > it(*m_workOrderHistory);
    it.toBack();

    while ( !result && it.hasPrevious() ) {
      WorkOrder *workOrder = it.previous();

      if ( !workOrder->isUndone() && !workOrder->isUndoing() ) {
        result = workOrder;
      }
    }

    return result;
  }


  QMutex *Project::mutex() {
    return m_mutex;
  }


  QString Project::projectRoot() const {
    return m_projectRoot->path();
  }


  QString Project::newProjectRoot() const {
    return m_newProjectRoot;
  }


  void Project::setName(QString newName) {
    m_name = newName;
    emit nameChanged(m_name);
  }


  QUndoStack *Project::undoStack() {
    return &m_undoStack;
  }


  QString Project::nextImageListGroupName() {
    int numLists = m_images->size();
    QString maxName = "";
    QString newGroupName = "Group";

    foreach (ImageList *imageList, *m_images) {
      QString name = imageList->name();
      if ( !name.contains("Group") ) continue;
      if ( maxName.isEmpty() ) {
        maxName = name;
      }
      else if (name > maxName) {
        maxName = name;
      }
    }

    if ( maxName.isEmpty() ) {
      newGroupName += QString::number(numLists+1);
    }
    else {
      int maxNum = maxName.remove("Group").toInt();
      maxNum++;

      newGroupName += QString::number(maxNum);
    }
    return newGroupName;

  }


  void Project::waitForImageReaderFinished() {
    QMutexLocker locker(m_imageReadingMutex);
  }


  void Project::waitForShapeReaderFinished() {
    QMutexLocker locker(m_shapeReadingMutex);
  }


  QList<WorkOrder *> Project::workOrderHistory() {
    QList<WorkOrder *> result;
    foreach (WorkOrder *workOrder, *m_workOrderHistory) {
      result.append(workOrder);
    }

    return result;
  }


  void Project::checkActiveControlAndImageList() {
    if (m_activeControl && m_activeImageList) {
      emit activeControlAndImageListSet();
    }
  }


  void Project::checkControlsAndImagesAvailable() {
    if (controls().count() > 0 && images().count() > 0) {
      emit controlsAndImagesAvailable();
    }
  }


  void Project::setActiveControl(QString displayName) {
    Control *previousControl = m_activeControl;
    if (m_activeControl) {

      // If the current active control has been modified, ask user if they want to save or discard
      // changes.
      if (m_activeControl->isModified()) {
        QMessageBox msgBox;
        msgBox.setText("Save current active control");
        msgBox.setInformativeText("The current active control has been modified.  Do you want "
                                  "to save before setting a new active control?");
        msgBox.setStandardButtons(QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
        msgBox.setDefaultButton(QMessageBox::Save);
        int ret = msgBox.exec();
        switch (ret) {
          // Save current active control
          case QMessageBox::Save:
            m_activeControl->write();
            break;
          // Discard any changes made to cnet
          case QMessageBox::Discard:
            // Close, then re-open effectively discarding edits
            m_activeControl->closeControlNet();
            m_activeControl->openControlNet();
            emit discardActiveControlEdits();
            break;
          // Cancel operation
          case QMessageBox::Cancel:
            return;
        }
      }
      emit activeControlSet(false);
      ProjectItem *item = directory()->model()->findItemData(m_activeControl->
                          displayProperties()->displayName(), Qt::DisplayRole);
      item->setTextColor(Qt::black);
      // Make sure active not used in a CnetEditorWidget before closing
      if (!directory()->controlUsedInCnetEditorWidget(m_activeControl)) {
        m_activeControl->closeControlNet();
      }
    }

    ProjectItem *item = directory()->model()->findItemData(displayName, Qt::DisplayRole);
    if (item && item->isControl()) {
      m_activeControl = item->control();

      try {
          m_activeControl->controlNet()->SetImages(*(activeImageList()->serialNumberList()));
          item->setTextColor(Qt::darkGreen);
      }
      catch(IException &e){
          if (previousControl) {
            m_activeControl = previousControl;
            item = directory()->model()->findItemData(m_activeControl->
                                displayProperties()->displayName(), Qt::DisplayRole);
            item->setTextColor(Qt::darkGreen);
            m_activeControl->controlNet()->SetImages(*(activeImageList()->serialNumberList()));
          }
          else {
            m_activeControl = NULL;
          }
          throw IException(e);
        }
      }
    emit activeControlSet(true);
  }


  Control *Project::activeControl() {

    if (!m_activeControl && (m_controls->count() == 1 && m_controls->at(0)->count() ==1)) {
      //  Can only set a default control if an active imageList exists or if a default can be set
      if (activeImageList()) {
        QString controlName = m_controls->at(0)->at(0)->displayProperties()->displayName();
        setActiveControl(controlName);
      }
    }

    return m_activeControl;
  }


  void Project::cnetModified() {
    if (m_activeControl && m_activeControl->isModified()) {
      emit activeControlModified();
    }
    setClean(false);
  }


  void Project::setActiveImageList(QString displayName) {
    ImageList *previousImageList = m_activeImageList;
    if (m_activeImageList) {
      ProjectItem *item = directory()->model()->findItemData(m_activeImageList->
                    name(), Qt::DisplayRole);
      item->setTextColor(Qt::black);
    }
    ProjectItem *item = directory()->model()->findItemData(displayName, Qt::DisplayRole);
    if (item && item->isImageList()) {
      m_activeImageList = item->imageList();

      if (m_activeControl) {
        try {
          activeControl()->controlNet()->SetImages(*(m_activeImageList->serialNumberList()));
        }
        catch(IException &e){
          if (previousImageList) {
            m_activeImageList = previousImageList;
            item = directory()->model()->findItemData(m_activeImageList->
                          name(), Qt::DisplayRole);
            item->setTextColor(Qt::darkGreen);
            activeControl()->controlNet()->SetImages(*(m_activeImageList->serialNumberList()));
          }
          else {
            m_activeImageList = NULL;
          }
          throw IException(e);
        }
      }
      item->setTextColor(Qt::darkGreen);
      emit activeImageListSet();
    }
  }


  ImageList *Project::activeImageList() {

    if (!m_activeImageList && m_images->count() == 1) {
      QString imageList = m_images->at(0)->name();

      setActiveImageList(imageList);
    }
    return m_activeImageList;
  }


  QString Project::cnetRoot(QString projectRoot) {
    return projectRoot + "/cnets";
  }


  QString Project::cnetRoot() const {
    return cnetRoot( m_projectRoot->path() );
  }


  QList<ControlList *> Project::controls() {
    return *m_controls;
  }


  ControlList *Project::controlList(QString name) {
    QListIterator< ControlList * > it(*m_controls);

    ControlList *result  = NULL;
    while (it.hasNext() && !result) {
      ControlList *list = it.next();

      if (list->name() == name) result = list;
    }

    return result;
  }


  QString Project::imageDataRoot(QString projectRoot) {
    return projectRoot + "/images";
  }


  QString Project::imageDataRoot() const {
    return imageDataRoot( m_projectRoot->path() );
  }


  QString Project::shapeDataRoot(QString projectRoot) {
    return projectRoot + "/shapes";
  }


  QString Project::shapeDataRoot() const {
    return shapeDataRoot( m_projectRoot->path() );
  }


  QList<ShapeList *> Project::shapes() {
    return *m_shapes;
  }


  QList<ImageList *> Project::images() {
    return *m_images;
  }


  QString Project::templateRoot(QString projectRoot) {
    return projectRoot + "/templates";
  }


  QString Project::templateRoot() const {
    return templateRoot( m_projectRoot->path() );
  }


  QList<TemplateList *> Project::templates() {
    QList<TemplateList *> allTemplates = *m_mapTemplates + *m_regTemplates;
    return allTemplates;
  }


  QList<TemplateList *> Project::mapTemplates() {
    return *m_mapTemplates;
  }


  QList<TemplateList *> Project::regTemplates() {
    return *m_regTemplates;
  }


  QString Project::targetBodyRoot(QString projectRoot) {
    return projectRoot + "/targets";
  }


  QString Project::targetBodyRoot() const {
    return targetBodyRoot( m_projectRoot->path() );
  }


  TargetBodyList Project::targetBodies() {
    return *m_targets;
  }


  QString Project::resultsRoot(QString projectRoot) {
    return projectRoot + "/results";
  }


  QString Project::resultsRoot() const {
    return resultsRoot( m_projectRoot->path() );
  }


  QList<BundleSolutionInfo *> Project::bundleSolutionInfo() {
    return *m_bundleSolutionInfo;
  }


  QString Project::bundleSolutionInfoRoot(QString projectRoot) {
    return projectRoot + "/results/bundle";
  }


  QString Project::bundleSolutionInfoRoot() const {
    return bundleSolutionInfoRoot( m_projectRoot->path() );
  }


  void Project::deleteAllProjectFiles() {

    // Currently the deleteFromDisk methods for Image and Shape delete the Cube if it exists, the
    //  other objects deleteFromDisk methods simply remove files.  This could be achieved easier
    //  in this method by simply calling QDir::removeRecursively(), but for future functionality
    //  call each objects deleteFromDisk.  Currently there are no cleanup methods for Bundle results
    //  or templates, so simply remove directory recursively.
    foreach (ImageList *imagesInAFolder, *m_images) {
      imagesInAFolder->deleteFromDisk(this);
    }

    if ( !m_projectRoot->rmdir( imageDataRoot() ) ) {
      warn( tr("Did not properly clean up images folder [%1] in project").arg( imageDataRoot() ) );
    }

    foreach (ShapeList *shapesInAFolder, *m_shapes) {
      shapesInAFolder->deleteFromDisk(this);
    }

    if ( !m_projectRoot->rmdir( shapeDataRoot() ) ) {
      warn( tr("Did not properly clean up shapes folder [%1] in project").
            arg( shapeDataRoot() ) );
    }

    foreach (ControlList *controlsInAFolder, *m_controls) {
      controlsInAFolder->deleteFromDisk(this);
    }

    if ( !m_projectRoot->rmdir( cnetRoot() ) ) {
      warn( tr("Did not properly clean up control network folder [%1] in project")
             .arg( cnetRoot() ) );
    }

    if ( !(QDir(resultsRoot()).removeRecursively()) ) {
      warn( tr("Did not properly clean up results folder [%1] in project")
             .arg( resultsRoot() ) );
    }

    if ( !(QDir(templateRoot()).removeRecursively()) ) {
      warn( tr("Did not properly clean up templates folder [%1] in project")
             .arg( templateRoot() ) );
    }

    if ( !m_projectRoot->rmpath( m_projectRoot->path() ) ) {
      warn( tr("Did not properly clean up project in [%1]").arg( m_projectRoot->path() ) );
    }
  }


  void Project::relocateProjectRoot(QString newProjectRoot) {
    *m_projectRoot = newProjectRoot;
    emit projectRelocated(this);
  }


  bool Project::save() {
    // Let caller know if the save dialog was cancelled
    bool saveDialogCompleted = true;

    if (m_isTemporaryProject) {
      QString newDestination = QFileDialog::getSaveFileName(NULL,
                                                            QString("Project Location"),
                                                            QString("."));

      if ( !newDestination.isEmpty() ) {
        m_isTemporaryProject = false;
        save( QFileInfo(newDestination + "/").absolutePath() );

        // delete the temporary project
        deleteAllProjectFiles();
        relocateProjectRoot(newDestination);

        // 2014-03-14 kle This is a lame kludge because we think that relocateProjectRoot is not
        // working properly. For example, when we save a new project and try to view a control net
        // the it thinks it's still in the /tmp area
        // see ticket #5292
        open(newDestination);
      }
      // Dialog was cancelled
      else {
        saveDialogCompleted = false;
      }
    }
    else {
      // Save all modified controls. If "Save As" is being processed,
      // the controls are written in the Control::copyToNewProjectRoot, so the controls in
      // current project are not modified.
      foreach (ControlList *controlList, *m_controls) {
        foreach (Control *control, *controlList) {
          if (control->isModified()) {
            control->write();
          }
        }
      }
      save(m_projectRoot->absolutePath(), false);
      emit cnetSaved(true);
    }

    return saveDialogCompleted;
  }




  void Project::save(FileName newPath, bool verifyPathDoesntExist) {
    if ( verifyPathDoesntExist && QFile::exists( newPath.toString() ) ) {
      throw IException(IException::Io,
                       QString("Projects may not be saved to an existing path [%1]; "
                               "please select a new path or delete the current folder")
                       .arg(newPath.original()),
                       _FILEINFO_);
    }

    QDir dir;
    if (!dir.mkpath(newPath.toString())) {
      throw IException(IException::Io,
                       QString("Unable to save project at [%1] "
                               "because we could not create the folder")
                       .arg(newPath.original()),
                       _FILEINFO_);
    }

    //  TODO Set newpath member variable.  This is used for some of the data copy methods and is not
    //  the ideal way to handle this.  Maybe change the data copy methods to either take the new
    //  project root in addition to the data root or put the data root in the dataList (ImageList,
    //  etc.). If performing a "Save", m_newProjectRoot == m_projectRoot
    m_newProjectRoot = newPath.toString();

    //  For now set the member variable rather than calling setName which emits signal and updates
    //  ProjectItemModel & the project name on the tree.  This will be updated when the new project
    //  is opened.
    m_name = newPath.name();

    QFile projectSettingsFile(newPath.toString() + "/project.xml");
    if (!projectSettingsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
                       QString("Unable to save project at [%1] because the file [%2] "
                               "could not be opened for writing")
                       .arg(newPath.original()).arg(projectSettingsFile.fileName()),
                       _FILEINFO_);
    }

    QXmlStreamWriter writer(&projectSettingsFile);
    writer.setAutoFormatting(true);

    writer.writeStartDocument();

    // Do amazing, fantastical stuff here!!!
    save(writer, newPath);

    writer.writeEndDocument();

    QFile projectHistoryFile(newPath.toString() + "/history.xml");
    if (!projectHistoryFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
                       QString("Unable to save project at [%1] because the file [%2] "
                               "could not be opened for writing")
                       .arg(newPath.original()).arg(projectHistoryFile.fileName()),
                       _FILEINFO_);
    }

    QXmlStreamWriter historyWriter(&projectHistoryFile);
    historyWriter.setAutoFormatting(true);

    historyWriter.writeStartDocument();
    saveHistory(historyWriter);
    historyWriter.writeEndDocument();

    QFile projectWarningsFile(newPath.toString() + "/warnings.xml");
    if (!projectWarningsFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
                       QString("Unable to save project at [%1] because the file [%2] could not be "
                               "opened for writing")
                       .arg(newPath.original()).arg(projectWarningsFile.fileName()),
                       _FILEINFO_);
    }

    QXmlStreamWriter warningsWriter(&projectWarningsFile);
    warningsWriter.setAutoFormatting(true);

    warningsWriter.writeStartDocument();
    saveWarnings(warningsWriter);
    warningsWriter.writeEndDocument();

    //  Save the Directory structure
    QFile directoryStateFile(newPath.toString() + "/directory.xml");
    if (!directoryStateFile.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
      throw IException(IException::Io,
                       QString("Unable to save project at [%1] because the file [%2] could not be "
                               "opened for writing")
                       .arg(newPath.original()).arg(directoryStateFile.fileName()),
                       _FILEINFO_);
    }

    QXmlStreamWriter directoryStateWriter(&directoryStateFile);
    directoryStateWriter.setAutoFormatting(true);

    directoryStateWriter.writeStartDocument();

    /*
     * TODO: Does Project need to know about Directory?
     * This is the only place that project uses m_directory. This makes me wonder if it is
     * necessary for project to have a Directory member variable.
     */
    m_directory->save(directoryStateWriter, newPath);

    directoryStateWriter.writeEndDocument();
    m_isOpen = true;

    emit projectSaved(this);

  }


  void Project::addToProject(WorkOrder *workOrder) {
    if (workOrder) {
      connect(workOrder, SIGNAL(finished(WorkOrder *)),
              this, SIGNAL(workOrderFinished(WorkOrder *)));

      workOrder->setPrevious(lastNotUndoneWorkOrder());

      if (workOrder->setupExecution()) {
        if (workOrder->previous()) workOrder->previous()->setNext(workOrder);

        m_workOrderHistory->append(workOrder);

        if (workOrder->isSavedToHistory()) {
          emit workOrderStarting(workOrder);
        }

        // Work orders that create clean states (save, save as) don't belong on the undo stack.
        //   Instead, we tell the undo stack that we're now clean.
        if (workOrder->createsCleanState()) {
          m_undoStack.setClean();
          workOrder->execute();
        }
        // All other work orders go onto the undo stack, unless specifically told not to
        else if (workOrder->isUndoable()) {
          // This calls WorkOrder::redo for us through Qt's QUndoStack::push method, redo is only
          // implemented in the base class.  Child work orders do not implement redo.
          m_undoStack.push(workOrder);
        }
        else {
          // If we get this far the WorkOrder is not-undoable therefore we have to call redo by
          // hand.

          workOrder->redo();
        }
        // Clean up deleted work orders (the m_undoStack.push() can delete work orders)
        m_workOrderHistory->removeAll(NULL);
      }
      else {
        delete workOrder;
        workOrder = NULL;
      }
    }
  }


  template<typename Data> void Project::warn(QString text, Data relevantData) {
    storeWarning(text, relevantData);
    directory()->showWarning(text, relevantData);
  }


  void Project::warn(QString text) {
    foreach (QString line, text.split("\n")) {
      storeWarning(line);
      directory()->showWarning(line);
    }
  }


  void Project::storeWarning(QString text) {
    m_warnings->append(text);
  }


  void Project::imagesReady(ImageList images) {

    m_numImagesCurrentlyReading -= images.count();

    foreach (Image *image, images) {
      connect(image, SIGNAL(destroyed(QObject *)),
              this, SLOT(imageClosed(QObject *)));
      connect(this, SIGNAL(projectRelocated(Project *)),
              image, SLOT(updateFileName(Project *)));

      (*m_idToImageMap)[image->id()] = image;
      if (images.name() != "") {
        createOrRetrieveImageList(images.name(), images.path())->append(image);
      }
      else {
        createOrRetrieveImageList(FileName(images[0]->fileName()).dir().dirName(), "")->append(image);
      }
    }

    // We really can't have all of the cubes in memory before
    //   the OS stops letting us open more files.
    // Assume cameras are being used in other parts of code since it's
    //   unknown
    QMutexLocker lock(m_mutex);
    emit imagesAdded(m_images->last());

    Image *openImage;
    foreach (openImage, images) {
      openImage->closeCube();
    }

//     if(m_projectPvl && m_projectPvl->HasObject("MosaicFileList") )
//       m_fileList->fromPvl(m_projectPvl->FindObject("MosaicFileList") );

//     if(m_projectPvl && m_projectPvl->HasObject("MosaicScene") )
//       m_scene->fromPvl(m_projectPvl->FindObject("MosaicScene") );

    if (m_numImagesCurrentlyReading == 0) {
      m_imageReadingMutex->unlock();
    }
  }


  bool Project::hasTarget(QString id) {
    foreach (TargetBodyQsp targetBody, *m_targets) {
      if (QString::compare(targetBody->targetName(), id, Qt::CaseInsensitive) == 0) {
        return true;
      }
    }
    return false;
  }


  void Project::addTarget(Target *target) {

    TargetBodyQsp targetBody = TargetBodyQsp(new TargetBody(target));

    m_targets->append(targetBody);

  }


  bool Project::hasCamera(QString id) {
    foreach (GuiCameraQsp camera, *m_guiCameras) {

      if (QString::compare(camera->instrumentId(), id, Qt::CaseInsensitive) == 0) {
        return true;
      }
    }
    return false;
  }


  void Project::addCamera(Camera *camera) {

    GuiCameraQsp guiCamera = GuiCameraQsp(new GuiCamera(camera));

    m_guiCameras->append(guiCamera);

  }


  void Project::addImagesToIdMap(ImageList images) {

    foreach (Image *image, images) {
      (*m_idToImageMap)[image->id()] = image;
    }
  }


  void Project::removeImages(ImageList &imageList) {
    foreach (Image *image, imageList) {
      delete image;
    }
    foreach (ImageList *list, *m_images) {
      if (list->name() == imageList.name()) {
        m_images->removeOne(list);
      }
    }
  }


  void Project::imageClosed(QObject *imageObj) {
    QMutableListIterator<ImageList *> it(*m_images);
    while (it.hasNext()) {
      ImageList *list = it.next();

      int foundElement = list->indexOf((Image *)imageObj);

      if (foundElement != -1) {
        list->removeAt(foundElement);
      }
    }

    m_idToImageMap->remove(m_idToImageMap->key((Image *)imageObj));
  }


  void Project::imageListDeleted(QObject *imageListObj) {
    int indexToRemove = m_images->indexOf(static_cast<ImageList *>(imageListObj));
    if (indexToRemove != -1) {
      m_images->removeAt(indexToRemove);
    }
  }


  void Project::controlClosed(QObject *controlObj) {
    m_idToControlMap->remove(m_idToControlMap->key((Control *)controlObj));
  }


  void Project::controlListDeleted(QObject *controlListObj) {
    int indexToRemove = m_controls->indexOf(static_cast<ControlList *>(controlListObj));
    if (indexToRemove != -1) {
      m_controls->removeAt(indexToRemove);
    }

    if (controls().count() == 0) {
      emit allControlsRemoved();
    }
  }


  void Project::shapeListDeleted(QObject *shapeListObj) {
    int indexToRemove = m_shapes->indexOf(static_cast<ShapeList *>(shapeListObj));
    if (indexToRemove != -1) {
      m_shapes->removeAt(indexToRemove);
    }
  }


  void Project::bundleSolutionInfoClosed(QObject *bundleSolutionInfoObj) {
    QMutableListIterator<BundleSolutionInfo *> it(*m_bundleSolutionInfo);
    while (it.hasNext()) {
      BundleSolutionInfo *bundleSolutionInfo = it.next();
      if (!bundleSolutionInfo) {
        // throw error???
      }

      int foundElement = m_bundleSolutionInfo->indexOf(
          (BundleSolutionInfo *)bundleSolutionInfoObj);

      if (foundElement != -1) {
        m_bundleSolutionInfo->removeAt(foundElement);
      }
    }

    m_idToBundleSolutionInfoMap->remove(
        m_idToBundleSolutionInfoMap->key((BundleSolutionInfo * )bundleSolutionInfoObj));
  }


  void Project::targetBodyClosed(QObject *targetBodyObj) {
//    QMutableListIterator<TargetBody *> it(*m_targets);
//    while ( it.hasNext() ) {
//      TargetBody *targetBody = it.next();
//      if (!targetBody) {
//        // throw error???
//      }

//      int foundElement = m_targets->indexOf( (TargetBody *)targetBodyObj );

//      if (foundElement != -1) {
//        m_targets->removeAt(foundElement);
//      }
//    }

//    m_idToTargetBodyMap->remove(m_idToTargetBodyMap->key((TargetBody *)targetBodyObj));
  }



  void Project::shapesReady(ShapeList shapes) {

    m_numShapesCurrentlyReading -= shapes.count();

    foreach (Shape *shape, shapes) {
      connect(shape, SIGNAL(destroyed(QObject *)),
              this, SLOT(shapeClosed(QObject *)));
      connect(this, SIGNAL(projectRelocated(Project *)),
              shape, SLOT(updateFileName(Project *)));

      (*m_idToShapeMap)[shape->id()] = shape;
      if (shapes.name() != "") {
        createOrRetrieveShapeList(shapes.name(), shapes.path())->append(shape);
      }
      else {
        createOrRetrieveShapeList(FileName(shapes[0]->fileName()).dir().dirName(), "")->append(shape);
      }

    }

    // We really can't have all of the cubes in memory before
    //   the OS stops letting us open more files.
    // Assume cameras are being used in other parts of code since it's
    //   unknown
    QMutexLocker lock(m_shapeMutex);
    emit shapesAdded(m_shapes->last());

    Shape *openShape;
    foreach (openShape, shapes) {
      openShape->closeCube();
    }

    if (m_numShapesCurrentlyReading == 0) {
      m_shapeReadingMutex->unlock();
    }
  }


  void Project::shapeClosed(QObject *imageObj) {
    QMutableListIterator<ShapeList *> it(*m_shapes);
    while (it.hasNext()) {
      ShapeList *list = it.next();

      int foundElement = list->indexOf((Shape *)imageObj);

      if (foundElement != -1) {
        list->removeAt(foundElement);
      }
    }

    m_idToShapeMap->remove(m_idToShapeMap->key((Shape *)imageObj));
  }


  Project::XmlHandler::XmlHandler(Project *project) {
    m_project = project;
    m_workOrder = NULL;
  }


  QMutex *Project::workOrderMutex() {
    return m_workOrderMutex;
  }


  bool Project::XmlHandler::startElement(const QString &namespaceURI, const QString &localName,
                                         const QString &qName, const QXmlAttributes &atts) {
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {

      if (localName == "project") {
        QString name = atts.value("name");
        if (!name.isEmpty()) {
          m_project->setName(name);
        }
      }
      else if (localName == "controlNets") {
        m_controls.append(new ControlList(m_project, reader()));
      }
      else if (localName == "imageList") {
        m_imageLists.append(new ImageList(m_project, reader()));
      }
      else if (localName == "shapeList") {
        m_shapeLists.append(new ShapeList(m_project, reader()));
      }
      else if (localName == "mapTemplateList") {
        m_mapTemplateLists.append( new TemplateList(m_project, reader()));
      }
      else if (localName == "regTemplateList") {
        m_regTemplateLists.append( new TemplateList(m_project, reader()));
      }
      //  workOrders are stored in history.xml, using same reader as project.xml
      else if (localName == "workOrder") {
        QString type = atts.value("type");

        m_workOrder = WorkOrderFactory::create(m_project, type);
        ASSERT(m_workOrder->metaObject()->className() == type);

        m_workOrder->read(reader());
      }
      //  warnings stored in warning.xml, using same reader as project.xml
      else if (localName == "warning") {
        QString warningText = atts.value("text");

        if (!warningText.isEmpty()) {
          m_project->warn(warningText);
        }
      }
      else if (localName == "directory") {
        m_project->directory()->load(reader());
      }
      else if (localName == "dockRestore") {
//    QVariant geo_data = QVariant(atts.value("geometry"));
//    restoreGeometry(geo_data);
//    QVariant layout_data = QVariant(atts.value("state"));
//    restoreState(layout_data);
      }

      else if (localName == "bundleSolutionInfo") {
        m_bundleSolutionInfos.append(new BundleSolutionInfo(m_project, reader()));
      }
      else if (localName == "activeImageList") {
        QString displayName = atts.value("displayName");
        m_project->setActiveImageList(displayName);
      }
      else if (localName == "activeControl") {
        // Find Control
        QString displayName = atts.value("displayName");
        m_project->setActiveControl(displayName);
      }
    }

    return true;
  }


  bool Project::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                       const QString &qName) {
    if (localName == "imageLists") {
      foreach (ImageList *imageList, m_imageLists) {
        m_project->imagesReady(*imageList);
      }
    }
    else if (localName == "shapeLists") {
      // TODO does this go here under project or should it be under shapes?
      foreach (ShapeList *shapeList, m_shapeLists) {
        m_project->shapesReady(*shapeList);
      }
    }
    else if (localName == "mapTemplateLists") {
      foreach (TemplateList *templateList, m_mapTemplateLists) {
        m_project->addTemplates(templateList);
      }
    }
    else if (localName == "regTemplateLists") {
      foreach (TemplateList *templateList, m_regTemplateLists) {
        m_project->addTemplates(templateList);
      }
    }
    else if (localName == "workOrder") {
      m_project->m_workOrderHistory->append(m_workOrder);
      m_workOrder = NULL;
    }
    else if (localName == "controlNets") {
      foreach (ControlList *list, m_controls) {
        foreach (Control *control, *list) {
          m_project->addControl(control);
        }
        delete list;
      }
      m_controls.clear();
    }
    else if (localName == "results") {
      foreach (BundleSolutionInfo *bundleInfo, m_bundleSolutionInfos) {
        m_project->addBundleSolutionInfo(bundleInfo);

        // If BundleSolutionInfo contains adjusted images, add to the project id map.
        if (bundleInfo->adjustedImages().count()) {
          foreach (ImageList *adjustedImageList, bundleInfo->adjustedImages()) {
            m_project->addImagesToIdMap(*adjustedImageList);
          }
        }
      }
    }
    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
}