kinfu.hpp

// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
 
// This code is also subject to the license terms in the LICENSE_KinectFusion.md file found in this module's directory
 
#ifndef __OPENCV_RGBD_KINFU_HPP__
#define __OPENCV_RGBD_KINFU_HPP__
 
#include "opencv2/core.hpp"
#include "opencv2/core/affine.hpp"
#include <opencv2/rgbd/volume.hpp>
 
namespace cv {
namespace kinfu {
 
struct CV_EXPORTS_W Params
{
 
    CV_WRAP Params(){}
 
    CV_WRAP Params(Matx33f volumeInitialPoseRot, Vec3f volumeInitialPoseTransl)
    {
      setInitialVolumePose(volumeInitialPoseRot,volumeInitialPoseTransl);
    }
 
    CV_WRAP Params(Matx44f volumeInitialPose)
    {
      setInitialVolumePose(volumeInitialPose);
    }
 
    CV_WRAP void setInitialVolumePose(Matx33f R, Vec3f t);
 
    CV_WRAP void setInitialVolumePose(Matx44f homogen_tf);
 
    CV_WRAP static Ptr<Params> defaultParams();
 
    CV_WRAP static Ptr<Params> coarseParams();
 
    CV_WRAP static Ptr<Params> hashTSDFParams(bool isCoarse);
 
    CV_WRAP static Ptr<Params> coloredTSDFParams(bool isCoarse);
 
    CV_PROP_RW Size frameSize;
 
    CV_PROP_RW kinfu::VolumeType volumeType;
 
    CV_PROP_RW Matx33f intr;
 
    CV_PROP_RW Matx33f rgb_intr;
    CV_PROP_RW float depthFactor;
 
    CV_PROP_RW float bilateral_sigma_depth;
    CV_PROP_RW float bilateral_sigma_spatial;
    CV_PROP_RW int   bilateral_kernel_size;
 
    CV_PROP_RW int pyramidLevels;
 
    CV_PROP_RW Vec3i volumeDims;
    CV_PROP_RW float voxelSize;
 
    CV_PROP_RW float tsdf_min_camera_movement;
 
    Affine3f volumePose;
 
    CV_PROP_RW float tsdf_trunc_dist;
 
    CV_PROP_RW int tsdf_max_weight;
 
    CV_PROP_RW float raycast_step_factor;
 
    // gradient delta in voxel sizes
    // fixed at 1.0f
    // float gradient_delta_factor;
 
    CV_PROP_RW Vec3f lightPose;
 
    CV_PROP_RW float icpDistThresh;
    CV_PROP_RW float icpAngleThresh;
    CV_PROP_RW std::vector<int> icpIterations;
 
    CV_PROP_RW float truncateThreshold;
};
 
class CV_EXPORTS_W KinFu
{
public:
    CV_WRAP static Ptr<KinFu> create(const Ptr<Params>& _params);
    virtual ~KinFu();
 
    virtual const Params& getParams() const = 0;
 
    CV_WRAP virtual void render(OutputArray image) const = 0;
 
    CV_WRAP virtual void render(OutputArray image, const Matx44f& cameraPose) const = 0;
 
    CV_WRAP virtual void getCloud(OutputArray points, OutputArray normals) const = 0;
 
    CV_WRAP virtual void getPoints(OutputArray points) const = 0;
 
    CV_WRAP virtual  void getNormals(InputArray points, OutputArray normals) const = 0;
 
    CV_WRAP virtual void reset() = 0;
 
    virtual const Affine3f getPose() const = 0;
 
    CV_WRAP virtual bool update(InputArray depth) = 0;
};
 
}
}
#endif