BundleObservationVector.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "BundleObservationVector.h"
 
#include <algorithm>
 
#include <QDebug>
 
#include "BundleObservation.h"
#include "IsisBundleObservation.h"
#include "Camera.h"
#include "CsmBundleObservation.h"
#include "IException.h"
 
namespace Isis {
 
  BundleObservationVector::BundleObservationVector() {
  }
 
 
  BundleObservationVector::BundleObservationVector(const BundleObservationVector &src)
      :QVector<BundleObservationQsp>(src) {
    m_observationNumberToObservationMap = src.m_observationNumberToObservationMap;
    m_imageSerialToObservationMap = src.m_imageSerialToObservationMap;
    m_instIdToObservationMap = src.m_instIdToObservationMap;
  }
 
 
  BundleObservationVector::~BundleObservationVector() {
    clear();
  }
 
 
  BundleObservationVector &BundleObservationVector::operator=(const BundleObservationVector &src) {
    if (&src != this) {
      QVector<BundleObservationQsp>::operator=(src);
      m_observationNumberToObservationMap = src.m_observationNumberToObservationMap;
      m_imageSerialToObservationMap = src.m_imageSerialToObservationMap;
      m_instIdToObservationMap = src.m_instIdToObservationMap;
    }
    return *this;
  }
 
 
  BundleObservationQsp BundleObservationVector::addNew(BundleImageQsp bundleImage,
                                                       QString observationNumber,
                                                       QString instrumentId,
                                                       BundleSettingsQsp bundleSettings) {
 
    BundleObservationQsp bundleObservation;
    bool addToExisting = false;
 
    if (bundleSettings->solveObservationMode() &&
        m_observationNumberToObservationMap.contains(observationNumber)) {
      bundleObservation = m_observationNumberToObservationMap.value(observationNumber);
 
      addToExisting = true;
    }
 
    if (addToExisting) {
      // if we have already added a BundleObservation with this number, we have to add the new
      // BundleImage to this observation
      bundleObservation->append(bundleImage);
 
      bundleImage->setParentObservation(bundleObservation);
 
      // update observation number to observation ptr map
      m_observationNumberToObservationMap.insertMulti(observationNumber, bundleObservation);
 
      // update image serial number to observation ptr map
      m_imageSerialToObservationMap.insertMulti(bundleImage->serialNumber(), bundleObservation);
    }
    else {
      // create new BundleObservation and append to this vector
 
      bool isIsisObservation = bundleImage->camera()->GetCameraType() != Camera::Csm;
 
      if (isIsisObservation) {
        bundleObservation.reset(new IsisBundleObservation(bundleImage,
                                                      observationNumber,
                                                      instrumentId,
                                                      bundleSettings->bundleTargetBody()));
      }
      else {
        bundleObservation.reset(new CsmBundleObservation(bundleImage,
                                                         observationNumber,
                                                         instrumentId,
                                                         bundleSettings->bundleTargetBody()));
      }
 
      if (!bundleObservation) {
        QString message = "Unable to allocate new BundleObservation ";
        message += "for " + bundleImage->fileName();
        throw IException(IException::Programmer, message, _FILEINFO_);
      }
 
      // Find the bundle observation solve settings for this new observation
      BundleObservationSolveSettings solveSettings;
      // When there is only one bundle observation solve setting, use it for all observations
      if ( bundleSettings->numberSolveSettings() == 1) {
        solveSettings = bundleSettings->observationSolveSettings(0);
      }
      // Otherwise, we want to grab the bundle observation solve settings that is associated with
      // the observation number for this new observation
      else {
        solveSettings = bundleSettings->observationSolveSettings(observationNumber);
      }
 
      bundleObservation->setSolveSettings(solveSettings);
 
      bundleObservation->setIndex(size());
 
      bundleImage->setParentObservation(bundleObservation);
 
      append(bundleObservation);
 
      if (isIsisObservation) {
        QSharedPointer<IsisBundleObservation> isisObs = qSharedPointerDynamicCast<IsisBundleObservation>(bundleObservation);
        isisObs->initializeExteriorOrientation();
        if (bundleSettings->solveTargetBody()) {
          isisObs->initializeBodyRotation();
        }
      }
 
      // update observation number to observation ptr map
      m_observationNumberToObservationMap.insertMulti(observationNumber, bundleObservation);
 
      // update image serial number to observation ptr map
      m_imageSerialToObservationMap.insertMulti(bundleImage->serialNumber(), bundleObservation);
 
      // update instrument ID to observation ptr map
      // separate held observations out into their own entry
      if (bundleObservation->numberParameters() == 0) {
        m_instIdToObservationMap.insertMulti("held", bundleObservation);
      }
      else {
        m_instIdToObservationMap.insertMulti(instrumentId, bundleObservation);
      }
 
    }
    return bundleObservation;
  }
 
 
  int BundleObservationVector::numberParameters() {
    int numParameters = 0;
 
    for (int i = 0; i < size(); i++) {
      numParameters += at(i)->numberParameters();
    }
    return numParameters;
  }
 
 
  BundleObservationQsp BundleObservationVector::
      observationByCubeSerialNumber(QString cubeSerialNumber) {
    BundleObservationQsp bundleObservation;
 
    if (m_imageSerialToObservationMap.contains(cubeSerialNumber))
      bundleObservation = m_imageSerialToObservationMap.value(cubeSerialNumber);
 
    return bundleObservation;
  }
 
 
  QList<QString> BundleObservationVector::instrumentIds() const {
    return m_instIdToObservationMap.uniqueKeys();
  }
 
 
  QList<BundleObservationQsp> BundleObservationVector::
      observationsByInstId(QString instrumentId) const {
    QList<BundleObservationQsp> list = m_instIdToObservationMap.values(instrumentId);
    // multimap returns them in reverse order they were put in, so invert them to preserve order
    std::reverse(std::begin(list), std::end(list));
    return list;
  }
}