东南大学数字图像处理作业-C++原生实现（不调库）对BMP图像旋转和平移

已于 2022-05-10 17:20:52 修改
阅读量1.3k 收藏 13
点赞数 6
分类专栏： 代码 文章标签： c++ mfc 图像处理
于 2022-05-10 17:15:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/good18Levin/article/details/124692791
版权

1 代码

包含三个文件：把bmp.h、bmp.cpp、main.cpp
1.1 bmp.h

#pragma once
#include <cstdio>
#include <cstdlib>
using namespace std;

typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef unsigned int DWORD;

//位图文件头定义
typedef struct  tagBITMAPFILEHEADER {
	//	WORD bfType;//单独读取，结构体中就不定义了
	DWORD bfSize;//文件大小
	WORD bfReserved1;//保留字
	WORD bfReserved2;//保留字
	DWORD bfOffBits;//从文件头到实际位图数据的偏移字节数
}BITMAPFILEHEADER;

//位图信息头定义
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 tagRgbImgData
{
	BYTE blue;
	BYTE green;
	BYTE red;
}DATA;

// 灰度图像的像素信息
typedef struct tagGrayBmpData
{
	BYTE gray;
}GRAYDATA;

// 调色板的结构定义，灰度图有256个调色板
typedef struct tagRGBQUAD {
	BYTE rgbBlue;    // 蓝色的亮度(值范围为0-255) 
	BYTE rgbGreen;   // 绿色的亮度(值范围为0-255) 
	BYTE rgbRed;     // 红色的亮度(值范围为0-255) 
	BYTE rgbReserved;// 保留，必须为0 
} RGBQUAD;

double xAfterRot(int x, int y, double theta, int cx, int cy);
double yAfterRot(int x, int y, double theta, int cx, int cy);

// 检查图片类型是不是BMP
int checkImgType(const char* filename);
// 彩色BMP图像读取操作
DATA* readRgbBmp(const char* filename, WORD* bfType, BITMAPFILEHEADER* strHead, BITMAPINFOHEADER* strInfo, int* h, int* mw, int* imgSize, int* cx, int* cy);
// 灰色BMP图像读取操作
GRAYDATA* readGrayBmp(const char* filename, WORD* bfType, BITMAPFILEHEADER* strHead, BITMAPINFOHEADER* strInfo, RGBQUAD* ipRGB, int* h, int* mw, int* imgSize, int* cx, int* cy);
int modifyWidth(int biWidth);
int getImageSize(int biWidth, int biHeight, int bitCount);
DATA* scale(const DATA* src, float x, float y, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType);
GRAYDATA* scaleGray(const GRAYDATA* src, float x, float y, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType, RGBQUAD* ipRGB);


DATA* rotation(const DATA* src, double theta, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType);
GRAYDATA* rotationGray(const GRAYDATA* src, double theta, int mh, int mw,
	int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo,WORD bfType, RGBQUAD* ipRGB);

1. 2 bmp.cpp

#include <cstdio>
#include <iostream>
#include <vector>
#include<algorithm>
#include <cmath>
#define PI acos(-1)
#include <cstdlib>
#include<exception>
#include<set>
#include "bmp.h"
using namespace std;

int checkImgType(const char* filename) {
	FILE* fpi = fopen(filename, "rb");
	WORD bfType;
	if (fpi == NULL) {
		cout << filename << " 文件未能找到" << endl;
		return 0;
	}
	else {
		fread(&bfType, 1, sizeof(WORD), fpi);
		if (0x4d42 != bfType) {
			cout << "Error: The file is not a bmp image!" << endl;
			return 0;
		}
	}
	return 1;
}


int modifyWidth(int biWidth) {
	if (biWidth % 4 == 0)
		return biWidth;
	return (biWidth / 4 + 1) * 4;
}

int getImageSize(int biWidth, int biHeight, int bitCount) {
	int bytePerPixel = bitCount / 8;
	int LineBytes = (biWidth * bytePerPixel + 3) / 4 * 4; //这个其实也相当于是每行的宽度，但是这里的宽度指的是字节数，而不是像素数
	return LineBytes * biWidth;
}

DATA * readRgbBmp(const char* filename, WORD * bfType, BITMAPFILEHEADER* strHead, BITMAPINFOHEADER* strInfo, int* h, int* mw, int* imgSize, int * cx, int* cy) {
	FILE* fpi = fopen(filename, "rb");
	fread(bfType, 1, sizeof(WORD), fpi);
	fread(strHead, 1, sizeof(tagBITMAPFILEHEADER), fpi);
	fread(strInfo, 1, sizeof(tagBITMAPINFOHEADER), fpi);
	*h = (*strInfo).biHeight;
	*mw = modifyWidth((*strInfo).biWidth);
	*imgSize = (*h) * (*mw);
	*cx = (*mw) / 2;
	*cy = (*h) / 2;
	DATA* imgData = new DATA[*imgSize];
	fread(imgData, 1, sizeof(DATA) * (*imgSize), fpi);
	return imgData;
}

GRAYDATA* readGrayBmp(const char* filename, WORD* bfType, BITMAPFILEHEADER* strHead, BITMAPINFOHEADER* strInfo, RGBQUAD* ipRGB, int* h, int* mw, int* imgSize, int* cx, int* cy) {
	FILE* fpi = fopen(filename, "rb");
	fread(bfType, 1, sizeof(WORD), fpi);
	fread(strHead, 1, sizeof(tagBITMAPFILEHEADER), fpi);
	fread(strInfo, 1, sizeof(tagBITMAPINFOHEADER), fpi);
	fread(ipRGB, sizeof(RGBQUAD) * 256, 1, fpi);
	*h = (*strInfo).biHeight;
	*mw = modifyWidth( (*strInfo).biWidth );
	*imgSize = (*h) * (*mw);
	*imgSize = (*h) * (*mw);
	*cx = (*mw) / 2;
	*cy = (*h) / 2;
	//GRAYDATA* imgData = new GRAYDATA[*imgSize];
	GRAYDATA* imgData = (GRAYDATA*) malloc(sizeof(GRAYDATA) * (*imgSize));
	fread(imgData, 1, sizeof(GRAYDATA) * (*imgSize), fpi);
	return imgData;
}


DATA* scale(const DATA* src, float x, float y, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType) {
	float target_x, target_y;
	int int_target_x, int_target_y;
	DATA* target = new DATA[imgSize];
	int* needItr = new int[imgSize];
	memset(target, 0, sizeof(DATA) * imgSize);
	memset(needItr, 0, sizeof(int) * imgSize);

	for (int i = 0; i < mh; i++)
		for (int j = 0; j < mw; j++) {
			target_x = (j - cx) / x + cx;
			target_y = (i - cy) / y + cy;
			int_target_x = (int)target_x;
			int_target_y = (int)target_y;
			if (int_target_x - target_x < 0 || int_target_y - target_y < 0 || int_target_x <0 || int_target_x > mw || int_target_y < 0 || int_target_y > mh) {
				target[i * mw + j].red = 0;
				target[i * mw + j].green = 0;
				target[i * mw + j].blue = 0;
				needItr[i * mw + j] = 1;
			}
			else {
				try {
					target[i * mw + j].blue = src[int_target_y * mw + int_target_x].blue;
					target[i * mw + j].red = src[int_target_y * mw + int_target_x].red;
					target[i * mw + j].green = src[int_target_y * mw + int_target_x].green;
				}
				catch (...) {
					cout << "i: " << i << "j:" << j << endl;
				}
			}
		}

	cout << "Doing the interpolation, please wait.......(0\%)" << endl;

	for (int i = 0; i < mh; i++) {
		int last = -1;
		for (int j = 0; j < mw; j++) {
			// 这里应该是找到每一行的需要插值的点
			// last的值应该是每一行中需要插值的第一个点的前面一个点
			if (needItr[i * mw + j] == 0) {
				last = j;
				continue;
			}
			else {
				// 当找到一个需要插值的点的时候
				// 首先期望找到这个插值点右侧的不需要插值的第一个点

				int k = j;
				//find next position which has value
				while (k < mw && needItr[i * mw + k] == 1) {
					k++;
				}
				if (k >= mw) {			//in the last position of the line
					if (last == -1)
						break;
					target[i * mw + j] = target[i * mw + last];
				}
				else {
					if (last == -1) {		//in the first position of the line
						target[i * mw + j] = target[i * mw + k];
					}
					else {				//in the middle
						float coe = (j - last) * 1.0 / (k - last);
						target[i * mw + j].red = (BYTE)(((int)target[i * mw + k].red - (int)target[i * mw + last].red) * coe + (int)target[i * mw + last].red);
						target[i * mw + j].green = (BYTE)(((int)target[i * mw + k].green - (int)target[i * mw + last].green) * coe + (int)target[i * mw + last].green);
						target[i * mw + j].blue = (BYTE)(((int)target[i * mw + k].blue - (int)target[i * mw + last].blue) * coe + (int)target[i * mw + last].blue);
					}
				}
			}
			needItr[i * mw + j] = 0;
		}
	}

	cout << "Doing the interpolation, please wait.......(50\%)" << endl;
	//then do the vertical interpolation
	for (int i = 0; i < mw; i++) {
		int last = -1;
		for (int j = 0; j < mh; j++) {
			if (needItr[j * mw + i] == 0) {
				last = j;
				continue;
			}
			else {
				int k = j;
				//find next position which has value
				while (k < mh && needItr[k * mw + i] == 1) {
					k++;
				}
				if (k >= mh) {			//in the last position of the line
					if (last == -1)
						break;
					target[j * mw + i] = target[last * mw + i];
				}
				else {
					if (last == -1) {		//in the first position of the line
						target[j * mw + i] = target[k * mw + i];
					}
					else {				//in the middle
						float coe = (j - last) * 1.0 / (k - last);
						target[j * mw + i].red = (BYTE)(((int)target[k * mw + i].red - (int)target[last * mw + i].red) * coe + (int)target[last * mw + i].red);
						target[j * mw + i].green = (BYTE)(((int)target[k * mw + i].green - (int)target[last * mw + i].green) * coe + (int)target[last * mw + i].green);
						target[j * mw + i].blue = (BYTE)(((int)target[k * mw + i].blue - (int)target[last * mw + i].blue) * coe + (int)target[last * mw + i].blue);
					}
				}
			}
			needItr[j * mw + i] = 0;
		}
	}


	FILE* fpo1;
	fpo1 = fopen("scale.bmp", "wb");
	BITMAPFILEHEADER newHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	fwrite(&bfType, 1, sizeof(WORD), fpo1);
	fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
	fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
	fwrite(target, 1, sizeof(DATA) * (imgSize), fpo1);
	fclose(fpo1);
	delete[] needItr;
	return target;
}


GRAYDATA*  scaleGray(const GRAYDATA* src, float x, float y, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType,  RGBQUAD* ipRGB) {
	float target_x, target_y;
	int int_target_x, int_target_y;
	GRAYDATA* target = new GRAYDATA[imgSize];
	int* needItr = new int[imgSize];
	memset(target, 0, sizeof(GRAYDATA) * imgSize);
	memset(needItr, 0, sizeof(int) * imgSize);

	for (int i = 0; i < mh; i++)
		for (int j = 0; j < mw; j++) {
			target_x = (j - cx) / x + cx;
			target_y = (i - cy) / y + cy;
			int_target_x = (int)target_x;
			int_target_y = (int)target_y;
			if (int_target_x - target_x < 0 || int_target_y - target_y < 0 || int_target_x <0 || int_target_x > mw || int_target_y < 0 || int_target_y > mh) {
				target[i * mw + j].gray = 0;
				needItr[i * mw + j] = 1;
			}
			else {
				//cout << "i: " << i << "j:" << j << endl;
				try {
					target[i * mw + j].gray = src[int_target_y * mw + int_target_x].gray;
				}
				catch (...) {
					//cout << "i: " << i << "j:" << j << endl;
				}
			}
		}

	cout << "Doing the interpolation, please wait.......(0\%)" << endl;

	for (int i = 0; i < mh; i++) {
		int last = -1;
		for (int j = 0; j < mw; j++) {
			// 这里应该是找到每一行的需要插值的点
			// last的值应该是每一行中需要插值的第一个点的前面一个点
			if (needItr[i * mw + j] == 0) {
				last = j;
				continue;
			}
			else {
				// 当找到一个需要插值的点的时候
				// 首先期望找到这个插值点右侧的不需要插值的第一个点

				int k = j;
				//find next position which has value
				while (k < mw && needItr[i * mw + k] == 1) {
					k++;
				}
				if (k >= mw) {			//in the last position of the line
					if (last == -1)
						break;
					target[i * mw + j] = target[i * mw + last];
				}
				else {
					if (last == -1) {		//in the first position of the line
						target[i * mw + j] = target[i * mw + k];
					}
					else {				//in the middle
						float coe = (j - last) * 1.0 / (k - last);
						target[i * mw + j].gray = (BYTE)(((int)target[i * mw + k].gray - (int)target[i * mw + last].gray) * coe + (int)target[i * mw + last].gray);

					}
				}
			}
			needItr[i * mw + j] = 0;
		}
	}


	cout << "Doing the interpolation, please wait.......(50\%)" << endl;
	//then do the vertical interpolation
	for (int i = 0; i < mw; i++) {
		int last = -1;
		for (int j = 0; j < mh; j++) {
			if (needItr[j * mw + i] == 0) {
				last = j;
				continue;
			}
			else {
				int k = j;
				//find next position which has value
				while (k < mh && needItr[k * mw + i] == 1) {
					k++;
				}
				if (k >= mh) {			//in the last position of the line
					if (last == -1)
						break;
					target[j * mw + i] = target[last * mw + i];
				}
				else {
					if (last == -1) {		//in the first position of the line
						target[j * mw + i] = target[k * mw + i];
					}
					else {				//in the middle
						float coe = (j - last) * 1.0 / (k - last);
						target[j * mw + i].gray = (BYTE)(((int)target[k * mw + i].gray - (int)target[last * mw + i].gray) * coe + (int)target[last * mw + i].gray);

					}
				}
			}
			needItr[j * mw + i] = 0;
		}
	}

	FILE* fpo1;
	fpo1 = fopen("scaleGray.bmp", "wb");
	BITMAPFILEHEADER newHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	newHead.bfReserved1 = newHead.bfReserved2 = 0;
	newHead.bfOffBits = sizeof(bfType) + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
	newHead.bfSize = newHead.bfOffBits + imgSize;
	newInfo.biHeight = (DWORD)mh;
	newInfo.biWidth = (DWORD)mw;
	newInfo.biSizeImage = (DWORD)(imgSize);
	fwrite(&bfType, 1, sizeof(WORD), fpo1);
	fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
	fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
	fwrite(ipRGB, sizeof(RGBQUAD), 256, fpo1);
	fwrite(target, 1, sizeof(GRAYDATA) * (imgSize), fpo1);
	fclose(fpo1);
	delete[] needItr;
	return target;
}



DATA * rotation(const DATA* src, double theta, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType) {
	float target_x = 0, target_y = 0;
	int int_target_x, int_target_y;

	DATA* target = new DATA[imgSize];
	int* needItr = new int[imgSize];
	int* noneedItr = new int[imgSize];

	memset(target, 0, sizeof(DATA) * imgSize);
	memset(needItr, 0, sizeof(int) * imgSize);
	memset(noneedItr, 0, sizeof(int) * imgSize);

	int count1 = 0;
	// 这里面越界的点很少啊
	for (int i = 0; i < mh; i++)
		for (int j = 0; j < mw; j++) {
			/*target_x, target_y = xyAfterRot(j - cx, i - cy, theta);
			target_x  += cx;
			target_y  += cy;*/
			target_x = (int)xAfterRot(j, i, theta, cx, cy);
			target_y = (int)yAfterRot(j, i, theta, cx, cy);
			int_target_x = (int)target_x;
			int_target_y = (int)target_y;

			//int_target_x - target_x < 0 || int_target_y - target_y < 0
			if (int_target_x <0 || int_target_x > mw || int_target_y < 0 || int_target_y > mh) {
				target[i * mw + j].red = 0;
				target[i * mw + j].green = 0;
				target[i * mw + j].blue = 0;
				needItr[i * mw + j] = 1;
				count1 += 1;
			}
			else {
				target[i * mw + j].blue = src[int_target_y * mw + int_target_x].blue;
				target[i * mw + j].red = src[int_target_y * mw + int_target_x].red;
				target[i * mw + j].green = src[int_target_y * mw + int_target_x].green;
				//cout << "here rotate "<<endl;
			}
		}

	cout << "count1" << float(count1) / (mh * mw) << endl;

	FILE* fpo1;
	fpo1 = fopen("rotation.bmp", "wb");
	BITMAPFILEHEADER newHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	fwrite(&bfType, 1, sizeof(WORD), fpo1);
	fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
	fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
	fwrite(target, 1, sizeof(DATA) * (imgSize), fpo1);
	fclose(fpo1);
	delete[] needItr;
	return target;
}


GRAYDATA* rotationGray(const GRAYDATA* src, double theta, int mh, int mw, int imgSize, int cx, int cy, BITMAPFILEHEADER strHead, BITMAPINFOHEADER strInfo, WORD bfType, RGBQUAD* ipRGB) {
	float target_x = 0, target_y = 0;
	int int_target_x, int_target_y;

	GRAYDATA* target = new GRAYDATA[imgSize];
	int* needItr = new int[imgSize];
	int* noneedItr = new int[imgSize];

	memset(target, 0, sizeof(GRAYDATA) * imgSize);
	memset(needItr, 0, sizeof(int) * imgSize);
	memset(noneedItr, 0, sizeof(int) * imgSize);

	int count1 = 0;
	// 这里面越界的点很少啊
	for (int i = 0; i < mh; i++)
		for (int j = 0; j < mw; j++) {
			/*target_x, target_y = xyAfterRot(j - cx, i - cy, theta);
			target_x  += cx;
			target_y  += cy;*/
			target_x = (int)xAfterRot(j, i, theta, cx ,cy);
			target_y = (int)yAfterRot(j, i, theta, cx,  cy);
			int_target_x = (int)target_x;
			int_target_y = (int)target_y;

			//int_target_x - target_x < 0 || int_target_y - target_y < 0
			if (int_target_x <0 || int_target_x > mw || int_target_y < 0 || int_target_y > mh) {
				target[i * mw + j].gray = 0;
				needItr[i * mw + j] = 1;
				count1 += 1;
			}
			else {
				target[i * mw + j].gray = src[int_target_y * mw + int_target_x].gray;

				//cout << "here rotate "<<endl;
			}
		}

	cout << "count1" << float(count1) / (mh * mw) << endl;

	FILE* fpo1;
	fpo1 = fopen("rotationGray.bmp", "wb");
	BITMAPFILEHEADER newHead = strHead;
	BITMAPINFOHEADER newInfo = strInfo;
	newHead.bfReserved1 = newHead.bfReserved2 = 0;
	newHead.bfOffBits = sizeof(bfType) + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
	newHead.bfSize = newHead.bfOffBits + imgSize;
	newInfo.biHeight = (DWORD)mh;
	newInfo.biWidth = (DWORD)mw;
	newInfo.biSizeImage = (DWORD)(imgSize);
	fwrite(&bfType, 1, sizeof(WORD), fpo1);
	fwrite(&newHead, 1, sizeof(tagBITMAPFILEHEADER), fpo1);
	fwrite(&newInfo, 1, sizeof(tagBITMAPINFOHEADER), fpo1);
	fwrite(ipRGB, sizeof(RGBQUAD), 256, fpo1);
	fwrite(target, 1, sizeof(GRAYDATA) * (imgSize), fpo1);
	fclose(fpo1);
	return target;
}



double xAfterRot(int x, int y, double theta, int cx, int cy) {
	x = x - cx;
	y = y - cy;
	double result = x * cos(theta) - y * sin(theta);
	//double result = x * cos(theta) + y * sin(theta);
	return result += cx;
}
double yAfterRot(int x, int y, double theta, int cx, int cy) {
	x = x - cx;
	y = y - cy;
	double result = x * sin(theta) + y * cos(theta);
	//double result = -x * sin(theta) + y * cos(theta);

	return result += cy;
}

1.3 main.cpp

#include "bmp.cpp"
using namespace std;


int main() {
	const char* filename1 = (char*)"D:\\TestEverything\\BmpCenteredManipuation\\Debug\\Coman.bmp"; //彩色图像
	const char* filename2 = (char*)"D:\\TestEverything\\BmpCenteredManipuation\\Debug\\barbara.bmp"; //灰度图像
	BITMAPFILEHEADER strHead1, strHead2;
	BITMAPINFOHEADER strInfo1, strInfo2;
	int h1, h2, mw1, mw2, imgSize1, imgSize2;
	DATA* imgData1, *imgData3;
	GRAYDATA* imgData2, *imgData4;
	WORD bfType1, bfType2;
	RGBQUAD* ipRGB = (RGBQUAD*)malloc(sizeof(RGBQUAD) * 256);
	int cx1, cx2, cy1, cy2;


	if (checkImgType(filename1)) {
		imgData1 = readRgbBmp(filename1, &bfType1, &strHead1, &strInfo1, &h1, &mw1, &imgSize1, &cx1, &cy1);
		float mulX, mulY;
		cout << "Scale, input the x coefficient (0.1<x<4.0): ";
		cin >> mulX;
		cout << "Scale, input the y coefficient (0.1<y<4.0): ";
		cin >> mulY;
		imgData3 = scale(imgData1, mulX, mulY, h1, mw1, imgSize1, cx1, cy1, strHead1, strInfo1, bfType1);

		double theta;
		cout << "Rotation, input the angle to be rotate (0 < theta < 360): ";
		cin >> theta;
		theta = theta / 180 * PI;
		rotation(imgData3, theta, h1, mw1, imgSize1, cx1, cy1, strHead1, strInfo1, bfType1);
	}
	if (checkImgType(filename2)) {
		imgData2 = readGrayBmp(filename2, &bfType2, &strHead2, &strInfo2, ipRGB, &h2, &mw2, &imgSize2, &cx2, &cy2);
		float mulX, mulY;
		cout << "Scale, input the x coefficient (0.1<x<4.0): ";
		cin >> mulX;
		cout << "Scale, input the y coefficient (0.1<y<4.0): ";
		cin >> mulY;
		imgData4 = scaleGray(imgData2, mulX, mulY, h2, mw2, imgSize2, cx2, cy2, strHead2, strInfo2, bfType2, ipRGB);

		const char* filename4 = (char*)"D:\TestEverything\BmpCenteredManipuation\BmpCenteredManipuation\scaleGray.bmp"; //彩色图像

		double theta;
		cout << "Rotation, input the angle to be rotate (0 < theta < 360): ";
		cin >> theta;
		theta = theta / 180 * PI;
		rotationGray(imgData4, theta, h2, mw2, imgSize2, cx2, cy2, strHead2, strInfo2, bfType2, ipRGB);

	}
	return 0;
}

2 实现效果

  1. 1 灰度图
    在这里插入图片描述

在这里插入图片描述
2.2 彩色图
在这里插入图片描述
在这里插入图片描述

3 实现难点

BMP的存储结构；转化时的矩阵变换操作

图灵和柯南道尔的大弟子
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++：BMP图像旋转180度(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-27 410
C++：BMP图像旋转180度(附完整源码)
C++数字图像处理（不用opencv）
tongjingqi_的博客
09-28 4183
转载：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.lavend
C++实现图像的旋转，裁剪，gamma变换，平移
Dandelion_2的博客
07-16 1089
#include<opencv2/opencv.hpp> #include<iostream> using namespace cv; using namespace std; /************************************************************************************************************** Function: RotateImage Description:
VC++对BMP位图进行图像平移实例
03-15
内容索引:VC/C++源码,图形处理,BMP,平移图像　　VC++平移图像的一个实例，以前有朋友让找的，后来在一本书中发现了，虽然功能不太多，但正好是实现BMP位图的平移，上下左右都可以移，被移动的区域用白色填充。 　　注：好像只能打开BMP格式的图像，其它格式打开很慢，甚至打不开。源码在VC6编译通过。
BMP图片的平移
weixin_44474840的博客
04-12 538
BMP图片的平移 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示； 全新的 KaTeX数学公式 ...
图像处理 膨胀腐蚀 matlab算法实现
04-15
图像处理是计算机视觉和图像处理领域中的一个重要分支，它涉及到图像的获取、处理、分析和理解。图像处理技术广泛应用于机器视觉、人工智能、计算机视觉、图像识别、物流自动化、医疗图像分析等领域。 Matlab 作为...
【免费下载！】AES,ECC,SHA-256的简单实现（java，调库）
01-20
在设计和实现系统时，选择调用了以下密码库： ...2)图片文件（.png）: 采用对称加密算法对图像数据进行加密，确保图像隐私不被泄露。 3)音频文件（.mp4）: 对音频数据进行保护，通过密码学算法确保音频文件的机密性。
不调库，纯python实现机器学习经典算法.zip
最新发布
05-08
"不调库，纯python实现机器学习经典算法.zip" 提供了一种动手实践的方法，让我们深入理解这些算法的内部工作原理。在这个压缩包中，很可能是包含了若干Python源代码文件，用于演示如何从零开始构建常见的机器学习...
python线性回归的不调库实现
12-21
适用于初学者，内含python线性回归不调库的实现方法（含注释）
BMP处理（读写+水印+灰度+平移+锐化）
Solomon的博客
08-27 860
文章目录引言程序基本框架 引言 学校让用C做个项目，我选择了BMP文件处理,BMP基本的文件格式我就不讲解了，网上都可以查到详细资料，我就直接展示我的程序啦！ 程序基本框架
上海交大数字图像处理期末作业
11-07
上海交大 数字图像处理 期末作业 研究生一年级作业，共十题
数字图像处理 东南大学
12-30
数字图像处理 鲍旭东 东南大学 20字够了否？
数字图像处理大作业
03-20
c++实现的数字图像处理程序，包括平移，剪切，锐化，模糊，傅里叶变换，dct变换等
c语言 bmp处理,C语言实现BMP图像处理（开运算）
weixin_32469089的博客
05-20 791
开运算可以把比结构元素小的特定图像细节出去，同时保证不产生全局的几何失真。滤掉比结构元素小的突刺，切断细长搭接而起到分离作用。运算：用B开启A就是选出了A中某些与B相匹配的点，这些点可由完全包含在A中的结构元素B的平移得到。也就是先腐蚀后加膨胀。#include #include #include int main(int* argc, char** argv){FILE* fp = fopen(...
数字图像处理 || c++对图像进行对数变换，幂律变换，比特面分层以及均衡化处理
perry0528的博客
09-27 2435
对数变换： CImg&lt;int&gt; SrcImg; SrcImg.load_tiff("E:/Desktop/picture_process/Lenna/3/Fig0305(a)(DFT_no_log).tif"); SrcImg.display(); cimg_forXY(SrcImg, x, y) { SrcImg(x, y) = int(log(double(SrcImg(x, y...
数字图像处理入门（c++实现，参考北交视频）
人工智能方向，计算机视觉
07-14 7002
目录直方图计算直方图均衡均值/高斯 低通滤波中值滤波数学形态学处理腐蚀膨胀开运算闭运算总结 我是看着这个学习的，在此推荐一下: 北交图像处理与机器学习 在此记录一下自己的学习过程 直方图计算 灰度直方图反映了图像灰度的分布（统计）特征 计算公式： h(rk)=nkh(r_{k})=n_{k}h(rk​)=nk​ rk为灰度级,n为该灰度级的像素个数r_{k}为灰度级,n为该灰度级的像素个数rk​为灰度级,n为该灰度级的像素个数 之后我们来写这部分的代码： 首先有初始化： // 计算图像直方图 int h
数字图像处理期末测试
ljyanjy
01-06 2万+
创建以YUVtoJPEG为名称的M文件，读取CIF格式的YUV文件mobile_cif_300f.yuv的前60帧，并逐一以jpg格式保存各视频帧至当前目录下，视频帧帧号命名相对应的jpg图片。保存的jpg图片满足以下条件： 第1-10帧，视频帧缩小1倍后，利用双线性内插法放大回原尺寸； 第11-20帧，对视频帧混入椒盐噪声，再作中值滤波； 第21-30帧，对视频帧混入高斯噪声，再作图像维...
数字图像处理复习总结
热门推荐
sunshine_lyn的博客
01-03 4万+
复习着感觉记不住，于是乎，有了这篇博文，如果也同样选修了数字图像处理课程的小伙伴们可以参考一哈！ 纯手码字…逢考必过！ 概念 采样与量化 灰度变换缓慢的景物：粗采样、细量化 有大量细节变化的图像：细采样、粗量化 采样不够出现马赛克；量化不够出现假轮廓 锐化：突出灰度的过渡部分（增强图像的细节边缘和轮廓） 例：高通滤波、梯度算子、拉普拉斯算子 平滑：用于模糊处理和降低噪声 例：低通滤波...
图像处理之(24位)BMP旋转以及镜像算法
Mica_Dai的博客
10-02 1万+
在图像处理，图形学、计算机视觉中，我们经常能够见到bmp这种格式的图片； 处理bmp图像，C++
k-means聚类分析 python不调库实现
11-30
以下是Python实现K-means聚类分析的代码： ```python import numpy as np def kmeans(X, K, max_iters=100): # 随机初始化K个质心 centroids = X[np.random.choice(len(X), K, replace=False)] for i in range...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值