C++实现最大值滤波器

最新推荐文章于 2021-09-17 15:32:51 发布
最新推荐文章于 2021-09-17 15:32:51 发布
阅读量2.8k 收藏 2
点赞数
分类专栏： C/C++ 文章标签： c++ 最大值滤波
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/j56754gefge/article/details/38478337
版权

    今天给大家分享我最近写的几行代码，用C语言实现的1*3、3*1以及3*3最大值滤波....

    首先，什么是最大值滤波？

    做图像研究的人都知道，常用的一个平滑操作是中值滤波，比如3*3中值滤波就是用当前位置的3*3领域内9个像素值的中间大小的值来替代当前位置像素值。  同理，3*3最大值滤波就是用当前位置3*3领域内9个像素值的最大的值来替代当前位置像素值。

    其次，我为什么要写这个代码？

    实不相瞒，鄙人常用openCV，但是我发现CV里面只提供了中值滤波，没有提供最大值滤波（matlab里面倒是有个ordfilt2函数提供了该功能），因为要用，就写了这么个函数。

    以前我写过一些代码放到资源里去给人下载，别人用的时候提了很多意见，我又懒得改了再传，所以这次直接贴到博客，大家给点意见，我觉得合理就直接改了。下面开始贴代码。

<hr/>
// 第一段代码：第一种版本的1*3最大值滤波
#include <stdio.h>

#ifndef MAX
#define MAX(a,b) (a>b?a:b)
#endif

/* 
	1*3 maximum filter;
	B(i,j) is set to local maximum of A(i,j) neighborhood;
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _rowMaxFilter( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply row-max to each row
	Apt = A, Bpt = B;
	for( i=0; i<rows; i++ ){
		if( Apt[0]>Apt[1] )
			Bpt[1] = Apt[0];
		else
			Bpt[0] = Apt[1];
		for( j=2; j<cols; j++ )
			if( Apt[j-1]>Apt[j] )
				Bpt[j] = Apt[j-1];
			else
				Bpt[j-1] = MAX( Apt[j-2], Apt[j] );
		Apt += witdhstepA;
		Bpt += widthstepB;
	}
}

void  rowMaxFilter( const int *A, int rows, int cols, int *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  rowMaxFilter( const float *A, int rows, int cols, float *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  rowMaxFilter( const double *A, int rows, int cols, double *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}

/* >>>TEST<<<
int main()
{
	// use matlab to generate a random array: A = rand(5,6)
	float A[5*6] = { 1.0347, 0.8884, 1.4384, -0.1022, -0.0301, -0.8637, 0.7269, -1.1471, 0.3252, -0.2414, -0.1649, 0.0774, -0.3034, -1.0689, -0.7549, 0.3192, 0.6277, -1.2141, 0.2939, -0.8095, 1.3703, 0.3129, 1.0933, -1.1135, -0.7873, -2.9443, -1.7115, -0.8649, 1.1093, -0.0068 };
	float B[30];
	rowMaxFilter( A, 5, 6, B, 6, 6 );
	for( int i=0; i<5; i++ ){
		for( int j=0; j<6; j++ )
			printf("%g\t",B[i*6+j]);
		printf("\n");
	}
	// true result is:
	//1.0347  1.4384  1.4384  1.4384  -0.0301 -0.0301
	//0.7269  0.7269  0.3252  0.3252  0.0774  0.0774
	//-0.3034 -0.3034 0.3192  0.6277  0.6277  0.6277
	//0.2939  1.3703  1.3703  1.3703  1.0933  1.0933
	//-0.7873 -0.7873 -0.8649 1.1093  1.1093  1.1093
	return 0;
}
*/

//===================corresponding matlab code========================================
/*
function  B = colMaxFilter(A)
%% 3*1 maximum filter
%% B(i,j) is set to local maximum of A(i,j) neighborhood
B = A;
[M,N] = size(A);
for i=1:N
    % apply col-max to each col
    if A(1,i)>A(2,i)
        B(2,i) = A(1,i);
    else
        B(1,i) = A(2,i);
    end
    for j=3:M
        if A(j-1,i)>A(j,i)
            B(j,i) = A(j-1,i);
        else
            B(j-1,i) = max(A(j-2,i),A(j,i));
        end
    end
end

%% TEST
% A = rand(50,60);
% B1 = ordfilt2(A,3,[1;1;1]);
% B2 = colMaxFilter(A);
% C = B1 - B2;
% max(abs(C(:))) % should be ZERO
*/
<hr/>

// 第二段代码：第二种版本的1*3滤波
#include <stdio.h>

/* 
	1*3 maximum filter;
	if A(i,j) is local maximum, then B(i,j)=A(i,j); else B(i,j)=0
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _rowMaxFilter2( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply row-max to each row
	Apt = A, Bpt = B;
	for( i=0; i<rows; i++ ){
		for( j=1; j<cols; j++ )
			if( Apt[j-1]>Apt[j] )
				Bpt[j] = 0;
			else
				Bpt[j-1] = 0;
		Apt += witdhstepA;
		Bpt += widthstepB;
	}
}

void  rowMaxFilter2( const int *A, int rows, int cols, int *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}
void  rowMaxFilter2( const float *A, int rows, int cols, float *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}
void  rowMaxFilter2( const double *A, int rows, int cols, double *B, int widthstepA, int witdhstepB)
{
	_rowMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}

/* >>>TEST<<<
int main()
{
	// use matlab to generate a random array: A = rand(5,6)
	float A[5*6] = { 1.0347, 0.8884, 1.4384, -0.1022, -0.0301, -0.8637, 0.7269, -1.1471, 0.3252, -0.2414, -0.1649, 0.0774, -0.3034, -1.0689, -0.7549, 0.3192, 0.6277, -1.2141, 0.2939, -0.8095, 1.3703, 0.3129, 1.0933, -1.1135, -0.7873, -2.9443, -1.7115, -0.8649, 1.1093, -0.0068 };
	float B[30];
	rowMaxFilter2( A, 5, 6, B, 6, 6 );
	for( int i=0; i<5; i++ ){
		for( int j=0; j<6; j++ )
			printf("%g\t",B[i*6+j]);
		printf("\n");
	}
	// true result is:
	//1.0347         0    1.4384         0   -0.0301         0
	//0.7269         0    0.3252         0         0    0.0774
	//-0.3034         0         0         0    0.6277         0
	//0.2939         0    1.3703         0    1.0933         0
	//-0.7873         0         0         0    1.1093         0
	return 0;
}
*/

//===================corresponding matlab code========================================
/*
function   B = rowMaxFilter2(A)
%% 1*3 maximum filter
%% if A(i,j) is local maximum, then B(i,j)=A(i,j); else B(i,j)=0
B = A;
[M,N] = size(A);
for i=1:M
    % apply row-max to each row
    for j=2:N
        if A(i,j-1)>A(i,j)
            B(i,j) = 0;
        else
            B(i,j-1) = 0;
        end
    end
end
%% TEST
% A = rand(30,40);
% B1 = ordfilt2(A,3,[1 1 1]);
% B1(B1~=A) = 0;
% B2 = rowMaxFilter2(A);
% B1-B2 % should be all zero
*/
<hr/>
// 第三段代码：第一种版本的3*1滤波
#include <math.h>

#ifndef MAX
#define MAX(a,b) (a>b?a:b)
#endif

/* 
	3*1 maximum filter;
	B(i,j) is set to local maximum of A(i,j) neighborhood;
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _colMaxFilter( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{	
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply col-max to each col
	Apt = A, Bpt = B;
	for( i=0; i<cols; i++ ){
		if( Apt[0]>Apt[witdhstepA] )
			Bpt[widthstepB] = Apt[0];
		else
			Bpt[0] = Apt[witdhstepA];
		for( j=2; j<rows; j++ )
			if( Apt[(j-1)*witdhstepA]>Apt[j*witdhstepA] )
				Bpt[j*widthstepB] = Apt[(j-1)*witdhstepA];
			else
				Bpt[(j-1)*widthstepB] = MAX( Apt[j*witdhstepA], Apt[(j-2)*witdhstepA] );
		Apt++, Bpt++;
	}
}

void  colMaxFilter( const int *A, int rows, int cols, int *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  colMaxFilter( const float *A, int rows, int cols, float *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  colMaxFilter( const double *A, int rows, int cols, double *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter(A,rows,cols,B,widthstepA,witdhstepB);
}

/* >>>TEST<<<
int main()
{
	// use matlab to generate a random array: A = rand(5,6)
	float A[5*6] = { 1.0347, 0.8884, 1.4384, -0.1022, -0.0301, -0.8637, 0.7269, -1.1471, 0.3252, -0.2414, -0.1649, 0.0774, -0.3034, -1.0689, -0.7549, 0.3192, 0.6277, -1.2141, 0.2939, -0.8095, 1.3703, 0.3129, 1.0933, -1.1135, -0.7873, -2.9443, -1.7115, -0.8649, 1.1093, -0.0068 };
	float B[30];
	colMaxFilter( A, 5, 6, B, 6, 6 );
	for( int i=0; i<5; i++ ){
		for( int j=0; j<6; j++ )
			printf("%g\t",B[i*6+j]);
		printf("\n");
	}
	// true result is:
	//1.0347    0.8884    1.4384   -0.1022   -0.0301    0.0774
	//1.0347    0.8884    1.4384    0.3192    0.6277    0.0774
	//0.7269   -0.8095    1.3703    0.3192    1.0933    0.0774
	//0.2939   -0.8095    1.3703    0.3192    1.1093   -0.0068
	//0.2939   -0.8095    1.3703    0.3129    1.1093   -0.0068
	return 0;
}
*/

//===================corresponding matlab code========================================
/*
function  B = rowMaxFilter(A)
%% 1*3 maximum filter
%% B(i,j) is set to local maximum of A(i,j) neighborhood
B = A;
[M,N] = size(A);
for i=1:M
    % apply row-max to each row
    if A(i,1)>A(i,2)
        B(i,2) = A(i,1);
    else
        B(i,1) = A(i,2);
    end
    for j=3:N
        if A(i,j-1)>A(i,j)
            B(i,j) = A(i,j-1);
        else
            B(i,j-1) = max(A(i,j-2),A(i,j));
        end
    end
end

%% TEST
% A = rand(50,60);
% B1 = ordfilt2(A,3,[1 1 1]);
% B2 = rowMaxFilter(A);
% C = B1 - B2;
% max(abs(C(:))) % should be ZERO
*/
<hr/>
// 第四段代码：第二种版本的3*1滤波
#include <stdio.h>

/* 
	3*1 maximum filter;
	if A(i,j) is local maximum, then B(i,j)=A(i,j); else B(i,j)=0
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _colMaxFilter2( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply col-max to each col
	Apt = A, Bpt = B;
	for( i=0; i<cols; i++ ){
		for( j=1; j<rows; j++ )
			if( Apt[(j-1)*witdhstepA]>Apt[j*witdhstepA] )
				Bpt[j*widthstepB] = 0;
			else
				Bpt[(j-1)*widthstepB] = 0;
		Apt++;
		Bpt++;
	}
}

void  colMaxFilter2( const int *A, int rows, int cols, int *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}
void  colMaxFilter2( const float *A, int rows, int cols, float *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}
void  colMaxFilter2( const double *A, int rows, int cols, double *B, int widthstepA, int witdhstepB)
{
	_colMaxFilter2(A,rows,cols,B,widthstepA,witdhstepB);
}

/* >>>TEST<<<
int main()
{
	// use matlab to generate a random array: A = rand(5,6)
	float A[5*6] = { 1.0347, 0.8884, 1.4384, -0.1022, -0.0301, -0.8637, 0.7269, -1.1471, 0.3252, -0.2414, -0.1649, 0.0774, -0.3034, -1.0689, -0.7549, 0.3192, 0.6277, -1.2141, 0.2939, -0.8095, 1.3703, 0.3129, 1.0933, -1.1135, -0.7873, -2.9443, -1.7115, -0.8649, 1.1093, -0.0068 };
	float B[30];
	colMaxFilter2( A, 5, 6, B, 6, 6 );
	for( int i=0; i<5; i++ ){
		for( int j=0; j<6; j++ )
			printf("%g\t",B[i*6+j]);
		printf("\n");
	}
	// true result is:
	//1.0347    0.8884    1.4384   -0.1022   -0.0301         0
	//0         0         0         0         0    0.0774
	//0         0         0    0.3192         0         0
	//0.2939   -0.8095    1.3703         0         0         0
	//0         0         0         0    1.1093   -0.0068
	return 0;
}
*/

//===================corresponding matlab code========================================
/*
function   B = colMaxFilter2(A)
%% 3*1 maximum filter
%% if A(i,j) is local maximum, then B(i,j)=A(i,j); else B(i,j)=0
B = A;
[M,N] = size(A);
for i=1:N
    % apply col-max to each col
    for j=2:M
        if A(j-1,i)>A(j,i)
            B(j,i) = 0;
        else
            B(j-1,i) = 0;
        end
    end
end
%% TEST
% A = rand(30,40);
% B1 = ordfilt2(A,3,[1;1;1]);
% B1(B1~=A) = 0;
% B2 = colMaxFilter2(A);
% B1-B2 % should be all zero
*/
<hr/>
// 第五段代码：3*3最大值滤波 ~ 应该是属于第一种版本
#include <stdlib.h>

#ifndef MAX
#define MAX(a,b) (a>b?a:b)
#endif

/* 
	1*3 maximum filter;
	B(i,j) is set to local maximum of A(i,j) neighborhood;
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _rowMaxFilter( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply row-max to each row
	Apt = A, Bpt = B;
	for( i=0; i<rows; i++ ){
		if( Apt[0]>Apt[1] )
			Bpt[1] = Apt[0];
		else
			Bpt[0] = Apt[1];
		for( j=2; j<cols; j++ )
			if( Apt[j-1]>Apt[j] )
				Bpt[j] = Apt[j-1];
			else
				Bpt[j-1] = MAX( Apt[j-2], Apt[j] );
		Apt += witdhstepA;
		Bpt += widthstepB;
	}
}

/* 
	3*1 maximum filter;
	B(i,j) is set to local maximum of A(i,j) neighborhood;
	suppose: A's size is rows*cols, A(i,j) (i<rows,j<cols) is indexed by A[i*witdhstepA+j], 
	i.e. A's element is arranged in memory like: the first row, the second row, ... so on. B is alike. widthstep should be no smaller than cols.
	(the memory arrangement actually accords with that in openCV)
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _colMaxFilter( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{	
	int i = 0, j = 0;
	const T *Apt = A;
	T *Bpt = B;
	// copy A into B
	while( i++<rows ){
		j = 0;
		while( j++<cols )
			*(Bpt++) = *(Apt++);
		Apt += witdhstepA - cols;
		Bpt += widthstepB - cols;
	}
	// apply col-max to each col
	Apt = A, Bpt = B;
	for( i=0; i<cols; i++ ){
		if( Apt[0]>Apt[witdhstepA] )
			Bpt[widthstepB] = Apt[0];
		else
			Bpt[0] = Apt[witdhstepA];
		for( j=2; j<rows; j++ )
			if( Apt[(j-1)*witdhstepA]>Apt[j*witdhstepA] )
				Bpt[j*widthstepB] = Apt[(j-1)*witdhstepA];
			else
				Bpt[(j-1)*widthstepB] = MAX( Apt[j*witdhstepA], Apt[(j-2)*witdhstepA] );
		Apt++, Bpt++;
	}
}

/*
	3*3 maximum filter;
	B(i,j) is set to local maximum of A(i,j) neighborhood.
	by: Yu Xianguo, NUDT, 2014/6/19
*/
template<typename T>
void  _maximumFilter( const T *A, int rows, int cols, T *B, int witdhstepA, int widthstepB )
{
	T *tmp = new T [rows*cols] ();
	_rowMaxFilter( A, rows, cols, tmp, witdhstepA, cols );
	_colMaxFilter( tmp, rows, cols, B, cols, widthstepB );
	delete [] tmp;
}

void  maximumFilter( const int *A, int rows, int cols, int *B, int widthstepA, int witdhstepB)
{
	_maximumFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  maximumFilter( const float *A, int rows, int cols, float *B, int widthstepA, int witdhstepB)
{
	_maximumFilter(A,rows,cols,B,widthstepA,witdhstepB);
}
void  maximumFilter( const double *A, int rows, int cols, double *B, int widthstepA, int witdhstepB)
{
	_maximumFilter(A,rows,cols,B,widthstepA,witdhstepB);
}

/* >>>TEST<<<
int main()
{
	// use matlab to generate a random array: A = rand(5,6)
	float A[5*6] = { 1.0347, 0.8884, 1.4384, -0.1022, -0.0301, -0.8637, 0.7269, -1.1471, 0.3252, -0.2414, -0.1649, 0.0774, -0.3034, -1.0689, -0.7549, 0.3192, 0.6277, -1.2141, 0.2939, -0.8095, 1.3703, 0.3129, 1.0933, -1.1135, -0.7873, -2.9443, -1.7115, -0.8649, 1.1093, -0.0068 };
	float B[30];
	maximumFilter( A, 5, 6, B, 6, 6 );
	for( int i=0; i<5; i++ ){
		for( int j=0; j<6; j++ )
			printf("%g\t",B[i*6+j]);
		printf("\n");
	}
	// true result is:
	//1.0347    1.4384    1.4384    1.4384    0.0774    0.0774
	//1.0347    1.4384    1.4384    1.4384    0.6277    0.6277
	//0.7269    1.3703    1.3703    1.3703    1.0933    1.0933
	//0.2939    1.3703    1.3703    1.3703    1.1093    1.1093
	//0.2939    1.3703    1.3703    1.3703    1.1093    1.1093
	return 0;
}
*/











yuxianguo_chn
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Opencv写的空间滤波包括最大最小中值滤波
08-08
Opencv写的空间滤波包括最大最小中值滤波等等，借鉴数字图像处理matlab版page117 的函数，几何平均，算术平均，调和平均，反调和平局，中值，中点等
SciPy 库中maximum_filter配合generate_binary_structure获取局部极大值
qq_36892712的博客
12-28 750
是 SciPy 库中的一个函数，它用于计算图像的最大值滤波。这个函数在图像处理中经常被用到，特别是在特征提取和边缘检测等任务中。input: 输入的 ndarray。将应用滤波器的输入图像或数据。size: 标量或元组，可选。定义滤波器窗口的大小。如果是一个标量，那么这将是每个维度的大小。如果是一个元组，那么这将指定每个维度的大小。footprint: 布尔数组，可选。定义滤波器的形状，如果提供了 footprint ， size 参数将被忽略。output: ndarray ，可选。
python时间序列峰值检测_Python-二维阵列中的峰值检测
weixin_39631689的博客
12-10 341
小编典典我使用局部最大滤波器检测到峰值。这是第一个4个爪子的数据集的结果：我还在9个爪子的第二个数据集上运行了它，效果也很好。这是你的操作方式：import numpy as npfrom scipy.ndimage.filters import maximum_filterfrom scipy.ndimage.morphology import generate_binary_structure...
介绍一个“王者”算法，它能认出游戏里的所有英雄
august5291的博客
09-17 761
https://www.fgba.net/sitemap.xml
图像处理：空域滤波器的C++实现（最大、最小、均值、中值、锐化）
Mr Qin的博客
01-18 1009
使用方式： AveFilter(img, ave_img);// 均值滤波，用来平滑图像 MinFilter(img, min_img);// 最小值滤波 MediumFilter(img, medium_img);// 均值滤波 MaxFilter(img, max_img);// 最大值滤波 SharpFilter(img, sharp_img,1);//图像锐化（这里锐化因子为1） 函数 //均值滤波 void AveFilter(Mat &src, Mat &
用c++实现Canny算子
06-30
在C++中实现Canny算子，你需要创建一个函数，接受输入图像、高斯滤波器的标准差、以及低阈值和高阈值作为参数。函数将返回边缘图像。`Canny.cpp`文件很可能是这个函数的实现，其中包含了上述步骤的具体代码。 在...
自编 C++ Builder 顺序统计滤波器
05-05
冈萨雷斯的《数字图像处理》一书提供了这些滤波器的理论基础，我们将结合书中的公式来实现最大值滤波、最小值滤波和中点滤波。 首先，我们要理解顺序统计滤波的基本概念。这种滤波方法通过考虑图像邻域内的像素值来...
KCF C++实现
11-30
在C++中实现KCF，通常涉及到图像处理、特征提取、滤波器更新等多个环节。下面将详细介绍KCF的基本原理及其C++实现的关键点。** ### KCF算法概述 KCF全称为Kernelized Correlation Filters，由Martínez和Hernández...
卷积神经网络C++实现
08-07
C++的STL（Standard Template Library）也能提供许多便利的数据结构和算法，如向量、队列、堆等，可以帮助组织和操作神经网络的权重和激活值。 总的来说，这个C++实现的卷积神经网络项目为学习者提供了一个实践和...
OpenCV实现canny边缘检测（C++实现）.zip
04-12
3. **非极大值抑制**：为了消除边缘检测过程中的虚假响应，算法会检查每个像素点是否在其梯度方向上具有局部最大值。如果不是，则抑制该像素点，以减少假边缘。 4. **双阈值检测**：设定两个阈值，低阈值用于检测弱...
opencv-基于c++实现的opencv图像处理算法之Canny边缘检测.zip
最新发布
05-15
在C++中实现这些步骤，你需要使用OpenCV库提供的函数，如`GaussianBlur`用于高斯滤波，`Sobel`用于计算梯度，`compare`和`threshold`用于非极大值抑制和双阈值检测，以及`findContours`等函数进行边缘细化。...
OpenCV实现边缘检测综合示例（C++实现）.zip
04-12
在梯度方向上，非极大值点被抑制，只保留局部最大值。 4. **双阈值检测**：设置两个阈值（低阈值和高阈值），低于低阈值的像素被视为背景，高于高阈值的像素被视为前景，介于两者之间的像素则根据连接性进行判断。 ...
susan特征检测c++函数
11-20
6. **非极大值抑制**：为了消除边缘检测产生的虚假特征点，对候选特征点进行非极大值抑制，保留局部最大值点，去除其他点。 7. **锐化**：可选步骤，通过应用高斯差分滤波器来增强特征点附近的边缘，提高检测结果的...
Canny 边沿提取算子 C++代码实现
09-05
在梯度强度的最大值处保留边沿，而其他非最大值像素被抑制，以减少假阳性。 4. **双阈值检测**：设定两个阈值，低阈值用于连接弱边沿，高阈值用于保留强边沿。低于低阈值的像素将被忽略，介于两者之间的像素被视为...
Canny算法的C++代码实现
01-19
在每个像素点，如果它的梯度值不是沿着梯度方向的最大值，则将其设为零，这样就去掉了边缘检测过程中的虚假响应。 4. **双阈值检测**： 设置两个阈值，一个低阈值和一个高阈值。如果某个像素的梯度幅度大于高阈值...
滤波算法比较
fishingtd的专栏
09-23 887
滤波算法比较： 1、限幅滤波法（又称程序判断滤波法）       A、方法：           根据经验判断，确定两次采样允许的最大偏差值（设为A）           每次检测到新值时判断：           如果本次值与上次值之差           如果本次值与上次值之差>A,则本次值无效,放弃本次值,用上次值代替本次值       B、优点：           能
python时间序列峰值检测_python – 二维数组中的峰值检测
weixin_39581716的博客
12-10 624
我使用局部最大值滤波器检测峰值。这是你的第一个数据集的4爪子的结果：这里是你怎么做：import numpy as npfrom scipy.ndimage.filters import maximum_filterfrom scipy.ndimage.morphology import generate_binary_structure, binary_erosionimport matplot...
滤波算法（2）(最大值、最小值、低通、巴特沃斯、Robinson_Guard)
沧浪之水清兮
07-13 3422
最大值滤波 void max_filter(Mat src, Mat dst,int kernalsize) { int ksize; if (kernalsize % 2 == 0) { ksize = kernalsize / 2; } else { ksize = (kernalsize - 1) / 2; } if (kernalsize>src.rows ||
最大值，最小值滤波的opencv3.0实现
热门推荐
xiaojiajia007的博客
11-12 1万+
图像平滑 1.1 算法介绍 （1）空间邻域平均法： 在图像中以当前像素 f(i,j)为中心切出一个 3*3 像素组成的图像块，如下图所示，设当 前像素 f(i,j)的灰度值为g(i,j)时，则： g(i,j)={f(i,j)+f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)+f(i-1,j)+f(i+1,j)+f(i-1,j+1),+f(i,j+1)+f(i+1,j+1)}/
基于c++的opencv实现查找图像局部最大值
05-26
可以使用OpenCV的函数`cv::minMaxLoc`来查找图像的局部最大值。 以下是一个示例代码，它使用`cv::...如果要查找图像中的所有局部最大值，则需要使用其他方法，例如使用高斯滤波器或算法如SIFT / SURF来查找关键点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值