/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/ntk/camera/rgbd_processor.h

Go to the documentation of this file.

#ifndef NTK_CAMERA_RGBD_PROCESSOR_H
#define NTK_CAMERA_RGBD_PROCESSOR_H

#include <ntk/core.h>
#include <opencv/cv.h>
#include <ntk/camera/rgbd_image.h>

namespace ntk
{

class RGBDProcessor
{
public:
  enum ProcessorFlag {
    NoProcessing = 0x0,
    FixGeometry = 0x1, // transform euclidian distance to depth (z component)
    UndistortImages = 0x2, // apply undistort
    FixBias = 0x4, // fix depth bias using polynomials
    FilterAmplitude = 0x8, // remove low amplitude pixels
    FilterNormals = 0x10, // remove normals not aligned enough with line of sight
    FilterUnstable = 0x20, // remove depth values changing too much between consecutive frames
    FilterEdges = 0x40, // remove pixels with high depth spatial derivative
    FilterThresholdDepth = 0x80, // set a depth range
    FilterMedian = 0x100,
    ComputeMapping = 0x200, // compute mappings between rgb and depth
    ComputeNormals = 0x400, // compute normals (required by FilterNormals)
    ComputeKinectDepthTanh = 0x800, // compute depth in meters from kinect values
    ComputeKinectDepthLinear = 0x1000, // compute depth in meters from kinect values
    ComputeKinectDepthBaseline = 0x2000, // compute depth in meters from kinect values
    NoAmplitudeIntensityUndistort = 0x4000, // apply undistort
    Pause = 0x8000, // disable temporary the processing
    RemoveSmallStructures = 0x10000,
    FillSmallHoles = 0x20000,
    FlipColorImage = 0x40000, // horizontally flip the color image
    NiteProcessed = 0x80000, // raw = mapped = postprocessed
    SmoothDepth = 0x100000, // smooth depth map
  };

public:
  RGBDProcessor();

public:
  bool hasFilterFlag(ProcessorFlag flag) const { return m_flags&flag; }
  void setFilterFlags(int flags) { m_flags = flags; }
  void setFilterFlag(ProcessorFlag flag, bool enabled)
  { if (enabled) m_flags |= flag; else m_flags &= ~flag; }

  void setMinDepth(float meters) { m_min_depth = meters; }
  float minDepth() const { return m_min_depth; }
  void setMaxDepth(float meters) { m_max_depth = meters; }
  float maxDepth() const { return m_max_depth; }

  void setMaxNormalAngle(float angle_in_deg) { m_max_normal_angle = angle_in_deg; }

  void setMaxTimeDelta(float v) { m_max_time_depth_delta = v; }

  void setMaxSpacialDelta(float v) { m_max_spatial_depth_delta = v; }

  void setMappingResolution(float r) { m_mapping_resolution = r; }

public:
  virtual void processImage(RGBDImage& image);

  virtual void undistortImages();
  virtual void fixDepthGeometry();
  virtual void removeLowAmplitudeOutliers();
  virtual void removeNormalOutliers();
  virtual void removeUnstableOutliers();
  virtual void removeEdgeOutliers();
  virtual void applyDepthThreshold();
  virtual void computeNormals();
  virtual void computeMappings();
  virtual void medianFilter();
  virtual void computeKinectDepthLinear();
  virtual void computeKinectDepthTanh();
  virtual void computeKinectDepthBaseline();
  virtual void removeSmallStructures();
  virtual void fillSmallHoles();

protected:
  RGBDImage* m_image;
  int m_flags;
  cv::Mat1f m_last_depth_image;
  float m_min_depth;
  float m_max_depth;
  float m_max_normal_angle;
  float m_max_time_depth_delta;
  float m_max_spatial_depth_delta;
  float m_mapping_resolution;
};

class KinectProcessor : public RGBDProcessor
{
public:
  KinectProcessor()
    : RGBDProcessor()
  {
    setFilterFlag(RGBDProcessor::ComputeKinectDepthBaseline, true);
    setFilterFlag(RGBDProcessor::NoAmplitudeIntensityUndistort, true);
  }
};

class NiteProcessor : public RGBDProcessor
{
public:
  NiteProcessor()
    : RGBDProcessor()
  {
    // Everything is done by the grabber.
    setFilterFlags(RGBDProcessor::NiteProcessed | RGBDProcessor::ComputeMapping);
  }

protected:
  virtual void computeMappings();
};

void compute_color_encoded_depth(const cv::Mat1f& depth, cv::Mat3b& color_dept,
                                 double* min_val = 0, double* max_val = 0);

} // ntk

#endif // NTK_CAMERA_RGBD_PROCESSOR_H