Hu Chunming / village_ascend_arm

#include "RoadSegAnalysis.h"

uint8_t seg_colors[][3] = { {0, 0, 0}, {0, 255, 255}, {128, 255, 0}, {255, 128, 0}, {128, 0, 255}, {255, 0, 128}, {0, 128, 255}, {0, 255, 128}, {128, 255, 255}};
uint8_t lane_colors[][3] = { {0, 0, 0}, {255, 0, 0}, {0, 255, 0}, {0, 0, 255}, {255, 255, 0}, {255, 0, 255}, {0, 255, 255}, {128, 255, 0}, {255, 128, 0}};

RoadSegAnalysis::RoadSegAnalysis(/* args */)
{
}

RoadSegAnalysis::~RoadSegAnalysis()
{
    release();
}

int RoadSegAnalysis::init(int devId, std::string sdk_root){
    ACL_CALL(aclrtCreateContext(&ctx, devId), SY_SUCCESS, SY_FAILED);

    std::string model_path = sdk_root + "/models/road_seg/tzroad_seg240108_310p.om";

    rs_param param;
    param.modelNames = (char*)model_path.data();
    param.thresld = 0.25;
    param.devId = devId;

    LOG_INFO("rs_init start");
    int ret = rs_init(&m_handle, param);
    if (ret != 0) {
        return -1;
	}

    LOG_INFO("rs_init success");

    return SY_SUCCESS;
}

std::vector<RoadInfo> RoadSegAnalysis::detect(vector<sy_img> vec_img){

    std::vector<RoadInfo> vec_road_info;

    const int batchsize = vec_img.size();
    rs_result results[batchsize];
    const int fea_size = 360*640;
    for (int b = 0; b < batchsize; b++) {
        results[b].seg_array = new unsigned char[fea_size];
        results[b].direct_seg = new unsigned char[fea_size];
    }

    int ret = SY_FAILED;

    do
    {
        ret = aclrtSetCurrentContext(ctx);
        if (SY_SUCCESS != ret) {
            printf("aclrtSetCurrentContext failed!");
            break;
        }

        ret = rs_batch(m_handle, vec_img.data(), batchsize, results);
        if (SY_SUCCESS != ret) {
            printf("rs_batch failed!");
            break;
        }
        
        for (int b = 0; b < batchsize; b++) {
            auto one_result = results[b];
            RoadInfo one_road = parse_road(one_result, vec_img[b]);
            // one_road.vec_line = parse_line(one_result, vec_img[b]);
            // one_road.vec_road = parse_road(one_road, one_result, vec_img[b]);
            one_road.vec_direct = parse_direct(one_result, vec_img[b]);
            vec_road_info.push_back(one_road);
        }

    } while (0);

     for (int b = 0; b < batchsize; b++) {
        delete[] results[b].seg_array; 
        results[b].seg_array = NULL;
        delete[] results[b].direct_seg; 
        results[b].direct_seg = NULL;
    }

    return vec_road_info;
}

void test(vector<int> vec_type, std::vector<cv::Point> vec_pt, std::string file_name){
    cv::Mat image(cv::Size(640, 360), CV_8UC3, cv::Scalar(0, 0, 0));

    for (int i = 0; i < vec_type.size(); ++i) {
        int k = vec_type[i];
        const cv::Scalar color(seg_colors[k][0], seg_colors[k][1], seg_colors[k][2]);
        polylines(image, vec_pt, true, color, 3, cv::LINE_AA);
    }

    cv::imwrite(file_name, image);
    image.release();
}

void clip_xy(int& x, int& y, int width, int height){
    if (x < 0) {
        x = 0;
    }

    if (y < 0) {
        y = 0;
    }
    
    if (x >= width) {
        x = width -1;
    }
    
    if (y >= height) {
        y = height -1;
    }
}

std::vector<LineInfo> RoadSegAnalysis::parse_line(rs_result one_result, sy_img src) {
	float scale_w = src.w_ / 640.0;
	float scale_h = src.h_ / 360.0;
    std::vector<std::pair<std::vector<cv::Point>, int>> combined;
    lanes_process(one_result.reg_array, one_result.lane_count, combined, scale_w, scale_h);

    std::vector<LineInfo> vec_line;
    for (const auto& lane_info : combined) {
        LineInfo info;
        info.vec_pt = lane_info.first;
        info.line_type = lane_info.second;
        vec_line.push_back(info);
    }
    
    return vec_line;
}

cv::Mat mask_to_rgb(cv::Mat img, cv::Mat mask) {
    cv::Mat masks = img.clone();
    int reg_cls = 9;
    for (int i = 0; i < masks.rows; i++) {
        for (int j = 0; j < masks.cols; j++) {
            for (int k = 1; k < reg_cls; k++) {
                if (mask.at<int>(i,j) == k) {
                    masks.at<cv::Vec3b>(i,j)[0] = seg_colors[k][0];
                    masks.at<cv::Vec3b>(i,j)[1] = seg_colors[k][1];
                    masks.at<cv::Vec3b>(i,j)[2] = seg_colors[k][2];
                }
            }
        }
    }
    return masks;
}

RoadInfo RoadSegAnalysis::parse_road(rs_result one_result, sy_img src)
{
    int src_width = src.w_;
    int src_height = src.h_;
    float scale_w = src_width / 640.0;
	float scale_h = src_height / 360.0;

    RoadInfo one_road;

    std::vector<std::pair<std::vector<cv::Point>, int>> combined;
    lanes_process(one_result.reg_array, one_result.lane_count, combined);
    std::vector<std::vector<cv::Point>> poly_masks, lanes;
    std::vector<int> region_classes, cats;
    std::map<double, int> x_sort;
    bool large_resolution = false;
    if (src_width > 1920) large_resolution = true;

    cv::Mat seg_output = seg_post_process(large_resolution, one_result.seg_array, combined, poly_masks, region_classes, lanes, cats, x_sort); //m_masks:mask前的结果  poly_masks后的结果               

    // cv::Mat image_lane(cv::Size(src_width, src_height), CV_8UC3, cv::Scalar(0, 0, 0));
    for (int i = 0; i < lanes.size(); ++i) {
        LineInfo info;
        const cv::Scalar color(seg_colors[i][0], seg_colors[i][1], seg_colors[i][2]);
        for (size_t j = 0; j < lanes[i].size(); j++) {
            cv::Point pt;
            pt.x = lanes[i][j].x * scale_w;
            pt.y = lanes[i][j].y * scale_h;
            clip_xy(pt.x, pt.y, src_width, src_height);
            info.vec_pt.push_back(pt);

            // if (j > 0) {
            //     cv::line(image_lane, info.vec_pt[j-1], info.vec_pt[j], color, 2, 8);
            // }
            
        }
        
        info.line_type = cats[i];
        one_road.vec_line.push_back(info);
    }

    // cv::imwrite("./image_lane.jpg", image_lane);
    // seg_output.release();
    // image_lane.release();
    
    // cv::Mat image(cv::Size(src_width, src_height), CV_8UC3, cv::Scalar(0, 0, 0));
    for (int i = 0; i < poly_masks.size(); ++i) {
        SegInfo seg_info;

        for (size_t j = 0; j < poly_masks[i].size(); j++) {
            cv::Point pt;
            pt.x = poly_masks[i][j].x * scale_w;
            pt.y = poly_masks[i][j].y * scale_h;
            clip_xy(pt.x, pt.y, src_width, src_height);
            seg_info.vec_pt.push_back(pt);
        }

        seg_info.seg_type = region_classes[i];
        one_road.vec_road.push_back(seg_info);

        // int k = seg_info.seg_type;
        // const cv::Scalar color(seg_colors[k][0], seg_colors[k][1], seg_colors[k][2]);
        // polylines(image, seg_info.vec_pt, true, color, 3, cv::LINE_AA);
    }

    // cv::imwrite("./image_road.jpg", image);
    // image.release();

    return one_road;
}

std::vector<SegInfo> RoadSegAnalysis::parse_direct(rs_result one_result, sy_img src) {

    std::vector<std::vector<cv::Point>> direct_masks;
    std::vector<int> direct_classes;
    bool large_resolution = false;
    if (src.w_ > 1920) large_resolution = true;
    cv::Mat direct_output = direct_post_process(large_resolution, one_result.direct_seg, direct_masks, direct_classes);          
    

    // cv::Mat image(cv::Size(640, 360), CV_8UC3, cv::Scalar(0, 0, 0));

    std::vector<SegInfo> vec_road;
    for (int i = 0; i < direct_masks.size(); ++i) {
        SegInfo seg_info;
        seg_info.seg_type = direct_classes[i];
        seg_info.vec_pt = direct_masks[i];

        vec_road.push_back(seg_info);

        // int k = seg_info.seg_type;
        // const cv::Scalar color(seg_colors[k][0], seg_colors[k][1], seg_colors[k][2]);
        // polylines(image, seg_info.vec_pt, true, color, 3, cv::LINE_AA);
    }

    // cv::imwrite("./image_direct.jpg", image);
    // image.release();

    return vec_road;
}

int RoadSegAnalysis::release() {

    ACL_CALL(aclrtSetCurrentContext(ctx), SY_SUCCESS, SY_FAILED);	

    if (m_handle) {
        rs_release(&m_handle);
    }

    if(ctx){
        aclrtDestroyContext(ctx);
        ctx = nullptr;
    }

    return SY_SUCCESS;
}

// head_or_tail 0：车头  1：车尾
int RoadSegAnalysis::check_reverse_driving(std::vector<SegInfo>& vec_direct, sy_rect src_rc, int src_width, int src_height, int head_or_tail) {

    float scale_w = 640.0 / src_width;
	float scale_h = 360.0 / src_height;

    sy_rect rc;
    rc.left_ = src_rc.left_ * scale_w;
    rc.width_ = src_rc.width_ * scale_w;
    rc.top_ = src_rc.top_ * scale_h;
    rc.height_ = src_rc.height_ * scale_h;

    std::vector<cv::Point> polygon_pts;
    cv::Point pt_lt;
    pt_lt.x = rc.left_;
    pt_lt.y = rc.top_;
    polygon_pts.push_back(pt_lt);
    cv::Point pt_rt;
    pt_rt.x = rc.left_ + rc.width_;
    pt_rt.y = rc.top_;
    polygon_pts.push_back(pt_rt);
    cv::Point pt_rb;
    pt_rb.x = rc.left_ + rc.width_;
    pt_rb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_rb);
    cv::Point pt_lb;
    pt_lb.x = rc.left_;
    pt_lb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_lb);

    int coming_count = 0;
    int leaving_count = 0;
    for (size_t i = 0; i < vec_direct.size(); i++) {
        SegInfo& region = vec_direct[i];
        if (region.seg_type == 1) {
            for (size_t j = 0; j < polygon_pts.size(); j++) {
                double dist  = pointPolygonTest(region.vec_pt, polygon_pts[j], false);
                if (dist > 0) {
                    coming_count ++;
                }
            }
        } else if (region.seg_type == 2) {
            for (size_t j = 0; j < polygon_pts.size(); j++) {
                double dist  = pointPolygonTest(region.vec_pt, polygon_pts[j], false);
                if (dist > 0) {
                    leaving_count ++;
                }
            }
        }
    }

    int direct = 0;
    if(coming_count > 0 && leaving_count > 0) {
        if (coming_count > leaving_count) {
            direct = 1;
        } else {
            direct = 2;
        }
    } else if(coming_count > 0 && leaving_count <= 0) {
        direct = 1;
    } else if(coming_count <= 0 && leaving_count > 0) {
        direct = 2;
    } 


    // int center_x = (rc.left_ + rc.width_ / 2) * scale_w;
    // int center_y = (rc.top_ + rc.height_ / 2) * scale_h;
    // if(center_x < 0 ||center_x >= direct_mask.cols || center_y < 0 || center_y >= direct_mask.rows){
    //     return -1;
    // }

    // '来': 1,  '去': 2,  '近': 3,  '远': 4
    // int direct = direct_mask.at<int>(center_x, center_y);
    if (direct == 1 && head_or_tail == 0) {
        // 来车道，车头，正常行驶
        return 0;
    } else if (direct == 1 && head_or_tail == 1){
        // 来车道，车尾，逆行
        return 1;
    } else if (direct == 2 && head_or_tail == 0){
        // 去车道，车头，逆行
        return 1;
    } else if (direct == 2 && head_or_tail == 1){
        // 去车道，车尾，正常行驶
        return 0;
    } 
    
    return -1;
}

int RoadSegAnalysis::check_cross_line(std::vector<LineInfo>& vec_line, sy_rect src_rc, int src_width, int src_height) {

    float scale_w = 640.0 / src_width;
    float scale_h = 360.0 / src_height;

    sy_rect rc;
    rc.left_ = src_rc.left_ * scale_w;
    rc.width_ = src_rc.width_ * scale_w;
    rc.top_ = src_rc.top_ * scale_h;
    rc.height_ = src_rc.height_ * scale_h;

    std::vector<cv::Point> polygon_pts;
    cv::Point pt_lt;
    pt_lt.x = rc.left_;
    pt_lt.y = rc.top_;
    polygon_pts.push_back(pt_lt);
    cv::Point pt_rt;
    pt_rt.x = rc.left_ + rc.width_;
    pt_rt.y = rc.top_;
    polygon_pts.push_back(pt_rt);
    cv::Point pt_rb;
    pt_rb.x = rc.left_ + rc.width_;
    pt_rb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_rb);
    cv::Point pt_lb;
    pt_lb.x = rc.left_;
    pt_lb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_lb);


    for (size_t i = 0; i < vec_line.size(); i++) {
        LineInfo& line = vec_line[i];
        if (line.line_type == 1 || line.line_type == 2) {
            // 黄实线
            int in_count = 0;
            for (size_t j = 0; j < line.vec_pt.size(); j++) {
                double dist  = pointPolygonTest(polygon_pts, line.vec_pt[j], false);
                if (dist > 0) {
                    in_count ++;
                }
            }

            if (in_count > 5)
            {//有5个点就认为是压线了
                return line.line_type;
            }
        }
    }
    
    return -1;
}

int RoadSegAnalysis::check_cross_region(std::vector<SegInfo>& vec_reg, sy_rect src_rc, int src_width, int src_height, int region_type) {

    float scale_w = 640.0 / src_width;
    float scale_h = 360.0 / src_height;

    sy_rect rc;
    rc.left_ = src_rc.left_ * scale_w;
    rc.width_ = src_rc.width_ * scale_w;
    rc.top_ = src_rc.top_ * scale_h;
    rc.height_ = src_rc.height_ * scale_h;

    std::vector<cv::Point> polygon_pts;
    cv::Point pt_lt;
    pt_lt.x = rc.left_;
    pt_lt.y = rc.top_;
    polygon_pts.push_back(pt_lt);
    cv::Point pt_rt;
    pt_rt.x = rc.left_ + rc.width_;
    pt_rt.y = rc.top_;
    polygon_pts.push_back(pt_rt);
    cv::Point pt_rb;
    pt_rb.x = rc.left_ + rc.width_;
    pt_rb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_rb);
    cv::Point pt_lb;
    pt_lb.x = rc.left_;
    pt_lb.y = rc.top_ + rc.height_;
    polygon_pts.push_back(pt_lb);


    for (size_t i = 0; i < vec_reg.size(); i++) {
        SegInfo& seg = vec_reg[i];
        if (seg.seg_type == region_type) {
            
            int in_count = 0;
            // 车辆与region相交
            for (size_t j = 0; j < seg.vec_pt.size(); j++) {
                double dist  = pointPolygonTest(polygon_pts, seg.vec_pt[j], false);
                if (dist > 0) {
                    in_count ++;
                }
            }

            if (in_count > 5)
            {//有5个点就认为是压线了
                return 1;
            }

            // 车辆与region相交情形未检测出来，检测车辆在region中情形
            for (size_t j = 0; j < polygon_pts.size(); j++) {
                double dist  = pointPolygonTest(seg.vec_pt, polygon_pts[j], false);
                if (dist > 0) {
                    return 1;
                }
            }
        }
    }
    
    return -1;
}

cv::Mat RoadSegAnalysis::mask_to_rgb(cv::Mat img, cv::Mat mask) {
    cv::Mat masks = img.clone();
    int reg_cls = 8;
    for (int i = 0; i < masks.rows; i++) {
        for (int j = 0; j < masks.cols; j++) {
            for (int k = 1; k < reg_cls; k++) {
                if (mask.at<int>(i,j) == k) {
                    masks.at<cv::Vec3b>(i,j)[0] = seg_colors[k][0];
                    masks.at<cv::Vec3b>(i,j)[1] = seg_colors[k][1];
                    masks.at<cv::Vec3b>(i,j)[2] = seg_colors[k][2];
                }
            }
        }
    }
    return masks;
}

float RoadSegAnalysis::contourArea(std::vector<cv::Point> contour, cv::Point2f& center) {
    cv::RotatedRect rect = cv::minAreaRect(contour);  // 最小外接矩形 rect[0]中心点 rect[1]宽 高  rect[2]旋转角度
    center = rect.center;
    return cv::contourArea(contour);
}

void RoadSegAnalysis::lanes_process(const rs_lane* lanes, int lane_count, std::vector<std::pair<std::vector<cv::Point>, int>>& combined, float scale_w, float scale_h) {   
    std::vector<std::vector<cv::Point> > lanes_xys;
    std::vector<int> lanes_cls;
	for (int i = 0; i < lane_count; i++) {
        std::vector<cv::Point> xys;
		for (int j = 0; j < lanes[i].num_points; j++) {
            int x = static_cast<int>(lanes[i].points[j].x_ * scale_w);
            int y = static_cast<int>(lanes[i].points[j].y_ * scale_h);
            if (x > 0 && y > 0) {
                xys.emplace_back(x, y);
            }
        }
        if (!xys.empty()) {
            lanes_xys.push_back(xys);
            lanes_cls.push_back(lanes[i].cls);
        }
    }

    for (size_t i = 0; i < lanes_xys.size(); ++i) {
        combined.push_back(std::make_pair(lanes_xys[i], lanes_cls[i]));
    }
    if (!combined.empty()) {
        //按车道线起点坐标排序,相应的类别顺序也会变化以保证标签对齐
		std::sort(combined.begin(), combined.end(), [](const std::pair<std::vector<cv::Point>, int>& a, const std::pair<std::vector<cv::Point>, int>& b) {
			return a.first[0].x < b.first[0].x;
		});
    }
}

cv::Mat RoadSegAnalysis::imshow_lanes(cv::Mat img, const rs_lane* lanes, int lane_count) {
	float scale_w = img.cols / 640.0;
	float scale_h = img.rows / 360.0;
    std::vector<std::pair<std::vector<cv::Point>, int>> combined;
    lanes_process(lanes, lane_count, combined, scale_w, scale_h);

    for (const auto& lane_info : combined) {
        const auto& xys = lane_info.first;
        int cls = lane_info.second;
		cv::Scalar color(lane_colors[cls][0],lane_colors[cls][1],lane_colors[cls][2]);
        for (size_t i = 1; i < xys.size(); ++i) {
            cv::line(img, xys[i - 1], xys[i], color, 4);
        }
    }
    
    return img;
}

int RoadSegAnalysis::Mask2LanePoints(const cv::Mat& pred, std::vector<std::vector<cv::Point>>&lanes, std::vector<int>& cats) {
    std::vector<int> labels = {8, 9, 10, 11};
    for(auto cat: labels) {
        cv::Mat b_masks, measure_labels, stats, centroids;
        cv::compare(pred, cat, b_masks, cv::CMP_EQ); //将pred元素逐个和cat比较，相同255，不同0
        // cv::threshold(pred, b_masks, 126, 255, cv::THRESH_OTSU);    //生成二值图
        // 连通域计算 b_masks:闭操作后的二值图像 measure_labels:和原图一样大的标记图 centroids:nccomps×2的矩阵,表示每个连通域的质心(x, y)
        // stats:nccomps×5的矩阵 表示每个连通区域的外接矩形和面积(x, y, w, h, area)，索引0是背景信息
        int nccomps = cv::connectedComponentsWithStats (b_masks, measure_labels, stats, centroids, 4); //8
        for(int cv_measure_id = 1; cv_measure_id < nccomps; cv_measure_id++ ) {	//跳过背景信息0
            cv::Mat cv_measure_mask;
            cv::compare(measure_labels, cv_measure_id, cv_measure_mask, cv::CMP_EQ);
            std::vector< std::vector< cv::Point> > contours;
            cv::findContours(cv_measure_mask,contours,cv::noArray(),cv::RETR_TREE,cv::CHAIN_APPROX_SIMPLE);
            std::vector<cv::Point> contours_poly;
            for (int j = 0; j < contours.size();j++) {
                float area = cv::contourArea(contours[j]);  if (area < 60) continue; //30
                cv::approxPolyDP(cv::Mat(contours[j]), contours_poly, 6, true); //减小epsilon提高拟合精度(需要调试，epsilon过小会使多边形不够简化，单条线变多条)
                if (contours_poly.size() == 1) continue;
                lanes.push_back(contours_poly);
                cats.push_back(cat);
            }
        }    
    }
    return 0;
}


cv::Mat RoadSegAnalysis::seg_post_process(bool large_resolution, unsigned char *seg_array, std::vector<std::pair<std::vector<cv::Point>, int>> combined, std::vector<std::vector<cv::Point>> &poly_masks, std::vector<int> &region_classes, std::vector<std::vector<cv::Point>> &lanes, std::vector<int> &cats, std::map<double, int> &x_sort) {
    std::vector<int> pred_cls; 
    int h = 360, w = 640;
    cv::Mat lanes_masks = cv::Mat_<int>(h,w); //正常分割结果
    cv::Mat mask_rmlane = cv::Mat_<int>(h,w); //车道线区域置为背景
    cv::Mat solve_masks = cv::Mat_<int>(h,w); //计算主行驶区域用(虚线及减速标线归入行车道)
    int step_size = h*w;
    int seg_min_region_area = 512; //1024 

	for (int i = 0; i < h; ++i) {
		for (int j = 0; j < w; ++j) {
			int max_cls = seg_array[(i * w + j)];
			lanes_masks.ptr<int>(i)[j] = max_cls;
            pred_cls.push_back(max_cls);
            mask_rmlane.ptr<int>(i)[j] = max_cls;
            solve_masks.ptr<int>(i)[j] = max_cls;
		}
	}

    for (const auto& lane_info : combined) {
        const auto& xys = lane_info.first;
        int cls = lane_info.second;
		if (cls == 1) cls = 8;  /*黄实线*/ if (cls == 2) cls = 9;  /*白实线*/
        if (cls == 3) cls = 10; /*虚线*/   if (cls == 4) cls = 11; /*黄虚线*/
        for (size_t i = 1; i < xys.size(); ++i) {
            cv::line(lanes_masks, xys[i - 1], xys[i], cls, 4); //绘制车道线用于求连通域
            if (cls == 10 || cls == 11)   cls = 1; //求主行驶区域时将虚线归入行车道 
			cv::line(solve_masks, xys[i - 1], xys[i], cls, 4);
            
        }
    }

    /* 求背景区域--mask车道区域，场景变化用
    cv::compare(lanes_masks, 0, background_mask, cv::CMP_EQ); //将lanes_masks元素逐个和0比较，相同255，不同0*/
#if 1
    //--mask远处区域------------------------------------------------
    cv::Mat mask_black = mask_rmlane.clone();
    if (large_resolution)   mask_black(cv::Rect(0, 0, w, int(h * 0.14))) = 0;  
    else    mask_black(cv::Rect(0, 0, w, int(h * 0.22))) = 0;           
    mask_black(cv::Rect(0, int(h * 0.95), w, int(h * 0.05))) = 0;
    mask_black(cv::Rect(0, 0, int(w * 0.02), h)) = 0;
    mask_black(cv::Rect(int(w * 0.95), 0, int(w * 0.05), h)) = 0;
    mask_rmlane = mask_black;
    //-------------------------------------------------------------------------
#endif
    //2.去重获取预测到的类别
    std::vector<int> labels(pred_cls);
    std::sort(labels.begin(),labels.end());
    labels.erase(std::unique(labels.begin(),labels.end()),labels.end());
  
    //4.求车道线区域
    int flag = Mask2LanePoints(lanes_masks, lanes, cats); ///////////////////////// 车道线如何与mask结合
 
    //5.求道路区域
    int count = 0;
    for(auto cat: labels) {
        // std::cout << cat << std::endl;
        cv::Mat b_masks, measure_labels, stats, centroids;
        cv::Mat n_masks = cv::Mat_<int>(h,w);
        n_masks = cv::Scalar(255);
        cv::compare(mask_rmlane, cat, b_masks, cv::CMP_EQ); //将mask_rmlane元素逐个和cat比较，相同255，不同0
        //连通域计算
        int nccomps = cv::connectedComponentsWithStats (b_masks, measure_labels, stats, centroids, 8);
        for(int i = 1; i < nccomps; i++ ) {	//跳过背景信息0
            //移除过小的区域，并将对应位置置为0
            if (stats.at<int>(i, cv::CC_STAT_AREA) < seg_min_region_area) {
                cv::Mat comparison_result;
                cv::compare(measure_labels, cv::Scalar(i), comparison_result, cv::CMP_EQ); //相等为255不等为0
                n_masks.setTo(0, comparison_result); // 将comparison_result中非零区域置为0

                cv::bitwise_and(mask_rmlane,n_masks,mask_rmlane);
                continue;
            }

            double centr_x = centroids.at<double>(i, 0);
            double centr_y = centroids.at<double>(i, 1);

            int region_class = cat;
            // printf("region_class: %d\n", region_class);
            cv::Mat region_mask;
            cv::bitwise_and(measure_labels,n_masks,measure_labels);/////
            cv::compare(measure_labels, i, region_mask, cv::CMP_EQ);

            std::vector< std::vector< cv::Point> > contours;
            cv::findContours(region_mask,contours,cv::noArray(),cv::RETR_TREE,cv::CHAIN_APPROX_SIMPLE);
            std::vector<cv::Point> contours_poly;
            for (int j = 0; j < contours.size();j++) {
                cv::approxPolyDP(cv::Mat(contours[j]), contours_poly, 10, true);
                if (contours_poly.size() <= 2) continue;
                poly_masks.push_back(contours_poly);
                region_classes.push_back(cat);
                if (x_sort.count(centr_x)) centr_x += 0.0001;
                x_sort.insert(std::make_pair(centr_x, count));
                ++ count;
            }
        }    
    }

#if 0
    //6.draw lanes
    for (int i = 0; i < lanes.size(); ++i) {
        int thickness = 4;
        for (int j = 0; j < lanes[i].size()-1; ++j) {
            cv::line(mask_rmlane, lanes[i][j], lanes[i][j+1], {seg_colors[cats[i]][0],seg_colors[cats[i]][1],seg_colors[cats[i]][2]}, thickness);
            // std::cout << lanes[i][j] << " " << lanes[i][j+1] << " " << cats[i] << std::endl;
        }
    }
#endif
    return mask_rmlane;
}

cv::Mat RoadSegAnalysis::direct_post_process(bool large_resolution, unsigned char *direct_array, std::vector<std::vector<cv::Point>> &poly_masks, std::vector<int> &region_classes) {
    std::vector<int> pred_cls; 
    int h = 360, w = 640, step_size = h*w, seg_min_region_area = 512;
    cv::Mat mask_rmlane = cv::Mat_<int>(h,w); //车道线区域置为背景
	for (int i = 0; i < h; ++i) {
		for (int j = 0; j < w; ++j) {
			int max_cls = direct_array[(i * w + j)];
            pred_cls.push_back(max_cls);
            mask_rmlane.ptr<int>(i)[j] = max_cls;
		}
	}

#if 1 /*mask远处区域*/
    cv::Mat mask_black = mask_rmlane.clone();
    if (large_resolution)   mask_black(cv::Rect(0, 0, w, int(h * 0.14))) = 0;  
    else    mask_black(cv::Rect(0, 0, w, int(h * 0.22))) = 0;           
    mask_black(cv::Rect(0, int(h * 0.95), w, int(h * 0.05))) = 0;
    mask_black(cv::Rect(0, 0, int(w * 0.02), h)) = 0;
    mask_black(cv::Rect(int(w * 0.95), 0, int(w * 0.05), h)) = 0;
    mask_rmlane = mask_black;
#endif
    //去重获取预测到的类别
    std::vector<int> labels(pred_cls);
    std::sort(labels.begin(),labels.end());
    labels.erase(std::unique(labels.begin(),labels.end()),labels.end());
 
    //求道路区域
    for(auto cat: labels) {
        cv::Mat b_masks, measure_labels, stats, centroids;
        cv::Mat n_masks = cv::Mat_<int>(h,w);   n_masks = cv::Scalar(255);
        cv::compare(mask_rmlane, cat, b_masks, cv::CMP_EQ); //将mask_rmlane元素逐个和cat比较，相同255，不同0
        //连通域计算
        int nccomps = cv::connectedComponentsWithStats (b_masks, measure_labels, stats, centroids, 8);
        for(int i = 1; i < nccomps; i++ ) {	//跳过背景信息0
            if (stats.at<int>(i, cv::CC_STAT_AREA) < seg_min_region_area) { //移除过小的区域，并将对应位置置为0
                cv::Mat comparison_result;
                cv::compare(measure_labels, cv::Scalar(i), comparison_result, cv::CMP_EQ); //相等为255不等为0
                n_masks.setTo(0, comparison_result); // 将comparison_result中非零区域置为0
                cv::bitwise_and(mask_rmlane,n_masks,mask_rmlane);
                continue;
            }

            cv::Mat region_mask;
            cv::bitwise_and(measure_labels,n_masks,measure_labels);/////
            cv::compare(measure_labels, i, region_mask, cv::CMP_EQ);

            std::vector<std::vector<cv::Point>> contours;
            cv::findContours(region_mask,contours,cv::noArray(),cv::RETR_TREE,cv::CHAIN_APPROX_SIMPLE);
            std::vector<cv::Point> contours_poly;
            for (int j = 0; j < contours.size();j++) {
                cv::approxPolyDP(cv::Mat(contours[j]), contours_poly, 10, true);
                if (contours_poly.size() <= 2) continue;
                poly_masks.push_back(contours_poly);
                region_classes.push_back(cat);  
            }
        }    
    }
    return mask_rmlane;
}