BundleSettings.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "BundleSettings.h"
 
#include <QDataStream>
#include <QDebug>
#include <QList>
#include <QString>
#include <QtGlobal> // qMax()
#include <QUuid>
#include <QXmlStreamWriter>
#include <QXmlInputSource>
 
#include "BundleObservationSolveSettings.h"
#include "IException.h"
#include "IString.h"
#include "Project.h" // currently used for xml handler
#include "PvlKeyword.h"
#include "PvlObject.h"
#include "SpecialPixel.h"
#include "XmlStackedHandlerReader.h"
 
namespace Isis {
 
  BundleSettings::BundleSettings() {
    init();
    BundleObservationSolveSettings defaultSolveSettings;
    m_observationSolveSettings.append(defaultSolveSettings);
  }
 
  void BundleSettings::init() {
    m_validateNetwork = true;
 
    m_solveObservationMode = false;
    m_solveRadius          = false;
    m_updateCubeLabel      = false;
    m_errorPropagation     = false;
    m_createInverseMatrix  = false;
    m_cubeList             =    "";
    m_outlierRejection     = false;
    m_outlierRejectionMultiplier = 3.0;
 
    // Parameter Uncertainties (Weighting)
    // The units are meters for either coordinate type
    m_globalPointCoord1AprioriSigma  = Isis::Null;
    m_globalPointCoord2AprioriSigma = Isis::Null;
    m_globalPointCoord3AprioriSigma    = Isis::Null;
 
    // Convergence Criteria
    m_convergenceCriteria = BundleSettings::Sigma0;
    m_convergenceCriteriaThreshold = 1.0e-10;
    m_convergenceCriteriaMaximumIterations = 50;
 
    // Maximum Likelihood Estimation Options no default in the constructor - must be set.
    m_maximumLikelihood.clear();
 
    // Self Calibration ??? (from ipce only)
 
    // Target Body
    m_solveTargetBody = false;
//    m_solveTargetBodyPolePosition = false;
//    m_solveTargetBodyZeroMeridian = false;
//    m_solveTargetBodyRotationRate = false;
//    m_solveTargetBodyRadiusMethod = None;
 
    // Control Points
    m_cpCoordTypeReports = SurfacePoint::Latitudinal;
    m_cpCoordTypeBundle = SurfacePoint::Latitudinal;
 
    // Output Options
    m_outputFilePrefix = "";
  }
 
 
  BundleSettings::BundleSettings(Project *project,
                                 XmlStackedHandlerReader *xmlReader) {
    init();
    xmlReader->setErrorHandler(new XmlHandler(this, project));
    xmlReader->pushContentHandler(new XmlHandler(this, project));
  }
 
 
  BundleSettings::BundleSettings(const BundleSettings &other)
      : m_validateNetwork(other.m_validateNetwork),
        m_cubeList(other.m_cubeList),
        m_solveObservationMode(other.m_solveObservationMode),
        m_solveRadius(other.m_solveRadius),
        m_updateCubeLabel(other.m_updateCubeLabel),
        m_errorPropagation(other.m_errorPropagation),
        m_createInverseMatrix(other.m_createInverseMatrix),
        m_outlierRejection(other.m_outlierRejection),
        m_outlierRejectionMultiplier(other.m_outlierRejectionMultiplier),
        m_globalPointCoord1AprioriSigma(other.m_globalPointCoord1AprioriSigma),
        m_globalPointCoord2AprioriSigma(other.m_globalPointCoord2AprioriSigma),
        m_globalPointCoord3AprioriSigma(other.m_globalPointCoord3AprioriSigma),
        m_observationSolveSettings(other.m_observationSolveSettings),
        m_convergenceCriteria(other.m_convergenceCriteria),
        m_convergenceCriteriaThreshold(other.m_convergenceCriteriaThreshold),
        m_convergenceCriteriaMaximumIterations(other.m_convergenceCriteriaMaximumIterations),
        m_maximumLikelihood(other.m_maximumLikelihood),
        m_solveTargetBody(other.m_solveTargetBody),
        m_bundleTargetBody(other.m_bundleTargetBody),
        m_cpCoordTypeReports(other.m_cpCoordTypeReports),
        m_cpCoordTypeBundle(other.m_cpCoordTypeBundle),
        m_outputFilePrefix(other.m_outputFilePrefix){
  }
 
 
  BundleSettings::~BundleSettings() {
  }
 
 
  BundleSettings &BundleSettings::operator=(const BundleSettings &other) {
    if (&other != this) {
      m_validateNetwork = other.m_validateNetwork;
      m_cubeList = other.m_cubeList;
      m_solveObservationMode = other.m_solveObservationMode;
      m_solveRadius = other.m_solveRadius;
      m_updateCubeLabel = other.m_updateCubeLabel;
      m_errorPropagation = other.m_errorPropagation;
      m_createInverseMatrix = other.m_createInverseMatrix;
      m_outlierRejection = other.m_outlierRejection;
      m_outlierRejectionMultiplier = other.m_outlierRejectionMultiplier;
      m_globalPointCoord1AprioriSigma = other.m_globalPointCoord1AprioriSigma;
      m_globalPointCoord2AprioriSigma = other.m_globalPointCoord2AprioriSigma;
      m_globalPointCoord3AprioriSigma = other.m_globalPointCoord3AprioriSigma;
      m_observationSolveSettings = other.m_observationSolveSettings;
      m_convergenceCriteria = other.m_convergenceCriteria;
      m_convergenceCriteriaThreshold = other.m_convergenceCriteriaThreshold;
      m_convergenceCriteriaMaximumIterations = other.m_convergenceCriteriaMaximumIterations;
      m_solveTargetBody = other.m_solveTargetBody;
      m_bundleTargetBody = other.m_bundleTargetBody;
      m_cpCoordTypeReports = other.m_cpCoordTypeReports;
      m_cpCoordTypeBundle = other.m_cpCoordTypeBundle;
      m_maximumLikelihood = other.m_maximumLikelihood;
      m_outputFilePrefix = other.m_outputFilePrefix;
    }
    return *this;
  }
 
 
  void BundleSettings::setValidateNetwork(bool validate) {
    m_validateNetwork = validate;
  }
 
 
  bool BundleSettings::validateNetwork() const {
    return m_validateNetwork;
  }
 
 
  void BundleSettings::setCubeList(QString cubeList)    {
    m_cubeList = cubeList;
  }
 
 
  QString BundleSettings::cubeList() const {
    return m_cubeList;
  }
 
 
  // =============================================================================================//
  // ======================== Solve Options ======================================================//
  // =============================================================================================//
 
  void BundleSettings::setSolveOptions(bool solveObservationMode,
                                       bool updateCubeLabel,
                                       bool errorPropagation,
                                       bool solveRadius,
                                       SurfacePoint::CoordinateType coordTypeBundle,
                                       SurfacePoint::CoordinateType coordTypeReports,
                                       double globalPointCoord1AprioriSigma,
                                       double globalPointCoord2AprioriSigma,
                                       double globalPointCoord3AprioriSigma) {
    m_solveObservationMode = solveObservationMode;
    m_solveRadius = solveRadius;
    m_updateCubeLabel = updateCubeLabel;
    m_errorPropagation = errorPropagation;
    m_cpCoordTypeReports = coordTypeReports;
    m_cpCoordTypeBundle = coordTypeBundle;
    // m_cpCoordTypeBundle = SurfacePoint::Latitudinal;
 
    if (globalPointCoord1AprioriSigma > 0.0) { // otherwise, we leave as default Isis::Null
      m_globalPointCoord1AprioriSigma = globalPointCoord1AprioriSigma;
    }
    else {
      m_globalPointCoord1AprioriSigma = Isis::Null;
    }
 
    if (globalPointCoord2AprioriSigma > 0.0) {
      m_globalPointCoord2AprioriSigma = globalPointCoord2AprioriSigma;
    }
    else {
      m_globalPointCoord2AprioriSigma = Isis::Null;
    }
 
    // This is ugly.  *** TODO *** Revisit this section to try to find a cleaner solution.
    // I think we will have to do similar checking other places.
    // See pvlObject, save,   (DAC 03-29-2017)
    if (coordTypeBundle == SurfacePoint::Latitudinal) {
      if (m_solveRadius && globalPointCoord3AprioriSigma > 0.0) {
        m_globalPointCoord3AprioriSigma = globalPointCoord3AprioriSigma;
      }
      else {
      m_globalPointCoord3AprioriSigma = Isis::Null;
      }
    }
    else if (coordTypeBundle == SurfacePoint::Rectangular) {
      if (globalPointCoord3AprioriSigma > 0.0) {
        m_globalPointCoord3AprioriSigma = globalPointCoord3AprioriSigma;
      }
      else {
      m_globalPointCoord3AprioriSigma = Isis::Null;
      }
    }
  }
 
 
  void BundleSettings::setOutlierRejection(bool outlierRejection, double multiplier) {
    m_outlierRejection = outlierRejection;
    if (m_outlierRejection) {
      m_outlierRejectionMultiplier = multiplier;
    }
    else {
      m_outlierRejectionMultiplier = 3.0;
    }
  }
 
 
  void BundleSettings::setObservationSolveOptions(
      QList<BundleObservationSolveSettings> obsSolveSettingsList) {
    m_observationSolveSettings = obsSolveSettingsList;
  }
 
 
  SurfacePoint::CoordinateType BundleSettings::controlPointCoordTypeReports() const {
    return (m_cpCoordTypeReports);
  }
 
 
  SurfacePoint::CoordinateType BundleSettings::controlPointCoordTypeBundle() const {
    return (m_cpCoordTypeBundle);
  }
 
 
  bool BundleSettings::createInverseMatrix() const {
    return (m_errorPropagation && m_createInverseMatrix);
  }
 
 
  bool BundleSettings::outlierRejection() const {
    return m_outlierRejection;
  }
 
 
  bool BundleSettings::solveObservationMode() const {
    return m_solveObservationMode;
  }
 
 
  bool BundleSettings::solveRadius() const {
    return m_solveRadius;
  }
 
 
  bool BundleSettings::updateCubeLabel() const {
    return m_updateCubeLabel;
  }
 
 
  bool BundleSettings::errorPropagation() const {
    return m_errorPropagation;
  }
 
 
  void BundleSettings::setCreateInverseMatrix(bool createMatrixFile) {
    m_createInverseMatrix = createMatrixFile;
  }
 
 
  double BundleSettings::outlierRejectionMultiplier() const {
    return m_outlierRejectionMultiplier;
  }
 
 
  double BundleSettings::globalPointCoord1AprioriSigma() const {
    return m_globalPointCoord1AprioriSigma;
  }
 
 
  double BundleSettings::globalPointCoord2AprioriSigma() const {
    return m_globalPointCoord2AprioriSigma;
  }
 
 
  double BundleSettings::globalPointCoord3AprioriSigma() const {
    return m_globalPointCoord3AprioriSigma;
  }
 
 
  int BundleSettings::numberSolveSettings() const {
     return m_observationSolveSettings.size();
  }
 
 
  BundleObservationSolveSettings
      BundleSettings::observationSolveSettings(QString observationNumber) const {
 
    BundleObservationSolveSettings defaultSolveSettings;
 
    for (int i = 0; i < numberSolveSettings(); i++) {
      if (m_observationSolveSettings[i].observationNumbers().contains(observationNumber)) {
        return m_observationSolveSettings[i];
      }
    }
    return defaultSolveSettings;
  }
 
 
  BundleObservationSolveSettings
      BundleSettings::observationSolveSettings(int n) const {
 
    if (n >= 0 && n < numberSolveSettings()) {
      return m_observationSolveSettings[n];
    }
    QString msg = "Unable to find BundleObservationSolveSettings with index = ["
                  + toString(n) + "].";
    throw IException(IException::Unknown, msg, _FILEINFO_);
  }
 
 
  QList<BundleObservationSolveSettings> BundleSettings::observationSolveSettings() const {
    return m_observationSolveSettings;
  }
 
 
  // =============================================================================================//
  // ======================== Convergence Criteria ===============================================//
  // =============================================================================================//
 
  BundleSettings::ConvergenceCriteria
      BundleSettings::stringToConvergenceCriteria(QString criteria) {
    if (criteria.compare("SIGMA0", Qt::CaseInsensitive) == 0) {
      return BundleSettings::Sigma0;
    }
    else if (criteria.compare("PARAMETERCORRECTIONS", Qt::CaseInsensitive) == 0) {
      return BundleSettings::ParameterCorrections;
    }
    else throw IException(IException::Programmer,
                          "Unknown bundle convergence criteria [" + criteria + "].",
                          _FILEINFO_);
  }
 
 
  QString BundleSettings::convergenceCriteriaToString(
              BundleSettings::ConvergenceCriteria criteria) {
    if (criteria == Sigma0)                    return "Sigma0";
    else if (criteria == ParameterCorrections) return "ParameterCorrections";
    else  throw IException(IException::Programmer,
                           "Unknown convergence criteria enum [" + toString(criteria) + "].",
                           _FILEINFO_);
  }
 
 
  void BundleSettings::setConvergenceCriteria(BundleSettings::ConvergenceCriteria criteria,
                                              double threshold,
                                              int maximumIterations) {
    m_convergenceCriteria = criteria;
    m_convergenceCriteriaThreshold = threshold;
    m_convergenceCriteriaMaximumIterations = maximumIterations;
  }
 
 
  BundleSettings::ConvergenceCriteria BundleSettings::convergenceCriteria() const {
    return m_convergenceCriteria;
  }
 
 
  double BundleSettings::convergenceCriteriaThreshold() const {
    return m_convergenceCriteriaThreshold;
  }
 
 
  int BundleSettings::convergenceCriteriaMaximumIterations() const {
    return m_convergenceCriteriaMaximumIterations;
  }
 
 
 
  // =============================================================================================//
  // ======================== Parameter Uncertainties (Weighting) ================================//
  // =============================================================================================//
//   void BundleSettings::setGlobalLatitudeAprioriSigma(double sigma) {
//     m_globalLatitudeAprioriSigma = sigma;
//   }
//
//
//
//   void BundleSettings::setGlobalLongitudeAprioriSigma(double sigma) {
//     m_globalLongitudeAprioriSigma = sigma;
//   }
//
//
//
//   void BundleSettings::setGlobalRadiiAprioriSigma(double sigma) {
//     m_globalRadiusAprioriSigma = sigma;
//   }
 
 
  // =============================================================================================//
  // ======================== Maximum Likelihood Estimation Options ==============================//
  // =============================================================================================//
 
 
  void BundleSettings::addMaximumLikelihoodEstimatorModel(MaximumLikelihoodWFunctions::Model model,
                                                          double maxModelCQuantile) {
 
    if (m_maximumLikelihood.size() == 0 && model > MaximumLikelihoodWFunctions::HuberModified) {
      QString msg = "For bundle adjustments with multiple maximum likelihood estimators, the first "
                    "model must be of type HUBER or HUBER_MODIFIED.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    m_maximumLikelihood.append(qMakePair(model, maxModelCQuantile));
  }
 
 
  QList< QPair< MaximumLikelihoodWFunctions::Model, double > >
      BundleSettings::maximumLikelihoodEstimatorModels() const {
    return m_maximumLikelihood;
  }
 
 
  // =============================================================================================//
  // ======================== Self Calibration ??? (from ipce only) =========================//
  // =============================================================================================//
 
  // =============================================================================================//
  // ======================== Target Body ??? (from ipce only) ==============================//
  // =============================================================================================//
 
  void BundleSettings::setBundleTargetBody(BundleTargetBodyQsp bundleTargetBody) {
    m_bundleTargetBody = bundleTargetBody;
  }
 
 
  BundleTargetBodyQsp BundleSettings::bundleTargetBody() const {
    return m_bundleTargetBody;
  }
 
 
//  bool BundleSettings::solveTargetBodyPolePosition() const {
//    return m_solveTargetBodyPolePosition;
//  }
 
 
  int BundleSettings::numberTargetBodyParameters() const {
    if (!m_bundleTargetBody)
      return 0;
 
    return m_bundleTargetBody->numberParameters();
  }
 
 
  bool BundleSettings::solveTargetBody() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    else {
      return (m_bundleTargetBody->numberParameters() > 0);
    }
  }
 
 
  bool BundleSettings::solvePoleRA() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleRA();
  }
 
 
  bool BundleSettings::solvePoleRAVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleRAVelocity();
  }
 
 
  bool BundleSettings::solvePoleDec() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleDec();
  }
 
 
  bool BundleSettings::solvePoleDecVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePoleDecVelocity();
  }
 
 
  bool BundleSettings::solvePM() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePM();
  }
 
 
  bool BundleSettings::solvePMVelocity() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePMVelocity();
  }
 
 
  bool BundleSettings::solvePMAcceleration() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solvePMAcceleration();
  }
 
 
  bool BundleSettings::solveTriaxialRadii() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solveTriaxialRadii();
  }
 
 
  bool BundleSettings::solveMeanRadius() const {
    if (!m_bundleTargetBody) {
      return false;
    }
    return m_bundleTargetBody->solveMeanRadius();
  }
 
 
//  void BundleSettings::setTargetBodySolveOptions(bool solveTargetBodyPolePosition,
//                                                 double aprioriRaPole, double sigmaRaPole,
//                                                 double aprioriDecPole, double sigmaDecPole,
//                                                 bool solveTargetBodyZeroMeridian,
//                                                 double aprioriW0, double sigmaW0,
//                                                 bool solveTargetBodyRotationRate,
//                                                 double aprioriWDot, double sigmaWDot,
//                                                 TargetRadiiSolveMethod solveRadiiMethod,
//                                                 double aprioriRadiusA, double sigmaRadiusA,
//                                                 double aprioriRadiusB, double sigmaRadiusB,
//                                                 double aprioriRadiusC, double sigmaRadiusC,
//                                                 double aprioriMeanRadius, double sigmaMeanRadius) {
 
 
//    m_solveTargetBody = true;
//    m_solveTargetBodyPolePosition = solveTargetBodyPolePosition;
//    m_aprioriRaPole = aprioriRaPole;
//    m_sigmaRaPole = sigmaRaPole;
//    m_aprioriDecPole = aprioriDecPole;
//    m_sigmaDecPole = sigmaDecPole;
//    m_solveTargetBodyZeroMeridian =solveTargetBodyZeroMeridian;
//    m_aprioriW0 = aprioriW0;
//    m_sigmaW0 = sigmaW0;
//    m_solveTargetBodyRotationRate = solveTargetBodyRotationRate;
//    m_aprioriWDot = aprioriWDot;
//    m_sigmaWDot = sigmaWDot;
//    m_solveTargetBodyRadiusMethod = solveRadiiMethod;
//    m_aprioriRadiusA = aprioriRadiusA;
//    m_sigmaRadiusA = sigmaRadiusA;
//    m_aprioriRadiusB = aprioriRadiusB;
//    m_sigmaRadiusB = sigmaRadiusB;
//    m_aprioriRadiusC = aprioriRadiusC;
//    m_sigmaRadiusC = sigmaRadiusC;
//    m_aprioriMeanRadius = aprioriMeanRadius;
//    m_sigmaMeanRadius = sigmaMeanRadius;
 
//    m_bundleTargetBody->setSolveSettings(solveTargetBodyPolePosition, aprioriRaPole, sigmaRaPole,
//                                         aprioriDecPole, sigmaDecPole, solveTargetBodyZeroMeridian,
//                                         aprioriW0, sigmaW0, solveTargetBodyRotationRate,
//                                         aprioriWDot, sigmaWDot, solveRadiiMethod, aprioriRadiusA,
//                                         sigmaRadiusA, aprioriRadiusB, sigmaRadiusB, aprioriRadiusC,
//                                         sigmaRadiusC, aprioriMeanRadius, sigmaMeanRadius);
//  }
 
 
  // =============================================================================================//
  // ========================= Output Options (from Jigsaw only) ================================//
  // =============================================================================================//
  void BundleSettings::setOutputFilePrefix(QString outputFilePrefix) {
    m_outputFilePrefix = outputFilePrefix;
  }
 
 
  QString BundleSettings::outputFilePrefix() const {
    return m_outputFilePrefix;
  }
 
 
  void BundleSettings::save(QXmlStreamWriter &stream, const Project *project) const {
    stream.writeStartElement("bundleSettings");
 
    stream.writeStartElement("globalSettings");
 
    stream.writeTextElement("validateNetwork", toString(validateNetwork()));
 
    stream.writeStartElement("solveOptions");
    stream.writeAttribute("solveObservationMode", toString(solveObservationMode()));
    stream.writeAttribute("solveRadius", toString(solveRadius()));
    stream.writeAttribute("controlPointCoordTypeReports", toString(controlPointCoordTypeReports()));
    stream.writeAttribute("controlPointCoordTypeBundle", toString(controlPointCoordTypeBundle()));
    stream.writeAttribute("updateCubeLabel", toString(updateCubeLabel()));
    stream.writeAttribute("errorPropagation", toString(errorPropagation()));
    stream.writeAttribute("createInverseMatrix", toString(createInverseMatrix()));
    stream.writeEndElement();
 
    stream.writeStartElement("aprioriSigmas");
    if (IsSpecial(globalPointCoord1AprioriSigma())) {
      stream.writeAttribute("pointCoord1", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord1", toString(globalPointCoord1AprioriSigma()));
    }
    if (IsSpecial(globalPointCoord2AprioriSigma())) {
      stream.writeAttribute("pointCoord2", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord2", toString(globalPointCoord2AprioriSigma()));
    }
    if (IsSpecial(globalPointCoord3AprioriSigma())) {
      stream.writeAttribute("pointCoord3", "N/A");
    }
    else {
      stream.writeAttribute("pointCoord3", toString(globalPointCoord3AprioriSigma()));
    }
    stream.writeEndElement();
 
    stream.writeStartElement("outlierRejectionOptions");
    stream.writeAttribute("rejection", toString(outlierRejection()));
    if (outlierRejection()) {
      stream.writeAttribute("multiplier", toString(outlierRejectionMultiplier()));
    }
    else {
      stream.writeAttribute("multiplier", "N/A");
    }
    stream.writeEndElement();
 
    stream.writeStartElement("convergenceCriteriaOptions");
    stream.writeAttribute("convergenceCriteria",
                          convergenceCriteriaToString(convergenceCriteria()));
    stream.writeAttribute("threshold",
                          toString(convergenceCriteriaThreshold()));
    stream.writeAttribute("maximumIterations",
                          toString(convergenceCriteriaMaximumIterations()));
    stream.writeEndElement();
 
    stream.writeStartElement("maximumLikelihoodEstimation");
    for (int i = 0; i < m_maximumLikelihood.size(); i++) {
      stream.writeStartElement("model");
      stream.writeAttribute("type",
                          MaximumLikelihoodWFunctions::modelToString(m_maximumLikelihood[i].first));
      stream.writeAttribute("quantile", toString(m_maximumLikelihood[i].second));
      stream.writeEndElement();
    }
    stream.writeEndElement();
 
    stream.writeStartElement("outputFileOptions");
    stream.writeAttribute("fileNamePrefix", outputFilePrefix());
    stream.writeEndElement();
 
    stream.writeEndElement(); // end global settings
 
    if (!m_observationSolveSettings.isEmpty()) {
      stream.writeStartElement("observationSolveSettingsList");
      for (int i = 0; i < m_observationSolveSettings.size(); i++) {
        m_observationSolveSettings[i].save(stream, project);
      }
      stream.writeEndElement();
    }
    else {
      // throw error??? should not write if no observation settings...
    }
    stream.writeEndElement();
  }
 
 
  BundleSettings::XmlHandler::XmlHandler(BundleSettings *bundleSettings, Project *project) {
    m_xmlHandlerBundleSettings = bundleSettings;
    m_xmlHandlerProject = project;
    m_xmlHandlerCharacters = "";
    m_xmlHandlerObservationSettings.clear();
  }
 
 
  BundleSettings::XmlHandler::~XmlHandler() {
  }
 
 
  bool BundleSettings::XmlHandler::startElement(const QString &namespaceURI,
                                                const QString &localName,
                                                const QString &qName,
                                                const QXmlAttributes &attributes) {
    m_xmlHandlerCharacters = "";
 
    if (XmlStackedHandler::startElement(namespaceURI, localName, qName, attributes)) {
 
      if (localName == "solveOptions") {
 
        QString solveObservationModeStr = attributes.value("solveObservationMode");
        if (!solveObservationModeStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_solveObservationMode = toBool(solveObservationModeStr);
        }
 
        QString solveRadiusStr = attributes.value("solveRadius");
        if (!solveRadiusStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_solveRadius = toBool(solveRadiusStr);
        }
 
        QString coordTypeReportsStr = attributes.value("controlPointCoordinateTypeReports");
        if (!coordTypeReportsStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_cpCoordTypeReports =
            SurfacePoint::stringToCoordinateType(coordTypeReportsStr);
        }
 
        QString coordTypeBundleStr = attributes.value("controlPointCoordinateTypeBundle");
        if (!coordTypeBundleStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_cpCoordTypeBundle =
            SurfacePoint::stringToCoordinateType(coordTypeBundleStr);
        }
 
        QString updateCubeLabelStr = attributes.value("updateCubeLabel");
        if (!updateCubeLabelStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_updateCubeLabel = toBool(updateCubeLabelStr);
        }
 
        QString errorPropagationStr = attributes.value("errorPropagation");
        if (!errorPropagationStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_errorPropagation = toBool(errorPropagationStr);
        }
 
        QString createInverseMatrixStr = attributes.value("createInverseMatrix");
        if (!createInverseMatrixStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_createInverseMatrix = toBool(createInverseMatrixStr);
        }
      }
      else if (localName == "aprioriSigmas") {
 
        QString globalPointCoord1AprioriSigmaStr = attributes.value("pointCoord1");
        m_xmlHandlerBundleSettings->m_globalPointCoord1AprioriSigma = Isis::Null;
        // TODO: why do I need to init this one and not other sigmas???
        if (!globalPointCoord1AprioriSigmaStr.isEmpty()) {
          if (globalPointCoord1AprioriSigmaStr == "N/A") {
            m_xmlHandlerBundleSettings->m_globalPointCoord1AprioriSigma = Isis::Null;
          }
          else {
            m_xmlHandlerBundleSettings->m_globalPointCoord1AprioriSigma
                = toDouble(globalPointCoord1AprioriSigmaStr);
          }
        }
 
        QString globalPointCoord2AprioriSigmaStr = attributes.value("pointCoord2");
        if (!globalPointCoord2AprioriSigmaStr.isEmpty()) {
          if (globalPointCoord2AprioriSigmaStr == "N/A") {
            m_xmlHandlerBundleSettings->m_globalPointCoord2AprioriSigma = Isis::Null;
          }
          else {
            m_xmlHandlerBundleSettings->m_globalPointCoord2AprioriSigma
                = toDouble(globalPointCoord2AprioriSigmaStr);
          }
        }
 
        QString globalPointCoord3AprioriSigmaStr = attributes.value("radius");
        if (!globalPointCoord3AprioriSigmaStr.isEmpty()) {
          if (globalPointCoord3AprioriSigmaStr == "N/A") {
            m_xmlHandlerBundleSettings->m_globalPointCoord3AprioriSigma = Isis::Null;
          }
          else {
            m_xmlHandlerBundleSettings->m_globalPointCoord3AprioriSigma
                = toDouble(globalPointCoord3AprioriSigmaStr);
          }
        }
      }
      else if (localName == "outlierRejectionOptions") {
        QString outlierRejectionStr = attributes.value("rejection");
        if (!outlierRejectionStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_outlierRejection = toBool(outlierRejectionStr);
        }
 
        QString outlierRejectionMultiplierStr = attributes.value("multiplier");
        if (!outlierRejectionMultiplierStr.isEmpty()) {
          if (outlierRejectionMultiplierStr != "N/A") {
            m_xmlHandlerBundleSettings->m_outlierRejectionMultiplier
                = toDouble(outlierRejectionMultiplierStr);
          }
          else {
            m_xmlHandlerBundleSettings->m_outlierRejectionMultiplier = 3.0;
          }
        }
      }
      else if (localName == "convergenceCriteriaOptions") {
 
        QString convergenceCriteriaStr = attributes.value("convergenceCriteria");
        if (!convergenceCriteriaStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_convergenceCriteria
              = stringToConvergenceCriteria(convergenceCriteriaStr);
        }
 
        QString convergenceCriteriaThresholdStr = attributes.value("threshold");
        if (!convergenceCriteriaThresholdStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_convergenceCriteriaThreshold
              = toDouble(convergenceCriteriaThresholdStr);
        }
 
        QString convergenceCriteriaMaximumIterationsStr = attributes.value("maximumIterations");
        if (!convergenceCriteriaMaximumIterationsStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_convergenceCriteriaMaximumIterations
              = toInt(convergenceCriteriaMaximumIterationsStr);
        }
      }
      else if (localName == "model") {
        QString type = attributes.value("type");
        QString quantile = attributes.value("quantile");
        if (!type.isEmpty() && !quantile.isEmpty()) {
          m_xmlHandlerBundleSettings->m_maximumLikelihood.append(
              qMakePair(MaximumLikelihoodWFunctions::stringToModel(type),
                        toDouble(quantile)));
        }
      }
      else if (localName == "outputFileOptions") {
        QString outputFilePrefixStr = attributes.value("fileNamePrefix");
        if (!outputFilePrefixStr.isEmpty()) {
          m_xmlHandlerBundleSettings->m_outputFilePrefix = outputFilePrefixStr;
        }
      }
      else if (localName == "bundleObservationSolveSettings") {
        m_xmlHandlerObservationSettings.append(
            new BundleObservationSolveSettings(m_xmlHandlerProject, reader()));
      }
    }
    return true;
  }
 
 
  bool BundleSettings::XmlHandler::characters(const QString &ch) {
    m_xmlHandlerCharacters += ch;
    return XmlStackedHandler::characters(ch);
  }
 
 
  bool BundleSettings::XmlHandler::endElement(const QString &namespaceURI, const QString &localName,
                                     const QString &qName) {
    if (!m_xmlHandlerCharacters.isEmpty()) {
      if (localName == "validateNetwork") {
        m_xmlHandlerBundleSettings->m_validateNetwork = toBool(m_xmlHandlerCharacters);
      }
      else if (localName == "observationSolveSettingsList") {
        for (int i = 0; i < m_xmlHandlerObservationSettings.size(); i++) {
          m_xmlHandlerBundleSettings->m_observationSolveSettings.append(
              *m_xmlHandlerObservationSettings[i]);
        }
        m_xmlHandlerObservationSettings.clear();
      }
 
      m_xmlHandlerCharacters = "";
    }
    return XmlStackedHandler::endElement(namespaceURI, localName, qName);
  }
 
 
  bool BundleSettings::XmlHandler::fatalError(const QXmlParseException &exception) {
    qDebug() << "Parse error with BundleSettings at line " << exception.lineNumber()
             << ", " << "column " << exception.columnNumber() << ": "
             << qPrintable(exception.message());
    return false;
  }
}