【目标跟踪】|Meansift 算法原理及对应代码解释 matlab C

最新推荐文章于 2024-03-14 15:55:56 发布
最新推荐文章于 2024-03-14 15:55:56 发布
阅读量1.9k 收藏 33
点赞数 6
分类专栏： 目标跟踪
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35608277/article/details/115585735
版权

背景原理

MeanShift算法属于核密度估计法，它不需要任何先验知识而完全依靠特征空间中样本点的计算其密度函数值。

无参密度估计方法：不事先规定概率密度函数的结构形式，在某一连续点处的密度函数值 由该点邻域中的若干样本点估计 得出。常用的无参密度估计方法有：直方图法、最近邻域法和核密度估计法。

核密度估计法的原理在直方图法基础上，加了一个用于平滑数据的核函数。

MeanShift的基本思想及物理含义：

在一定范围内的所有采样点相对于基准点的“合运动方向”， 即为meanshift向量的方向
注意，各个分运动需要根据样本点距离基准点的距离，用核函数进行加权。
在这里插入图片描述
比较学术描述：
在这里插入图片描述
在这里插入图片描述
ref
https://blog.csdn.net/jinshengtao/article/details/30258833

核函数也叫窗口函数，在核估计中起到平滑的作用。常用的核函数有：Uniform，Epannechnikov，Gaussian等。
在这里插入图片描述

核密度估计

直方图到核密度估计

需要观察这些样本的分布情况，往往我们会采用直方图的方法来进行直观的展现。
直方图就是密度函数。
绘制直方图时，需要确定bins，如果bins不同，那么最后的直方图会产生很大的差别。如下面的两直方图，右边比左边的直方图多划分了bins，导致最后的结果有很大的差别，左边时双峰的，右边时单峰的。
在这里插入图片描述
同时，直方图展示的分布曲线并不平滑，即在一个bin中的样本具有相等的概率密度

概率密度函数不连续，这同样存在很大的问题。如果我们将这些不连续的区间连续起来，那么这很大程度上便能符合我们的要求，其中一个思想就是对于样本中的某一点的概率密度，如果能把邻域的信息利用起来，那么最后的概率密度就会很大程度上改善不连续的问题

密度函数就是分布函数的一阶导数。通过估计分布函数的一阶导数来估计密度函数呢？一个最简单而有效的估计分布函数的方法是所谓的「经验分布函数（empirical distribution function）」：

在这里插入图片描述

采用直方图的思想。选一个x附近的小区间，数一下在这个区间里面的点的个数，除以总个数，作为X=x处的密度函数值

根据分布函数概念，也可以写作：
在这里插入图片描述
把分布函数用上面的经验分布函数替代，那么上式分子上就是落在[x-h,x+h]区间的点的个数。我们可以把f(x)的估计写成：
在这里插入图片描述

其中 h叫做「窗宽（bandwidth）」
如果记在这里插入图片描述，K就是核函数。

那么估计式可以写为：
在这里插入图片描述
密度函数的积分应该等于1：在这里插入图片描述

基于此，核函数应该有以下特性
（非负、对称、积分为1，符合概率密度性质，并且均值为0）

如下：
在这里插入图片描述

二、基于MeanShift的目标跟踪算法

基于均值漂移的目标跟踪算法通过分别计算目标区域和候选区域内 像素的特征值概率得到关于目标模型和候选模型的描述，
然后利用相似函数 度量 初始帧目标模型和当前帧的候选模版的相似性，选择使相似函数最大的候选模型
得到关于目标模型的Meanshift向量，这个向量正是目标由初始位置向正确位置移动的向量。

由于均值漂移算法的快速收敛性，通过不断迭代计算Meanshift向量，算法最终将收敛到目标的真实位置，达到跟踪的目的。
在这里插入图片描述

2.1 目标模型和候选模型的描述（计算区域内像素的特征值概率）

在这里插入图片描述

其中表述为一维图像，在编程中需要对二维图像转换。

  • zi( 1,2,…,n)对应代码中 i,j,对n累加，即对整个图像像素（i,j）的累加
  • b(zi)为该像素对应的颜色特征值，u 为对应遍历整个颜色特征的序号
整个计算过程分为三步

2.1.1 核函数计算

即1-目标框中每个像素到中心点的距离的平方比上中心点平方和
在这里插入图片描述在这里插入图片描述

 % 核函数
for i=1:a  
    for j=1:b   %目标区域内进行计算
        dist=(i-y(1))^2+(j-y(2))^2;  %距离目标中心越远，距离越大
        m_wei(i,j)=1-dist/h; %epanechnikov profile  
    end  
end  
C=1/sum(sum(m_wei));%归一化系数

2.1.2 目标区域内每个像素点的颜色特征计算

Mean Shift 最初的方式是采用的颜色直方图的建模方式，有基于RGB模型和基于HSV模型两种方式。基于RGB模型的彩色直方图反映的是图像中每一种（R，G，B）组合出现的次数，因为有R、G、B三种色彩，所以这样的彩色直方图是三维的，彩色直方图的横坐标被分成了256份，所以一共有256256256种色彩。实际操作中为了减小计算量，把256个小区间划分为16个大的区间(划分的bin越多越精确)，然后用一个颜色特征值代替三维的特征向量（d=256R+16G+B），将三维的彩色直方图降维成一维的直方图（另外一种降维的方法是将RGB模型转换为HSV模型，只使用其中的H分量，即色调分量）。

for i=1:a  
    for j=1:b  
        %rgb颜色空间量化为16*16*16 bins  
        q_r=fix(double(temp(i,j,1))/16);  %fix为趋近0，向下取整函数   红，将256分成1~16个去间，属于1~16哪个区间bin？
        q_g=fix(double(temp(i,j,2))/16);  %绿
        q_b=fix(double(temp(i,j,3))/16);  %蓝色通道
        q_temp=q_r*256+q_g*16+q_b;            %设置每个像素点红色、绿色、
        蓝色分量所占比重  256 16 1
        color_q(i,j)=q_temp

color_q(i,j)范围属于0-4096

2.1.3 目标区域概率密度计算

目标区域概率密度 表示为hist1， 为 0-4096的种颜色特征的统计值
即 累加4096种颜色特征在各个像素出现的频率。在这里插入图片描述

对应公式，对整个像素区域的颜色特征值进行累加

for i=1:a  
    for j=1:b  
   
        hist1(color_q(i,j)+1) = hist1(color_q(i,j)+1)+m_wei(i,j);    %遍历目标区域每个像素点，计算直方图统计，得到每种颜色特征取值分布，对出现的该种分布累加上该像素点对应的权重  
        
    end  
end  
hist1=hist1*C;

2.1.4 候选区域特征计算相同

按照上一帧的位置计算
在这里插入图片描述
得到候选区域的特征分布 p
ps
在这里插入图片描述

2.2 相似性度量

在这里插入图片描述

        for i=1:4096  
            if(hist2(i)~=0) %不等于  
                w(i)=sqrt(hist1(i)/hist2(i));  %每个灰度值的相似度度量 向量
            else  
                w(i)=0;  
            end  
        end

2.3 偏移位置更新

在这里插入图片描述

        for i=1:a;  
            for j=1:b  
                sum_w=sum_w+w(uint32(q_temp1(i,j))+1);  %对全像素的相似度进行累加
                xw=xw+w(uint32(q_temp1(i,j))+1)*[i-y(1)-0.5,j-y(2)-0.5];  %计算移动量，相似度乘以该像素位置-目标位置-0.5
            end  
        end  
        Y=xw/sum_w;  
        %中心点位置更新  
        rect(1)=rect(1)+Y(2);  
        rect(2)=rect(2)+Y(1);

2.4 迭代

在这里插入图片描述

    %%%%%%%mean shift迭代  
    while((Y(1)^2+Y(2)^2>0.5)&num<20)   %迭代条件  
        num=num+1;  
        temp1=imcrop(Im,rect);  %以上一帧位置，进行裁剪候选区域，
		%。。。。
	end

因此meansift只能在固定大小跟踪，且不能应对快速目标移出。

3 汇总code

3.2 matlab

function [] = select()  
close all;  
clear all;  
%%%%%%%%%%%%%%%%%%根据一幅目标全可见的图像圈定跟踪目标%%%%%%%%%%%%%%%%%%%%%%%  
I=imread('img/4.jpg');  
figure(1);  
imshow(I);  
  
  
[temp,rect]=imcrop(I);  %rect 左上角定点横纵坐标+长宽
[a,b,c]=size(temp);         %a:row,b:col  
  
  
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%计算目标图像的权值矩阵%%%%%%%%%%%%%%%%%%%%%%%  
y(1)=a/2;  
y(2)=b/2;  
tic_x=rect(1)+rect(3)/2;  
tic_y=rect(2)+rect(4)/2;  %在图像中 目标中心坐标
m_wei=zeros(a,b);%权值矩阵   跟目标区域大小相同
h=y(1)^2+y(2)^2 ;%带宽  四分之一个目标区域大小的窗口
  
 % 核函数
for i=1:a  
    for j=1:b   %目标区域内进行计算
        dist=(i-y(1))^2+(j-y(2))^2;  %目标区域内进行计算，距离目标中心越远，距离越大
        m_wei(i,j)=1-dist/h; %epanechnikov profile  
    end  
end  
C=1/sum(sum(m_wei));%归一化系数  
  
  
%计算目标权值直方图qu  目标模型 
%hist1=C*wei_hist(temp,m_wei,a,b);%target model  
hist1=zeros(1,4096); %颜色空间量化为16*16*16 bins(将256*256*256降维)
for i=1:a  
    for j=1:b  
        %rgb颜色空间量化为16*16*16 bins  
        q_r=fix(double(temp(i,j,1))/16);  %fix为趋近0，向下取整函数   红，将256分成1~16个去间，属于1~16哪个区间bin？
        q_g=fix(double(temp(i,j,2))/16);  %绿
        q_b=fix(double(temp(i,j,3))/16);  %蓝色通道
        q_temp=q_r*256+q_g*16+q_b;            %设置每个像素点红色、绿色、蓝色分量所占比重  256 16 1
        hist1(q_temp+1)= hist1(q_temp+1)+m_wei(i,j);    %遍历目标区域每个像素点，计算直方图统计，得到每种颜色特征取值分布，对出现的该种分布累加上该像素点对应的权重  
        
    end  
end  
hist1=hist1*C;  
rect(3)=ceil(rect(3));  
rect(4)=ceil(rect(4));  %向上取整
  
  
  
  
%%%%%%%%%%%%%%%%%%%%%%%%%读取序列图像  
myfile=dir('H:\code\1doctor_code\matlab_code\tracking\img\*.jpg');  
lengthfile=length(myfile);  
  
  
for l=1:lengthfile  
    Im=imread(strcat('H:\code\1doctor_code\matlab_code\tracking\img\',myfile(l).name));  
    num=0;  
    Y=[2,2];  
      
      
    %%%%%%%mean shift迭代  
    while((Y(1)^2+Y(2)^2>0.5)&num<20)   %迭代条件  
        num=num+1;  
        temp1=imcrop(Im,rect);  %以上一帧位置，进行裁剪候选区域，
        %计算侯选区域直方图（概率密度）  
        %hist2=C*wei_hist(temp1,m_wei,a,b);%target candidates pu  
        hist2=zeros(1,4096);  
        for i=1:a  
            for j=1:b  
                q_r=fix(double(temp1(i,j,1))/16);  
                q_g=fix(double(temp1(i,j,2))/16);  
                q_b=fix(double(temp1(i,j,3))/16);  
                q_temp1(i,j)=q_r*256+q_g*16+q_b;  
                hist2(q_temp1(i,j)+1)= hist2(q_temp1(i,j)+1)+m_wei(i,j);  
            end  
        end  
        hist2=hist2*C;  
        figure(2);  
        subplot(1,2,1);  
        plot(hist2);  
        hold on;  
          
        w=zeros(1,4096);  
        for i=1:4096  
            if(hist2(i)~=0) %不等于  
                w(i)=sqrt(hist1(i)/hist2(i));  %每个灰度值的相似度度量 向量
            else  
                w(i)=0;  
            end  
        end       
        %变量初始化  
        sum_w=0;  
        xw=[0,0];  
        for i=1:a;  
            for j=1:b  
                sum_w=sum_w+w(uint32(q_temp1(i,j))+1);  %对全像素的相似度进行累加
                xw=xw+w(uint32(q_temp1(i,j))+1)*[i-y(1)-0.5,j-y(2)-0.5];  %计算移动量，相似度乘以该像素位置-目标位置-0.5
            end  
        end  
        Y=xw/sum_w;  
        %中心点位置更新  
        rect(1)=rect(1)+Y(2);  
        rect(2)=rect(2)+Y(1);  
    end  
      
      
    %%%跟踪轨迹矩阵%%%  
    tic_x=[tic_x;rect(1)+rect(3)/2];  
    tic_y=[tic_y;rect(2)+rect(4)/2];  
      
    v1=rect(1);  
    v2=rect(2);  
    v3=rect(3);  
    v4=rect(4);  
    %%%显示跟踪结果%%%  
    subplot(1,2,2);  
    imshow(uint8(Im));  
    title('目标跟踪结果及其运动轨迹');  
    hold on;  
    plot([v1,v1+v3],[v2,v2],[v1,v1],[v2,v2+v4],[v1,v1+v3],[v2+v4,v2+v4],[v1+v3,v1+v3],[v2,v2+v4],'LineWidth',2,'Color','r');  
    plot(tic_x,tic_y,'LineWidth',2,'Color','b');  
      
      
end

3.2 C code

#include “stdafx.h”  
#include “cv.h”  
#include “highgui.h”  
#define  u_char unsigned char  
#define  DIST 0.5  
#define  NUM 20  
  
//全局变量  
bool pause = false;  
bool is_tracking = false;  
CvRect drawing_box;  
IplImage *current;  
double *hist1, *hist2;  
double *m_wei;                                                                  //权值矩阵  
double C = 0.0;                                                                //归一化系数  
  
void init_target(double *hist1, double *m_wei, IplImage *current)  
{  
    IplImage *pic_hist = 0;  
    int t_h, t_w, t_x, t_y;  
    double h, dist;  
    int i, j;  
    int q_r, q_g, q_b, q_temp;  
      
    t_h = drawing_box.height;  
    t_w = drawing_box.width;  
    t_x = drawing_box.x;  
    t_y = drawing_box.y;  
  
    h = pow(((double)t_w)/2,2) + pow(((double)t_h)/2,2);            //带宽  
    pic_hist = cvCreateImage(cvSize(300,200),IPL_DEPTH_8U,3);     //生成直方图图像  
  
    //初始化权值矩阵和目标直方图  
    for (i = 0;i < t_w*t_h;i++)  
    {  
        m_wei[i] = 0.0;  
    }  
  
    for (i=0;i<4096;i++)  
    {  
        hist1[i] = 0.0;  
    }  
  
    for (i = 0;i < t_h; i++)  
    {  
        for (j = 0;j < t_w; j++)  
        {  
            dist = pow(i - (double)t_h/2,2) + pow(j - (double)t_w/2,2);  
            m_wei[i * t_w + j] = 1 - dist / h;   
            //printf(“%f\n”,m_wei[i * t_w + j]);  
            C += m_wei[i * t_w + j] ;  
        }  
    }  
  
    //计算目标权值直方  
    for (i = t_y;i < t_y + t_h; i++)  
    {  
        for (j = t_x;j < t_x + t_w; j++)  
        {  
            //rgb颜色空间量化为16*16*16 bins  
            q_r = ((u_char)current->imageData[i * current->widthStep + j * 3 + 2]) / 16;  
            q_g = ((u_char)current->imageData[i * current->widthStep + j * 3 + 1]) / 16;  
            q_b = ((u_char)current->imageData[i * current->widthStep + j * 3 + 0]) / 16;  
            q_temp = q_r * 256 + q_g * 16 + q_b;  
            hist1[q_temp] =  hist1[q_temp] +  m_wei[(i - t_y) * t_w + (j - t_x)] ;  
        }  
    }  
  
    //归一化直方图  
    for (i=0;i<4096;i++)  
    {  
        hist1[i] = hist1[i] / C;  
        //printf(“%f\n”,hist1[i]);  
    }  
  
    //生成目标直方图  
    double temp_max=0.0;  
  
    for (i = 0;i < 4096;i++)         //求直方图最大值，为了归一化  
    {  
        //printf(“%f\n”,val_hist[i]);  
        if (temp_max < hist1[i])  
        {  
            temp_max = hist1[i];  
        }  
    }  
    //画直方图  
    CvPoint p1,p2;  
    double bin_width=(double)pic_hist->width/4096;  
    double bin_unith=(double)pic_hist->height/temp_max;  
  
    for (i = 0;i < 4096; i++)  
    {  
        p1.x = i * bin_width;  
        p1.y = pic_hist->height;  
        p2.x = (i + 1)*bin_width;  
        p2.y = pic_hist->height - hist1[i] * bin_unith;  
        //printf(“%d,%d,%d,%d\n”,p1.x,p1.y,p2.x,p2.y);  
        cvRectangle(pic_hist,p1,p2,cvScalar(0,255,0),-1,8,0);  
    }  
    cvSaveImage(”hist1.jpg”,pic_hist);  
    cvReleaseImage(&pic_hist);  
}  
  
void MeanShift_Tracking(IplImage *current)  
{  
    int num = 0, i = 0, j = 0;  
    int t_w = 0, t_h = 0, t_x = 0, t_y = 0;  
    double *w = 0, *hist2 = 0;  
    double sum_w = 0, x1 = 0, x2 = 0,y1 = 2.0, y2 = 2.0;  
    int q_r, q_g, q_b;  
    int *q_temp;  
    IplImage *pic_hist = 0;  
  
    t_w = drawing_box.width;  
    t_h = drawing_box.height;  
      
    pic_hist = cvCreateImage(cvSize(300,200),IPL_DEPTH_8U,3);     //生成直方图图像  
    hist2 = (double *)malloc(sizeof(double)*4096);  
    w = (double *)malloc(sizeof(double)*4096);  
    q_temp = (int *)malloc(sizeof(int)*t_w*t_h);  
  
    while ((pow(y2,2) + pow(y1,2) > 0.5)&& (num < NUM))  
    {  
        num++;  
        t_x = drawing_box.x;  
        t_y = drawing_box.y;  
        memset(q_temp,0,sizeof(int)*t_w*t_h);  
        for (i = 0;i<4096;i++)  
        {  
            w[i] = 0.0;  
            hist2[i] = 0.0;  
        }  
  
        for (i = t_y;i < t_h + t_y;i++)  
        {  
            for (j = t_x;j < t_w + t_x;j++)  
            {  
                //rgb颜色空间量化为16*16*16 bins  
                q_r = ((u_char)current->imageData[i * current->widthStep + j * 3 + 2]) / 16;  
                q_g = ((u_char)current->imageData[i * current->widthStep + j * 3 + 1]) / 16;  
                q_b = ((u_char)current->imageData[i * current->widthStep + j * 3 + 0]) / 16;  
                q_temp[(i - t_y) *t_w + j - t_x] = q_r * 256 + q_g * 16 + q_b;  
                hist2[q_temp[(i - t_y) *t_w + j - t_x]] =  hist2[q_temp[(i - t_y) *t_w + j - t_x]] +  m_wei[(i - t_y) * t_w + j - t_x] ;  
            }  
        }  
  
        //归一化直方图  
        for (i=0;i<4096;i++)  
        {  
            hist2[i] = hist2[i] / C;  
            //printf(“%f\n”,hist2[i]);  
        }  
        //生成目标直方图  
        double temp_max=0.0;  
  
        for (i=0;i<4096;i++)         //求直方图最大值，为了归一化  
        {  
            if (temp_max < hist2[i])  
            {  
                temp_max = hist2[i];  
            }  
        }  
        //画直方图  
        CvPoint p1,p2;  
        double bin_width=(double)pic_hist->width/(4368);  
        double bin_unith=(double)pic_hist->height/temp_max;  
  
        for (i = 0;i < 4096; i++)  
        {  
            p1.x = i * bin_width;  
            p1.y = pic_hist->height;  
            p2.x = (i + 1)*bin_width;  
            p2.y = pic_hist->height - hist2[i] * bin_unith;  
            cvRectangle(pic_hist,p1,p2,cvScalar(0,255,0),-1,8,0);  
        }  
        cvSaveImage(”hist2.jpg”,pic_hist);  
      
        for (i = 0;i < 4096;i++)  
        {  
            if (hist2[i] != 0)  
            {  
                w[i] = sqrt(hist1[i]/hist2[i]);  
            }else  
            {  
                w[i] = 0;  
            }  
        }  
              
        sum_w = 0.0;  
        x1 = 0.0;  
        x2 = 0.0;  
  
        for (i = 0;i < t_h; i++)  
        {  
            for (j = 0;j < t_w; j++)  
            {  
                //printf(“%d\n”,q_temp[i * t_w + j]);  
                sum_w = sum_w + w[q_temp[i * t_w + j]];  
                x1 = x1 + w[q_temp[i * t_w + j]] * (i - t_h/2);  
                x2 = x2 + w[q_temp[i * t_w + j]] * (j - t_w/2);  
            }  
        }  
        y1 = x1 / sum_w;  
        y2 = x2 / sum_w;  
          
        //中心点位置更新  
        drawing_box.x += y2;  
        drawing_box.y += y1;  
  
        //printf(“%d,%d\n”,drawing_box.x,drawing_box.y);  
    }  
    free(hist2);  
    free(w);  
    free(q_temp);  
    //显示跟踪结果  
    cvRectangle(current,cvPoint(drawing_box.x,drawing_box.y),cvPoint(drawing_box.x+drawing_box.width,drawing_box.y+drawing_box.height),CV_RGB(255,0,0),2);  
    cvShowImage(”Meanshift”,current);  
    //cvSaveImage(“result.jpg”,current);  
    cvReleaseImage(&pic_hist);  
}  
  
void onMouse( int event, int x, int y, int flags, void *param )  
{  
    if (pause)  
    {  
        switch(event)  
        {  
        case CV_EVENT_LBUTTONDOWN:   
            //the left up point of the rect  
            drawing_box.x=x;  
            drawing_box.y=y;  
            break;  
        case CV_EVENT_LBUTTONUP:  
            //finish drawing the rect (use color green for finish)  
            drawing_box.width=x-drawing_box.x;  
            drawing_box.height=y-drawing_box.y;  
            cvRectangle(current,cvPoint(drawing_box.x,drawing_box.y),cvPoint(drawing_box.x+drawing_box.width,drawing_box.y+drawing_box.height),CV_RGB(255,0,0),2);  
            cvShowImage(”Meanshift”,current);  
              
            //目标初始化  
            hist1 = (double *)malloc(sizeof(double)*16*16*16);  
            m_wei =  (double *)malloc(sizeof(double)*drawing_box.height*drawing_box.width);  
            init_target(hist1, m_wei, current);  
            is_tracking = true;  
            break;  
        }  
        return;  
    }  
}  
  
  
  
int _tmain(int argc, _TCHAR* argv[])  
{  
    CvCapture *capture=cvCreateFileCapture(”test.avi”);  
    current = cvQueryFrame(capture);  
    char res[20];  
    int nframe = 0;  
  
    while (1)  
    {     
    /*  sprintf(res,”result%d.jpg”,nframe); 
        cvSaveImage(res,current); 
        nframe++;*/  
        if(is_tracking)  
        {  
            MeanShift_Tracking(current);  
        }  
  
        int c=cvWaitKey(1);  
        //暂停  
        if(c == ‘p’)   
        {  
            pause = true;  
            cvSetMouseCallback( ”Meanshift”, onMouse, 0 );  
        }  
        while(pause){  
            if(cvWaitKey(0) == ‘p’)  
                pause = false;  
        }  
        cvShowImage(”Meanshift”,current);  
        current = cvQueryFrame(capture); //抓取一帧  
    }  
  
    cvNamedWindow(”Meanshift”,1);  
    cvReleaseCapture(&capture);  
    cvDestroyWindow(”Meanshift”);  
    return 0;  
}
rrr2
关注
  • 6
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Mean-shift MATLAB代码
09-17
Mean-shift MATLAB code.简单易用。当前比较流行的聚类方法
基于KCF算法的高速目标跟踪matlab程序
10-30
【标题】"基于KCF算法的高速目标跟踪matlab程序" 涉及的主要知识点是计算机视觉中的目标跟踪技术和KCF（Kernelized Correlation Filter）算法，以及MATLAB编程环境的应用。 目标跟踪是计算机视觉领域的一个核心问题...
【计算机视觉】目标跟踪| Meanshift均值漂移算法详细介绍|附代码
最新发布
Yaoyao2024的博客
03-14 1557
背景：Meanshift算法是Fukunaga于1975年提出的，其基本思想是利用概率密度的梯度爬升来寻找局部最优。到了1995年，YizongCheng针对离x越近的采样点对x周围的统计特性越有效，定义了一族核函数，并根据所有样本点的重要性不同，设定了一个权重系数，扩大了MeanShift的使用范围。啥是概率密度？？？
深入剖析Mean Shift聚类算法原理
houxiaogang05
11-22 1835
转自：http://www.360doc.com/content/19/0623/22/99071_844418459.shtml Mean Shift（均值漂移）是基于密度的非参数聚类算法，其算法思想是假设不同簇类的数据集符合不同的概率密度分布，找到任一样本点密度增大的最快方向（最快方向的含义就是Mean Shift），样本密度高的区域对应于该分布的最大值，这些样本点最终会在局部密度最大值收敛...
mean shift算法的基本原理
坤的专栏
03-13 1万+
Mean Shift算法,一般是指一个迭代的步骤,即先算出当前点的偏移均值,移动该点到其偏移均值,然后以此为新的起始点,继续移动,直到满足一定的条件结束。 给定d维空间Rd的n个样本点 ,i=1,…,n,在空间中任选一点x，那么Mean Shift向量的基本形式定义为: Sk是一个半径为h的高维球区域,满足以下关系的y点的集合, k表示在这n个样本点xi中,有k个点落入Sk区域中.
OpenCV 均值漂移（Mean Shift）算法查找物体
啊琪专栏
08-03 378
Meanshift算法是基于核密度估计的爬山算法，可用于聚类、图像分割、跟踪等。本文利用OpenCV进行图片种物体识别 1.
聚类——MeanShift算法以及Python实现
kwame211的博客
11-15 1826
均值漂移算法(MeanShift)是一种旨在发现团blobs)的聚类算法 核心思想 寻找核密度极值点并作为簇的质心，然后根据最近邻原则将样本点赋予质心 算法简介 核密度估计 根据样本分布估计在样本空间的每一点的密度。估计某点的密度时，核密度估计方法会考虑该点邻近区域的样本点的影响，邻近区域大小由带宽h决定，该参数对最终密度估计的影响非常大。通常采用高斯核： N(x)=12π−−√hex...
MATLAB目标跟踪经典卡尔曼算法matlab实现代码
03-10
MATLAB目标跟踪经典卡尔曼算法matlab实现代码本资源系百度网盘分享地址
目标跟踪,目标跟踪算法,matlab
09-10
在提供的压缩包文件中，"目标跟踪"可能包含实现这些算法的MATLAB代码示例。MATLAB是一种强大的数学计算和编程环境，特别适合于进行信号处理、控制理论和图像处理等领域的研究。通过学习和分析这些代码，可以加深对...
17种视觉目标跟踪算法代码、论文及原理解读打包下载.rar
05-16
17种视觉目标跟踪算法（含相关滤波和深度学习2大派系）的代码（含matlab、Python和c的实现）、论文以及自己学习心得和网上权威原理解读，自己上研究生区间实验室师兄弟专业整理，大部分代码均能调通。【BACF、C-COT...
mean_shift算法MATLAB代码
08-24
meanshift均值平移跟踪算法中核函数窗宽的自动选取代码，根据目标大小变化核窗宽，使得当目标出现大小变化时准确跟踪到目标中心.
meanshift算法综述均值漂移
06-13
基于meanshift算法的均值漂移综述，读书报告
均值漂移聚类matlab代码-Aspire:具有随机效应的异常样品表型鉴定
05-26
均值漂移聚类matlab代码向往 Aspire：随机效应下的异常样品表型鉴定 描述：该软件实现了带有随机效应的异常样本表型识别（ASPIRE），可在一批样本之间进行联合聚类和聚类匹配。 每个样本都被视为由高斯分布和潜在无限多个分量的混合所生成的一组数据点。 给定一批样本，ASPIRE算法将联合处理所有样本以识别本地集群，然后恢复全局集群。 该算法使用Dirichlet处理混合物对每个样本进行建模，并在引入样本之间的依存关系之前，根据全局Dirichlet处理来分配局部分布。 与标准HDPM模型（假定所有局部聚类在所有样本中都继承相同的组件）不同，ASPIRE算法考虑了可能会导致局部聚类手段从一个样本转移到另一个样本的随机效应的潜在存在。 推断由折叠的Gibbs采样器执行。 平台：该算法在C ++ 11中开发。 该可执行文件是在Windows 7 64位环境中使用带有编译器配置的32-64位发行版生成的。 C + 11功能提供了多线程。 在同一程序包中有一个Matlab包装函数示例（demo）。 但是可执行文件是独立的，如果以相同格式提供适当的文件，则可执行文件可以工作。 文件格式：输入
KCF 目标跟踪matlab代码
02-28
总之，这个KCF目标跟踪MATLAB代码库是一个完整的解决方案，它不仅实现了高效的跟踪算法，还考虑了用户交互和结果保存，是研究和实践视觉目标跟踪的好工具。通过深入理解和使用这个代码，你可以进一步掌握KCF算法及其...
用Camshift算法对指定目标进行跟踪
weixin_33908217的博客
07-26 418
原理 Camshift算法是Continuously Adaptive Mean Shift algorithm的简称。它是一个基于MeanSift的改进算法。它首次由Gary R.Bradski等人提出和应用在人脸的跟踪上，并取得了不错的效果。因为它是利用颜色的概率信息进行的跟踪。使得它的执行效率比較高。 Camshift算法的过程由以下步骤组成： （1）确定初始目标及其区域...
OpenCV 学习笔记（mean shift 算法）
Ivan 的专栏
08-29 2574
OpenCV 学习笔记（mean shift 算法） Mean shift 是一种机器学习算法，并不仅仅局限于图像上的应用。关于 Mean shift 算法介绍的书和文章很多，这里就不多介绍了。简单的说，Meanshift 算法是一种迭代算法，需要给一个初始的区域，然后这个算法会反复的调整这个区域，使得这个区域最吻合我们期望的特征。 OpenCV 中有两处用到了 Mean Shift 。分别是： pyrMeanShiftFiltering meanShift 这里只介绍第二个函数的使用方法。 我
六种常见聚类算法
轩逸云的博客
03-31 7万+
Kmeans 聚类原则：以空间中k个点为中心进行聚类，对最靠近他们的对象归类。逐次计算各簇中心的值为新的中心值，迭代更新，直至得到最好的聚类结果 算法流程： 适当选择k个类的初始中心； 在第n次迭代中，对任意一个样本，求其到k个中心的距离，将该样本归到距离最短的中心所在的类/簇； 利用均值等方法更新该类的中心值； 对于所有的k个聚类中心，如果利用（2）（3）的迭代法更新后，值保持不变，则迭代结束；否则，则继续迭代。 优点： 速度快，简单 缺点： 适合聚类球状类簇，不能发现一些混合度
mean-shift均值偏移算法
AAAA202012的博客
08-28 1696
背景 Meanshift算法是Fukunaga于1975年提出的，其基本思想是利用概率密度的梯度爬升来寻找局部最优。1995年，YizongCheng针对离x越近的采样点对x周围的统计特性越有效，定义了一族核函数，并根据所有样本点的重要性不足，设定了一个权重系数，扩大了Meanshift的使用范围。 原理 给定d维空间中的n个样本点xix_ixi​(iii = 1,…,nnn),在x点的Meanshift向量的基本形式定义为： 其中，ShS_hSh​是一个半径为h的高维球区域，k表示n个样本点中由k个点落
基于MeanShift的目标跟踪算法及实现
热门推荐
Where there is life, there is hope
06-12 14万+
这次将介绍基于MeanShift的目标跟踪算法，首先谈谈简介，然后给出算法实现流程，最后实现了一个单目标跟踪的MeanShift算法【matlab/c两个版本】   一、简介      首先扯扯无参密度估计理论，无参密度估计也叫做非参数估计，属于数理统计的一个分支，和参数密度估计共同构成了概率密度估计方法。参数密度估计方法要求特征空间服从一个已知的概率密度函数，在实际的应用中这个条件很难达到
meanshift聚类算法原理
04-16
Meanshift聚类算法是一种基于密度的聚类方法，其原理是通过不断地迭代，将样本点沿着密度方向移动，进而找到样本点分布的全局极值。具体来说，对于每个样本点，算法计算该点周围一定距离内样本点的平均位置，并将该点移动至该平均位置，直到该点满足收敛条件。通过这样的过程，算法能够寻找到样本点集合中的聚类中心。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值