BDIP和BVLC纹理分析

Young Deok Chun 等人提出了基于 BVLC 矩和 BDIP 矩的一种纹理分析方法。BVLC 能显示粗糙和光滑特性，BDIP 能够很好的提取波谷和边缘。它们直接在彩色空间上进行处理，能有效的结合颜色特征。

BDIP&BVLC

BDIP（block difference of inverse probabilities），基于块的逆转概率。描述了在一个M*M大小的块内，像素值变化的快慢，计算的BDIP值越大，原图像像素值变化越剧烈。
BVLC(block-based of variation of local correlation coefficients)，基于块的局部相关系数。描述了一个像素点与周围四个方向（-90， 0， -45， 45）的相关度，计算的BVLC值越大，原图像越粗糙。

---

I(i, j)表示属于M*M块中某一个像素值 。

---

四个方向位移。

像素平移示意图：

k，l分别表示水平和垂直移动 ，I(i, j)表示属于M*M块中某一个像素值，O（4）表示四个平移方向 
σ（k，l）表示在平移后M*M像素块里的标准差 ，σ（0，0）表示当前M*M块的标准差 
μ（k，l）表示在平移后M*M像素块里的均值 ，μ（0，0）表示当前M*M块的均值

---

BDIP code:

void bdip(const Mat& src)
{
    Mat bdip;
    bdip = src.clone();

    int nRows;
    int nCols;
    nRows = src.rows;
    nCols = src.cols;
    //计算bdip特征图
    for(int r = ; r < nRows; ++r)
    {
        for(int c = ; c < nCols; ++c)
        {
            float blockValue = 0.0;
            int blockSum = ;
            int blockMax = ;

            //边缘不做考虑
            if( == r || nRows -  == r ||
                 == c || nCols -  == c)
            {
                blockValue = ;
            }
            else
            {
                uchar v1, v2, v3, v4;
                v1 = src.ptr<uchar>(r)[c];
                v2 = src.ptr<uchar>(r)[c + ];
                v3 = src.ptr<uchar>(r + )[c];
                v4 = src.ptr<uchar>(r + )[c + ];

                blockSum = v1 + v2 + v3 + v4;
                blockMax = MAX(MAX(v1, v2), MAX(v3, v4));
                blockValue =  - blockSum*1.0/blockMax;
            }

            bdip.ptr<uchar>(r)[c] = *blockValue;
        }
    }

#if 1
    imshow("bdip", bdip);
    cvWaitKey();
#endif

    return;
}

BVLC code:

struct  SHIFTDIRECTION
{
    int x;
    int y;
};
const SHIFTDIRECTION shift[] = {, , , , , , , , , };

void bvlc(const Mat& src)
{
    int nRows;
    int nCols;
    nRows = src.rows;
    nCols = src.cols;

    //填充边界
    Mat tmp;
    copyMakeBorder(src, tmp, , , , ,BORDER_REFLECT);
    tmp.convertTo(tmp, CV_32FC1, 1.0, );

    Mat bvlc;
    bvlc = src.clone();

    //计算blvc特征图
    for(int r = ; r < nRows + ; ++r)
    {
        for(int c = ; c < nCols + ; ++c)
        {
            float variance[] = {0.0};
            float mean[] = {0.0};
            float value[] = {,};

            for(int i = ; i < ; ++i)
            {
                int curR = r + shift[i].x;
                int curC = c + shift[i].y;

                //计算平移后四个像素均值、方差
                if(i < )
                {
                    mean[i] =
                        tmp.ptr<float>(curR)[curC] +
                        tmp.ptr<float>(curR + )[curC] +
                        tmp.ptr<float>(curR)[curC + ] +
                        tmp.ptr<float>(curR + )[curC + ];
                    mean[i] /= ;

                    variance[i] =
                        pow((tmp.ptr<float>(curR)[curC] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR + )[curC] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR)[curC + ] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR + )[curC + ] - mean[i]), );
                }

                //最后一个块的位置方向与前三块有区别
                else
                {
                    mean[i] =
                        tmp.ptr<float>(curR)[curC] +
                        tmp.ptr<float>(curR - )[curC] +
                        tmp.ptr<float>(curR)[curC + ] +
                        tmp.ptr<float>(curR - )[curC + ];
                    mean[i] /= ;

                    variance[i] =
                        pow((tmp.ptr<float>(curR)[curC] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR - )[curC] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR)[curC + ] - mean[i]), ) +
                        pow((tmp.ptr<float>(curR - )[curC + ] - mean[i]), );
                }

                variance[i] /= ;
                variance[i] = sqrt(variance[i]);
            }   

            //计算四个方向块与原块的相关系数value[i]
            for(int i = ; i < ; ++i)
            {
                value[i - ] =
                    tmp.ptr<float>(r)[c]*tmp.ptr<float>(r + shift[i].x)[c +shift[i].y] - mean[]*mean[i] +
                    tmp.ptr<float>(r + )[c]*tmp.ptr<float>(r + shift[i].x)[c +shift[i].y] - mean[]*mean[i] +
                    tmp.ptr<float>(r)[c + ]*tmp.ptr<float>(r + shift[i].x)[c +shift[i].y] - mean[]*mean[i] +
                    tmp.ptr<float>(r + )[c + ]*tmp.ptr<float>(r + shift[i].x)[c +shift[i].y] - mean[]*mean[i];

                value[i - ] /= ;
                value[i - ] /= (variance[]*variance[i]);
            }

            //获取最大和最小相关系数
            float max = value[];
            float min = value[];

            for(int i = ; i < ; ++i)
            {
                if(value[i] > max)
                {
                    max = value[i];
                }

                if(value[i] < min)
                {
                    min = value[i];
                }
            }

            //计算BLVC数值
            bvlc.ptr<uchar>(r - )[c - ] = max - min;
        }
    }

#if 1
    imshow("bvlc", bvlc);
    waitKey();
#endif

    return;
}

---

【转载自】

BDIP-BVLC纹理 - xxxxyxxxx的博客 - CSDN博客 https://blog.csdn.net/xxxxyxxxx/article/details/76358491

Image retrieval using bdip and bvlc moments_百度学术 http://xueshu.baidu.com/usercenter/paper/show?paperid=6fe4e1826e57f7007558cb9414214fd3&site=xueshu_se