C++ 按质量/连接性对像素进行分组以进行图像处理（OpenCV）

我在OpenCV中使用它来帮助分割背景和前景。在用户标记前景和背景项目的帮助下，我可以得到一个结果

然而，结果会带来很多噪音。即使用户标记了面部和身体，我们仍然从选择区域之外获得像素

我可以使用什么样的技术来帮助清理这一点？谢谢

---

您可以使用findcontours获取分割图像中的所有轮廓，并删除除最大轮廓以外的所有轮廓

与前景相比，所有这些伪影看起来都很薄。因此，可能一个具有适当窗口大小的中值滤波器可以实现

以下是维基百科的一个例子：

---

OpenCV 3.0 beta版具有“连接组件”功能。您可以计算所有区域的面积并选择最大的区域

在OpenCV 2.4的情况下，可以包括connectedcomponents.cpp 从到您的项目，并使用“connectedComponentsWithStats”功能：

nLabels = connectedComponentsWithStats(mask, labelImage, stats, centroids, connectivity, CV_32S);

“stats”数组中的第五列（索引4）包含区域区域

connectedcomponents.cpp：

#include "precomp.hpp"
#include <vector>

namespace cv{
namespace connectedcomponents{

struct NoOp{
    NoOp(){
    }
    void init(int /*labels*/){
    }
    inline
    void operator()(int r, int c, int l){
        (void) r;
        (void) c;
        (void) l;
    }
    void finish(){}
};
struct Point2ui64{
    uint64 x, y;
    Point2ui64(uint64 _x, uint64 _y):x(_x), y(_y){}
};

struct CCStatsOp{
    const _OutputArray* _mstatsv;
    cv::Mat statsv;
    const _OutputArray* _mcentroidsv;
    cv::Mat centroidsv;
    std::vector<Point2ui64> integrals;

    CCStatsOp(OutputArray _statsv, OutputArray _centroidsv): _mstatsv(&_statsv), _mcentroidsv(&_centroidsv){
    }
    inline
    void init(int nlabels){
        _mstatsv->create(cv::Size(CC_STAT_MAX, nlabels), cv::DataType<int>::type);
        statsv = _mstatsv->getMat();
        _mcentroidsv->create(cv::Size(2, nlabels), cv::DataType<double>::type);
        centroidsv = _mcentroidsv->getMat();

        for(int l = 0; l < (int) nlabels; ++l){
            int *row = (int *) &statsv.at<int>(l, 0);
            row[CC_STAT_LEFT] = INT_MAX;
            row[CC_STAT_TOP] = INT_MAX;
            row[CC_STAT_WIDTH] = INT_MIN;
            row[CC_STAT_HEIGHT] = INT_MIN;
            row[CC_STAT_AREA] = 0;
        }
        integrals.resize(nlabels, Point2ui64(0, 0));
    }
    void operator()(int r, int c, int l){
        int *row = &statsv.at<int>(l, 0);
        row[CC_STAT_LEFT] = MIN(row[CC_STAT_LEFT], c);
        row[CC_STAT_WIDTH] = MAX(row[CC_STAT_WIDTH], c);
        row[CC_STAT_TOP] = MIN(row[CC_STAT_TOP], r);
        row[CC_STAT_HEIGHT] = MAX(row[CC_STAT_HEIGHT], r);
        row[CC_STAT_AREA]++;
        Point2ui64 &integral = integrals[l];
        integral.x += c;
        integral.y += r;
    }
    void finish(){
        for(int l = 0; l < statsv.rows; ++l){
            int *row = &statsv.at<int>(l, 0);
            row[CC_STAT_WIDTH] = row[CC_STAT_WIDTH] - row[CC_STAT_LEFT] + 1;
            row[CC_STAT_HEIGHT] = row[CC_STAT_HEIGHT] - row[CC_STAT_TOP] + 1;

            Point2ui64 &integral = integrals[l];
            double *centroid = &centroidsv.at<double>(l, 0);
            double area = ((unsigned*)row)[CC_STAT_AREA];
            centroid[0] = double(integral.x) / area;
            centroid[1] = double(integral.y) / area;
        }
    }
};

//Find the root of the tree of node i
template<typename LabelT>
inline static
LabelT findRoot(const LabelT *P, LabelT i){
    LabelT root = i;
    while(P[root] < root){
        root = P[root];
    }
    return root;
}

//Make all nodes in the path of node i point to root
template<typename LabelT>
inline static
void setRoot(LabelT *P, LabelT i, LabelT root){
    while(P[i] < i){
        LabelT j = P[i];
        P[i] = root;
        i = j;
    }
    P[i] = root;
}

//Find the root of the tree of the node i and compress the path in the process
template<typename LabelT>
inline static
LabelT find(LabelT *P, LabelT i){
    LabelT root = findRoot(P, i);
    setRoot(P, i, root);
    return root;
}

//unite the two trees containing nodes i and j and return the new root
template<typename LabelT>
inline static
LabelT set_union(LabelT *P, LabelT i, LabelT j){
    LabelT root = findRoot(P, i);
    if(i != j){
        LabelT rootj = findRoot(P, j);
        if(root > rootj){
            root = rootj;
        }
        setRoot(P, j, root);
    }
    setRoot(P, i, root);
    return root;
}

//Flatten the Union Find tree and relabel the components
template<typename LabelT>
inline static
LabelT flattenL(LabelT *P, LabelT length){
    LabelT k = 1;
    for(LabelT i = 1; i < length; ++i){
        if(P[i] < i){
            P[i] = P[P[i]];
        }else{
            P[i] = k; k = k + 1;
        }
    }
    return k;
}

//Based on "Two Strategies to Speed up Connected Components Algorithms", the SAUF (Scan array union find) variant
//using decision trees
//Kesheng Wu, et al
//Note: rows are encoded as position in the "rows" array to save lookup times
//reference for 4-way: {{-1, 0}, {0, -1}};//b, d neighborhoods
const int G4[2][2] = {{1, 0}, {0, -1}};//b, d neighborhoods
//reference for 8-way: {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}};//a, b, c, d neighborhoods
const int G8[4][2] = {{1, -1}, {1, 0}, {1, 1}, {0, -1}};//a, b, c, d neighborhoods
template<typename LabelT, typename PixelT, typename StatsOp = NoOp >
struct LabelingImpl{
LabelT operator()(const cv::Mat &I, cv::Mat &L, int connectivity, StatsOp &sop){
    CV_Assert(L.rows == I.rows);
    CV_Assert(L.cols == I.cols);
    CV_Assert(connectivity == 8 || connectivity == 4);
    const int rows = L.rows;
    const int cols = L.cols;
    //A quick and dirty upper bound for the maximimum number of labels.  The 4 comes from
    //the fact that a 3x3 block can never have more than 4 unique labels for both 4 & 8-way
    const size_t Plength = 4 * (size_t(rows + 3 - 1)/3) * (size_t(cols + 3 - 1)/3);
    LabelT *P = (LabelT *) fastMalloc(sizeof(LabelT) * Plength);
    P[0] = 0;
    LabelT lunique = 1;
    //scanning phase
    for(int r_i = 0; r_i < rows; ++r_i){
        LabelT * const Lrow = L.ptr<LabelT>(r_i);
        LabelT * const Lrow_prev = (LabelT *)(((char *)Lrow) - L.step.p[0]);
        const PixelT * const Irow = I.ptr<PixelT>(r_i);
        const PixelT * const Irow_prev = (const PixelT *)(((char *)Irow) - I.step.p[0]);
        LabelT *Lrows[2] = {
            Lrow,
            Lrow_prev
        };
        const PixelT *Irows[2] = {
            Irow,
            Irow_prev
        };
        if(connectivity == 8){
            const int a = 0;
            const int b = 1;
            const int c = 2;
            const int d = 3;
            const bool T_a_r = (r_i - G8[a][0]) >= 0;
            const bool T_b_r = (r_i - G8[b][0]) >= 0;
            const bool T_c_r = (r_i - G8[c][0]) >= 0;
            for(int c_i = 0; Irows[0] != Irow + cols; ++Irows[0], c_i++){
                if(!*Irows[0]){
                    Lrow[c_i] = 0;
                    continue;
                }
                Irows[1] = Irow_prev + c_i;
                Lrows[0] = Lrow + c_i;
                Lrows[1] = Lrow_prev + c_i;
                const bool T_a = T_a_r && (c_i + G8[a][1]) >= 0   && *(Irows[G8[a][0]] + G8[a][1]);
                const bool T_b = T_b_r                            && *(Irows[G8[b][0]] + G8[b][1]);
                const bool T_c = T_c_r && (c_i + G8[c][1]) < cols && *(Irows[G8[c][0]] + G8[c][1]);
                const bool T_d =          (c_i + G8[d][1]) >= 0   && *(Irows[G8[d][0]] + G8[d][1]);

                //decision tree
                if(T_b){
                    //copy(b)
                    *Lrows[0] = *(Lrows[G8[b][0]] + G8[b][1]);
                }else{//not b
                    if(T_c){
                        if(T_a){
                            //copy(c, a)
                            *Lrows[0] = set_union(P, *(Lrows[G8[c][0]] + G8[c][1]), *(Lrows[G8[a][0]] + G8[a][1]));
                        }else{
                            if(T_d){
                                //copy(c, d)
                                *Lrows[0] = set_union(P, *(Lrows[G8[c][0]] + G8[c][1]), *(Lrows[G8[d][0]] + G8[d][1]));
                            }else{
                                //copy(c)
                                *Lrows[0] = *(Lrows[G8[c][0]] + G8[c][1]);
                            }
                        }
                    }else{//not c
                        if(T_a){
                            //copy(a)
                            *Lrows[0] = *(Lrows[G8[a][0]] + G8[a][1]);
                        }else{
                            if(T_d){
                                //copy(d)
                                *Lrows[0] = *(Lrows[G8[d][0]] + G8[d][1]);
                            }else{
                                //new label
                                *Lrows[0] = lunique;
                                P[lunique] = lunique;
                                lunique = lunique + 1;
                            }
                        }
                    }
                }
            }
        }else{
            //B & D only
            const int b = 0;
            const int d = 1;
            const bool T_b_r = (r_i - G4[b][0]) >= 0;
            for(int c_i = 0; Irows[0] != Irow + cols; ++Irows[0], c_i++){
                if(!*Irows[0]){
                    Lrow[c_i] = 0;
                    continue;
                }
                Irows[1] = Irow_prev + c_i;
                Lrows[0] = Lrow + c_i;
                Lrows[1] = Lrow_prev + c_i;
                const bool T_b = T_b_r                            && *(Irows[G4[b][0]] + G4[b][1]);
                const bool T_d =          (c_i + G4[d][1]) >= 0   && *(Irows[G4[d][0]] + G4[d][1]);
                if(T_b){
                    if(T_d){
                        //copy(d, b)
                        *Lrows[0] = set_union(P, *(Lrows[G4[d][0]] + G4[d][1]), *(Lrows[G4[b][0]] + G4[b][1]));
                    }else{
                        //copy(b)
                        *Lrows[0] = *(Lrows[G4[b][0]] + G4[b][1]);
                    }
                }else{
                    if(T_d){
                        //copy(d)
                        *Lrows[0] = *(Lrows[G4[d][0]] + G4[d][1]);
                    }else{
                        //new label
                        *Lrows[0] = lunique;
                        P[lunique] = lunique;
                        lunique = lunique + 1;
                    }
                }
            }
        }
    }

    //analysis
    LabelT nLabels = flattenL(P, lunique);
    sop.init(nLabels);

    for(int r_i = 0; r_i < rows; ++r_i){
        LabelT *Lrow_start = L.ptr<LabelT>(r_i);
        LabelT *Lrow_end = Lrow_start + cols;
        LabelT *Lrow = Lrow_start;
        for(int c_i = 0; Lrow != Lrow_end; ++Lrow, ++c_i){
            const LabelT l = P[*Lrow];
            *Lrow = l;
            sop(r_i, c_i, l);
        }
    }

    sop.finish();
    fastFree(P);

    return nLabels;
}//End function LabelingImpl operator()

};//End struct LabelingImpl
}//end namespace connectedcomponents

//L's type must have an appropriate depth for the number of pixels in I
template<typename StatsOp>
static
int connectedComponents_sub1(const cv::Mat &I, cv::Mat &L, int connectivity, StatsOp &sop){
CV_Assert(L.channels() == 1 && I.channels() == 1);
CV_Assert(connectivity == 8 || connectivity == 4);

int lDepth = L.depth();
int iDepth = I.depth();
using connectedcomponents::LabelingImpl;
//warn if L's depth is not sufficient?

CV_Assert(iDepth == CV_8U || iDepth == CV_8S);

if(lDepth == CV_8U){
    return (int) LabelingImpl<uchar, uchar, StatsOp>()(I, L, connectivity, sop);
}else if(lDepth == CV_16U){
    return (int) LabelingImpl<ushort, uchar, StatsOp>()(I, L, connectivity, sop);
}else if(lDepth == CV_32S){
    //note that signed types don't really make sense here and not being able to use unsigned matters for scientific projects
    //OpenCV: how should we proceed?  .at<T> typechecks in debug mode
    return (int) LabelingImpl<int, uchar, StatsOp>()(I, L, connectivity, sop);
}

CV_Error(CV_StsUnsupportedFormat, "unsupported label/image type");
return -1;
}

}

int cv::connectedComponents(InputArray _img, OutputArray _labels, int connectivity, int ltype){
const cv::Mat img = _img.getMat();
_labels.create(img.size(), CV_MAT_DEPTH(ltype));
cv::Mat labels = _labels.getMat();
connectedcomponents::NoOp sop;
if(ltype == CV_16U){
    return connectedComponents_sub1(img, labels, connectivity, sop);
}else if(ltype == CV_32S){
    return connectedComponents_sub1(img, labels, connectivity, sop);
}else{
    CV_Error(CV_StsUnsupportedFormat, "the type of labels must be 16u or 32s");
    return 0;
}
}

int cv::connectedComponentsWithStats(InputArray _img, OutputArray _labels, OutputArray statsv,
                                 OutputArray centroids, int connectivity, int ltype)
{
const cv::Mat img = _img.getMat();
_labels.create(img.size(), CV_MAT_DEPTH(ltype));
cv::Mat labels = _labels.getMat();
connectedcomponents::CCStatsOp sop(statsv, centroids);
if(ltype == CV_16U){
    return connectedComponents_sub1(img, labels, connectivity, sop);
}else if(ltype == CV_32S){
    return connectedComponents_sub1(img, labels, connectivity, sop);
}else{
    CV_Error(CV_StsUnsupportedFormat, "the type of labels must be 16u or 32s");
    return 0;
}
}

#包括“precomp.hpp”
#包括
命名空间cv{
名称空间连接组件{
结构NoOp{
NoOp（）{
}
void init（int/*标签*/）{
}
内联
void运算符（）（int r，int c，int l）{
（无效）r；
（c）无效；
（无效）l；
}
void finish（）{}
};
结构点2UI64{
uint64 x，y；
点2ui64（uint64_x，uint64_y）：x（x），y（y）{
};
结构CCStatsOp{
常数输出阵列*mstatsv；
cv：：Mat statsv；
常量输出*\u mcentroidsv；
cv：：Mat质心SV；
向量积分；
CCStatsOp（输出阵列、输出阵列和中心SV）：\mstatsv（&\U statsv）、\mcentroidsv（&\U中心SV）{
}
内联
void init（int-nlabels）{
_mstatsv->create（cv:：Size（CC_STAT_MAX，nlabels），cv:：DataType:：type）；
statsv=\u mstatsv->getMat（）；
_mcentroidsv->create（cv:：Size（2，nlabels），cv:：DataType:：type）；
质心SV=\u mcentroidsv->getMat（）；
对于（int l=0；l<（int）nlabels；++l）{
int*行=（int*）和statsv.at（l，0）；
行[CC_STAT_LEFT]=INT_MAX；
行[CC_STAT_TOP]=INT_MAX；
行[CC_STAT_WIDTH]=INT_MIN；
行[CC_STAT_HEIGHT]=INT_MIN；
行[CC_STAT_AREA]=0；
}
调整大小（nlabels，Point2ui64（0,0））；
}
void运算符（）（int r，int c，int l）{
int*row=&statsv.at（l，0）；
行[CC_STAT_LEFT]=MIN（行[CC_STAT_LEFT]，c）；
行[CC_STAT_WIDTH]=MAX（行[CC_STAT_WIDTH]，c）；
行[CC_STAT_TOP]=MIN（行[CC_STAT_TOP]，r）；
行[CC_STAT_HEIGHT]=最大值（行[CC_STAT_HEIGHT]，r）；
行[CC_STAT_AREA]+；
点2ui64&integral=积分[l]；
积分x+=c；
积分y+=r；
}
空隙饰面（）{
对于（int l=0；l根）{
根=根j；
}
毛根（P，j，根）；
}
setRoot（P，i，root）；
返回根；
}
//展平联合查找树并重新标记组件
模板
内联静态
唇带扁平度（唇带*P，唇带长度）{
LabelT k=1；
对于（标签i=1；i