Isis 3.0 Object Programmers' Reference

Home

---

BundleAdjust.h

Go to the documentation of this file.

#ifndef BundleAdjust_h
#define BundleAdjust_h

#include "ControlNet.h"
#include "SerialNumberList.h"
#include "ObservationNumberList.h"
#include "Camera.h"
#include "Statistics.h"
#include "SpicePosition.h"
#include "Progress.h"

namespace Isis {
  class LeastSquares;
  class BasisFunction;

  class BundleAdjust {
    public:
      BundleAdjust(const std::string &cnetFile, const std::string &cubeList,
                   bool printSummary=true);
      BundleAdjust(const std::string &cnetFile, const std::string &cubeList,
                   const std::string &heldList,bool printSummary=true);
      BundleAdjust(Isis::ControlNet &cnet, Isis::SerialNumberList &snlist,
                   bool printSummary=true);
      BundleAdjust(Isis::ControlNet &cnet, Isis::SerialNumberList &snlist,
                   Isis::SerialNumberList &heldsnlist,bool printSummary=true);
      ~BundleAdjust();

      double Solve(double tol, int maxIterations);

      Isis::ControlNet *ControlNet() { return p_cnet; };

      Isis::SerialNumberList *SerialNumberList() { return p_snlist; };
      int Images() const;
      int Observations() const;
      std::string Filename(int index);
      Table Cmatrix(int index);
      Table SpVector(int index);

      void SetSolveTwist(bool solve);
      void SetSolveRadii(bool solve);

      enum CmatrixSolveType {
        None,
        AnglesOnly,
        AnglesVelocity,
        AnglesVelocityAcceleration,
        All
      };

      enum SpacecraftPositionSolveType {
        Nothing,
        PositionOnly,
        PositionVelocity,
        PositionVelocityAcceleration
      };

      void SetSolveCmatrix(CmatrixSolveType type);
      void SetSolveSpacecraftPosition(SpacecraftPositionSolveType type);

      void SetCkDegree( int degree ) { p_ckDegree = degree; };

      void SetSolveCamDegree( int degree ) { p_solveCamDegree = degree; };

      int BasisColumns() const;

      double Error() const { return p_error; };
      double Iteration() const { return p_iteration; };

      int HeldPoints() const { return p_heldPoints; };
      int IgnoredPoints() const { return p_ignoredPoints; };
      int GroundPoints() const { return p_groundPoints; };
      void SetObservationMode ( bool observationMode );

      void SetSolutionMethod ( std::string solutionMethod ) { p_solutionMethod = solutionMethod;};

    private:
      void Init(Progress *progress=0);

      void ComputeNumberPartials();

      void AddPartials (LeastSquares &lsq,
                        int point);
      void Update (BasisFunction &basis);

      int PointIndex (int i) const;

      int ImageIndex (int i) const;

      void CheckHeldList();
      void ApplyHeldList();

      Isis::ControlNet *p_cnet;
      Isis::SerialNumberList *p_snlist;
      Isis::SerialNumberList *p_heldsnlist;
      Isis::ObservationNumberList *p_onlist;

      double p_error;
      int p_iteration;
      bool p_printSummary;

      int p_numImagePartials;
      int p_numPointPartials;

      bool p_solveTwist;
      bool p_solveRadii;
      bool p_observationMode;
      CmatrixSolveType p_cmatrixSolveType;
      SpacecraftPositionSolveType p_spacecraftPositionSolveType;

      double LowDHigh(std::vector<double> &lookC,
                      std::vector<double> &dlookC,
                      int index);

      enum PartialDerivative {
        WRT_Latitude,
        WRT_Longitude,
        WRT_Radius
      };

      std::vector<double> PointPartial(Isis::ControlPoint &point, PartialDerivative wrt);

      int p_heldPoints;
      int p_groundPoints;
      int p_ignoredPoints;
      int p_heldImages;
      int p_heldObservations;
      std::vector<int> p_pointIndexMap;
      std::vector<int> p_imageIndexMap;
      bool p_cleanUp;

      void IterationSummary(double avErr, double sigmaXY,
                            double sigmaHat, double sigmaX, double sigmaY);
      Statistics p_statx;
      Statistics p_staty;
      std::string p_solutionMethod;
      int p_ckDegree;
      int p_solveCamDegree;
      int p_numberCameraCoefSolved;  
  };
};

#endif