图像加噪c语言,数字图像处理_椒盐噪声_纯C

loadbmp.h

#include

#include

#include

#include

#include

#define pi (double)3.14159265359

#define BI_RGB 0

#define BI_RLE8 1

#define BI_RLE4 2

#define BI_BITFIELDS 3

typedef unsigned long DWORD;

typedef int BOOL;

typedef unsigned char BYTE;

typedef unsigned short WORD;

typedef float FLOAT;

typedef int INT;

typedef unsigned int UINT;

typedef char CHAR;

typedef short SHORT;

typedef long LONG;

#pragma pack(push)

#pragma pack(1)

typedef struct tagBITMAPINFOHEADER{

DWORD biSize;

LONG biWidth;

LONG biHeight;

WORD biPlanes;

WORD biBitCount;

DWORD biCompression;

DWORD biSizeImage;

LONG biXPelsPerMeter;

LONG biYPelsPerMeter;

DWORD biClrUsed;

DWORD biClrImportant;

} BITMAPINFOHEADER;

#pragma pack(pop)

#pragma pack(push)

#pragma pack(1)

typedef struct tagBITMAPFILEHEADER {

WORD bfType;

DWORD bfSize;

WORD bfReserved1;

WORD bfReserved2;

DWORD bfOffBits;

} BITMAPFILEHEADER;

#pragma pack(pop)

#pragma pack(push)

#pragma pack(1)

typedef struct tagRGBQUAD {

BYTE rgbBlue;

BYTE rgbGreen;

BYTE rgbRed;

BYTE rgbReserved;

} RGBQUAD;

#pragma pack(pop)

int nWidth;

int nHeight;

int nLen;

int nByteWidth;

BYTE *lpBackup;

BYTE *lpBitmap;

BYTE *lpBits;

/*复数定义*/

typedef struct

{

double re;

double im;

}COMPLEX;

/*复数加运算*/

COMPLEX Add(COMPLEX c1, COMPLEX c2)

{

COMPLEX c;

c.re=c1.re+c2.re;

c.im=c1.im+c2.im;

return c;

}

/*复数减运算*/

COMPLEX Sub(COMPLEX c1, COMPLEX c2)

{

COMPLEX c;

c.re=c1.re-c2.re;

c.im=c1.im-c2.im;

return c;

}

/*复数乘运算*/

COMPLEX Mul(COMPLEX c1, COMPLEX c2)

{

COMPLEX c;

c.re=c1.re*c2.re-c1.im*c2.im;

c.im=c1.re*c2.im+c2.re*c1.im;

return c;

}

void GetPoints(BYTE *lpPoints)

{

int x,y,p;

for(y=0;y

{

for(x=0;x

{

p=x*3+y*nByteWidth;

lpPoints[x+y*nWidth]=(BYTE)(0.299*(float)lpBits[p+2]+0.587*(float)lpBits[p+1]+0.114*(float)lpBits[p]+0.1);

}

}

}

void PutPoints(BYTE *lpPoints)

{

int x,y,p,p1;

for(y=0;y

{

for(x=0;x

{

p=x*3+y*nByteWidth;

p1=x+y*nWidth;

lpBits[p]=lpPoints[p1];

lpBits[p+1]=lpPoints[p1];

lpBits[p+2]=lpPoints[p1];

}

}

}

void LoadBitmap()

{int nBWidth;

BITMAPINFOHEADER *pInfo;

unsigned int PaletteSize;

RGBQUAD *pPalette;

BITMAPFILEHEADER bmh;

BITMAPINFOHEADER bmi;

BYTE *lpTemp=lpBitmap;

BYTE *lpBits2;

int x,y,p1,p2,Palette;

pInfo=(BITMAPINFOHEADER *)(lpBitmap+sizeof(BITMAPFILEHEADER));

nWidth=pInfo->biWidth;

nByteWidth=nWidth*3;

if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);

nHeight=pInfo->biHeight;

if (pInfo->biBitCount!=24)

{

if (pInfo->biBitCount!=8)

{

printf("Invalidation Bitmap");

free(lpBitmap);

lpBitmap=0;

return;

}

PaletteSize=1<biBitCount;

if (pInfo->biClrUsed!=0 && pInfo->biClrUsedbiClrUsed;

lpBits=lpBitmap+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);

pPalette=(RGBQUAD *)lpBits;

lpBits+=sizeof(RGBQUAD)*PaletteSize;

nLen=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nByteWidth*nHeight;

lpTemp=lpBitmap;

lpBitmap=(BYTE*)malloc(sizeof(BYTE)*nLen);

bmh.bfType='B'+'M'*256;

bmh.bfSize=nLen;

bmh.bfReserved1=0;

bmh.bfReserved2=0;

bmh.bfOffBits=54;

bmi.biSize=sizeof(BITMAPINFOHEADER);

bmi.biWidth=nWidth;

bmi.biHeight=nHeight;

bmi.biPlanes=1;

bmi.biBitCount=24;

bmi.biCompression=BI_RGB;

bmi.biSizeImage=0;

bmi.biXPelsPerMeter=0;

bmi.biYPelsPerMeter=0;

bmi.biClrUsed=0;

bmi.biClrImportant=0;

nBWidth=pInfo->biWidth;

if (nBWidth%4) nBWidth+=4-(nBWidth%4);

memset(lpBitmap,0,nLen);

memcpy(lpBitmap,&bmh,sizeof(BITMAPFILEHEADER));

memcpy(lpBitmap+sizeof(BITMAPFILEHEADER),&bmi,sizeof(BITMAPINFOHEADER));

lpBits2=lpBitmap+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);

for(y=0;y

{

for(x=0;x

{

p1=y*nBWidth+x;

p2=y*nByteWidth+x*3;

if (lpBits[p1]

else Palette=0;

lpBits2[p2]=pPalette[Palette].rgbBlue;

lpBits2[p2+1]=pPalette[Palette].rgbGreen;

lpBits2[p2+2]=pPalette[Palette].rgbRed;

}

}

free(lpTemp);

}

lpBits=lpBitmap+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);

if (lpBackup) free(lpBackup);

lpBackup=(BYTE*)malloc(sizeof(BYTE)*nLen);

memcpy(lpBackup,lpBitmap,nLen);

}

void OpenFile()

{

FILE* fp;

if ((fp=fopen("miss.bmp","r+b")) == NULL)

return;

if (lpBitmap)

free(lpBitmap);

fseek(fp, 0L, SEEK_END);

nLen=ftell(fp);

fseek(fp, 0L, SEEK_SET);

lpBitmap=(BYTE*)malloc(sizeof(BYTE)*nLen);

fread(lpBitmap,nLen,1,fp);

LoadBitmap();

}

void SaveAs()

{

BITMAPFILEHEADER bmh;

FILE* fp;

int nLen=nByteWidth*nHeight;

BYTE *pMem=(BYTE*)malloc(nLen+sizeof(BITMAPINFOHEADER));

BITMAPINFOHEADER *bmi=(BITMAPINFOHEADER *)pMem;

if (lpBitmap==0) return;

if ((fp=fopen("miss0.bmp","w+b")) == NULL)

return;

bmi->biSize=sizeof(BITMAPINFOHEADER);

bmi->biWidth=nWidth;

bmi->biHeight=nHeight;

bmi->biPlanes=1;

bmi->biBitCount=24;

bmi->biCompression=BI_RGB;

bmi->biSizeImage=0;

bmi->biXPelsPerMeter=0;

bmi->biYPelsPerMeter=0;

bmi->biClrUsed=0;

bmi->biClrImportant=0;

bmh.bfType='B'+'M'*256;

bmh.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nLen;

bmh.bfReserved1=0;

bmh.bfReserved2=0;

bmh.bfOffBits=54;

memcpy(pMem+sizeof(BITMAPINFOHEADER),lpBits,nLen);

fwrite(&bmh,sizeof(BITMAPFILEHEADER), 1, fp);

fwrite(pMem,nLen+sizeof(BITMAPINFOHEADER), 1, fp);

fclose(fp);

}

peppernoise.c

#define EXTRA_NAME "@PepperSaltNoise."

#include "loadbmp.h"

void Pepper_Noise()

{int x,y,p;

if (lpBitmap==0) return;

srand((unsigned)time(NULL));

for(y=0;y

{

for(x=0;x

{

if (rand()>31500)

{

p=x*3+y*nByteWidth;

lpBits[p+2]=255;

lpBits[p+1]=255;

lpBits[p]=255;

}

}

}

}

void main(int argc, char *argv[])

{

OpenFile();

Pepper_Noise();

SaveAs();

}

图片格式必须为bmp格式转换前:

转换后: