Obstacle detection

Now for me, the most confused place is realsense SDK2.0 How do you use it? , How to combine the code with the image obtained by the camera .

Obstacle detection ideas

1. Read image
2. Binary processing of the image ( Use open or close operations ), Only detect the range of distance within one meter ( use realsense camera )
3. Pass threshold size ( First set the threshold size ),Canny edge detection Obstacles detected , Draw the outline and calculate its convex hull ( I don't think it's reliable to use color as one of the judging elements , In case this object is colorful )
4. Generate the final image

Reference code

#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include "RSWrapper.h"
#include "opencv2/imgproc/imgproc.hpp"
#include <librealsense/rs.hpp>
using namespace rs2;
using namespace std;
using namespace cv;
void mask_depth(Mat &image,Mat& th,int throld=1000)
{
    int nr = image.rows; //  The horizontal axis 
    int nc = image.cols; //  The vertical axis  
    for (int i = 0; i<nr; i++)
    {
        for (int j = 0; j<nc; j++) 
        {
            if (image.at<ushort>(i, j)>throld)
            th.at<ushort>(i, j) = 0;
        }
    }
}
//  Find obstacles 
vector<vector<Point> > find_obstacle(Mat &depth, int thresh = 20, int max_thresh = 255, int area = 500)
{
    Mat dep;
    depth.copyTo(dep);
    mask_depth(depth, dep, 1000);
    dep.convertTo(dep, CV_8UC1, 1.0 / 16);
    //imshow("color", color);
    imshow("depth", dep);
    Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));// The size of the core can be adjusted appropriately 
    Mat out;
    // Carry out the opening operation 
    morphologyEx(dep, out, MORPH_OPEN, element);
    //dilate(dhc, out, element);
 
    imshow("opencv", out);
    Mat src_copy = dep.clone();
    Mat threshold_output;
    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
    RNG rng(12345);

    //  Binarization of the image 
    threshold(dep, threshold_output, thresh, 255, CV_THRESH_BINARY);

    //  Contour discovery 
    findContours(threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
 
    //  Calculate the convex hull of each contour 
    vector<vector<Point> >hull(contours.size());
    vector<vector<Point> > result;
    for (int i = 0; i < contours.size(); i++)
    {
        convexHull(Mat(contours[i]), hull[i], false);
    }
 
    //  Draw the outline and its convex hull 
    Mat drawing = Mat::zeros(threshold_output.size(), CV_8UC3);
    for (int i = 0; i< contours.size(); i++)
    {
        if (contourArea(contours[i]) < area)// The area is less than area Convex hull of , Negligible 
        continue;
        result.push_back(hull[i]);
        Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
    drawContours(drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point());
    drawContours(drawing, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point());
    }
    imshow("contours", drawing);
    return result;
}
 
 
int main(int argc, char* argv[])
{
    Mat dhc;
    Mat dep;
    int idxImageRes = 1, idxFrameRate = 30;
    RSWrapper depthCam(idxImageRes, idxImageRes, idxFrameRate, idxFrameRate);
    while (true)
    {
        //  obtain RGB Images 
        Mat color, depth;
        bool ret = depthCam.capture(color, depth);
        if (!ret) 
        {
            cerr << "Get realsense camera data failure!" << std::endl;
            break;
        }
        vector<vector<Point> > result;
        result = find_obstacle(depth, 20, 255, 500);
        if (cvWaitKey(1) == 27)
        break;
    }
    depthCam.release();
}