0 引言

大多数分割算法都基于图像灰度值的两个基本性质之一：不连续性和相似性。第一类方法根据灰度的突变（如边缘）将图像分割为多个区域：首先寻找边缘线段，然后将这些线段连接为边界的方法来识别区域。第二类方法根据一组预定义的准则把一幅图像分割为多个区域。本节讨论两种相关的区域分割方法:(1)在数据中寻找聚类的经典方法，它与亮度和颜色等变量有关;(2)用聚类从图像中提取“超像素”的现代方法。

回到顶部

1 使用k均值聚类的区域分割

1.1 原理

聚类方法的思想是将样本集合按照其特征的相似性划分为若干类别，使同一类别样本的特征具有较高的相似性，不同类别样本的特征具有较大的差异性。令{z1, z2, z3 ..., zn}是样本集合，在图像分割中，样本向量z的每个分量表示一个数值像素属性。例如，分割只基于灰度尺度时，z是一个表示像素灰度的标量。分割的如果是RGB彩色图像，z通常是一个三维向量，这个三维向量的每个分量是RGB三通道的灰度值。k均值聚类的目的就是将样本集合划分为k个满足如下最优准则的不相交的聚类集合C={C1, C2, ..., Ck}：

式中，mi是集合Ci中样本的均值向量（或质心），||z-mi||项是Ci中的一个样本到均值mi的欧式距离。换言之，这个公式说，我们感兴趣的是找到集合C={C1, C2, ..., Ck}，集合中的每个点到该集合的均值的距离之和是最小的。

基于聚类的区域分割，就是基于图像的灰度、颜色、纹理、形状等特征，用聚类算法把图像分成若干类别或区域，使每个点到聚类中心的均值最小。k 均值（k-means）是一种无监督聚类算法。基于 k 均值聚类算法的区域分割，算法步骤为：

（1）初始化算法：规定一组初始均值

（2）将样本分配给聚类：对所有的像素点，计算像素到每个聚类中心的距离，将像素分类到距离最小的一个聚类中；

（3）更新聚类中心：根据分类结果计算出新的聚类中心；

（4）完备性验证：计算当前步骤和前几步中平均向量之间的差的欧几里得范数。计算残差E，即k个范数之和。若E≤T，其中T是一个规定的非负阈值，则停止。否则，返回步骤2。

1.2 cv::kmeans函数

OpenCV提供了函数cv::kmeans来实现 k-means 聚类算法。函数cv::kmeans不仅可以基于灰度、颜色对图像进行区域分割，也可以基于样本的其它特征如纹理、形状进行聚类。

double cv::kmeans(InputArray data,  //用于聚类的数据，类型为 CV_32F
                  int K, //设定的聚类数量
                  InputOutputArray bestLabels,  //输出整数数组，用于存储每个样本的聚类类别索引
                  TermCriteria criteria,  //算法终止条件：即最大迭代次数或所需精度
                  int attempts,  //用于指定使用不同初始标记执行算法的次数
                  int flags,  //初始化聚类中心的方法：0=随机初始化 1=kmeans++方法初始化 2=第一次用用户指定的标签初始化，后面attempts-1都用随机或版随机的初始化
                  OutputArray centers = noArray()  //聚类中心的输出矩阵，每个聚类中心占一行
                  )

示例图像分割之k均值聚类

Mat src = imread("./14.tif", 0);
Mat dataPixels = src.reshape(0, 1);//可以是一列，每一行表示一个样本；或者一行，一列是一个样本；样本的分量数为通道数
dataPixels.convertTo(dataPixels, CV_32FC1);//输入需要是32位浮点型
int numCluster = 3;
Mat labels;
Mat centers;
kmeans(dataPixels, numCluster, labels, TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 10, 0.1), 3, KMEANS_PP_CENTERS, centers);
Mat dst = Mat::zeros(src.size(), CV_8UC1);
float* pdata = dataPixels.ptr<float>(0);
for (int i = 0; i < src.rows * src.cols; i++) {
    int k = labels.ptr<int>(i)[0];//每个像素对应的标签k，即属于集合k
    pdata[i] = centers.ptr<float>(k)[0];//用集合中心替换该像素
}
dataPixels.convertTo(dataPixels, CV_8UC1);
dst = dataPixels.reshape(0, src.rows);

1.3 cv::kmeans源码

当图片非常大时，对图像进行简单的计算操作，耗时就会变得非常大，常用的加速方法如OpenMp,TBB,OpenCL和CUDA。使用cuda时，图片在cpu和gpu之间的传输时间就达到上百ms，不适合本来就是ms级的计算。在kmeans源码中使用parallel_for_并行计算各个样本到聚类中心的距离。这边写一个简单的例子，了解下parallel_for_的用法。

示例利用并行计算加速图片旋转

// 方法1：并行 将该方法写成一个类，继承ParallelLoopBody，然后重写()，利用parallel_for_可以开启并行
class trans :public ParallelLoopBody {
public:
    trans(const uchar* _src, uchar*_dst, int _dims, int _istep):src(_src), dst(_dst), dims(_dims), istep(_istep) {}
    void operator()(const Range& range) const //重载操作符()
    {
        for (int n = range.start; n < range.end; ++n)
        {
            for (int i = 0; i < dims; i++)
                dst[i * istep + (istep - 1 - n)] = src[n * dims + i];
        }
    }
private:
    const uchar* src;
    uchar* dst;
    int dims;
    int istep;
};
// 方法2 for循环
void rotate(Mat& src, Mat& dst, int srcWidth, int srcHeight)
{
    int istep = src.step;
    uchar* psrc = src.ptr<uchar>();
    uchar* pdst = dst.ptr<uchar>();
    for (size_t i = 0; i < srcHeight; i++)
        for (size_t j = 0; j < srcWidth; j++)
            pdst[j * istep + (istep-1-i)] = psrc[i * istep + j];
}
 
//调用
uchar* psrc = src.ptr<uchar>(); 
uchar* pdst = dst.ptr<uchar>();
int dims = src.cols;
int istep = src.step;
int N = src.rows;
rotate(src, dst, ROTATE_90_CLOCKWISE);// opencv提供的方法 3ms
rotate(src, dst, src.cols, src.rows);// 自己写的for循环 20ms
parallel_for_(Range(0, N), trans(psrc, pdst, dims, istep)); // 并行加速3ms

源码位于opencv路径下sources\modules\core\src\kmeans.cpp中，首先是初始化算法：规定一组初始center，一种是随机产生，另一种是用kmeans++初始化。kmeans++初始化聚类中心是以概率的形式逐个选择聚类中心，并在选择聚类中心时，给距离较远的点更高的权重，即更容易被选择为聚类中心。假设有5个点，随机选择其中一个点为中心，计算其他点到该点的距离的平方分别为10，20，5，15。则选下一个聚类中心时它们的权值为0.2,0.4,0.1和0.3。用代码写就是，距离平方和50，在【0,50】间随机生成一个数，用这个数挨个减去10，再减去20...直到结果小于0，下一个聚类中心就是该点。

// 随机产生聚类中心
// dims 样本向量的分量数
// box  存放了所有样本中每个分量的最大值和最小值
static void generateRandomCenter(int dims, const Vec2f* box, float* center, RNG& rng)
{
    float margin = 1.f / dims;
    for (int j = 0; j < dims; j++)
        center[j] = ((float)rng * (1.f + margin * 2.f) - margin) * (box[j][1] - box[j][0]) + box[j][0];
}
/*
k-means center initialization using the following algorithm:
Arthur & Vassilvitskii (2007) k-means++: The Advantages of Careful Seeding
*/
static void generateCentersPP(const Mat& data, Mat& _out_centers,
    int K, RNG& rng, int trials)
{
    CV_TRACE_FUNCTION();
    const int dims = data.cols, N = data.rows;
    cv::AutoBuffer<int, 64> _centers(K);
    int* centers = &_centers[0];
    cv::AutoBuffer<float, 0> _dist(N * 3);// 3倍样本数量大小，存不同时刻样本到最近聚类中心的距离
    float* dist = &_dist[0], * tdist = dist + N, * tdist2 = tdist + N;
    double sum0 = 0;
    // 第一个聚类中心随机生成
    centers[0] = (unsigned)rng % N;// %N 即可获得[0,N-1]的随机数
    // 计算所有样本到第一个中心的距离，并求和
    for (int i = 0; i < N; i++)
    {
        dist[i] = hal::normL2Sqr_(data.ptr<float>(i), data.ptr<float>(centers[0]), dims);
        sum0 += dist[i];
    }
    // 计算第2、3...个聚类中心，离第一个中心越远的点权重越高
    for (int k = 1; k < K; k++)
    {
        double bestSum = DBL_MAX;
        int bestCenter = -1;
 
        for (int j = 0; j < trials; j++)// 相当于随机抛硬币掉在哪个格子里，做trials次
        {
            double p = (double)rng * sum0;//(double)rng会产生0-1的随机数
            int ci = 0;
            for (; ci < N - 1; ci++)
            {
                p -= dist[ci];
                if (p <= 0)
                    break;
            }
            //选中第ci个样本为聚类中心，计算距离，如果有样本离新聚类中心更近，距离会被更新
            parallel_for_(Range(0, N),
                KMeansPPDistanceComputer(tdist2, data, dist, ci),
                (double)divUp((size_t)(dims * N), CV_KMEANS_PARALLEL_GRANULARITY));
            double s = 0;
            for (int i = 0; i < N; i++)//所有样本离其最近的聚类中心之和
            {
                s += tdist2[i];
            }
 
            if (s < bestSum)
            {
                bestSum = s;
                bestCenter = ci;
                std::swap(tdist, tdist2);// 把总和最小的数据暂存在tdist中
            }
        }
        if (bestCenter < 0)
            CV_Error(Error::StsNoConv, "kmeans: can't update cluster center (check input for huge or NaN values)");
        centers[k] = bestCenter;
        sum0 = bestSum;
        std::swap(dist, tdist);// 把总和最小的数据从tdist放入dist
    }
 
    for (int k = 0; k < K; k++)// centers中存放的是聚类中心对应的样本在样本集合中的索引
    {
        const float* src = data.ptr<float>(centers[k]);
        float* dst = _out_centers.ptr<float>(k);
        for (int j = 0; j < dims; j++)
            dst[j] = src[j];// 把k个聚类中心样本放到_out_centers中
    }
}

计算距离

// 并行计算每个样本距离中心的距离
// dist 3倍样本数量N的autobuffer，前N个存放上次的N个距离(dist_指向第一个)，后N个存放本次计算的N个距离(tdist2_指向第一个)
// data 样本向量集合
// ci   计算所有样本和第ci个样本的距离
class KMeansPPDistanceComputer : public ParallelLoopBody
{
public:
    KMeansPPDistanceComputer(float* tdist2_, const Mat& data_, const float* dist_, int ci_) :
        tdist2(tdist2_), data(data_), dist(dist_), ci(ci_)//成员初始化列表的写法
    { }
 
    void operator()(const cv::Range& range) const CV_OVERRIDE
    {
        CV_TRACE_FUNCTION();
        const int begin = range.start;
        const int end = range.end;
        const int dims = data.cols;
 
        for (int i = begin; i < end; i++)//遍历每一行，一行为一个样本向量，一个向量有dims个分量
        {//需要计算的是每个样本到离他最近的中心的距离，通过比较上一次dist中的距离和本次的tdist2哪个更小来实现
            tdist2[i] = std::min(hal::normL2Sqr_(data.ptr<float>(i), data.ptr<float>(ci), dims), dist[i]);
        }
    }
 
private:
    KMeansPPDistanceComputer& operator=(const KMeansPPDistanceComputer&); // = delete
 
    float* tdist2;
    const Mat& data;
    const float* dist;
    const int ci;
};

更新标签

// 并行计算每个样本到对应中心的距离，已知样本属于哪个集合，直接计算该样本到集合中心的距离
template<bool onlyDistance>
class KMeansDistanceComputer : public ParallelLoopBody
{
public:
    KMeansDistanceComputer(double* distances_,
        int* labels_,
        const Mat& data_,
        const Mat& centers_)
        : distances(distances_),
        labels(labels_),
        data(data_),
        centers(centers_)
    {
    }
 
    void operator()(const Range& range) const CV_OVERRIDE
    {
        CV_TRACE_FUNCTION();
        const int begin = range.start;
        const int end = range.end;
        const int K = centers.rows;
        const int dims = centers.cols;
 
        for (int i = begin; i < end; ++i)
        {
            const float* sample = data.ptr<float>(i);
            if (onlyDistance)// 只算距离，不重新分配标签
            {
                const float* center = centers.ptr<float>(labels[i]);
                distances[i] = hal::normL2Sqr_(sample, center, dims);
                continue;
            }
            else // 遍历每一个样本，计算该样本到每一个中心的距离，重新分配标签
            {
                int k_best = 0;
                double min_dist = DBL_MAX;
 
                for (int k = 0; k < K; k++)
                {
                    const float* center = centers.ptr<float>(k);
                    const double dist = hal::normL2Sqr_(sample, center, dims);
 
                    if (min_dist > dist)
                    {
                        min_dist = dist;
                        k_best = k;
                    }
                }
 
                distances[i] = min_dist;
                labels[i] = k_best;
            }
        }
    }
 
private:
    KMeansDistanceComputer& operator=(const KMeansDistanceComputer&); // = delete
 
    double* distances;
    int* labels;
    const Mat& data;
    const Mat& centers;
};

kmeans

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

//_data:特征向量集；K:聚类中心个数；_bestLabels:每个特征向量隶属聚类中心索引
 //criteria:迭代算法终止条件；attempts：尝试次数；
 //flags:第一次尝试初始化采取策略；_centers：存放聚类中心
double cv::kmeans(InputArray _data, int K,
    InputOutputArray _bestLabels,
    TermCriteria criteria, int attempts,
    int flags, OutputArray _centers)
{
    CV_INSTRUMENT_REGION();
    const int SPP_TRIALS = 3;
    Mat data0 = _data.getMat();
    const bool isrow = data0.rows == 1;// 输入的数据应该是一行，或者一列的，通道数是每个样本向量的分量数
    const int N = isrow ? data0.cols : data0.rows;// N表示样本向量个数
    const int dims = (isrow ? 1 : data0.cols) * data0.channels();// 每个样本向量的维度（分量数）
    const int type = data0.depth();//数据类型，应为32位浮点数
 
    attempts = std::max(attempts, 1);//至少尝试一次
    CV_Assert(data0.dims <= 2 && type == CV_32F && K > 0);
    CV_CheckGE(N, K, "Number of clusters should be more than number of elements");
 
    Mat data(N, dims, CV_32F, data0.ptr(), isrow ? dims * sizeof(float) : static_cast<size_t>(data0.step));
 
    _bestLabels.create(N, 1, CV_32S, -1, true);//_bestLabels为N*1大小矩阵，类型为32为有符号整型，每个样本向量有有一个标签
 
    Mat _labels, best_labels = _bestLabels.getMat();
    if (flags & CV_KMEANS_USE_INITIAL_LABELS) // 如果首次是由用户指定的
    {
        CV_Assert((best_labels.cols == 1 || best_labels.rows == 1) &&
            best_labels.cols * best_labels.rows == N &&
            best_labels.type() == CV_32S &&
            best_labels.isContinuous());
        best_labels.reshape(1, N).copyTo(_labels);
        for (int i = 0; i < N; i++)//将内容复制到_labels中
        {
            CV_Assert((unsigned)_labels.at<int>(i) < (unsigned)K);
        }
    }
    else //否则，创建空的_labels
    {
        if (!((best_labels.cols == 1 || best_labels.rows == 1) &&
            best_labels.cols * best_labels.rows == N &&
            best_labels.type() == CV_32S &&
            best_labels.isContinuous()))
        {
            _bestLabels.create(N, 1, CV_32S);
            best_labels = _bestLabels.getMat();
        }
        _labels.create(best_labels.size(), best_labels.type());
    }
    int* labels = _labels.ptr<int>();
 
    Mat centers(K, dims, type), old_centers(K, dims, type), temp(1, dims, type);
    cv::AutoBuffer<int, 64> counters(K);
    cv::AutoBuffer<double, 64> dists(N);
    RNG& rng = theRNG();
 
    if (criteria.type & TermCriteria::EPS)//算法精度
        criteria.epsilon = std::max(criteria.epsilon, 0.);
    else
        criteria.epsilon = FLT_EPSILON;
    criteria.epsilon *= criteria.epsilon;
 
    if (criteria.type & TermCriteria::COUNT)//最大迭代次数
        criteria.maxCount = std::min(std::max(criteria.maxCount, 2), 100);
    else
        criteria.maxCount = 100;
 
    if (K == 1)
    {
        attempts = 1;
        criteria.maxCount = 2;
    }
 
    cv::AutoBuffer<Vec2f, 64> box(dims);
    if (!(flags & KMEANS_PP_CENTERS))//随机初始化中心的话要计算下范围，在最大小值之间随机生成
    {
        {
            const float* sample = data.ptr<float>(0);
            for (int j = 0; j < dims; j++)
                box[j] = Vec2f(sample[j], sample[j]);
        }
        for (int i = 1; i < N; i++)
        {
            const float* sample = data.ptr<float>(i);
            for (int j = 0; j < dims; j++)
            {
                float v = sample[j];
                box[j][0] = std::min(box[j][0], v);
                box[j][1] = std::max(box[j][1], v);
            }
        }
    }
 
    double best_compactness = DBL_MAX;
    for (int a = 0; a < attempts; a++)//算法尝试次数为attempts次
    {
        double compactness = 0;
 
        for (int iter = 0; ;)
        {
            double max_center_shift = iter == 0 ? DBL_MAX : 0.0;
 
            swap(centers, old_centers);
            //循环初始，需要对centers进行初始化操作，这里主要是两种，一个是random，另一个是kmeans++算法
            if (iter == 0 && (a > 0 || !(flags & KMEANS_USE_INITIAL_LABELS)))
            {
                if (flags & KMEANS_PP_CENTERS)
                    generateCentersPP(data, centers, K, rng, SPP_TRIALS);
                else
                {
                    for (int k = 0; k < K; k++)
                        generateRandomCenter(dims, box.data(), centers.ptr<float>(k), rng);
                }
            }
            else //若为人工指定labels，或者不是第一次迭代，将样本划分进不同的集合，根据labels
            {
                // compute centers
                centers = Scalar(0); // 对centers进行初始化操作
                for (int k = 0; k < K; k++)
                    counters[k] = 0;// 对counter进行初始化操作，统计每个集合包含样本向量个数
 
                for (int i = 0; i < N; i++)// 将样本按照label分为k类，每一类计算样本值的总和、样本个数
                {
                    const float* sample = data.ptr<float>(i);
                    int k = labels[i];
                    float* center = centers.ptr<float>(k);
                    for (int j = 0; j < dims; j++)
                        center[j] += sample[j];
                    counters[k]++;
                }
 
                for (int k = 0; k < K; k++)// 遍历所有的集合，看有没有空的集合
                {
                    if (counters[k] != 0)
                        continue;
 
                    // if some cluster appeared to be empty then:
                    //   1. find the biggest cluster
                    //   2. find the farthest from the center point in the biggest cluster
                    //   3. exclude the farthest point from the biggest cluster and form a new 1-point cluster.
                    int max_k = 0;
                    for (int k1 = 1; k1 < K; k1++)// 1. 找最大的样本集合（counters中存放每个集合的样本数）
                    {
                        if (counters[max_k] < counters[k1])
                            max_k = k1;
                    }
 
                    double max_dist = 0;
                    int farthest_i = -1;
                    float* base_center = centers.ptr<float>(max_k);
                    float* _base_center = temp.ptr<float>(); // normalized
                    float scale = 1.f / counters[max_k];
                    for (int j = 0; j < dims; j++)
                        _base_center[j] = base_center[j] * scale;
 
                    for (int i = 0; i < N; i++)// 2. 找最大集合中离集合最远的点
                    {
                        if (labels[i] != max_k)
                            continue;
                        const float* sample = data.ptr<float>(i);
                        double dist = hal::normL2Sqr_(sample, _base_center, dims);
 
                        if (max_dist <= dist)
                        {
                            max_dist = dist;
                            farthest_i = i;
                        }
                    }
                    // 3. 从最大集合中去掉这个最远点，在空集合中加入该点
                    counters[max_k]--;
                    counters[k]++;
                    labels[farthest_i] = k;
 
                    const float* sample = data.ptr<float>(farthest_i);
                    float* cur_center = centers.ptr<float>(k);
                    for (int j = 0; j < dims; j++)
                    {
                        base_center[j] -= sample[j];//最大集合减去该样本的值
                        cur_center[j] += sample[j];//空集合加上该样本的值
                    }
                }
 
                for (int k = 0; k < K; k++)// 此时所有的集合都是有样本的
                {
                    float* center = centers.ptr<float>(k);
                    CV_Assert(counters[k] != 0);
 
                    float scale = 1.f / counters[k];
                    for (int j = 0; j < dims; j++)// center中是样本值的和,除以样本数量等于聚类中心
                        center[j] *= scale;
 
                    if (iter > 0)// 计算本次循环和上次聚类中心的差距，差距小于criteria.epsilon则为最后一次迭代
                    {
                        double dist = 0;
                        const float* old_center = old_centers.ptr<float>(k);
                        for (int j = 0; j < dims; j++)
                        {
                            double t = center[j] - old_center[j];
                            dist += t * t;
                        }
                        max_center_shift = std::max(max_center_shift, dist);
                    }
                }
            }
 
            bool isLastIter = (++iter == MAX(criteria.maxCount, 2) || max_center_shift <= criteria.epsilon);
 
            if (isLastIter)//是最后一次的话，就再计算下每个样本离聚类中心的距离，不重新分配标签以防出现空集合
            {
                // don't re-assign labels to avoid creation of empty clusters
                parallel_for_(Range(0, N), KMeansDistanceComputer<true>(dists.data(), labels, data, centers), (double)divUp((size_t)(dims * N), CV_KMEANS_PARALLEL_GRANULARITY));
                compactness = sum(Mat(Size(N, 1), CV_64F, &dists[0]))[0];// 记录距离和
                break;
            }
            else // 不是最后一次的话，计算距离的同时还要重新分配下标签，可能会导致空集合
            {
                // assign labels
                parallel_for_(Range(0, N), KMeansDistanceComputer<false>(dists.data(), labels, data, centers), (double)divUp((size_t)(dims * N * K), CV_KMEANS_PARALLEL_GRANULARITY));
            }
        }
        //compactness将记录所有距离，这里的距离是指，所有的特征向量到其聚类中心的距离之和，用于评价当前的聚类结果
        if (compactness < best_compactness)
        {
            best_compactness = compactness;
            if (_centers.needed())
            {
                if (_centers.fixedType() && _centers.channels() == dims)
                    centers.reshape(dims).copyTo(_centers);
                else
                    centers.copyTo(_centers);
            }
            _labels.copyTo(best_labels);
        }
    }
 
    return best_compactness;
}　

回到顶部

2 使用超像素的区域分割

超像素图像分割基于依赖于图像的颜色信息及空间关系信息，将图像分割为远超于目标个数、远小于像素数量的超像素块，达到尽可能保留图像中所有目标的边缘信息的目的，从而更好的辅助后续视觉任务（如目标检测、目标跟踪、语义分割等）。

超像素是由一系列位置相邻，颜色、亮度、纹理等特征相似的像素点组成的小区域，我们将其视为具有代表性的大“像素”，称为超像素。超像素技术通过像素的组合得到少量（相对于像素数量）具有感知意义的超像素区域，代替大量原始像素表达图像特征，可以极大地降低图像处理的复杂度、减小计算量。超像素分割的结果是覆盖整个图像的子区域的集合，或从图像中提取的轮廓线的集合。 超像素的数量越少，丧失的细节特征越多，但仍然能基本保留主要区域之间的边界及图像的基本拓扑。

常用的超像素分割方法有：简单线性迭代聚类（Simple Linear Iterative Clustering，SLIC）、能量驱动采样（Super-pixels Extracted via Energy-Driven Sampling，SEEDS）和线性谱聚类（Linear Spectral Clustering，LSC）。SLIC超像素算法是对上节讨论的k均值算法的一种改进，通常使用（但不限于）包含三个颜色分量和两个空间坐标的五维向量。

OpenCV 在 ximgproc 模块提供了ximgproc.createSuperpixelSLIC函数实现SLIC算法。需要编译opencv_contrib模块，可以参考VS2019编译Opencv4.6.0GPU版本，记得勾选ximgproc。

示例 SLIC超像素区域分割

#include<opencv2/ximgproc.hpp>
using namespace ximgproc;
...
Mat src = imread("./14.tif");
Mat slicLabel, slicMask, slicColor, slicDst;
Ptr<SuperpixelLSC> slic = createSuperpixelLSC(src);
slic->iterate(10);//迭代次数
slic->getLabels(slicLabel);//获取labels
slic->getLabelContourMask(slicMask);//获取超像素的边界
int number = slic->getNumberOfSuperpixels();//获取超像素的数量
src.setTo(Scalar(255, 255, 255), slicMask);