反向投影图

最新推荐文章于 2022-01-27 14:13:33 发布
最新推荐文章于 2022-01-27 14:13:33 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： OpenCV 算法 文章标签： dst buffer float arrays types 数据结构
    图像的反向投影图是用输入图像的某一位置上像素值（多维或灰度）对应在直方图的一个bin上的值来代替该像素值，所以得到的反向投影图是单通的。用统计学术语，输出图像象素点的值是观测数组在某个分布（直方图）下的概率。
反向投影图 - 十三月de天空 - 十三月de天空
 
其中 b(xi) 表示在位置 xi 上像素对应的直方图第 b(xi) 个 bin ，直方图共 m 个 bin ，qu表示第u个bin的值。

还是以例子说明
(1)例如灰度图像如下

Image=

  0    1    2    3

  4    5    6    7

  8    9   10   11

  8    9   14   15

(2)该灰度图的直方图为（bin指定的区间为[0,3)，[4,7)，[8,11)，[12,16)）

Histogram=

  4    4    6    2

(3)反向投影图

Back_Projection=

  4    4    4    4

  4    4    4    4

  6    6    6    6

  6    6    2    2

例如位置(0,0)上的像素值为0，对应的bin为[0,3)，所以反向直方图在该位置上的值这个bin的值4。


opencv提供的直方图反向投影函数：


CV_IMPL void
cvCalcArrBackProject( CvArr** img, CvArr* dst, const CvHistogram* hist )//输入为单通道的图像，输出为反向投影图形，hist为直方图数据结构
{
    CV_FUNCNAME( "cvCalcArrBackProject" );

    __BEGIN__;

    uchar* ptr[CV_MAX_DIM];
    uchar* dstptr = 0;
    int dststep = 0, step = 0;
    int i, dims;
    int cont_flag = -1;
    CvMat stub0, *mat0 = 0;
    CvSize size;

    if( !CV_IS_HIST(hist))
        CV_ERROR( CV_StsBadArg, "Bad histogram pointer" );

    if( !img )
        CV_ERROR( CV_StsNullPtr, "Null double array pointer" );

    CV_CALL( dims = cvGetDims( hist->bins ));
    
    for( i = 0; i <= dims; i++ )
    {
        CvMat stub, *mat = (CvMat*)(i < dims ? img[i] : dst);
        CV_CALL( mat = cvGetMat( mat, i == 0 ? &stub0 : &stub, 0, 1 ));//返回矩阵头，对于iplimage和cvmat类型返回值不同

        if( CV_MAT_CN( mat->type ) != 1 )
            CV_ERROR( CV_BadNumChannels, "Only 1-channel arrays are allowed here" );

        if( i == 0 )
        {
            mat0 = mat;
            step = mat0->step;
        }
        else
        {
            if( !CV_ARE_SIZES_EQ( mat0, mat ))
                CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal sizes" );

            if( mat0->step != mat->step )
                CV_ERROR( CV_StsUnmatchedSizes, "Not all the planes have equal steps" );

            if( !CV_ARE_TYPES_EQ( mat0, mat ))
                CV_ERROR( CV_StsUnmatchedFormats, "Not all the planes have equal types" );
        }

        cont_flag &= mat->type;
        if( i < dims )
            ptr[i] = mat->data.ptr;
        else
        {
            dstptr = mat->data.ptr;  //输出指针
            dststep = mat->step;
        }
    }

    size = cvGetMatSize(mat0);
    if( CV_IS_MAT_CONT( cont_flag ))
    {
        size.width *= size.height;
        size.height = 1;
        dststep = step = CV_STUB_STEP;
    }

    if( CV_MAT_DEPTH(mat0->type) > CV_8S && !CV_HIST_HAS_RANGES(hist))
        CV_ERROR( CV_StsBadArg, "histogram ranges must be set (via cvSetHistBinRanges) "
                                "before calling the function" );

    switch( CV_MAT_DEPTH(mat0->type) )
    {
    case CV_8U:
        IPPI_CALL( icvCalcBackProject_8u_C1R( ptr, step, dstptr, dststep, size, hist ));
     break;
    case CV_32F:
        {
        union { uchar** ptr; float** fl; } v;
        v.ptr = ptr;
     IPPI_CALL( icvCalcBackProject_32f_C1R( v.fl, step,
                                (float*)dstptr, dststep, size, hist ));
        }
     break;
    default:
        CV_ERROR( CV_StsUnsupportedFormat, "Unsupported array type" );
    }

    __END__;
}

static CvStatus CV_STDCALL
    icvCalcBackProject_8u_C1R( uchar** img, int step, uchar* dst, int dstStep,
                               CvSize size, const CvHistogram* hist )
{
    const int small_hist_size = 1<<12;
    int* tab = 0;
    int is_sparse = CV_IS_SPARSE_HIST(hist);
    int dims, histsize[CV_MAX_DIM];
    int i, x;
    CvStatus status;

    dims = cvGetDims( hist->bins, histsize );

    tab = (int*)cvStackAlloc( dims*256*sizeof(int));
    status = icvCalcHistLookupTables8u( hist, dims, histsize, tab );
    if( status < 0 )
        return status;

    if( !is_sparse )
    {
        int total = 1;
        CvMatND* mat = (CvMatND*)(hist->bins);
        float* bins = mat->data.fl;
        uchar* buffer = 0;

        for( i = 0; i < dims; i++ )
            total *= histsize[i];

        if( dims <= 3 && total >= -ICV_HIST_DUMMY_IDX )
            return CV_BADSIZE_ERR; // too big histogram

        if( dims > 1 && total <= small_hist_size && CV_IS_MAT_CONT(mat->type))
        {
            buffer = (uchar*)cvAlloc(total);
            if( !buffer )
                return CV_OUTOFMEM_ERR;
            for( i = 0; i < total; i++ )
            {
                int v = cvRound(bins[i]);
                buffer[i] = CV_CAST_8U(v);
            }
        }

        switch( dims )
        {
        case 1:
            {
            uchar tab1d[256];
            for( i = 0; i < 256; i++ )
            {
                int idx = tab[i];
                if( idx >= 0 )
                {
                    int v = cvRound(bins[idx]);
                    tab1d[i] = CV_CAST_8U(v);
                }
                else
                    tab1d[i] = 0;
            }

            for( ; size.height--; img[0] += step, dst += dstStep )
            {
                uchar* ptr = img[0];
                for( x = 0; x <= size.width - 4; x += 4 )
                {
                    uchar v0 = tab1d[ptr[x]];
                    uchar v1 = tab1d[ptr[x+1]];

                    dst[x] = v0;
                    dst[x+1] = v1;

                    v0 = tab1d[ptr[x+2]];
                    v1 = tab1d[ptr[x+3]];

                    dst[x+2] = v0;
                    dst[x+3] = v1;
                }

                for( ; x < size.width; x++ )
                    dst[x] = tab1d[ptr[x]];
            }
            }
            break;
        case 2:
            for( ; size.height--; img[0] += step, img[1] += step, dst += dstStep )
            {
                uchar* ptr0 = img[0];
                uchar* ptr1 = img[1];

                if( buffer )
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        int v0 = ptr0[x];
                        int v1 = ptr1[x];
                        int idx = tab[v0] + tab[256+v1];
                        int v = 0;

                        if( idx >= 0 )
                            v = buffer[idx];

                        dst[x] = (uchar)v;
                    }
                }
                else
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        int v0 = ptr0[x];
                        int v1 = ptr1[x];
                        int idx = tab[v0] + tab[256+v1];
                        int v = 0;

                        if( idx >= 0 )
                        {
                            v = cvRound(bins[idx]);
                            v = CV_CAST_8U(v);
                        }

                        dst[x] = (uchar)v;
                    }
                }
            }
            break;
        case 3:
            for( ; size.height--; img[0] += step, img[1] += step,
                                  img[2] += step, dst += dstStep )
            {
                uchar* ptr0 = img[0];
                uchar* ptr1 = img[1];
                uchar* ptr2 = img[2];

                if( buffer )
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        int v0 = ptr0[x];
                        int v1 = ptr1[x];
                        int v2 = ptr2[x];
                        int idx = tab[v0] + tab[256+v1] + tab[512+v2];
                        int v = 0;

                        if( idx >= 0 )
                            v = buffer[idx];

                        dst[x] = (uchar)v;
                    }
                }
                else
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        int v0 = ptr0[x];
                        int v1 = ptr1[x];
                        int v2 = ptr2[x];
                        int idx = tab[v0] + tab[256+v1] + tab[512+v2];
                        int v = 0;

                        if( idx >= 0 )
                        {
                            v = cvRound(bins[idx]);
                            v = CV_CAST_8U(v);
                        }
                        dst[x] = (uchar)v;
                    }
                }
            }
            break;
        default:
            for( ; size.height--; dst += dstStep )
            {
                if( buffer )
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        uchar* binptr = buffer;
                        int v = 0;

                        for( i = 0; i < dims; i++ )
                        {
                            int idx = tab[i*256 + img[i][x]];
                            if( idx < 0 )
                                break;
                            binptr += idx;
                        }
                        
                        if( i == dims )
                            v = binptr[0];

                        dst[x] = (uchar)v;
                    }
                }
                else
                {
                    for( x = 0; x < size.width; x++ )
                    {
                        float* binptr = bins;
                        int v = 0;

                        for( i = 0; i < dims; i++ )
                        {
                            int idx = tab[i*256 + img[i][x]];
                            if( idx < 0 )
                                break;
                            binptr += idx;
                        }

                        if( i == dims )
                        {
                            v = cvRound( binptr[0] );
                            v = CV_CAST_8U(v);
                        }

                        dst[x] = (uchar)v;
                    }
                }

                for( i = 0; i < dims; i++ )
                    img[i] += step;
            }
        }

        cvFree( &buffer );
    }
    else
    {
        CvSparseMat* mat = (CvSparseMat*)(hist->bins);
        int node_idx[CV_MAX_DIM];

        for( ; size.height--; dst += dstStep )
        {
            for( x = 0; x < size.width; x++ )
            {
                int v = 0;

                for( i = 0; i < dims; i++ )
                {
                    int idx = tab[i*256 + img[i][x]];
                    if( idx < 0 )
                        break;
                    node_idx[i] = idx;
                }
                if( i == dims )
                {
                    float* bin = (float*)cvPtrND( mat, node_idx, 0, 1, 0 );
                    v = cvRound(bin[0]);
                    v = CV_CAST_8U(v);
                }

                dst[x] = (uchar)v;
            }

            for( i = 0; i < dims; i++ )
                img[i] += step;
        }
    }

    return CV_OK;
}


nevermoredanny
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
学习OpenCV范例（十八）——反向投影
chenjiazhou12的专栏
03-26 7059
本次要讲的范例是反向投影，反向投影如果是按照字面上的理解，还有书本上的理解可能会比较困难，但是如果是举一些具体的简单的例子，那可能就比较容易接受了，应用的话，可以检测出肤色区域，例如，你有一个肤色直方图 ( Hue-Saturation 直方图 ),你可以用它来寻找图像中的肤色区域，现在我们来看看反向变换吧。 1、原理 图像的反向投影图是用输入图像的某一位置上像素值（多维或灰度）对应在直方图的
opencv3/C++ 直方图反向投影实例
08-25
OpenCV3/C++ 直方图反向投影实例 本文将详细讲解 OpenCV3 中的直方图反向投影实例，这是一个具有很高参考价值的实践示例。我们将从概念入手，逐步讲解直方图反向投影的原理和实现方法，並提供一个完整的示例代码。 ...
直方图反向投影匹配
07-27
这是一个基于vs2010和opencv的代码，可以处理图片的直方图反向投影，可以进行特征提取与分类。
彩色直方图反向投影_opencv_
09-30
彩色直方图反向投影是图像处理中的一个关键技术，主要应用于图像匹配和分类。在OpenCV库中，它被广泛使用，因为OpenCV提供了强大的图像处理和计算机视觉功能。OpenCV是一个开源的计算机视觉库，包含了大量的图像处理...
python使用numpy实现直方图反向投影示例
09-18
在图像处理领域，直方图反向投影是一种用于图像匹配和目标检测的技术。它通过比较目标图像和模板图像的直方图，找到最接近模板图像的区域。在Python中，我们可以利用NumPy库来实现这一过程。下面我们将详细讨论直方...
Python OpenCV处理图像之图像直方图和反向投影
09-20
主要为大家详细介绍了Python OpenCV处理图像之图像直方图和反向投影，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
opencv中直方图的反向投影详解
04-02
本程序详细解释了直方图反响投影后的图片和以前图片的对比 比给出直方图和图像对比
图像反向投影
ZYTTAE的专栏
11-27 1907
反向投影： OpenCV 资料里给出的概念是“一种记录给定图像中的像素点如何适应直方图模型像素分布的方式。简单的讲， 所谓反向投影就是首先计算某一特征的直方图模型，然后使用模型去寻找图像中存在的该特征。”简单一点理解就是模板匹配，给定一个目标模板，然后再逐个遍历原图像和模板图像相同的图像块，对比图像块和模板的直方图，然后把比较结果存入一个新的图像中，新图像中的全局极值就是模板在原图像中所在的位置
反向投影图的理解
记录计算机应用的点点滴滴！！！！！
01-22 1726
最近在研究meanshift的跟踪算法，遇到了反向投影图， 图像的反向投影图是用输入图像的某一位置上像素值（多维或灰度）对应在直方图（这个直方图可能是其他图像的直方图，也可能是当前图像的直方图）的一个bin上的值来代替该像素值，所以得到的反向投影图是单通的。用统计学术语，输出图像象素点的值是观测数组在某个分布（直方图）下的概率，下面是计算公式： 其中，m是bin（直方图区间）的个
python+OpenCV笔记（二十七）：反投影图像
ReadyGo!!!的博客
01-27 2496
python+OpenCV笔记（二十七）：反投影图像
OpenCV2马拉松第11圈——meanshift与直方图反向投影
abcd1992719g的专栏
05-10 2794
收入囊中 meanshift图像聚类meanshift object detect 葵花宝典 今天有点累，理论就讲少点吧T_T meanshift中文是均值飘逸，就是给定一个点，然后会移动到概率密度最大的地方。 对于图像，什么是概率密度最大？ 我们可以定义很多要素： 距离 RGB HSV 下面我有个例子，就是用距离(x,y)和HSV(h,s,v)作图像聚类的。
反向投影backproject的直观理解
热门推荐
viewcode的专栏
11-22 2万+
1. 什么是backproject？ 2. backproject 有什么用？ 3. 例证 1. 什么是backproject？ 反向投影：opencv docs给出的概念是“一种记录给定图像中的像素点如何适应直方图模型像素分布的方式。简单的讲， 所谓反向投影就是首先计算某一特征的直方图模型，然后使用模型去寻找图像中存在的该特征。” 第一句讲的是backproject
机器学习算法原理与实践（二）、meanshift算法图解以及在图像聚类、目标跟踪中的应用
Liu_LongPo的专栏
03-27 1万+
图解meanshift算法，方便理解。公式推导，总结meanshift算法在图像聚类中的应用,总结meanshift算法在目标跟踪的原理和应用
(一)反向投影的原理说明（1）
Cche的博客
09-14 1万+
目标：    一、概念： 反向投影是一种记录给定图像中的像素点如何适应直方图模型像素分布的方式。简单的讲，就是首先计算某一特征的直方图模型，然后使用模型去寻找图像中存在的该特征。例如，你有一个肤色直方图（Hue-Saturation直方图），你可以用它来寻找图像中的肤色区域 1、直方图反向投影矩阵的计算方法： 什么是反向投影？它可以实现什么功能？ 如何使用OpenCV函数calcBac...
opencv--python(四)haar,直方图+反向投影，meanshift和Camshift追踪算法
qq_42219077的博客
04-19 762
haar人脸检测器 OpenCV 已经包含了很多已经训练好的分类器，其中包括：面部，眼睛，微笑等。我们只需加载需要的 XML 分类器。然后以灰度格式加载输入图像或者是视频。如果检测到面部，它会返回面部所在的矩形区域 Rect（x,y,w,h） import numpy as np import cv2 #加载需要的xml分类器 face_cascade = cv2.CascadeClassi...
opencv如何增加反向投影的图像特征c++
最新发布
05-26
反向投影是一种图像处理技术，它可以将图像中的像素点映射到另一个图像上。在OpenCV中，可以使用cv...注意，这个例子中使用的是单通道图像，如果您的图像是多通道的，则需要调整代码以处理每个通道的直方图和反向投影。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值