图像信息处理实验四

最新推荐文章于 2022-12-01 16:47:42 发布
最新推荐文章于 2022-12-01 16:47:42 发布
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 图形学&图像信息处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32146369/article/details/78564858
版权 
要求：
1.Translation
2.Rotation
3.Scale
4.Shear
5.Mirror




#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <cmath>

#define Pi 3.14159
using namespace std;

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int DWORD;
WORD bfType;
int h,w;    //图像的高度和宽度
int size;   //像素个数
typedef struct tagIMAGEP  //每个像素
{
	BYTE blue;
	BYTE green;
	BYTE red;
}P;

typedef struct tagBITMAPINFOHEADER{
	DWORD biSize;//信息头大小
	DWORD biWidth;//图像宽度
	DWORD biHeight;//图像高度
	WORD biPlanes;//位平面数，必须为1
	WORD biBitCount;//每像素位数
	DWORD  biCompression; //压缩类型
	DWORD  biSizeImage; //压缩图像大小字节数
	DWORD  biXPelsPerMeter; //水平分辨率
	DWORD  biYPelsPerMeter; //垂直分辨率
	DWORD  biClrUsed; //位图实际用到的色彩数
	DWORD  biClrImportant; //本位图中重要的色彩数
}BITMAPINFOHEADER; //位图信息头定义

typedef struct  tagBITMAPFILEHEADER{
	DWORD bfSize;//文件大小
	WORD bfReserved1;//保留字
	WORD bfReserved2;//保留字
	DWORD bfOffBits;//从文件头到实际位图数据的偏移字节数
}BITMAPFILEHEADER;

BITMAPFILEHEADER strHead;
BITMAPINFOHEADER strInfo;
int mW;   //取整的宽度
int cx,cy;  //中心宽度，高度坐标

void mirror(const P* before){
	P* Q = new P[size];
	memset(Q, 0, sizeof(P) * size);
	for (int i = 0; i < h; i++){
		for (int j = 0; j < mW; j++){
			Q[i*mW + j] = before[i*mW + mW - 1 - j];
		}
	}
    //建新文件
	FILE *fpo1;
	fpo1=fopen("mirr.bmp","wb");
	fwrite(&bfType,1,sizeof(WORD),fpo1);
	fwrite(&strHead,1,sizeof(tagBITMAPFILEHEADER),fpo1);
	fwrite(&strInfo,1,sizeof(tagBITMAPINFOHEADER),fpo1);
	fwrite(Q,1,sizeof(P)*(size),fpo1);
	fclose(fpo1);
	delete[] Q;
}

void translation(const P* before, int x, int y){
	int moveX, moveY;
	//对4取整
	if(x % 4 == 0)
		moveX = x;
	else
		moveX = x/4*4;
	moveY = y;
    //新坐标
	int nH = h + moveY;
	int nW = mW + moveX;
	//新像素数
	int newSize = nH * nW;
	P* Q = new P[newSize];
	memset(Q, 0, sizeof(P)*newSize);
	//处理每个像素
	for (int i = 0; i < nH; i++){
		for (int j = 0; j < nW; j++){
			if(i < moveY){
				Q[i*nW + j].red = Q[i*nW + j].blue = Q[i*nW + j].green = 0;
				continue;
			}
			if(j < moveX)
				Q[i*nW + j].red = Q[i*nW + j].blue = Q[i*nW + j].green = 0;
			else
				Q[i*nW + j] = before[(i- moveY)*mW + (j - moveX)];
		}
	}
	//建立新的文件
	FILE *fpo1;
	fpo1=fopen("trans.bmp","wb");
	//新的文件头信息头
	BITMAPFILEHEADER nHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	//新的图像大小
	nHead.bfSize = (DWORD)(nHead.bfSize - size*3 + newSize*3);
	//新的图像高度和宽度
	newInfo.biHeight = (DWORD)nH;
	newInfo.biWidth = (DWORD)nW;
	newInfo.biSizeImage = (DWORD)(newSize * 3);
	fwrite(&bfType,1,sizeof(WORD),fpo1);
	fwrite(&nHead,1,sizeof(tagBITMAPFILEHEADER),fpo1);
	fwrite(&newInfo,1,sizeof(tagBITMAPINFOHEADER),fpo1);
	fwrite(Q,1,sizeof(P)*(newSize),fpo1);
	fclose(fpo1);
	//释放空间
	delete[] Q;
}
//坐标处理
double xAfterRot(int x, int y, double theta){
	x = x - cx;
	y = y - cy;
	double result = x * cos(theta) - y * sin(theta);
	return result += cx;
}
double yAfterRot(int x, int y, double theta){
	x = x - cx;
	y = y - cy;
	double result = x * sin(theta) + y * cos(theta);
	return result += cy;
}

void tXY(int &x, int &y, double theta){
	double tmpX[4],tmpY[4];
	double minX = 999999, minY = 999999, maxX = 0, maxY = 0;

	tmpX[0] = xAfterRot(0, 0, theta);
	tmpY[0] = yAfterRot(0, 0, theta);
	tmpX[1] = xAfterRot(mW, 0, theta);
	tmpY[1] = yAfterRot(mW, 0, theta);
	tmpX[2] = xAfterRot(mW, h, theta);
	tmpY[2] = yAfterRot(mW, h, theta);
	tmpX[3] = xAfterRot(0, h, theta);
	tmpY[3] = yAfterRot(0, h, theta);

	for(int i = 0; i < 4; i++){
		minX = min(tmpX[i], minX);
		maxX = max(tmpX[i], maxX);
		minY = min(tmpY[i], minY);
		maxY = max(tmpY[i], maxY);
	}
	x = (int)(maxX - minX + 2);
	y = (int)(maxY - minY + 2);
}

void rotation(const P* before, double theta){
	int nH;
	int nW;
	tXY(nW, nH, theta);
	if(nW % 4 !=0)
		nW = (nW / 4 + 1) * 4;
	int newSize = nH * nW;
	P* Q = new P[newSize];
	int* tK = new int[newSize];
	int* minIndexX = new int[nH];
	int* maxIndexX = new int[nH];
	int* minIndexY = new int[nW];
	int* maxIndexY = new int[nW];

	memset(Q, 0, sizeof(P)*newSize);
	for(int i = 0 ; i < nH; i++)
		minIndexX[i] = 999999;
	for(int i = 0; i < nW; i++)
		minIndexY[i] = 999999;
	memset(maxIndexX, 0, sizeof(int)*nH);
	memset(maxIndexY, 0, sizeof(int)*nW);

	for(int i = 0; i < newSize; i++)
		tK[i] = 1;

	int moveX = (nW - mW)/2;
	int moveY = (nH - h)/2;

	for(int i = 0; i < h; i++){
		for(int j = 0; j < mW; j++){
			int tmpX = (int)xAfterRot(j, i, theta) + moveX;
			int tmpY = (int)yAfterRot(j, i, theta) + moveY;
			Q[tmpY*nW + tmpX] = before[i*mW + j];
			tK[tmpY*nW + tmpX] = 0;
			minIndexX[tmpY] = min(tmpX,minIndexX[tmpY]);
			maxIndexX[tmpY] = max(tmpX,maxIndexX[tmpY]);
			minIndexY[tmpX] = min(tmpY,minIndexY[tmpX]);
			maxIndexY[tmpX] = max(tmpY,maxIndexY[tmpX]);
		}
	}

	//first do the horizontal interpolation
	for(int i = 0; i < nH; i++){
		int last = -1;
		for(int j = 0; j < nW; j++){
			if(j < minIndexX[i] || j > maxIndexX[i]){
				Q[i*nW + j].red = 255;
				Q[i*nW + j].green = 255;
				Q[i*nW + j].blue = 255;
				continue;
			}
			if(tK[i*nW + j] == 0){
				last = j;
				continue;
			}
			else{
				int k = j;
				//find next position which has value
				while(k < nW && tK[i*nW + k] == 1){
					k++;
				}
				if(k >= nW){			//in the last position of the line
					if(last == -1)
						break;
					Q[i*nW + j] = Q[i*nW + last];
				}
				else{
					if(last == -1){		//in the first position of the line
						Q[i*nW + j] = Q[i*nW + k];
					}
					else{				//in the middle
						float coe = (j-last)*1.0/(k-last);
						Q[i*nW + j].red = (BYTE)(((int)Q[i*nW + k].red - (int)Q[i*nW + last].red)*coe + (int)Q[i*nW + last].red);
						Q[i*nW + j].blue = (BYTE)(((int)Q[i*nW + k].blue - (int)Q[i*nW + last].blue)*coe + (int)Q[i*nW + last].blue);
						Q[i*nW + j].green = (BYTE)(((int)Q[i*nW + k].green - (int)Q[i*nW + last].green)*coe + (int)Q[i*nW + last].green);
					}
				}
			}
			tK[i*nW + j] = 0;
		}
	}
	//then do the vertical interpolation
	for(int i = 0; i < nW; i++){
		int last = -1;
		for(int j = 0; j < nH; j++){
			if(j < minIndexY[i] || j > maxIndexY[i]){
				continue;
			}
			if(tK[j*nW + i] == 0){
				last = j;
				continue;
			}
			else{
				int k = j;
				//find next position which has value
				while(k < nH && tK[k*nW + i] == 1){
					k++;
				}
				if(k >= nH){			//in the last position of the line
					if(last == -1)
						break;
					Q[j*nW + i] = Q[last*nW + i];
				}
				else{
					if(last == -1){		//in the first position of the line
						Q[j*nW + i] = Q[k*nW + i];
					}
					else{				//in the middle
						float coe = (j-last)*1.0/(k-last);
						Q[j*nW + i].red = (BYTE)(((int)Q[k*nW + i].red - (int)Q[last*nW + i].red)*coe + (int)Q[last*nW + i].red);
						Q[j*nW + i].blue = (BYTE)(((int)Q[k*nW + i].blue - (int)Q[last*nW + i].blue)*coe + (int)Q[last*nW + i].blue);
						Q[j*nW + i].green = (BYTE)(((int)Q[k*nW + i].green - (int)Q[last*nW + i].green)*coe + (int)Q[last*nW + i].green);
					}
				}
			}
			tK[j*nW + i] = 0;
		}
	}

    //把新生成的数据写入文件
	FILE *fpo1;
	fpo1=fopen("rotat.bmp","wb");
	BITMAPFILEHEADER nHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	nHead.bfSize = (DWORD)(nHead.bfSize - size*3 + newSize*3);
	newInfo.biHeight = (DWORD)nH;
	newInfo.biWidth = (DWORD)nW;
	newInfo.biSizeImage = (DWORD)(newSize * 3);
	fwrite(&bfType,1,sizeof(WORD),fpo1);
	fwrite(&nHead,1,sizeof(tagBITMAPFILEHEADER),fpo1);
	fwrite(&newInfo,1,sizeof(tagBITMAPINFOHEADER),fpo1);
	fwrite(Q,1,sizeof(P)*(newSize),fpo1);
	fclose(fpo1);
	delete[] Q;
	delete[] tK;
}

void shear(const P* before, double angle){
	int nH, nW ,newSize;
	P* Q;
	int* tK;

	nW = mW;

	nH = h + tan(angle)*mW;
	newSize = nW * nH;
	Q = new P[newSize];
	tK = new int[newSize];
    //判断所有像素是否已经有信息的标记数组
	for(int i = 0; i < newSize; i++)
		tK[i] = 1;
    //原来的
	for(int i = 0; i < h; i++){
		for(int j = 0; j < mW; j++){
            //求变换后的横纵坐标，并赋值对应的像素
			int tmpX = j;
			int tmpY = (int)(i + tan(angle)*j);
			Q[tmpY * nW + tmpX] = before[i*mW + j];
            //有信息后标记为0
			tK[tmpY * nW + tmpX] = 0;
		}
	}
    //没图像的位置都用白色填充
	for(int i = 0; i < newSize; i++)
		if(tK[i] == 1)
			Q[i].red = Q[i].green = Q[i].blue = 255;
    //新文件
	FILE *fpo1;
	fpo1=fopen("shear.bmp","wb");
	BITMAPFILEHEADER nHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	nHead.bfSize = (DWORD)(nHead.bfSize - size*3 + newSize*3);
	newInfo.biHeight = (DWORD)nH;
	newInfo.biWidth = (DWORD)nW;
	newInfo.biSizeImage = (DWORD)(newSize * 3);
	fwrite(&bfType,1,sizeof(WORD),fpo1);
	fwrite(&nHead,1,sizeof(tagBITMAPFILEHEADER),fpo1);
	fwrite(&newInfo,1,sizeof(tagBITMAPINFOHEADER),fpo1);
	fwrite(Q,1,sizeof(P)*(newSize),fpo1);
	fclose(fpo1);
	delete[] Q;
	delete[] tK;
}
//缩小放大
void scale(const P* before, float x, float y){
    //新的图像高度和宽度
	int nH = (int)(h * y);
	int tW = (int)(w * x);
	int nW;
	//对4取整
	if(tW % 4 == 0)
		nW = tW;
	else
		nW = (tW / 4 + 1) * 4;
	//新的图像大小
	int newSize = nH * nW;
	P* Q = new P[newSize];
	int* tK = new int[newSize];
	//先把整个图像置0
	memset(Q, 0, sizeof(P)*newSize);
	memset(tK, 0, sizeof(int)*newSize);
	//扫描需要的新图像
	for(int i = 0; i < nH; i++){
		for(int j = 0; j < nW; j++){
			float tX,tY;
			int intX,intY;
			//scale之后的坐标
			tX = (j*1.0/x);
			tY = (i*1.0/y);
			intX = (int)tX;
			intY = (int)tY;

			if(tX >= mW || tY >= h)
				Q[i*nW+j].red = Q[i*nW+j].green = Q[i*nW+j].blue = 255;
			else if(tX - intX > 0 || tY - intY > 0){
				Q[i*nW+j].red = Q[i*nW+j].green = Q[i*nW+j].blue = 255;
				tK[i*nW+j] = 1;
			}
			else
				Q[i*nW+j] = before[intY*mW + intX];
		}
	}
	//水平scale
	for(int i = 0; i < nH; i++){
		int last = -1;
		for(int j = 0; j < nW; j++){
			if(tK[i*nW + j] == 0){
				last = j;
				continue;
			}
			else{
				int k = j;
				//找到下一个有值的地方
				while(k < nW &&tK[i*nW + k] == 1 )
					k++;
				if(k >= nW){			//行最后
					if(last == -1)
						break;
					Q[i*nW + j] = Q[i*nW + last];
				}
				else{
					if(last == -1)	//行头
						Q[i*nW + j] = Q[i*nW + k];
					else{
						float coe = (j-last)*1.0/(k-last);
						Q[i*nW + j].red = (BYTE)(((int)Q[i*nW + k].red - (int)Q[i*nW + last].red)*coe + (int)Q[i*nW + last].red);
						Q[i*nW + j].blue = (BYTE)(((int)Q[i*nW + k].blue - (int)Q[i*nW + last].blue)*coe + (int)Q[i*nW + last].blue);
						Q[i*nW + j].green = (BYTE)(((int)Q[i*nW + k].green - (int)Q[i*nW + last].green)*coe + (int)Q[i*nW + last].green);
					}
				}
			}
			tK[i*nW + j] = 0;
		}
	}
	//竖直scale,这次没有
	for(int i = 0; i < nW; i++){
		int last = -1;
		for(int j = 0; j < nH; j++){
			if(tK[j*nW + i] == 0){
				last = j;
				continue;
			}
			else{
				int k = j;
				//find next position which has value
				while(k < nH && tK[k*nW + i] == 1){
					k++;
				}
				if(k >= nH){			//行最后
					if(last == -1)
						break;
					Q[j*nW + i] = Q[last*nW + i];
				}
				else{
					if(last == -1){		//行头
						Q[j*nW + i] = Q[k*nW + i];
					}
					else{
						float coe = (j-last)*1.0/(k-last);
						Q[j*nW + i].red = (BYTE)(((int)Q[k*nW + i].red - (int)Q[last*nW + i].red)*coe + (int)Q[last*nW + i].red);
						Q[j*nW + i].blue = (BYTE)(((int)Q[k*nW + i].blue - (int)Q[last*nW + i].blue)*coe + (int)Q[last*nW + i].blue);
						Q[j*nW + i].green = (BYTE)(((int)Q[k*nW + i].green - (int)Q[last*nW + i].green)*coe + (int)Q[last*nW + i].green);
					}
				}
			}
			tK[j*nW + i] = 0;
		}
	}
    //新文件
	FILE *fpo1;
	fpo1=fopen("scale.bmp","wb");
	BITMAPFILEHEADER nHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	nHead.bfSize = (DWORD)(nHead.bfSize - size*3 + newSize*3);
	newInfo.biHeight = (DWORD)nH;
	newInfo.biWidth = (DWORD)nW;
	newInfo.biSizeImage = (DWORD)(newSize * 3);
	fwrite(&bfType,1,sizeof(WORD),fpo1);
	fwrite(&nHead,1,sizeof(tagBITMAPFILEHEADER),fpo1);
	fwrite(&newInfo,1,sizeof(tagBITMAPINFOHEADER),fpo1);
	fwrite(Q,1,sizeof(P)*(newSize),fpo1);
	fclose(fpo1);
	delete[] Q;
	delete[] tK;
}

int main(){
	FILE *fpi;
	fpi=fopen("a.bmp","rb");
	if(fpi != NULL){
		//先读取文件类型
		fread(&bfType,1,sizeof(WORD),fpi);
		if(0x4d42!=bfType) {
			printf("不是bmp图像");
			return 0;
		}
		//读取bmp文件的文件头和信息头
		fread(&strHead,1,sizeof(tagBITMAPFILEHEADER),fpi);
		fread(&strInfo,1,sizeof(tagBITMAPINFOHEADER),fpi);
       	h=strInfo.biHeight;
       	w=strInfo.biWidth;
       	//如果图像宽度不是4的倍数要取整
       	if(w % 4 == 0)
       		mW = w;
       	else
       		mW = (w/4+1)*4;
        //图像像素数
       	size=strInfo.biSizeImage/3;
        //一个图像所有像素存在数组里
        P *imgP=new P[size];
        //读取bmp数据信息
		fread(imgP,1,sizeof(P)*size,fpi);
		fclose(fpi);
		cx = mW / 2;
		cy = h / 2;
		int x,y;
		//5个操作
		translation(imgP, 90, 0);
		mirror(imgP);
		scale(imgP, 0.5, 1);
		rotation(imgP, 45.0 / 180 * Pi);
		shear(imgP,25.0 / 180 * Pi);
		delete[] imgP;
	}
	else
		printf("fail to open the file");
	return 0;
}

水木流年追梦
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
图像信息处理实验报告
12-18
对于下面这幅图像，请问可以通过那些图像增强的手段，达到改善视觉效果的目的？请显示处理结果，并附简要处理流程说明。
图像处理技术（一）图像处理基础知识
热门推荐
qq_35330032的博客
08-30 2万+
1.1基本概念 图像处理的概念是对图像信息进行加工处理，以满足人的视觉心理和实际应用的需求。 模拟图像：连续图像，采用数字化（离散化）表示和数字技术处理之前的图像。 数字图像：由连续的模拟图像采样和量化而得的图像，组成其基本单位是像素。 像素的值代表图像在该位置的亮度或灰度，称为图像的灰度值。 数字图像像素具有整数坐标和整数灰度值。 1.2 图像增强：调整图像的对比度，突出重要细节，...
C++入门同步记录#3
Norikage的博客
03-10 104
#include<iostream> using namespace std; int main() { int ans1; char ans2; ans1 = 'M' - 'A' + 1; ans2 = 33; cout << ans1 << endl; cout << ans2 << endl; return 0; } /*#include<iostream> #includ
实验一 视频/图像信号处理实验
lzp05222的博客
05-02 1754
一、实验目的 掌握视频/图像文件输入输出。 掌握视频信号亮度方程原理和实现方法。 了解视频信号的存储方式。 了解视频信号不同分量的关系和存储关系。 二、实验器材 电脑 Matlab软件/或其他 三、实验原理 1、关于配色方程 （1）假定三个基色采用显像(电视)三基色配色方程数学表达式： 式中F表示待配色的彩色光的彩色量；R、G、B分别代表三基色分布系数；[R]、[G]、[B]分别代表三基色的单位量；R[R]、G[G]、B[B]为彩色量F中所含三基色光通量成分，它们共同决定所配彩色光的..
数字信号与图像处理实验一：信号处理基础
weixin_59430424的博客
12-01 2583
掌握信号处理的基本思想，理解采样信号的频谱特性,加强信号采样与重建的有关基本概念的理解，深入理解线性时不变系统输出与输入的关系，了解数字信号采样率转换前后信号频谱的特征。
冈萨雷斯《数字图像处理》学习笔记（一）绪论
qq_37692302的博客
04-16 2912
目录 一、 图像与图像处理的概念 二、图像处理科学的意义 三、 数字图像处理的特点 四、数字图像处理的主要方法 五、数字图像处理的主要内容 六、数字图像处理的起源与应用 七、数字图像处理领域的发展动向 图像处理的基本步骤：图像获取、滤波与增强、图像复原、彩色图像处理、小波与分辨率处理、压缩、形态学处理、分割、表示与描述、目标识别 一、 图像与图像处理的概念 图像(Image)：...
广工信息工程学院数字图像处理实验报告.docx
12-21
数字图像处理实验报告（广工信工）： 实验三：图像的空间域平滑和锐化 一、实验目的： （一）掌握图像模板运算的流程； （二）进一步理解图像的平滑、锐化原理； （三）了解图像平滑、锐化的效果和作用。
数字图像处理实验报告-灰度和彩色图像处理.docx
01-15
灰度和彩色图像处理，word版本 可编辑，附分析与总结 读取二进制文件lab3prob4,文件的尺寸是435*580，图像数据类型为‘uint8’，（1）读取并显示图像，colormap设置为gray；（2）重新显示（1）中图像，colormap设置...
高级图像处理实验.zip
04-15
【项目资源】：图像处理。包含前端、后端、移动开发、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源等各种技术项目的源码。包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：...
数字图像处理课程实验.zip
最新发布
04-15
【项目资源】：图像处理。包含前端、后端、移动开发、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源等各种技术项目的源码。包括C++、Java、python、web、C#、EDA等项目的源码。 【适用人群】：...
图像信息处理
06-20
图像信息处理，各种方法总结，你值得拥有哦
图像信息处理基础
03-25
自然界中所有的颜色都可以用红、绿、蓝(RGB)这三种颜色的光（红光波长700 nm、绿光波长546.1 nm、蓝光波长435.8 nm ）按不同的强度叠加而成，这就是人们常说的三基色原理。当三基色等量相加时，得到白色；等量的红绿相加而蓝为0值时得到黄色；等量的红蓝相加而绿为0时得到品红色；等量的绿蓝相加而红为0时得到青色。
图像信息处理实验三
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
11-17 1657
要求： 1.Image logarithmic operation for visibility enhancement 2.Histogram equalization #include #include #include void ToGrey(char* a, char* b) { BITMAPFILEHEADER fileHeader;// 位图头文件 BITMAPINFO
图像信息处理实验五
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
11-17 988
要求： 1.Image mean filtering 2.Laplacian image enhancement #include #include //线性均值滤波 void imf(char* a, char* b) { BITMAPFILEHEADER fileHeader;// 位图头文件 BITMAPINFOHEADER infoHeader;// 位图信息头 FILE
图像信息处理实验二
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
11-17 1124
要求： 1. Image binarization 2. Binary image erosion 3. Binary image delation 4. Binary image opening 5. Binary image closing #include #include void ToRGB(char* a, char* b) { BITMAPFILEHEADE
数字信号与图像处理实验三：图像处理基础与图像变换
weixin_59430424的博客
12-01 3136
在本次实验中，主要深入学习了对图像的操作，基本操作比如读入、显示、计算图像大小、灰度平均值等，高级操作比如图像压缩、对称等操作。通过本次实验，对于DCT变换的理解更加深刻，对于图像的操作也更加熟练。在实验中遇到了许多问题，比如在第一问中，一开始没有将图像转为灰度图，导致在求协方差矩阵时一直出错（matlab自带的函数conv()只能计算二维矩阵的协方差矩阵，RGB图像为三维矩阵）。
图像信息处理：What is digital image processing
qq_41555552的博客
01-22 577
Chapter 1：What is digital image processing 1.1 Image acquisition 图像采集 1.1.1 Automatic aperture correction and color balance 自动光圈校正与色彩平衡 Image stitching 图像缝合： Panaroma Image warping 图像扭转 Image morph...
图像的基本运算——scale， rotation， translation
weixin_30824599的博客
04-23 726
图像是视觉信息的直接反应，图像呈现出各种各样的特效都是通过图像的基本运算来完成的。图像最基本的运算有三种，分别是scale，rotation 和translation，叫做尺度，旋转和平移。很多图像的特效都可以用这三种基本运算来实现。可以对像素值或者像素的坐标做这些运算来达到特定的效果。 像素有两个属性，一个是像素的值，一个是像素的坐标。像素的值记录了像素的强度信...
数字图像处理实验彩色图像处理
05-19
数字图像处理实验中的彩色图像处理通常包括以下步骤： 1. 图像读取和显示：使用编程语言（如Python、MATLAB等）读取彩色图像，并使用图像显示函数将其显示在屏幕上。 2. 颜色空间转换：将彩色图像从RGB颜色空间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水木流年追梦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值