BundleAdjust.h

Go to the documentation of this file.

#ifndef BundleAdjust_h
#define BundleAdjust_h

// Qt lib
#include <QObject> // parent class

// std lib
#include <vector>
#include <fstream>

// cholmod lib
#include <cholmod.h>

// Isis lib
#include "BundleControlPoint.h"
#include "BundleObservationSolveSettings.h"
#include "BundleObservationVector.h"
#include "BundleResults.h"
#include "BundleSettings.h"
#include "BundleSolutionInfo.h"
#include "BundleTargetBody.h"
#include "Camera.h"
#include "CameraGroundMap.h"
#include "ControlMeasure.h"
#include "ControlNet.h"
#include "LinearAlgebra.h"
#include "MaximumLikelihoodWFunctions.h" // why not just forward declare???
#include "ObservationNumberList.h"
#include "Progress.h"
#include "SerialNumberList.h"
#include "SparseBlockMatrix.h"
#include "Statistics.h"

template< typename T > class QList;
template< typename A, typename B > class QMap;

namespace Isis {
  class Control;
  class ImageList;

  class BundleAdjust : public QObject {
      Q_OBJECT
    public:
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   const QString &cnetFile,
                   const QString &cubeList,
                   bool printSummary = true);
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   QString &cnet,
                   SerialNumberList &snlist,
                   bool printSummary = true);
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   Control &cnet,
                   SerialNumberList &snlist,
                   bool bPrintSummary);
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   ControlNet &cnet,
                   SerialNumberList &snlist,
                   bool printSummary = true);
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   ControlNetQsp cnet,
                   const QString &cubeList,
                   bool printSummary = true);
      BundleAdjust(BundleSettingsQsp bundleSettings,
                   Control &control,
                   QList<ImageList *> imgList,
                   bool printSummary);
      ~BundleAdjust();
      BundleSolutionInfo*    solveCholeskyBR();

      QList<ImageList *> imageLists();
      bool isAborted();

    public slots:
      bool solveCholesky();
      void abortBundle();
      void outputBundleStatus(QString status);

      // accessors

      ControlNetQsp    controlNet();
      SerialNumberList *serialNumberList();
      QString          fileName(int index);
      QString          iterationSummaryGroup() const;
      bool             isConverged();
      Table            cMatrix(int index);
      Table            spVector(int index);
      int              numberOfImages() const;
      double           iteration() const;

    signals:
      void statusUpdate(QString);
      void error(QString);
      void iterationUpdate(int);
      void pointUpdate(int);
      void statusBarUpdate(QString);
      void resultsReady(BundleSolutionInfo *bundleSolveInformation);
      void finished();

    private:
      //TODO Should there be a resetBundle(BundleSettings bundleSettings) method
      //     that allows for rerunning with new settings? JWB
      void init(Progress *progress = 0);
      bool initializeNormalEquationsMatrix();
      bool validateNetwork();
      bool solveSystem();
      void iterationSummary();
      BundleSolutionInfo* bundleSolveInformation();
      bool computeBundleStatistics();
      void applyParameterCorrections();
      bool errorPropagation();
      double computeResiduals();
      bool computeRejectionLimit();
      bool flagOutliers();

      // normal equation matrices methods

      bool formNormalEquations();
      bool computePartials(LinearAlgebra::Matrix  &coeffTarget,
                           LinearAlgebra::Matrix  &coeffImage,
                           LinearAlgebra::Matrix  &coeffPoint3D,
                           LinearAlgebra::Vector  &coeffRHS,
                           BundleMeasure          &measure,
                           BundleControlPoint     &point);
      bool formMeasureNormals(boost::numeric::ublas::symmetric_matrix<
                                  double, boost::numeric::ublas::upper >         &N22,
                              SparseBlockColumnMatrix                            &N12,
                              boost::numeric::ublas::compressed_vector< double > &n1,
                              LinearAlgebra::Vector                              &n2,
                              LinearAlgebra::Matrix                              &coeffTarget,
                              LinearAlgebra::Matrix                              &coeffImage,
                              LinearAlgebra::Matrix                              &coeffPoint3D,
                              LinearAlgebra::Vector                              &coeffRHS,
                              int                                                observationIndex);
      bool formPointNormals(boost::numeric::ublas::symmetric_matrix<
                                double, boost::numeric::ublas::upper >  &N22,
                            SparseBlockColumnMatrix                     &N12,
                            LinearAlgebra::Vector                       &n2,
                            LinearAlgebra::Vector                       &nj,
                            BundleControlPointQsp                       &point);
      bool formWeightedNormals(boost::numeric::ublas::compressed_vector< double >  &n1,
                               LinearAlgebra::Vector                               &nj);

      // dedicated matrix functions

      void productAB(SparseBlockColumnMatrix &A,
                     SparseBlockRowMatrix    &B);
      void accumProductAlphaAB(double                alpha,
                               SparseBlockRowMatrix  &A,
                               LinearAlgebra::Vector &B,
                               LinearAlgebra::Vector &C);
      bool invert3x3(boost::numeric::ublas::symmetric_matrix<
                          double, boost::numeric::ublas::upper >  &m);
      bool productATransB(boost::numeric::ublas::symmetric_matrix<
                              double, boost::numeric::ublas::upper >  &N22,
                          SparseBlockColumnMatrix                     &N12,
                          SparseBlockRowMatrix                        &Q);
      void productAlphaAV(double alpha,
                          boost::numeric::ublas::bounded_vector< double, 3 >  &v2,
                          SparseBlockRowMatrix                                &Q,
                          LinearAlgebra::Vector                               &v1);

      // CHOLMOD library methods

      bool initializeCHOLMODLibraryVariables();
      bool freeCHOLMODLibraryVariables();
      bool cholmodInverse();
      bool loadCholmodTriplet();
      bool wrapUp();

      // member variables

      BundleSettingsQsp m_bundleSettings;                    
      BundleResults  m_bundleResults;                        
      Statistics m_xResiduals;                               
      Statistics m_yResiduals;                               
      Statistics m_xyResiduals;                              
      ControlNetQsp m_controlNet;                            
      QString m_cnetFileName;                                
      QVector <BundleControlPointQsp> m_bundleControlPoints; 
      BundleObservationVector m_bundleObservations;          
      SerialNumberList *m_serialNumberList;                  
      BundleTargetBodyQsp m_bundleTargetBody;                
      bool m_abort;                                          
      QString m_iterationSummary;                            
      bool m_printSummary;                                   
      bool m_cleanUp;                                        
      int m_rank;                                            
      int m_iteration;                                       
      int m_numberOfImagePartials;                           
      QList<ImageList *> m_imageLists;                        
      // ==========================================================================================
      // === BEYOND THIS PLACE (THERE BE DRAGONS) all refers to the folded bundle solution.     ===
      // === Currently, everything uses the CHOLMOD library,                                    ===
      // === there is no dependence on the least-squares class.                                 ===
      // ==========================================================================================

      boost::numeric::ublas::symmetric_matrix<
          double,
          boost::numeric::ublas::upper,
          boost::numeric::ublas::column_major > m_normalInverse;
      cholmod_common  m_cholmodCommon;                       
      LinearAlgebra::Vector m_RHS;                           
      SparseBlockMatrix m_sparseNormals;                     
      cholmod_triplet  *m_cholmodTriplet;                    
      cholmod_sparse *m_cholmodNormal;                       
      cholmod_factor *m_L;                                   
      LinearAlgebra::Vector m_imageSolution;                 
      int m_previousNumberImagePartials;                     
  };
}

#endif