C++数字图像处理（不用opencv）

最新推荐文章于 2024-06-20 12:43:21 发布
最新推荐文章于 2024-06-20 12:43:21 发布
阅读量4.1k 收藏 34
点赞数 5
分类专栏： 笔记 文章标签： c++ 图像处理
原文链接：https://www.lavenderdh.cn/2020/11/09/%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%9ABMP%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%88%E6%8E%A7%E5%88%B6%E5%8F%B0%E7%A8%8B%E5%BA%8F%EF%BC%89/
版权

转载：https://www.lavenderdh.cn/2020/11/09/%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%9ABMP%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%88%E6%8E%A7%E5%88%B6%E5%8F%B0%E7%A8%8B%E5%BA%8F%EF%BC%89/

本文作者： Lavender @lavender

本文链接： https://www.lavenderdh.cn/2020/11/09/数字图像处理：BMP图像处理（控制台程序）/

版权声明： 本站所有文章除特别声明外，均采用 (CC)BY-NC-SA 许可协议。转载请注明出处！

实验任务书：
编写一个 VC++ 的控制台程序。要求如下：

一、打开一个 BMP 图像文件（图像大小不要太大）。

二、显示图像文件的数据。

对于读入的图像文件，显示位图数据 (选择一部分区域显示即可)。用 256 色或 256 级灰度图像进行验证。有两种显示方式：从上到下，从下到上。自己验证。

三、计算图像的直方图 (可以只显示灰度级 100~200 的直方图，为 0 的不显示；大小的处理，先归一化，再乘以 50)

对于 256 级灰度级的图像进行计算。存入一个 256 元素的数组中，并显示其数据。用图形的方式显示（数据为 0 的不显示，如果值太大，按比例缩小一下）。

四、图像的增亮或减暗

输入一个数字，如果是正数对图像进行增亮，如果是负数对图像进行减暗。

用其他软件进行查看，源图像和被增亮或减暗的图像进行对比，是不是达到了预想的效果。

五、main () 函数的要求

有选择。

main () 函数将指定 BMP 文件读入内存，将图像信息打印输出，最后又原样存入指定文件中。并进行计算需要的数据。

界面：

0---------- 结束

1---------- 读图像（8/24 位）

2----------- 写图像（8/24 位）

3----------- 显示图像数据（1 行到 10 行，1 列到 10 列，1010*** 的大小）（8/24 位）

4----------- 计算直方图（100-200 之间的灰度，1-10 行，1-0 列，1010*** 的大小）(8 位)

5----------- 对图像进行增亮或减暗（如加上 50 或减去 50**** 等）(8 位)

6----------- 图像反色

7----------- 变成灰度图（8/24 位）

8----------- 显示调色板 (8 位)

9-----------24 位彩色图像转换为 8**** 位灰度图像

10-----------24 位彩色图像转换为 8**** 位彩色图像


#include <Windows.h>
#include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
unsigned char *pBmpBuf;
int bmpWidth;
int bmpHeight;
RGBQUAD *pColorTable;
int biBitCount;
unsigned int **out_r;
unsigned int **out_g;
unsigned int **out_b;
bool readBmp(char *bmpName) // 读图像
{
    FILE *fp=fopen(bmpName,"rb");//二进制格式打开文件
    if(fp==0)
        return 0;
    fseek(fp,sizeof(BITMAPFILEHEADER),0);//文件指针跳过第一个结构体，定位到第二个结构体
    BITMAPINFOHEADER head;
    fread(&head,sizeof(BITMAPINFOHEADER),1,fp);//向head中写入第二个结构体的信息
    bmpWidth=head.biWidth;
    bmpHeight=head.biHeight;
    biBitCount=head.biBitCount;
    int lineByte=bmpWidth*biBitCount/8;//每行占几个Byte
    if(biBitCount==8)
    {
        pColorTable=new RGBQUAD[256];
        fread(pColorTable,sizeof(RGBQUAD),256,fp);
    }
    pBmpBuf=new unsigned char[lineByte*bmpHeight];//图像内容
    fread(pBmpBuf,1,lineByte*bmpHeight,fp);
    fclose(fp);
    return 1;
}
bool saveBmp(char *bmpName,unsigned char *imgBuf,int width,int height,int biBitCount,RGBQUAD *pColorTable) // 写图像
{
    if(!imgBuf) return 0;
    int colorTablesize=0;
    if(biBitCount==8) colorTablesize=1024;
    int lineByte=(width*biBitCount/8+3)/4*4;//为什么要是4的倍数
    FILE *fp=fopen(bmpName,"wb");
    if(fp==0) return 0;
    BITMAPFILEHEADER fileHead;
    fileHead.bfType=0x4D42;
    fileHead.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+colorTablesize+lineByte*height;
    fileHead.bfReserved1=0;
    fileHead.bfReserved2=0;
    fileHead.bfOffBits=54+colorTablesize;
    fwrite(&fileHead,sizeof(BITMAPFILEHEADER),1,fp);
    BITMAPINFOHEADER head;
    head.biBitCount=biBitCount;
    head.biClrImportant=0;
    head.biClrUsed=0;
    head.biCompression=0;
    head.biHeight=height;
    head.biPlanes=1;
    head.biSize=40;
    head.biSizeImage=lineByte*height;
    head.biWidth=width;
    head.biXPelsPerMeter=0;
    head.biYPelsPerMeter=0;
    fwrite(&head,sizeof(BITMAPINFOHEADER),1,fp);
    if(biBitCount==8)
        fwrite(pColorTable,sizeof(RGBQUAD),256,fp);
    fwrite(imgBuf,height*lineByte,1,fp);
    fclose(fp);
    return 1;
}
bool saveBmp_2(char *bmpName,unsigned char *imgBuf,int width,int height,int biBitCount,RGBQUAD *pColorTable) // 写图像
{
    if(!imgBuf) return 0;
    int colorTablesize=1024;
    int lineByte=(width*biBitCount/8+3)/4*4;
    int fix=lineByte-bmpWidth*3;
    unsigned char *p=imgBuf;
    FILE *fp=fopen(bmpName,"wb");
    if(fp==0) return 0;
    int lineBytetmp=((width*8)/8+3)/4*4;
    int fixtmp=lineBytetmp-bmpWidth;
    unsigned char *imgBuftmp=new unsigned char[lineBytetmp*bmpHeight];
    BITMAPFILEHEADER fileHead;
    fileHead.bfType=0x4D42;
    fileHead.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+256*4+lineBytetmp*bmpHeight;
    fileHead.bfReserved1=0;
    fileHead.bfReserved2=0;
    fileHead.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+256*4;
    fwrite(&fileHead,sizeof(BITMAPFILEHEADER),1,fp);
    BITMAPINFOHEADER head;
    head.biBitCount=8;
    head.biClrImportant=0;
    head.biClrUsed=256;
    head.biCompression=BI_RGB;
    head.biHeight=height;
    head.biPlanes=1;
    head.biSize=40;
    head.biSizeImage=lineBytetmp*height;
    head.biWidth=width;
    head.biXPelsPerMeter=0;
    head.biYPelsPerMeter=0;
    fwrite(&head,sizeof(BITMAPINFOHEADER),1,fp);
    RGBQUAD *pColorTabletmp=new RGBQUAD[256];
    for(int i=0;i<256;i++)
    {
        pColorTabletmp[i].rgbBlue=i;
        pColorTabletmp[i].rgbGreen=i;
        pColorTabletmp[i].rgbRed=i;
        pColorTabletmp[i].rgbReserved=0;
    }
    int pos=0;
    for(int i=0;i<bmpHeight;i++)
    {
        for(int j=0;j<bmpWidth;j++)
        {
            int blue=*p++;
            int green=*p++;
            int red=*p++;
            int gray=0.3*red+0.59*green+0.11*blue;
            imgBuftmp[pos]=gray;
            pos++;
        }
        p+=fix;
        for(int i=0;i<fixtmp;i++)
        {
            imgBuftmp[pos]=0;
            pos++;
        }
    }
    delete []pColorTable;
    delete []imgBuf;
    fwrite(pColorTabletmp,sizeof(RGBQUAD),256,fp);
    fwrite(imgBuftmp,height*lineBytetmp,1,fp);
    fclose(fp);
    return 1;
}
bool saveBmp_3(char *bmpName,unsigned char *imgBuf,int width,int height,int biBitCount,RGBQUAD *pColorTable) // 写图像
{
    if(!imgBuf) return 0;
    int colorTablesize=1024;
    int lineByte=(width*biBitCount/8+3)/4*4;
    int fix=lineByte-bmpWidth*3;
    unsigned char *p=imgBuf;
    FILE *fp=fopen(bmpName,"wb");
    if(fp==0) return 0;
    int lineBytetmp=((width*8)/8+3)/4*4;
    int fixtmp=lineBytetmp-bmpWidth;
    unsigned char *imgBuftmp=new unsigned char[lineBytetmp*bmpHeight];
    BITMAPFILEHEADER fileHead;
    fileHead.bfType=0x4D42;
    fileHead.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+256*4+lineBytetmp*bmpHeight;
    fileHead.bfReserved1=0;
    fileHead.bfReserved2=0;
    fileHead.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+256*4;
    fwrite(&fileHead,sizeof(BITMAPFILEHEADER),1,fp);
    BITMAPINFOHEADER head;
    head.biBitCount=8;
    head.biClrImportant=0;
    head.biClrUsed=256;
    head.biCompression=BI_RGB;
    head.biHeight=height;
    head.biPlanes=1;
    head.biSize=40;
    head.biSizeImage=lineBytetmp*height;
    head.biWidth=width;
    head.biXPelsPerMeter=0;
    head.biYPelsPerMeter=0;
    fwrite(&head,sizeof(BITMAPINFOHEADER),1,fp);
    RGBQUAD *pColorTabletmp=new RGBQUAD[256];
    int R[4]={0,85,170,255};
    int G[16]={0,17,34,51,68,85,102,119,136,153,170,187,204,221,238,255};
    int B[4]={0,85,170,255};
    int numcolortable=0;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<16;j++)
        {
            for(int k=0;k<4;k++)
            {
                pColorTabletmp[numcolortable].rgbRed=R[i];
                pColorTabletmp[numcolortable].rgbGreen=G[j];
                pColorTabletmp[numcolortable].rgbBlue=B[k];
                numcolortable++;
            }
        }
    }
    int pos=0;
    for(int i=0;i<bmpHeight;i++)
    {
        for(int j=0;j<bmpWidth;j++)
        {
            int blue=*p++;
            int green=*p++;
            int red=*p++;
            red=red/85*85;
            green=green/17*17;
            blue=blue/85*85;
            int _tmp=0;
            for(int i=0;i<256;i++)
            {
                if(red==pColorTabletmp[i].rgbRed&&green==pColorTabletmp[i].rgbGreen&&blue==pColorTabletmp[i].rgbBlue)
                {
                    _tmp=i;
                    break;
                }
            }
            imgBuftmp[pos]=_tmp;
            pos++;
        }
        p+=fix;
        for(int i=0;i<fixtmp;i++)
        {
            imgBuftmp[pos]=0;
            pos++;
        }
    }
    delete []pColorTable;
    delete []imgBuf;
    fwrite(pColorTabletmp,sizeof(RGBQUAD),256,fp);
    fwrite(imgBuftmp,height*lineBytetmp,1,fp);
    fclose(fp);
    return 1;
}
void startbmp(char *bmpName)  // 打开图片
{
    readBmp(bmpName);
    char writePath[] = "bmp_start.bmp";
	saveBmp(writePath,pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
    system("start bmp_start.bmp");
    system("pause");
}
void ImageShow(char *bmpName)// 显示图像数据
{
    readBmp(bmpName);
    cout<<"width="<<bmpWidth<<" height="<<bmpHeight<<" biBitCount="<<biBitCount<<endl;
    int lineByte=(bmpWidth*biBitCount/8+3)/4*4;
    int n=0,count_pixel=0;
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for(int i=0;i<bmpHeight;i++)
        {
            for(int j=0;j<bmpWidth;j++)
            {
                out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3];
                n++;
            }
        }
        cout<<"总的像素个素为:"<<n<<endl;
        cout<<"前十行十列10*10的数据："<<endl;
        for(int i=0;i<10;i++)
		{
			for(int j=0;j<10;j++)
			{
				cout<<out_r[i][j]<<" ";
			}
            cout<<endl;
        }
    }
    if(biBitCount==24)
    {
        for(int i=0;i<bmpHeight;i++)
        {
            for(int j=0;j<bmpWidth;j++)
            {
                for(int k=0;k<3;k++)
                {
                    count_pixel++;
                }
                n++;
            }
        }
        cout<<"总的像素个素为:"<<n<<endl;
    }
    if(biBitCount==24)
	{
		for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
				out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3];
				out_g[bmpHeight-1-i][j]=pBmpBuf[j*3+1+bmpWidth*i*3];
				out_b[bmpHeight-1-i][j]=pBmpBuf[j*3+bmpWidth*i*3];
			}
		}
        cout<<"前十行十列10*10的数据："<<endl;
		for(int i=0;i<10;i++)
		{
			for(int j=0;j<10;j++)
			{
				cout<<out_r[i][j]<<" ";
				cout<<out_g[i][j]<<" ";
				cout<<out_b[i][j]<<" ";
                cout<<"\t";
			}
            cout<<endl;
		}
	}
    system("pause");
}
void ImageShow_2(char *bmpName)// 显示图像数据
{
    readBmp(bmpName);
    cout<<"width="<<bmpWidth<<" height="<<bmpHeight<<" biBitCount="<<biBitCount<<endl;
    int lineByte=(bmpWidth*biBitCount/8+3)/4*4;
    int n=0,count_pixel=0;
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for(int i=0;i<bmpHeight;i++)
        {
            for(int j=0;j<bmpWidth;j++)
            {
                out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3];
                n++;
            }
        }
        cout<<"总的像素个素为:"<<n<<endl;
    }
}
void Histogram(char *bmpName)// 直方图
{
    int num[256]={0};
    int col_r[256]={0};
    int bmpsize=bmpWidth*bmpHeight;
    readBmp(bmpName);
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for(int i=0;i<bmpHeight;i++)
        {
            for(int j=0;j<bmpWidth;j++)
            {
                out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3];
            }
        }
        for(int k=0;k<256;k++)
        {
            for(int i=0;i<bmpHeight;i++)
		    {
			    for(int j=0;j<bmpWidth;j++)
			    {
                    if(k==out_r[i][j])
                        num[k]++;
			    }
            }
        }
        cout<<"直方图："<<endl;
        for(int i=0;i<256;i++)
            cout<<num[i]<<" ";
        cout<<endl;
        for(int i=0;i<256;i++)
        {
            col_r[i]=((double)num[i]/bmpsize)*50;
        }
        for(int i=0;i<256;i++)
        {
            cout<<i<<":";
            for(int j=0;j<col_r[i];j++)
                cout<<"*";
            cout<<endl;
        }
    }
    system("pause");
}
void BrightDark(char *bmpName)// 增量或减暗
{
    readBmp(bmpName);
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    int num_b_d;
    cin>>num_b_d;
    if(biBitCount==8)
    {
        for (int i=0;i<256;i++)
		{
			pColorTable[i].rgbBlue+=num_b_d;
			pColorTable[i].rgbGreen+=num_b_d;
			pColorTable[i].rgbRed+=num_b_d;
		}
        for(int i=0;i<256;i++)
		{
			if(pColorTable[i].rgbBlue>255)
                pColorTable[i].rgbBlue=255;
            if(pColorTable[i].rgbBlue<0)
                pColorTable[i].rgbBlue=0;
            if(pColorTable[i].rgbGreen>255)
                pColorTable[i].rgbGreen=255;
            if(pColorTable[i].rgbGreen<0)
                pColorTable[i].rgbGreen=0;
            if(pColorTable[i].rgbRed>255)
                pColorTable[i].rgbRed=255;
            if(pColorTable[i].rgbRed<0)
                pColorTable[i].rgbRed=0;
        }
    }
    char writePath[] = "bmp_bri_dar.bmp";
	saveBmp(writePath,pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
	delete[]pBmpBuf;
	if (biBitCount == 8)
		delete[]pColorTable;
    system("start bmp_bri_dar.bmp");
    system("pause");
}
void Inverse(char *bmpName) // 反色
{
    readBmp(bmpName);
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for (int i=0;i<256;i++)
		{
			pColorTable[i].rgbBlue=255-pColorTable[i].rgbBlue;
			pColorTable[i].rgbGreen=255-pColorTable[i].rgbGreen;
			pColorTable[i].rgbRed=255-pColorTable[i].rgbRed;
		}
    }
    if(biBitCount==24)
	{
        int lineByte=(bmpWidth*biBitCount/8+3)/4*4;
		int fix=lineByte-bmpWidth*3;
		for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
				out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3+i*fix];
				out_g[bmpHeight-1-i][j]=pBmpBuf[j*3+1+bmpWidth*i*3+i*fix];
				out_b[bmpHeight-1-i][j]=pBmpBuf[j*3+bmpWidth*i*3+i*fix];
			}
		}
		for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
                out_r[i][j]=255-out_r[i][j];
                out_g[i][j]=255-out_g[i][j];
                out_b[i][j]=255-out_b[i][j];
			}
		}
        for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
                pBmpBuf[j*3+2+bmpWidth*i*3+i*fix]=out_r[bmpHeight-1-i][j];
				pBmpBuf[j*3+1+bmpWidth*i*3+i*fix]=out_g[bmpHeight-1-i][j];
				pBmpBuf[j*3+bmpWidth*i*3+i*fix]=out_b[bmpHeight-1-i][j];
			}
		}
	}
    char writePath[] = "bmp_inverse.bmp";
	saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
	delete[]pBmpBuf;
	if (biBitCount == 8)
		delete[]pColorTable;
    system("start bmp_inverse.bmp");
    system("pause");
}
void ConvertGray(char *bmpName) // 变成灰度图
{
    readBmp(bmpName);
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for (int i=0;i<256;i++)
		{
			pColorTable[i].rgbBlue=0.11*pColorTable[i].rgbBlue+0.59*pColorTable[i].rgbGreen+0.3*pColorTable[i].rgbRed;
			pColorTable[i].rgbGreen=pColorTable[i].rgbRed=pColorTable[i].rgbBlue;
		}
    }
    if(biBitCount==24)
	{
        int lineByte=(bmpWidth*biBitCount/8+3)/4*4;
		int fix=lineByte-bmpWidth*3;
		for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
				out_r[bmpHeight-1-i][j]=pBmpBuf[j*3+2+bmpWidth*i*3+i*fix];
				out_g[bmpHeight-1-i][j]=pBmpBuf[j*3+1+bmpWidth*i*3+i*fix];
				out_b[bmpHeight-1-i][j]=pBmpBuf[j*3+bmpWidth*i*3+i*fix];
			}
		}
		for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
                out_r[i][j]=0.3*out_r[i][j]+0.59*out_g[i][j]+0.11*out_b[i][j];
                out_g[i][j]=out_b[i][j]=out_r[i][j];
			}
		}
        for(int i=0;i<bmpHeight;i++)
		{
			for(int j=0;j<bmpWidth;j++)
			{
                pBmpBuf[j*3+2+bmpWidth*i*3+i*fix]=out_r[bmpHeight-1-i][j];
				pBmpBuf[j*3+1+bmpWidth*i*3+i*fix]=out_g[bmpHeight-1-i][j];
				pBmpBuf[j*3+bmpWidth*i*3+i*fix]=out_b[bmpHeight-1-i][j];
			}
		}
	}
    char writePath[] = "bmp_gray.bmp";
	saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
	delete[]pBmpBuf;
	if (biBitCount == 8)
		delete[]pColorTable;
    system("start bmp_gray.bmp");
    system("pause");
}
void palette(char *bmpName) // 显示调色板
{
    readBmp(bmpName);
	out_r=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_r[i]=new unsigned int[bmpWidth];
	out_g=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_g[i]=new unsigned int[bmpWidth];
	out_b=new unsigned int *[bmpHeight];
	for(int i=0;i<bmpHeight;i++)
		out_b[i]=new unsigned int[bmpWidth];
    if(biBitCount==8)
    {
        for (int i=0;i<256;i++)
		{
			cout<<(double)pColorTable[i].rgbRed<<"\t"<<(double)pColorTable[i].rgbGreen<<"\t"<<(double)pColorTable[i].rgbBlue;
            cout<<endl;
		}
    }
    system("pause");
}
void TFtoEgray(char *bmpName)
{
    readBmp(bmpName);
	char writePath[] = "24to8gray.bmp";
	saveBmp_2(writePath,pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
    system("start 24to8gray.bmp");
    ImageShow_2("24to8gray.bmp");
    system("pause");
}
void TFtoEcolor(char *bmpName)
{
    readBmp(bmpName);
	char writePath[] = "24to8color.bmp";
	saveBmp_3(writePath,pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);
    system("start 24to8color.bmp");
    ImageShow_2("24to8color.bmp");
    system("pause");
}

int main()
{
    char readPath[107];

    strcpy(readPath,"girl.bmp");
    int number;
    do
    {
        system("cls");
        cout<<"\t\t\t图像处理"<<endl;
        cout<<"\t\t\t0、结束"<<endl;
        cout<<"\t\t\t1、读图像（8/24位）"<<endl;
        cout<<"\t\t\t2、写图像（8/24位）"<<endl;
        cout<<"\t\t\t3、显示图像数据（8/24位）"<<endl;
        cout<<"\t\t\t4、计算直方图（8位）"<<endl;
        cout<<"\t\t\t5、对图像进行增量或减暗（8位）"<<endl;
        cout<<"\t\t\t6、图像反色（8/24位）"<<endl;
        cout<<"\t\t\t7、变成灰度图（8/24位）"<<endl;
        cout<<"\t\t\t8、显示调色板（8位）"<<endl;
        cout<<"\t\t\t9、24位彩色图像转换为8位灰度图像（24位）"<<endl;
        cout<<"\t\t\t10、24位彩色图像转换为8位彩色图像（24位）"<<endl;
        cin>>number;
        if(number<0||number>10)
            cin>>number;
        switch (number)
        {
            case 0:exit(0); break;
            case 1:startbmp(readPath); break;
            case 2:exit(0); break;
            case 3:ImageShow(readPath); break;
            case 4:Histogram(readPath); break;
            case 5:BrightDark(readPath); break;
            case 6:Inverse(readPath); break;
            case 7:ConvertGray(readPath); break;
            case 8:palette(readPath); break;
            case 9:TFtoEgray(readPath); break;
            case 10:TFtoEcolor(readPath);break;
            default:        break;
        }
    }while(number!=11);
    system("pause");
    return 0;
}
不会卷积
关注
  • 5
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Visual C++数字图像处理技术详解 pdf+源码[百度网盘地址]
11-23
Visual C++数字图像处理技术详解 完整版 pdf + 源码 刘海波、沈晶、郭耸 等编著 《Visual C++数字图像处理技术详解》以数字图像处理技术为主线，全面地介绍在Visual C++环境下进行数字图像处理程序设计的方法。内容涵盖了数字图像的变换、增强、复原、重建、形态学处理、分割、匹配、压缩编码、特效处理等，各种方法均给出基本原理、典型算法、Visual C++源码及综合应用案例。同时，《Visual C++数字图像处理技术详解》还介绍了Visual C++与VTK、OpenCV和MATLAB等开发平台相结合进行数字图像处理的程序设计技术。
从零开始的图像处理---摒弃Opencv
PangCoder的博客
08-18 2183
面试上岗第一天的任务就是学习图像处理，一开始以为是用Opencv来做，后来才知到用纯c++的方法去实现，而且更难的是要用可视化编程，这让我有点崩溃，瞬间从有点小图像处理开发经验变成什么都不会的可怜虫了。 公司为了让我能够尽快熟悉vs2005开发工具（别问我为啥是2005，自己百度去，我自己用的还是2012呢），给了我下面的任务 设计要求： 1.在VS2005下使用c++编写一个图形界面程序
VC++打开预览BMP图像
03-17
摘要:VC/C++源码,图形处理,BMP　　VC++打开预览BMP图像，写的一个VC++小程序，用来打开预览BMP格式的图像，以前见到不少新手对于在窗体上显示BMP位图很是纠结，希望通过这个小小的VC++实例源码为你找到答案。
C++ Qt数字图像处理作业（无Opencv）
weixin_47564581的博客
09-03 2558
C++ Qt数字图像处理作业（无Opencv） 数字图像处理老师不让用opencv来实现直方图均衡化、中值滤波、锐化、边缘检测、直方图阈值分割。各个处理模块有参考csdn上大佬的算法。本着分享的精神，上传上来。代码和结构还有很大的优化空间，希望看客么也能给一些建议。 1.界面 主界面图片 每一次图片处理的直方图 边缘检测效果 2.代码结构 1.pro配置 2.代码 代码结构很简单，有打开图片，直方图的显示公共函数，代码中重复的内容很多，还可以进行优化。 mainwindow.h #ifndef
【OpenCV】在没有安装OpenCV的电脑运行OpenCV程序
编程语言小筑
10-12 438
题目来自OpenCV·China的每周一练： 我们在做项目时，通常需要把依赖于opencv，vs（例如vs2005），或者vc（例如vc6.0）的程序，在没有安装相关环境的电脑上去运行。那么现在有哪些方法可以摆脱这些依赖？（提供可行建议即可得10分） http://www.opencvchina.com/thread-1368-1-1.html 前面的童鞋讲得很全了，我再补充一下自己的理解~...
二值图像边缘提取算法C语言实现
zhangdieyan的专栏
06-07 9175
#define M 30 #define N 20 void edge(int image[M][N],int bianyuan[M][N]) {    int i,j;    int inner=1,outer=1;    for (i=0;i       for(j=0;j             bianyuan[i][j]=0;    for(i=1;i     
Canny边缘检测及利用C++实现
Ring__Rain的博客
05-16 1071
Canny算子边缘检测的具体步骤如下： 一、用高斯滤波器平滑图像 二、用Sobel等梯度算子计算梯度幅值和方向 三、对梯度幅值进行非极大值抑制 四、用双阈值算法检测和连接边缘 一、用高斯滤波器平滑图像 高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，特别是对抑制或消除服从正态分布的噪声非常有效。滤波可以消除或降低图像中噪声的影响，使用高斯滤波器主要是基于在滤波降噪的同时也可以最大限度保...
数字图像处理 中值滤波 均值滤波 C++ opencv
04-02
数字图像处理，用C++语言，自己编写了中值滤波器以及均值滤波器，并和opencv自带函数对比，可直接运行。
C++毕业设计项目基于Opencv+QT完成的数字图像处理系统源码（高分项目）.zip
03-24
C++毕业设计项目基于Opencv+QT完成的数字图像处理系统源码（高分项目）.zip本资源中的源码都是经过本地编译过可运行的。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的...
Visual C++数字图像处理技术详解(源代码).rar_vc++_vtk 分割_图像复原 opencv_图像算法_形态匹配
07-14
《Visual C++数字图像处理技术详解》的源代码，《Visual C++数字图像处理技术...同时，《Visual C++数字图像处理技术详解》还介绍了Visual C++与VTK、OpenCV和MATLAB等开发平台相结合进行数字图像处理的程序设计技术。
11个常用OpenCV+C++图像处理
12-04
内容包括如下（资料很全，包括源码、可执行文件、说明；...1_人脸检测与识别系统 2_指纹提取与识别系统 ...6_数字图像水印系统 7_CT图像重建系统 8_图像编辑器实现 9_图片浏览器实现 10_绘图板 11_所需软件
c++ data数组进行crop
m0_51141653的博客
04-13 2553
//src是输入，dst是输出，x,y,dst_w,dst_h对应crop左上角左边，crop宽和高，src_w和src_h对应原始图片尺寸 unsigned char* crop(const unsigned char* src, unsigned char* dst, int x, int y, int dst_w, int dst_h,int src_w, int src_h) { if(src != nullptr && src[0] == '\0') { .
图像处理-直方图均衡化（C++实现，不依赖opencv）
风轻云淡的博客
12-18 1759
近来接触图像处理领域，opencv入门之后，想自己动手实现一些算法，先从直方图均衡化开始吧！ 我使用的图像文件是只包含数据yuv格式图像，以后等需要的时候再处理从普通格式（jpg、png等）提取rgb或者yuv数据的过程。 首先获取一副yuv格式图像，如果不明白yuv格式内部数据的存储方式，可自行百度。先上处理效果。 处理前： 处理后： 直方图本身不具有去燥功能，只是增...
不利用opencv （glob算子）进行图片转视频，视频转图片
qq_32278309的博客
12-04 204
//视频转图片 #include<opencv2/opencv.hpp> using namespace cv; using namespace std; int main() { VideoCapture videoCap("F:\\桌面\\论文工作\\毕业论文\\毕业答辩\\1.mov"); Mat img; int count = 1; videoCap >> img; while (img.empty() == false) { //如果取到的图片.
C++ 视频转换成图片
02-28 3677
#include #include #include "opencv2\highgui\highgui.hpp" using namespace std; using namespace cv; void video2image(string video,string path) { VideoCapture capture(video); if(!capture.isOpened()
C++读取、旋转和保存bmp图像文件编程实现
weixin_33919950的博客
07-23 1537
     以前也遇到过bmp文件的读写。这篇博客很好，写的其他内容也值得学习。      参考：http://blog.csdn.net/xiajun07061225/article/details/6633938  学习       在读取bmp图片的时候，一定要注意内存对齐的问题，譬如文件头，否则无法读取出正确结果。 关于图片的像素数据，每一行的像素的字节数必须是4的整数倍。如果不是，则...
C++读取并保存Tiff文件（纯C++，不需要配置opencv、boost.GIL等环境）
Terrence_Pai的博客
04-22 8928
背景说明 最近需要写一个能在LINUX上读取tif图像、修改像素并保存的C文件，之前都是matlab直接调函数，现在突然使用C读取着实有点懵。 找了很多网上的程序却都是需要调特定函数库，opencv库的安装与配置环境在windows下跟着教程还能勉强实现，但到linux配环境属实有点难（为此还租了一个云服务器，哭~）。而且因为最后整个项目要打包到其他电脑运行，这个时候又得考虑去其他电脑是否安装opencv，或者得考虑生成静态库、动态库， ~，那对于像我这样的菜菜估计又是一大波得不到结果的操作（整了一天愣是没
C++ 不需要每个工程都手动添加OPenCV dll库、.h文件及.lib文件
yanzhenyu2019的博客
10-24 439
dll的调用 每个工程在调用dll的时候会从系统环境变量path路径下去查找，所以为了避免在每个工程的执行文件下都要添加所需的动态库，可在系统环境变量 path中添加动态库dll的路径 如：D:\openCV249\build\x64\vc10\bin 头文件的添加 拷贝OpenCV的头文件至VS安装路径下的include中，如在VS2010的编程环境中的路径为：C:\Program Files ...
C语言 指定一个数字输出区间内的一个斐波那契数列
最新发布
Random_N1的博客
06-20 366
/ 函数用于计算并打印从1到n的斐波那契数列a = b;b = next;int num;return 0;
数字图像处理和opencv
05-13
数字图像处理是指通过计算机算法对数字图像进行处理，包括图像增强、图像滤波、图像分割、图像识别等。而 OpenCV 是一个广泛使用的开源计算机视觉库，提供了丰富的图像处理和计算机视觉算法，包括图像增强、目标检测、图像分割、人脸识别等。OpenCV支持多种编程语言，包括C++，Python等。在数字图像处理中，OpenCV是一种非常强大的工具，可以帮助开发者快速实现各种图像处理算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值