图像处理（三）——中国传统工艺画风格的图像转换应用

中国传统工艺画风格的图像转换应用

1. 项目介绍

　　希望做一个应用，输入为普通RGB或HSI图像，输出为带有中国特色的蛋壳粘贴画。使用的技术有Matlab、superpixel算法等。

　　

　　                                        蛋壳粘贴画示意

　　如图，蛋壳粘贴画每一块破碎的蛋壳就像是一个超像素。项目构思为：首先利用superpixel算法找出超像素，对原图像进行分割；在每个超像素内求各像素点的均值，作为整块超像素的颜色值。这样每个超像素作为一块破碎的蛋壳，一幅蛋壳粘贴画就成功生成了！

 

2. 实现过程

　　在网上找到了superpixel算法的C语言实现，同时给出了调用C（语言实现的）函数的.m文件。但是没有找到Matlab代码实现的superpixel算法。于是想跟找到的代码一样，利用Matlab运行 .c文件。之后对 .c文件进行阅读、修改、增加自己的功能，以达到项目的目标。

 

2.1 尝试用Matlab运行 .c文件

　　我的Matlab要想在.m文件中调用C（语言实现的）函数还需要进行配置。

　　网上的教程说需要使用mex命令，以某种方式编译过C文件后才可以被Matlab运行。尝试运行mex命令：

　　

　　错误的原因是Windows SDK 7.1已经安装，但是它所携带的编译器没有安装。提示安装.NET Framework 4.0，之后重新运行Windows SDK 7.1的安装程序，勾选“Visual C++ Compilers”，这样Windows SDK 7.1的安装程序就会安装编译器。

　　另一种方法是“Install MinGW-w64 Compiler”，已经试过安装，但没有成功。

　　后来我发现其他人的电脑直接就能mex -setup成功，不会报错，因为装了VS2013；而我的电脑装的是VS2015，所以版本新并不一定好...

 

2.2 安装.NET Framework 4.0

　　从http://www.microsoft.com/zh-cn/download/details.aspx?id=17718下载.NET Framework 4.0独立安装包，进行安装。出现以下提示。

　　

　　意思是.NET Framework 4.0已经安装好了。我的系统是win10专业版。

 

2.3 再次运行Windows SDK 7.1的安装程序

　　安装程序是从http://www.microsoft.com/en-us/download/details.aspx?id=8279下载的。运行结果：

　　

　　“Visual C++ Compilers”选项不可勾选，将鼠标移到这个选项上显示“This feature is disabled because required .NET Framework 4.0 is not installed”。错误原因又是.NET Framework 4.0没有安装。刚才明明提示.NET Framework 4.0已经是系统的一部分。我的系统是win10专业版。

　　不知如何是好。

　　问题应该在于我的电脑里装了.NET Framework 4.6，它是.NET Framework 4.0的升级版，无法在有.NET 4.6的情况下安装.NET 4.0，因为他们本质上就是一个东西！

　　问题困扰了我那么久的原因：

　　　　a. 电脑上安装的是VS2015，而不是VS2013；

　　　　b. 原则上.NET 4.6应该兼容.NET 4.0，但是“Visual C++ Compilers”只认.NET 4.0；

　　　　c. 要先卸载.NET 4.6才能安装.NET 4.0，但是系统中.NET 4.6卸载不干净！

 

2.4 用Matlab运行简单的 .c文件

　　最后终于可以在我的matlab中运行 .c文件了，解决方法是直接安装“VC-Compiler-KB2519277.exe”（下载地址）。之后在matlab命令行中先后执行以下两条命令:

mex -setup
mex -setup C++

　　编译器即配置完成！

　　测试一下，编写一个简单的add.c，代码如下：　　

#include "mex.h" // 使用MEX文件必须包含的头文件

// 执行具体工作的C函数
double add(double x, double y)
{
    return x + y;
}

// MEX文件接口函数
void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
{
    double *a;
    double b, c;
    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
    a = mxGetPr(plhs[0]);
    b = *(mxGetPr(prhs[0]));
    c = *(mxGetPr(prhs[1]));
    *a = add(b, c);
}

　　在matlab命令行中执行命令:

mex add.c

　　之后就可以在matlab中直接调用add函数了，如下图：

　　

　　以上add.c 并不是单纯的C语言代码，内部代码多出了一个MEX文件接口函数。

　　

2.4 用Matlab运行自己的 .c文件

　　这是从网站上下载的slicmex.c，原文件下载，这里的slicmex.c经过了修改。

　　slicmex.c:

#include <mex.h>
#include <stdio.h>
#include <math.h>
#include <float.h>

void rgbtolab(int* rin, int* gin, int* bin, int sz, double* lvec, double* avec, double* bvec)
{
    int i; int sR, sG, sB;
    double R,G,B;
    double X,Y,Z;
    double r, g, b;
    const double epsilon = 0.008856;    //actual CIE standard
    const double kappa   = 903.3;        //actual CIE standard
    
    const double Xr = 0.950456;    //reference white
    const double Yr = 1.0;        //reference white
    const double Zr = 1.088754;    //reference white
    double xr,yr,zr;
    double fx, fy, fz;
    double lval,aval,bval;
    
    for(i = 0; i < sz; i++)
    {
        sR = rin[i]; sG = gin[i]; sB = bin[i];
        R = sR/255.0;
        G = sG/255.0;
        B = sB/255.0;
        
        if(R <= 0.04045)    r = R/12.92;
        else                r = pow((R+0.055)/1.055,2.4);
        if(G <= 0.04045)    g = G/12.92;
        else                g = pow((G+0.055)/1.055,2.4);
        if(B <= 0.04045)    b = B/12.92;
        else                b = pow((B+0.055)/1.055,2.4);
        
        X = r*0.4124564 + g*0.3575761 + b*0.1804375;
        Y = r*0.2126729 + g*0.7151522 + b*0.0721750;
        Z = r*0.0193339 + g*0.1191920 + b*0.9503041;
        
        //------------------------
        // XYZ to LAB conversion
        //------------------------
        xr = X/Xr;
        yr = Y/Yr;
        zr = Z/Zr;
        
        if(xr > epsilon)    fx = pow(xr, 1.0/3.0);
        else                fx = (kappa*xr + 16.0)/116.0;
        if(yr > epsilon)    fy = pow(yr, 1.0/3.0);
        else                fy = (kappa*yr + 16.0)/116.0;
        if(zr > epsilon)    fz = pow(zr, 1.0/3.0);
        else                fz = (kappa*zr + 16.0)/116.0;
        
        lval = 116.0*fy-16.0;
        aval = 500.0*(fx-fy);
        bval = 200.0*(fy-fz);
        
        lvec[i] = lval; avec[i] = aval; bvec[i] = bval;
    }
}

void getLABXYSeeds(int STEP, int width, int height, int* seedIndices, int* numseeds)
{
    const bool hexgrid = false;
    int n;
    int xstrips, ystrips;
    int xerr, yerr;
    double xerrperstrip,yerrperstrip;
    int xoff,yoff;
    int x,y;
    int xe,ye;
    int seedx,seedy;
    int i;

    xstrips = (0.5+(double)(width)/(double)(STEP));
    ystrips = (0.5+(double)(height)/(double)(STEP));
    
    xerr = width  - STEP*xstrips;if(xerr < 0){xstrips--;xerr = width - STEP*xstrips;}
    yerr = height - STEP*ystrips;if(yerr < 0){ystrips--;yerr = height- STEP*ystrips;}
    
    xerrperstrip = (double)(xerr)/(double)(xstrips);
    yerrperstrip = (double)(yerr)/(double)(ystrips);
    
    xoff = STEP/2;
    yoff = STEP/2;
    
    n = 0;
    for( y = 0; y < ystrips; y++ )
    {
        ye = y*yerrperstrip;
        for( x = 0; x < xstrips; x++ )
        {
            xe = x*xerrperstrip;
            seedx = (x*STEP+xoff+xe);
            if(hexgrid){ seedx = x*STEP+(xoff<<(y&0x1))+xe; if(seedx >= width)seedx = width-1; }//for hex grid sampling
            seedy = (y*STEP+yoff+ye);
            i = seedy*width + seedx;
            seedIndices[n] = i;
            n++;
        }
    }
    *numseeds = n;
}

void PerformSuperpixelSLIC(double* lvec, double* avec, double* bvec, double* kseedsl, double* kseedsa, double* kseedsb, double* kseedsx, double* kseedsy, int width, int height, int numseeds, int* klabels, int STEP, double compactness)
{
    int x1, y1, x2, y2;
    double l, a, b;
    double dist;
    double distxy;
    int itr;
    int n;
    int x,y;
    int i;
    int ind;
    int r,c;
    int k;
    int sz = width*height;
    const int numk = numseeds;
    int offset = STEP;
    
    double* clustersize = mxMalloc(sizeof(double)*numk);
    double* inv         = mxMalloc(sizeof(double)*numk);
    double* sigmal      = mxMalloc(sizeof(double)*numk);
    double* sigmaa      = mxMalloc(sizeof(double)*numk);
    double* sigmab      = mxMalloc(sizeof(double)*numk);
    double* sigmax      = mxMalloc(sizeof(double)*numk);
    double* sigmay      = mxMalloc(sizeof(double)*numk);
    double* distvec     = mxMalloc(sizeof(double)*sz);
    double invwt = 1.0/((STEP/compactness)*(STEP/compactness));
    
    for( itr = 0; itr < 10; itr++ )
    {
        for(i = 0; i < sz; i++){distvec[i] = DBL_MAX;}
     
        for( n = 0; n < numk; n++ )
        {
            x1 = kseedsx[n]-offset; if(x1 < 0) x1 = 0;
            y1 = kseedsy[n]-offset; if(y1 < 0) y1 = 0;
            x2 = kseedsx[n]+offset; if(x2 > width)  x2 = width;
            y2 = kseedsy[n]+offset; if(y2 > height) y2 = height;
            
            for( y = y1; y < y2; y++ )
            {
                for( x = x1; x < x2; x++ )
                {
                    i = y*width + x;
                    
                    l = lvec[i];
                    a = avec[i];
                    b = bvec[i];
                    
                    dist =            (l - kseedsl[n])*(l - kseedsl[n]) +
                                    (a - kseedsa[n])*(a - kseedsa[n]) +
                                    (b - kseedsb[n])*(b - kseedsb[n]);
                    
                    distxy =        (x - kseedsx[n])*(x - kseedsx[n]) + (y - kseedsy[n])*(y - kseedsy[n]);
                    
                    dist += distxy*invwt;
                    
                    if(dist < distvec[i])
                    {
                        distvec[i] = dist;
                        klabels[i]  = n;
                    }
                }
            }
        }
        //-----------------------------------------------------------------
        // Recalculate the centroid and store in the seed values
        //-----------------------------------------------------------------
        for(k = 0; k < numk; k++)
        {
            sigmal[k] = 0;
            sigmaa[k] = 0;
            sigmab[k] = 0;
            sigmax[k] = 0;
            sigmay[k] = 0;
            clustersize[k] = 0;
        }
        
        ind = 0;
        for( r = 0; r < height; r++ )
        {
            for( c = 0; c < width; c++ )
            {
                if(klabels[ind] >= 0)
                {
                    sigmal[klabels[ind]] += lvec[ind];
                    sigmaa[klabels[ind]] += avec[ind];
                    sigmab[klabels[ind]] += bvec[ind];
                    sigmax[klabels[ind]] += c;
                    sigmay[klabels[ind]] += r;
                    clustersize[klabels[ind]] += 1.0;
                }
                ind++;
            }
        }
        
        {for( k = 0; k < numk; k++ )
        {
            if( clustersize[k] <= 0 ) clustersize[k] = 1;
            inv[k] = 1.0/clustersize[k];//computing inverse now to multiply, than divide later
        }}
        
        {for( k = 0; k < numk; k++ )
        {
            kseedsl[k] = sigmal[k]*inv[k];
            kseedsa[k] = sigmaa[k]*inv[k];
            kseedsb[k] = sigmab[k]*inv[k];
            kseedsx[k] = sigmax[k]*inv[k];
            kseedsy[k] = sigmay[k]*inv[k];
        }}
    }
    mxFree(sigmal);
    mxFree(sigmaa);
    mxFree(sigmab);
    mxFree(sigmax);
    mxFree(sigmay);
    mxFree(clustersize);
    mxFree(inv);
    mxFree(distvec);
}

void EnforceSuperpixelConnectivity(int* labels, int width, int height, int numSuperpixels,int* nlabels, int* finalNumberOfLabels)
{
    int i,j,k;
    int n,c,count;
    int x,y;
    int ind;
    int oindex, adjlabel;
    int label;
    const int dx4[4] = {-1,  0,  1,  0};
    const int dy4[4] = { 0, -1,  0,  1};
    const int sz = width*height;
    const int SUPSZ = sz/numSuperpixels;
    int* xvec = mxMalloc(sizeof(int)*SUPSZ*10);
    int* yvec = mxMalloc(sizeof(int)*SUPSZ*10);

    for( i = 0; i < sz; i++ ) nlabels[i] = -1;
    oindex = 0;
    adjlabel = 0;//adjacent label
    label = 0;
    for( j = 0; j < height; j++ )
    {
        for( k = 0; k < width; k++ )
        {
            if( 0 > nlabels[oindex] )
            {
                nlabels[oindex] = label;
                //--------------------
                // Start a new segment
                //--------------------
                xvec[0] = k;
                yvec[0] = j;
                //-------------------------------------------------------
                // Quickly find an adjacent label for use later if needed
                //-------------------------------------------------------
                {for( n = 0; n < 4; n++ )
                {
                    int x = xvec[0] + dx4[n];
                    int y = yvec[0] + dy4[n];
                    if( (x >= 0 && x < width) && (y >= 0 && y < height) )
                    {
                        int nindex = y*width + x;
                        if(nlabels[nindex] >= 0) adjlabel = nlabels[nindex];
                    }
                }}
                
                count = 1;
                for( c = 0; c < count; c++ )
                {
                    for( n = 0; n < 4; n++ )
                    {
                        x = xvec[c] + dx4[n];
                        y = yvec[c] + dy4[n];
                        
                        if( (x >= 0 && x < width) && (y >= 0 && y < height) )
                        {
                            int nindex = y*width + x;
                            
                            if( 0 > nlabels[nindex] && labels[oindex] == labels[nindex] )
                            {
                                xvec[count] = x;
                                yvec[count] = y;
                                nlabels[nindex] = label;
                                count++;
                            }
                        }
                        
                    }
                }
                //-------------------------------------------------------
                // If segment size is less then a limit, assign an
                // adjacent label found before, and decrement label count.
                //-------------------------------------------------------
                if(count <= SUPSZ >> 2)
                {
                    for( c = 0; c < count; c++ )
                    {
                        ind = yvec[c]*width+xvec[c];
                        nlabels[ind] = adjlabel;
                    }
                    label--;
                }
                label++;
            }
            oindex++;
        }
    }
    *finalNumberOfLabels = label;
    
    mxFree(xvec);
    mxFree(yvec);
}

void mexFunction(int nlhs, mxArray *plhs[],
                 int nrhs, const mxArray *prhs[])
{
    int width;
    int height;
    int sz;
    int i, ii;
    int x, y;
    int* rin; int* gin; int* bin;
    int* klabels;
    int* clabels;
    double* lvec; double* avec; double* bvec;
    int step;
    int* seedIndices;
    int numseeds;
    double* kseedsx;double* kseedsy;
    double* kseedsl;double* kseedsa;double* kseedsb;
    int k;
    const mwSize* dims;//int* dims;
    int* outputNumSuperpixels;
    int* outlabels;
    int finalNumberOfLabels;
    unsigned char* imgbytes;
    int numelements;
    int numSuperpixels = 200;//default value
    double compactness = 10;//default value
    int numdims;
    
    if (nrhs < 1) {
        mexErrMsgTxt("At least one argument is required.") ;
    } else if(nrhs > 3) {
        mexErrMsgTxt("Too many input arguments.");
    }
    if(nlhs!=2) {
        mexErrMsgIdAndTxt("SLIC:nlhs","Two outputs required, a labels and the number of labels, i.e superpixels.");
    }
    //---------------------------
    numelements   = mxGetNumberOfElements(prhs[0]) ;
    numdims = mxGetNumberOfDimensions(prhs[0]) ;
    dims  = mxGetDimensions(prhs[0]) ;
    imgbytes  = (unsigned char*)mxGetData(prhs[0]) ;//mxGetData returns a void pointer, so cast it
    width = dims[1]; height = dims[0];//Note: first dimension provided is height and second is width
    sz = width*height;
    //---------------------------
    numSuperpixels  = mxGetScalar(prhs[1]);
    compactness     = mxGetScalar(prhs[2]);
    
    //---------------------------
    // Allocate memory
    //---------------------------
    rin    = mxMalloc( sizeof(int)      * sz ) ;
    gin    = mxMalloc( sizeof(int)      * sz ) ;
    bin    = mxMalloc( sizeof(int)      * sz ) ;
    lvec    = mxMalloc( sizeof(double)      * sz ) ;
    avec    = mxMalloc( sizeof(double)      * sz ) ;
    bvec    = mxMalloc( sizeof(double)      * sz ) ;
    klabels = mxMalloc( sizeof(int)         * sz );//original k-means labels
    clabels = mxMalloc( sizeof(int)         * sz );//corrected labels after enforcing connectivity
    seedIndices = mxMalloc( sizeof(int)     * sz );
    
    //---------------------------
    // Perform color conversion
    //---------------------------
    //if(2 == numdims)
    if(numelements/sz == 1)//if it is a grayscale image, copy the values directly into the lab vectors
    {
        for(x = 0, ii = 0; x < width; x++)//reading data from column-major MATLAB matrics to row-major C matrices (i.e perform transpose)
        {
            for(y = 0; y < height; y++)
            {
                i = y*width+x;
                lvec[i] = imgbytes[ii];
                avec[i] = imgbytes[ii];
                bvec[i] = imgbytes[ii];
                ii++;
            }
        }
    }
    else//else covert from rgb to lab
    {
        for(x = 0, ii = 0; x < width; x++)//reading data from column-major MATLAB matrics to row-major C matrices (i.e perform transpose)
        {
            for(y = 0; y < height; y++)
            {
                i = y*width+x;
                rin[i] = imgbytes[ii];
                gin[i] = imgbytes[ii+sz];
                bin[i] = imgbytes[ii+sz+sz];
                ii++;
            }
        }
        rgbtolab(rin,gin,bin,sz,lvec,avec,bvec);
    }
    //---------------------------
    // Find seeds
    //---------------------------
    step = sqrt((double)(sz)/(double)(numSuperpixels))+0.5;
    getLABXYSeeds(step,width,height,seedIndices,&numseeds);
    
    kseedsx    = mxMalloc( sizeof(double)      * numseeds ) ;
    kseedsy    = mxMalloc( sizeof(double)      * numseeds ) ;
    kseedsl    = mxMalloc( sizeof(double)      * numseeds ) ;
    kseedsa    = mxMalloc( sizeof(double)      * numseeds ) ;
    kseedsb    = mxMalloc( sizeof(double)      * numseeds ) ;
    for(k = 0; k < numseeds; k++)
    {
        kseedsx[k] = seedIndices[k]%width;
        kseedsy[k] = seedIndices[k]/width;
        kseedsl[k] = lvec[seedIndices[k]];
        kseedsa[k] = avec[seedIndices[k]];
        kseedsb[k] = bvec[seedIndices[k]];
    }
    //---------------------------
    // Compute superpixels
    //---------------------------
    PerformSuperpixelSLIC(lvec, avec, bvec, kseedsl,kseedsa,kseedsb,kseedsx,kseedsy,width,height,numseeds,klabels,step,compactness);
    //---------------------------
    // Enforce connectivity
    //---------------------------
    EnforceSuperpixelConnectivity(klabels,width,height,numSuperpixels,clabels,&finalNumberOfLabels);
    //---------------------------
    // Assign output labels
    //---------------------------
    plhs[0] = mxCreateNumericMatrix(height,width,mxINT32_CLASS,mxREAL);
    outlabels = mxGetData(plhs[0]);
    for(x = 0, ii = 0; x < width; x++)//copying data from row-major C matrix to column-major MATLAB matrix (i.e. perform transpose)
    {
        for(y = 0; y < height; y++)
        {
            i = y*width+x;
            outlabels[ii] = clabels[i];
            ii++;
        }
    }
    //---------------------------
    // Assign number of labels/seeds
    //---------------------------
    plhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
    outputNumSuperpixels = (int*)mxGetData(plhs[1]);//gives a void*, cast it to int*
    *outputNumSuperpixels = finalNumberOfLabels;
    //---------------------------
    // Deallocate memory
    //---------------------------
    mxFree(rin);
    mxFree(gin);
    mxFree(bin);
    mxFree(lvec);
    mxFree(avec);
    mxFree(bvec);
    mxFree(klabels);
    mxFree(clabels);
    mxFree(seedIndices);
    mxFree(kseedsx);
    mxFree(kseedsy);
    mxFree(kseedsl);
    mxFree(kseedsa);
    mxFree(kseedsb);
}

　　在matlab命令行中执行命令:

mex slicmex.c

　　就可以直接调用slicmex()函数了。

2.5 编写matlab代码

　　myslic_function2.m代码:

%======================================================================
% 此函数将图像分为超像素块，块儿内颜色取值一样，为之前块儿内颜色的均值
%======================================================================
function imgout=myslic_function2(imgin, number_of_sp, compactness_factor)

imgout = imgin;
[m,n] = size(imgin);
n=n/3;

[labels, numlabels] = slicmex(imgin,number_of_sp,compactness_factor);%numlabels is the same as number of superpixels

imgin = int32(imgin);
labelstmp = labels;
% 以下所有代码是将RGB图像的三个通道，以labels为模板，分别求每个超像素内颜色的均值。
img = imgin(:,:,1);
img1 = img;
for i = 1 : m
    for j = 1 : n
        if (labelstmp(i, j) >= 0)
            current = labelstmp(i, j);
            sums = 0;
            count = 0;
            %average= 0;
            % 找到一个块，计算块儿内颜色的均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        sums = sums + img(ii, jj);
                        count = count + 1;
                    end
                end
            end
            average = sums / count;
            % 将块儿内颜色设为均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        img1(ii, jj) = average;
                        labelstmp(ii, jj) = -1;
                    end
                end
            end            
        end
    end
end
imgout(:,:,1) = img1;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
labelstmp = labels;
img = imgin(:,:,2);
img1 = img;
for i = 1 : m
    for j = 1 : n
        if (labelstmp(i, j) >= 0)
            current = labelstmp(i, j);
            sums = 0;
            count = 0;
            %average= 0;
            % 找到一个块，计算块儿内颜色的均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        sums = sums + img(ii, jj);
                        count = count + 1;
                    end
                end
            end
            average = sums / count;
            % 将块儿内颜色设为均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        img1(ii, jj) = average;
                        labelstmp(ii, jj) = -1;
                    end
                end
            end            
        end
    end
end
imgout(:,:,2) = img1;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
labelstmp = labels;
img = imgin(:,:,3);
img1 = img;
for i = 1 : m
    for j = 1 : n
        if (labelstmp(i, j) >= 0)
            current = labelstmp(i, j);
            sums = 0;
            count = 0;
            %average= 0;
            % 找到一个块，计算块儿内颜色的均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        sums = sums + img(ii, jj);
                        count = count + 1;
                    end
                end
            end
            average = sums / count;
            % 将块儿内颜色设为均值
            for ii = 1 : m
                for jj = 1 : n
                    if (labelstmp(ii, jj) == current)
                        img1(ii, jj) = average;
                        labelstmp(ii, jj) = -1;
                    end
                end
            end            
        end
    end
end
imgout(:,:,3) = img1;

　　myslic_function2函数的效果为：

　　上面原图为img，myslic_function2函数处理过的图为img2，其关系为

　　　　img2 = myslic_function2(img, 1000, 100);

myslic_function2函数接受3个参数，分别是原图、结果想要的超像素的个数、Compactness factor（值越大超像素块儿边界越光滑）。

　　要想获得蛋壳粘贴画的效果，还应在超像素块儿间加上裂纹，当然裂纹也通过对slic算法的结果进行再处理产生。

　　产生裂纹的代码段：

img = imread('06.jpg');
edgeline = rgb2gray(img);

[labels, numlabels] = slicmex(img, 1000, 100);
[m,n]=size(labels);
for ii = 2 : m-1
                for jj = 2 : n-1
                    if (labels(ii, jj) == labels(ii-1, jj)&&labels(ii, jj) == labels(ii+1, jj)&&labels(ii, jj) == labels(ii, jj-1)&&labels(ii, jj) == labels(ii, jj+1) )
                        edgeline(ii, jj)=0;
                    else
                        edgeline(ii, jj)=255;
                    end
                end
end

% 对已经产生的裂纹进行高斯滤波，之后再进行阈值过滤
sigma = 1.3;
gausFilter = fspecial('gaussian',[5 5],sigma);
edgeline=imfilter(edgeline,gausFilter,'replicate');

edgeline(edgeline>100) = 255;
edgeline(edgeline<=100) = 0;

figure(3);
imshow(edgeline);

 

　　产生的裂纹效果：

 

　　最后，将产生裂纹加在经过myslic_function2函数处理后的图片上，代码如下：

img2(:,:,1)=img2(:,:,1) - edgeline;
img2(:,:,2)=img2(:,:,2) - edgeline;
img2(:,:,3)=img2(:,:,3) - edgeline;

 

　　最后的结果：

　　

 

 　　挺萌的还。附项目目录下载。其中image_shade1.m是运行的图形界面。