Program Listing for File DepthMap.h

↰ Return to documentation for file (lib/DepthEstimation/DepthMap.h)

#pragma once
#include "opencv2/core/core.hpp"
#include "util/Configuration.h"
#include "util/EigenCoreInclude.h"
#include "util/IndexThreadReduce.h"
#include "util/MovingAverage.h"
#include "util/SophusUtil.h"
#include "util/Timer.h"
#include "util/settings.h"

#include "DataStructures/Frame.h"
#include "DataStructures/ImageSet.h"
#include "DepthMapDebugImages.h"

#include <opencv2/calib3d.hpp>

namespace lsd_slam {

class DepthMapPixelHypothesis;
class KeyFrameGraph;

class KeyFrame;

class DepthMap {
public:
  typedef std::shared_ptr<DepthMap> SharedPtr;

  // Delete default constructors
  DepthMap(const DepthMap &) = delete;
  DepthMap &operator=(const DepthMap &) = delete;

  DepthMap(const std::shared_ptr<Frame> &frame);
  DepthMap(const std::shared_ptr<ImageSet> &set);

  // //== Propagation constructor for subsequent keyframes
  // DepthMap( const DepthMap::SharedPtr &other, const Frame::SharedPtr &frame
  // );

  ~DepthMap();

  void reset();

  // /**
  //  * does obervation and regularization only.
  //  **/
  // void updateKeyframe(std::deque< Frame::SharedPtr > referenceFrames);
  //
  // /**
  //  * does propagation and whole-filling-regularization (no observation, for
  //  that need to call updateKeyframe()!)
  //  **/
  // void createKeyFrame( const Frame::SharedPtr &new_keyframe );

  // void finalizeKeyFrame();

  // void invalidate();
  // inline bool isValid() {return (bool)activeKeyFrame;};

  // int debugPlotDepthMap();
  const DepthMapDebugImages &debugImages() const { return _debugImages; }

  // This is the only debug plot which is triggered externally..
  void plotDepthMap(const char *buf1, const char *buf2);

  //== Initializers, required only when propagating from a previous keyframe
  void initializeFromFrame();
  void initializeFromSet();
  void initializeFromGTDepth();
  void initializeFromStereo();
  void initializeRandomly();
  // void initializefromStereo( const std::shared_ptr<ImageSet> &set);

  void propagateFrom(const DepthMap::SharedPtr &new_keyframe,
                     float &rescaleFactor, bool stereo_depth);

  void finalize();

  // void activateExistingKF(const Frame::SharedPtr &kf);

  void activateExistingKF(const Frame::SharedPtr &kf);

  //==
  bool updateDepthFrom(const Frame::SharedPtr &frame);

  struct PerformanceData {
    PerformanceData(void) { ; }

    MsRateAverage update, create, finalize, observe, regularize, propagate,
        fillHoles, setDepth;
  };

  PerformanceData perf() const { return _perf; }
  void logPerformanceData();

  // Convenience accessors
  std::shared_ptr<Frame> &frame() { return _frame; }

  //
  DepthMapPixelHypothesis *hypothesisAt(const int x, const int y) {
    return currentDepthMap + x + y * Conf().slamImageSize.width;
  }

private:
  IndexThreadReduce threadReducer;

  PerformanceData _perf;
  DepthMapDebugImages _debugImages;

  // ============= parameter copies for convenience ===========================
  // these are just copies of the pointers given to this function, for
  // convenience. these are NOT managed by this object!
  std::shared_ptr<Frame> _frame;
  std::shared_ptr<ImageSet> _set;

  const float *activeKeyFrameImageData() { return frame()->image(0); }
  bool activeKeyFrameIsReactivated;

  // Frame::SharedPtr oldest_referenceFrame;
  // Frame::SharedPtr newest_referenceFrame;
  // std::vector< Frame::SharedPtr > referenceFrameByID;
  // int referenceFrameByID_offset;

  // ============= internally used buffers for intermediate calculations etc.
  // ============= for internal depth tracking, their memory is managed (created
  // & deleted) by this object.
  DepthMapPixelHypothesis *otherDepthMap;
  DepthMapPixelHypothesis *currentDepthMap;
  int *validityIntegralBuffer;

  // ============ internal functions
  // ================================================== does the line-stereo
  // seeking. takes a lot of parameters, because they all have been pre-computed
  // before.
  inline float doLineStereo(const float u, const float v, const float epxn,
                            const float epyn, const float min_idepth,
                            const float prior_idepth, float max_idepth,
                            const Frame *const referenceFrame,
                            const float *referenceFrameImage,
                            float &result_idepth, float &result_var,
                            float &result_eplLength, RunningStats *const stats);

  // Reset currentDepthMap by re-projecting is from activeKeyFrame to
  // new_keyframe
  void propagateDepthFrom(const DepthMap::SharedPtr &new_keyframe,
                          float &rescaleFactor);
  void propagateDepthFromSet(const DepthMap::SharedPtr &new_keyframe,
                             float &rescaleFactor);

  // This is a local state variable used to share data between the observeDepth*
  // functions.  Sucks, I know
  Frame::SharedPtr _observeFrame;
  void observeDepth(const Frame::SharedPtr &updateFrame);
  void observeDepthRow(int yMin, int yMax, RunningStats *stats);
  bool observeDepthCreate(const int &x, const int &y, const int &idx,
                          RunningStats *const &stats);
  bool observeDepthUpdate(const int &x, const int &y, const int &idx,
                          const float *keyFrameMaxGradBuf,
                          RunningStats *const &stats);
  bool makeAndCheckEPL(const int x, const int y, const Frame *const ref,
                       float *pepx, float *pepy, RunningStats *const stats);

  void regularizeDepthMap(bool removeOcclusion, int validityTH);
  template <bool removeOcclusions>
  void regularizeDepthMapRow(int validityTH, int yMin, int yMax,
                             RunningStats *stats);

  void buildRegIntegralBuffer();
  void buildRegIntegralBufferRow1(int yMin, int yMax, RunningStats *stats);
  void regularizeDepthMapFillHoles();
  void regularizeDepthMapFillHolesRow(int yMin, int yMax, RunningStats *stats);

  void resetCounters();

  // float clocksPropagate, clocksPropagateKF, clocksObserve, msObserve,
  // clocksReg1, clocksReg2, msReg1, msReg2, clocksFinalize;
};

} // namespace lsd_slam