ImportShapesWorkOrder.cpp

Go to the documentation of this file.

#include "ImportShapesWorkOrder.h"

#include <QDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QtConcurrentMap>

#include "Cube.h"
#include "CubeAttribute.h"
#include "FileName.h"
#include "IException.h"
#include "Project.h"
#include "ProjectItem.h"
#include "ProjectItemModel.h"
#include "SaveProjectWorkOrder.h"
#include "TextFile.h"

namespace Isis {

  ImportShapesWorkOrder::ImportShapesWorkOrder(Project *project) :
      WorkOrder(project) {
    // This workorder is synchronous and undoable.
    m_isUndoable = true;
    m_isSynchronous = false;
    m_newShapes = NULL;
    m_list = NULL;

    QAction::setText(tr("Import &Shape Models and Ground source..."));
    QUndoCommand::setText(tr("Import Shape Models and Ground source"));
    setModifiesDiskState(true);
  }


  ImportShapesWorkOrder::ImportShapesWorkOrder(const ImportShapesWorkOrder &other) :
      WorkOrder(other) {
    m_newShapes = NULL;
    m_list = other.m_list;
  }


  ImportShapesWorkOrder::~ImportShapesWorkOrder() {
    delete m_newShapes;
    m_newShapes = NULL;

    delete m_list;
    m_list = NULL;
  }


  ImportShapesWorkOrder *ImportShapesWorkOrder::clone() const {
    return new ImportShapesWorkOrder(*this);
  }


  bool ImportShapesWorkOrder::isExecutable(ProjectItem *item) {
    if (item) {
      return (item->text() == "Shapes");
    }

    return false;
  }


  bool ImportShapesWorkOrder::setupExecution() {
    WorkOrder::setupExecution();

    QStringList fileNames = QFileDialog::getOpenFileNames(
        qobject_cast<QWidget *>(parent()),
        tr("Import Shape Model Images"), "",
        tr("Isis cubes and list files (*.cub *.lis);;All Files (*)"));

    QStringList stateToSave;

    if (!fileNames.isEmpty()) {
      foreach (FileName fileName, fileNames) {
        if (fileName.extension() == "lis") {
          TextFile listFile(fileName.expanded());
          QString path = fileName.path();
          QString lineOfListFile;

          while (listFile.GetLine(lineOfListFile)) {
            if (lineOfListFile.contains(path)){
              stateToSave.append(lineOfListFile);
            }
            else {
              stateToSave.append(path + "/" + lineOfListFile);
            }
          }
        }
        else {
          stateToSave.append(fileName.original());
        }
      }
    }

    QMessageBox::StandardButton copyImagesAnswer = QMessageBox::No;
    if (!fileNames.isEmpty()) {
      copyImagesAnswer = QMessageBox::question(qobject_cast<QWidget *>(parent()),
               tr("Copy Shape Model Cubes into Project"),
               tr("Should images (DN data) be copied into project?"),
               QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel,
               QMessageBox::Yes);
    }

    bool copyDnData = (copyImagesAnswer == QMessageBox::Yes);

    stateToSave.prepend(copyDnData? "copy" : "nocopy");

    if (fileNames.count() > 1) {
      QUndoCommand::setText(tr("Import %1 Shape Model Images").arg(stateToSave.count() - 1));
    }
    else if (fileNames.count() == 1) {
      QUndoCommand::setText(tr("Import %1").arg(fileNames.first()));
    }

    setInternalData(stateToSave);

    bool doImport = fileNames.count() > 0 && copyImagesAnswer != QMessageBox::Cancel;

    return doImport;
  }


  void ImportShapesWorkOrder::undoExecution() {
    if (m_list && project()->shapes().size() > 0 ) {
      project()->waitForShapeReaderFinished();
      // Remove the shapes from disk.
      m_list->deleteFromDisk( project() );
      // Remove the shapes from the model, which updates the tree view.
      ProjectItem *currentItem =
          project()->directory()->model()->findItemData( QVariant::fromValue(m_list) );
      project()->directory()->model()->removeItem(currentItem);
    }
  }

  void ImportShapesWorkOrder::postUndoExecution() {
    if (m_list && project()->shapes().size() > 0 ) {
      foreach (Shape *shape, *m_list) {
        delete shape;
      }
      delete m_list;
    }
  }

  void ImportShapesWorkOrder::execute() {
    if (internalData().count() > 0) {
      importConfirmedShapes(internalData().mid(1), (internalData()[0] == "copy"));
      project()->setClean(false);
    }
  }

  void ImportShapesWorkOrder::postExecution() {
    if (m_newShapes && !m_newShapes->isEmpty()) {
      project()->addShapes(*m_newShapes);
      m_list = project()->shapes().last();

      delete m_newShapes;
      m_newShapes = NULL;
    }
    else {
      project()->undoStack()->undo();
    }

    if (m_warning != "") {
      project()->warn(m_warning);
    }
  }


  ImportShapesWorkOrder::OriginalFileToProjectCubeFunctor::OriginalFileToProjectCubeFunctor(
      QThread *guiThread, QDir destinationFolder, bool copyDnData) : m_errors(new IException),
      m_numErrors(new int(0)) {
    m_destinationFolder = destinationFolder;
    m_copyDnData = copyDnData;
    m_guiThread = guiThread;
  }


  ImportShapesWorkOrder::OriginalFileToProjectCubeFunctor::OriginalFileToProjectCubeFunctor(
      const OriginalFileToProjectCubeFunctor &other) : m_errors(other.m_errors),
      m_numErrors(other.m_numErrors) {
    m_destinationFolder = other.m_destinationFolder;
    m_copyDnData = other.m_copyDnData;
    m_guiThread = other.m_guiThread;
  }


  ImportShapesWorkOrder::OriginalFileToProjectCubeFunctor::~OriginalFileToProjectCubeFunctor() {
    m_destinationFolder = QDir();
    m_copyDnData = false;
    m_guiThread = NULL;
  }


  Cube *ImportShapesWorkOrder::OriginalFileToProjectCubeFunctor::operator()(
      const FileName &original) {
    Cube *result = NULL;

    if (*m_numErrors < 20) {
      try {
        QString destination = QFileInfo(m_destinationFolder, original.name())
                                .absoluteFilePath();
        Cube *input = new Cube(original, "r");

        if (m_copyDnData) {
          Cube *copiedCube = input->copy(destination, CubeAttributeOutput());
          delete input;
          input = copiedCube;
        }

        FileName externalLabelFile(destination);
        externalLabelFile = externalLabelFile.setExtension("ecub");

        Cube *projectShape = input->copy(externalLabelFile, CubeAttributeOutput("+External"));

        if (m_copyDnData) {
          // Make sure the external label has a fully relative path to the DN data
          projectShape->relocateDnData(FileName(destination).name());
        }

        //  Set new ecub to readOnly.  When closing cube, the labels were being re-written because
        // the cube was read/write. This caused a segfault when imported large number of images
        // because of a label template file being opened too many times. 
        projectShape->reopen();

        delete input;

        result = projectShape;
      }
      catch (IException &e) {
        m_errorsLock.lock();

        m_errors->append(e);
        (*m_numErrors)++;

        m_errorsLock.unlock();
      }
    }

    return result;
  }


  IException ImportShapesWorkOrder::OriginalFileToProjectCubeFunctor::errors() const {
    IException result;

    result.append(*m_errors);

    if (*m_numErrors >= 20) {
      result.append(
          IException(IException::Unknown,
                     tr("Aborted import shapes due to a high number of errors"),
                     _FILEINFO_));
    }
    return result;
  }


  void ImportShapesWorkOrder::importConfirmedShapes(QStringList confirmedShapes,
                                                             bool copyDnData) {
    try {
      if (!confirmedShapes.isEmpty()) {
        QDir folder = project()->addShapeFolder("import");

        setProgressRange(0, confirmedShapes.count());

        m_newShapes = new ShapeList;
        m_newShapes->reserve(confirmedShapes.count());

        QStringList confirmedShapesFileNames;
        QStringList confirmedShapesIds;

        foreach (QString confirmedShape, confirmedShapes) {
          QStringList fileNameAndId = confirmedShape.split(",");

          confirmedShapesFileNames.append(fileNameAndId.first());

          if (fileNameAndId.count() == 2) {
            confirmedShapesIds.append(fileNameAndId.last());
          }
          else {
            confirmedShapesIds.append(QString());
          }
        }

        OriginalFileToProjectCubeFunctor functor(thread(), folder, copyDnData);
        QFuture<Cube *> future = QtConcurrent::mapped(confirmedShapesFileNames, functor);

        QStringList newInternalData;
        newInternalData.append(internalData().first());

        QThreadPool::globalInstance()->releaseThread();
        for (int i = 0; i < confirmedShapes.count(); i++) {
          setProgressValue(i);

          Cube *cube = future.resultAt(i);

          if (cube) {
            Shape *newShape = new Shape(future.resultAt(i));

            if (confirmedShapesIds[i].isEmpty()) {
              confirmedShapesIds[i] = newShape->id();
            }
            else {
              newShape->setId(confirmedShapesIds[i]);
            }

            QStringList ShapeInternalData;
            ShapeInternalData.append(confirmedShapesFileNames[i]);
            ShapeInternalData.append(confirmedShapesIds[i]);

            newInternalData.append(ShapeInternalData.join(","));

            m_newShapes->append(newShape);

            newShape->moveToThread(thread());
            newShape->displayProperties()->moveToThread(thread());

            newShape->closeCube();
          }
        }
        QThreadPool::globalInstance()->reserveThread();

        m_warning = functor.errors().toString();

        m_newShapes->moveToThread(thread());

        setInternalData(newInternalData);
      }
    }
    catch (IException &e) {
      QMessageBox::critical(NULL, tr("Error"), tr(e.what()));
    }
  }
}