c语言实现图像2d卷积运算,【数字图像处理】图像形态学算法C语言实现（图像卷积，膨胀，腐蚀，开运算，闭运算，顶帽，黑帽，雕版，锐化）...

最新推荐文章于 2022-05-05 17:10:44 发布
最新推荐文章于 2022-05-05 17:10:44 发布
阅读量272 收藏
点赞数
文章标签： c语言实现图像2d卷积运算

/*

* @Descripttion:

* @version:

* @Author: Yueyang

* @email: 1700695611@qq.com

* @Date: 2020-11-10 21:59:39

* @LastEditors: Yueyang

* @LastEditTime: 2020-11-24 21:15:30

*/

#ifndef LI_CONV_C

#define LI_CONV_C

#include "cv.h"

#include "li_image_proc.h"

#include

/**

* @name: Li_GetKernel

* @msg: 获得卷积核矩阵

* @param {double* data 数据

* BYTE KernalKind 卷积核边长}

* @return {Li_Kernel*}

*/

LI_API

Li_Kernel* Li_GetKernel(double* data,BYTE KernalKind)

{

Li_Kernel * kernel;

kernel=(Li_Kernel*)li_malloc_arr(sizeof(Li_Kernel));

kernel->arr=(double*)li_malloc_arr(KernalKind*KernalKind*sizeof(double));

for(int i=0;i

kernel->arr[i]=data[i];

kernel->width=KernalKind;

kernel->height=KernalKind;

kernel->arrsize=KernalKind*KernalKind;

return kernel;

}

/**

* @name: Li_Convolute

* @msg: 计算图像卷积

* @param {Li_Image* img 卷积图像

* Li_Kernel* kernal 卷积核 }

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Convolute(Li_Image* img,Li_Kernel* kernal)

{

if(img->imgdepth==LI_DEP_8U){

if(kernal->width!=3) return NULL;

BYTE* ptr[9]={0};

BYTE* ptro;

Li_Image* out=Li_Copy_Image(img);

for(int i=0;iheight;i++)

for(int j=0;jwidth;j++)

{

BYTE sum=0;

if(j-1>=0&&i-1>=0)

ptr[0]=(BYTE*)img->at(img,j-1,i-1);

if(j>=0&&i-1>=0)

ptr[1]=(BYTE*)img->at(img,j+0,i-1);

if(j+1<=img->width&&i-1>=0)

ptr[2]=(BYTE*)img->at(img,j+1,i-1);

if(j-1>=0&&i>=0)

ptr[3]=(BYTE*)img->at(img,j-1,i+0);

if(j>=0&&i>=0)

ptr[4]=(BYTE*)img->at(img,j+0,i+0);

if(j+1<=img->width&&i>=0)

ptr[5]=(BYTE*)img->at(img,j+1,i+0);

if(j-1>=0&&i+1<=img->height)

ptr[6]=(BYTE*)img->at(img,j-1,i+1);

if(j>=0&&i+1<=img->height)

ptr[7]=(BYTE*)img->at(img,j+0,i+1);

if(j+1<=img->width&&i+1<=img->height)

ptr[8]=(BYTE*)img->at(img,j+1,i+1);

for(int k=0;k<9;k++)

{

double* ptr2=(double*)(kernal->arr+k);

if(ptr[k]!=NULL)

{

sum+= (BYTE)(*ptr[k] * (*ptr2));

}

else

{

sum+=0;

}

}

ptro=(BYTE*)out->at(out,j+0,i+0);

*ptro=sum;

}

return out;

}else if (img->imgdepth==LI_DEP_24U||img->imgdepth==LI_DEP_32U)

{

Li_Image* imgH[img->imgdepth+1];

Li_Image* imgL[img->imgdepth+1];

Li_Split(img,imgH);

for(int i=0;iimgdepth+1;i++)

imgL[i]= Li_Convolute(imgH[i],kernal);

Li_Image* out2=Li_Combine(imgL,img->imgdepth);

return out2;

}

}

/**

* @name: Li_Sharp

* @msg: 图像锐化

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Sharp(Li_Image* img)

{

double data[9]={1,1,1,1,-7,1,1,1,1};

if(img==NULL)return NULL;

if(img->imgdepth==LI_DEP_8U){

Li_Image* out;

Li_Kernel* kernel;

kernel=Li_GetKernel(data,3);

out= Li_Convolute(img,kernel);

return out;

}else if (img->imgdepth==LI_DEP_24U||img->imgdepth==LI_DEP_32U)

{

Li_Image* imgH[img->imgdepth+1];

Li_Image* imgL[img->imgdepth+1];

Li_Split(img,imgH);

for(int i=0;iimgdepth+1;i++)

{

imgL[i]=Li_Sharp(imgH[i]);

}

Li_Image* out2=Li_Combine(imgL,img->imgdepth);

return out2;

}

}

/**

* @name: Li_Emboss

* @msg: 图像雕版

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Emboss(Li_Image* img)

{

double data[9]={0,0,-1,0,-1,0,2,0,0};

if(img==NULL)return NULL;

if(img->imgdepth==LI_DEP_8U){

Li_Image* out;

Li_Kernel* kernel;

kernel=Li_GetKernel(data,3);

out= Li_Convolute(img,kernel);

return out;

}else if (img->imgdepth==LI_DEP_24U||img->imgdepth==LI_DEP_32U)

{

Li_Image* imgH[img->imgdepth+1];

Li_Image* imgL[img->imgdepth+1];

Li_Split(img,imgH);

for(int i=0;iimgdepth+1;i++)

{

imgL[i]=Li_Emboss(imgH[i]);

}

Li_Image* out2=Li_Combine(imgL,img->imgdepth);

return out2;

}

}

/**

* @name: Li_Erode

* @msg: 图像腐蚀(局部最小)

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Erode(Li_Image* img)

{

if(img->imgdepth==LI_DEP_8U){

BYTE kek=0;

BYTE* ptr[9]={0};

BYTE* ptro;

Li_Image* out=Li_Copy_Image(img);

for(int i=0;iheight;i++)

for(int j=0;jwidth;j++)

{

BYTE sum=0;

for(int k=0;k<9;k++)

ptr[k]=&kek;

if(j-1>=0&&i-1>=0)

ptr[0]=(BYTE*)img->at(img,j-1,i-1);

if(j>=0&&i-1>=0)

ptr[1]=(BYTE*)img->at(img,j+0,i-1);

if(j+1<=img->width&&i-1>=0)

ptr[2]=(BYTE*)img->at(img,j+1,i-1);

if(j-1>=0&&i>=0)

ptr[3]=(BYTE*)img->at(img,j-1,i+0);

if(j>=0&&i>=0)

ptr[4]=(BYTE*)img->at(img,j+0,i+0);

if(j+1<=img->width&&i>=0)

ptr[5]=(BYTE*)img->at(img,j+1,i+0);

if(j-1>=0&&i+1<=img->height)

ptr[6]=(BYTE*)img->at(img,j-1,i+1);

if(j>=0&&i+1<=img->height)

ptr[7]=(BYTE*)img->at(img,j+0,i+1);

if(j+1<=img->width&&i+1<=img->height)

ptr[8]=(BYTE*)img->at(img,j+1,i+1);

BYTE temp[9];

for(int k=0;k<9;k++)

{

if(ptr[k]!=NULL)

{

temp[k]= (BYTE)(*ptr[k]);

}

}

for(int m=0;m<9-1;m++)

for(int n=0;n<9-m-1;n++)

{

if(temp[m]>temp[m+1])

{

BYTE x=temp[m];

temp[m]=temp[n+1];

temp[n+1]=x;

}

}

ptro=(BYTE*)out->at(out,j+0,i+0);

*ptro=temp[0];

}

return out;

}else if (img->imgdepth==LI_DEP_24U||img->imgdepth==LI_DEP_32U)

{

Li_Image* imgH[img->imgdepth+1];

Li_Image* imgL[img->imgdepth+1];

Li_Split(img,imgH);

for(int i=0;iimgdepth+1;i++)

imgL[i]= Li_Medeum(imgH[i]);

Li_Image* out2=Li_Combine(imgL,img->imgdepth);

return out2;

}

}

/**

* @name: Li_Dilate

* @msg: 图像膨胀(局部最小)

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Dilate(Li_Image* img)

{

if(img->imgdepth==LI_DEP_8U){

BYTE kek=0;

BYTE* ptr[9]={0};

BYTE* ptro;

Li_Image* out=Li_Copy_Image(img);

for(int i=0;iheight;i++)

for(int j=0;jwidth;j++)

{

BYTE sum=0;

for(int k=0;k<9;k++)

ptr[k]=&kek;

if(j-1>=0&&i-1>=0)

ptr[0]=(BYTE*)img->at(img,j-1,i-1);

if(j>=0&&i-1>=0)

ptr[1]=(BYTE*)img->at(img,j+0,i-1);

if(j+1<=img->width&&i-1>=0)

ptr[2]=(BYTE*)img->at(img,j+1,i-1);

if(j-1>=0&&i>=0)

ptr[3]=(BYTE*)img->at(img,j-1,i+0);

if(j>=0&&i>=0)

ptr[4]=(BYTE*)img->at(img,j+0,i+0);

if(j+1<=img->width&&i>=0)

ptr[5]=(BYTE*)img->at(img,j+1,i+0);

if(j-1>=0&&i+1<=img->height)

ptr[6]=(BYTE*)img->at(img,j-1,i+1);

if(j>=0&&i+1<=img->height)

ptr[7]=(BYTE*)img->at(img,j+0,i+1);

if(j+1<=img->width&&i+1<=img->height)

ptr[8]=(BYTE*)img->at(img,j+1,i+1);

BYTE temp[9];

for(int k=0;k<9;k++)

{

if(ptr[k]!=NULL)

{

temp[k]= (BYTE)(*ptr[k]);

}

}

for(int m=0;m<9-1;m++)

for(int n=0;n<9-m-1;n++)

{

if(temp[m]>temp[m+1])

{

BYTE x=temp[m];

temp[m]=temp[n+1];

temp[n+1]=x;

}

}

ptro=(BYTE*)out->at(out,j+0,i+0);

*ptro=temp[8];

}

return out;

}else if (img->imgdepth==LI_DEP_24U||img->imgdepth==LI_DEP_32U)

{

Li_Image* imgH[img->imgdepth+1];

Li_Image* imgL[img->imgdepth+1];

Li_Split(img,imgH);

for(int i=0;iimgdepth+1;i++)

imgL[i]= Li_Medeum(imgH[i]);

Li_Image* out2=Li_Combine(imgL,img->imgdepth);

return out2;

}

}

/**

* @name: Li_Grandient

* @msg: 形态学梯度

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_Grandient(Li_Image* img)

{

Li_Image* erode=Li_Erode(img);

Li_Image* dilate=Li_Dilate(img);

Li_Image* minus=Li_Minus(dilate,erode);

Li_Destroy_Image(erode);

Li_Destroy_Image(dilate);

return minus;

}

/**

* @name: Li_Mod_Open

* @msg: 形态学开运算

* @param {Li_Image* img}

* @return {Li_Image* }

*/

LI_API

Li_Image* Li_Mod_Open(Li_Image* img)

{

Li_Image* dilate=Li_Dilate(img);//先膨胀

Li_Image* erode=Li_Erode(dilate);//先腐蚀

Li_Destroy_Image(dilate);

return erode;

}

/**

* @name: Li_Mod_Close

* @msg: 形态学闭运算

* @param {Li_Image* img}

* @return {Li_Image* }

*/

LI_API

Li_Image* Li_Mod_Close(Li_Image* img)

{

Li_Image* erode=Li_Erode(img);//先腐蚀

Li_Image* dilate=Li_Dilate(erode);//先膨胀

Li_Destroy_Image(erode);

return dilate;

}

/**

* @name: Li_TopHat

* @msg: 图像顶帽运算

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_TopHat(Li_Image* img)

{

Li_Image* open=Li_Mod_Open(img);

Li_Image* top=Li_Minus(img,open);

Li_Destroy_Image(open);

return top;

}

/**

* @name: Li_BlackHat

* @msg: 图像黑帽运算

* @param {Li_Image* img}

* @return {Li_Image*}

*/

LI_API

Li_Image* Li_BlackHat(Li_Image* img)

{

Li_Image* close=Li_Mod_Close(img);

Li_Image* black=Li_Minus(img,close);

Li_Destroy_Image(close);

return black;

}

#endif// !LI_CONV_C

夏虫爱吃冰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二维卷积运算之C语言实现二维卷积运算之C语言实现
09-18
二维卷积运算之C语言实现二维卷积运算之C语言实现 二维卷积运算之C语言实现二维卷积运算之C语言实现
ImageMorph_C＃图像_形态学_图像形态学_
10-03
实现二值形态学和灰度形态学算法程序及其在图像处理中的应用
基于C语言的图像去噪算法设计与实现
05-04
基于C语言的图像去噪算法设计与实现
RLE压缩算法C语言实现
12-03
RLE压缩算法C语言实现 RLE压缩算法C语言实现 RLE压缩算法C语言实现
基于C语言实现SM4加密算法图像加密应用源码.zip
01-04
基于C语言实现SM4加密算法图像加密应用源码.zip 基于C语言实现SM4加密算法图像加密应用源码.zip 基于C语言实现SM4加密算法图像加密应用源码.zip 开发语言：C语言 SM4加密算法应用 图像加密项目 带有可执行程序 开发语言：C语言 SM4加密算法应用 图像加密项目 带有可执行程序 开发语言：C语言 SM4加密算法应用 图像加密项目 带有可执行程序
二维卷积的c实现，很好的算法
10-29
二维卷积的c语言实现，若x为N1*M1的二维信号，y为N2*M2的二维信号，则卷积为(N1+N2-1)*(M1+M2-1)的信号 z(i,j)=∑ ∑x(m,n)y(i-m,j-n) m n
用c语言解决卷积法处理图像,【算法+图像处理】2D卷积与快速卷积算法C语言实现...
weixin_36250058的博客
05-23 911
卷积算法在图像处理中有着广泛的应用，通常使用的去噪算法、边缘增强算法等的实现都使用到了2D卷积算法。这里介绍一下2D卷积算法和快速卷积算法的C语言实现。卷积定义即步骤：1)滑动核，使其中心位于输入图像g的(i，j)像素上；2)利用上式求和，得到输出图像的(i，j)像素值；3)充分上面操纵，直到求出输出图像的所有像素值。1、2D卷积算法的实现bool convolve2DSlow(unsigned ...
2D卷积 HLS C/C++实现
qq_35608277的博客
03-02 705
void _2DConv(int8_t *in，int8_t *out,int8_t *filter,uint32_t nrows,uint32_t ncols,uint8_t k,uint8_t stride) /* in:输入图像 out：输出图像 filter：滤波器 nrows：输出图像的行数 ncols：输出图像的列数 k:滤波器大小（k*k） stride:滤波窗口步进长度 */ ...
c语言的卷积函数,C语言中的快速二维卷积
weixin_32349223的博客
05-20 605
我正在尝试用Python实现一个卷积神经网络。最初，我用的是化学信号的卷积2d函数来完成卷积，但是它有很多开销，而且如果只在C语言中实现自己的算法并从python调用它会更快，因为我知道我的输入是什么样子的。在我实现了两个功能：具有不可分核矩阵的卷积用可分离的内核对矩阵进行卷积(现在我假设python在将其传递给C之前进行秩检查和拆分)这两个函数都没有填充，因为我需要降维。在不可分离二维卷积// ...
用C语言实现卷积操作（包含单通道单卷积和多通道多卷积以及维度的转换）
热门推荐
qq_42585108的博客
05-05 1万+
用C语言实现卷积单通单卷积多通道多卷积维度转换（多维转一维）完整代码实现： 单通单卷积 卷积其实就是个点成相加的过程 原理图如下： 关键代码实现： //单通道单卷积 #define IMG_SIZE 5 #define W_SIZE 3 #define OUT_SIZE 3 // (f-w+2p)/s + 1 = (5-3+0)/1+1 = 3 int conv(float img[IMG_SIZE][IMG_SIZE],float w[W_SIZE][W_SIZE],float out[OUT_
C语言实现图的搜索算法示例
08-30
主要介绍了C语言实现图的搜索算法,结合具体实例形式分析了C语言实现图的定义及搜索相关操作技巧,需要的朋友可以参考下
二维卷积算法的C#实现
07-19
C#简单实现的二维卷积算法，可以直接使用， double[] conv2(double[] X, double[] Y)
用C语言实现卷积计算并绘制出卷积计算前后的结果图形
12-11
通过使用C语言实现卷积的计算过程，实现对任意长度的两个序列进行卷积的求解过程并对，结果绘制出图形
图像处理基本算法 C语言实现
06-28
图像平滑、图像增强、图像分割、图像二值化、图像画图工具如圆、直线、像素值趋势线等
二维卷积之C语言实现
07-03
二维卷积 完整的C代码实现，给出简单的实力
Python scipy的二维图像卷积运算与图像模糊处理操作示例
09-18
主要介绍了Python scipy的二维图像卷积运算与图像模糊处理操作,涉及Python数学运算与图形绘制相关操作技巧,需要的朋友可以参考下
卷积神经网络-基于ResNet实现的遥感图像分类算法.zip
最新发布
05-03
卷积神经网络 卷积神经网络_基于ResNet实现的遥感图像分类算法
卷积神经网络-基于AlexNet实现的遥感图像分类算法.zip
05-03
卷积神经网络 卷积神经网络_基于AlexNet实现的遥感图像分类算法
卷积神经网络-基于GoogleNet实现的遥感图像分类算法.zip
05-03
卷积神经网络 卷积神经网络_基于GoogleNet实现的遥感图像分类算法
matlab图像处理自己写的包含选取卷积核中心点的腐蚀膨胀开运算代码
06-01
好的，以下是一个 Matlab 实现的包含选取卷积核中心点的腐蚀、膨胀、开运算代码示例： ```matlab % 读取图像 img = imread('input.jpg'); % 定义结构元素 se_size = 5; se = strel('rectangle', [se_size se_size]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值