// 偏移量设置为17的原因，将求和后再位移，因为先位移会损失精度很多次，按照比例来说会有50%的计算损失1亮度
// 所以累积就是 m/2的亮度损失，m为滤波器的宽，在实验之后，放入PS也观察到了相似的结果，是8亮度，相对于m=19的滤波器
// 偏移17的缺点，滤波器的精度下降，滤波器所有值之和只为，0.999931，按照平均亮度是128算（实际上原图的平均亮度只有61），亮度损失只有1不到
// 从宏观上看，相对于23的offset图片整体的亮度提升了
// 亮度下降的另外一个原因是在处理边界的时候使用了周围补0来处理，所以亮度均值会下降

// main.cpp
int main()
{
	//opencv_guass_blur();
	//hw3_1dGuass();
	//hw3_inv_SSE();
	//hw3_1dMed_col_cal();
	//hw3_1dAvgF_col_cal();
	//hw3_1dAvgF_calGraph();
	//hw2_time_cmp();
	//hw2_24bitHist();
	//hw3_time_cmp();
	//hw3_1dAvgF();
	//bmpConverter bmpCvt = bmpConverter("./pic/H0102Rgb.bmp");
	//bmpCvt.Img2Bmp("./pic/test.bmp");
	//hw2_time_cmp();
	//hw2_14bit_convert();
	//bmpCvt.Img2Bmp("./pic/Fig0201Grey.bmp", 8);
	return 0;
}

// homework.cpp

void hw3_time_cmp()
{
	bmpConverter bmpCvt("./pic/Fig0201.bmp");
	int epoch_num = 1000;
	time_t start = clock();
	while (epoch_num--)
	{
		bmpCvt.RGB2Gry2(true, false);
	}
	time_t end = clock() - start;
	cout << "时间: " << end << endl;
	epoch_num = 1000;
	start = clock();
	while (epoch_num--)
	{
		bmpCvt.RGB2Gry2(false, false);
	}
	end = clock() - start;
	cout << "时间: " << end << endl;
	bmpCvt.RGB2Gry(true, true);
	bmpCvt.Img2Bmp("./pic/Fig0201Grey.bmp", 8);
}

void hw3_1dAvgF_col_cal()
{
	bmpConverter bmpCvt("./pic/H0302Gry.bmp");  // H0302Gry.bmp
	bmpCvt.AavgFilter2d1c(1, 21, true);
	bmpCvt.Img2Bmp("./pic/H0302Gry_F_col_cal.bmp");
}
void hw3_1dAvgF_calGraph()
{
	bmpConverter bmpCvt("./pic/H0302Gry.bmp");  // H0302Gry.bmp
	bmpCvt.AavgFilter2d1c(1, 21, true, 'g');
	bmpCvt.Img2Bmp("./pic/H0302Gry_F_calGraph.bmp");
}

void hw3_inv_SSE()
{
	bmpConverter bmpCvt("./pic/H0302Gry.bmp");
	bmpCvt.PInvert1c('s');
	bmpCvt.Img2Bmp("./pic/H0302Gry_inv_SSE.bmp");
}

void hw3_1dMed_col_cal()
{
	bmpConverter bmpCvt("./pic/H0302Gry.bmp");  // H0302Gry.bmp
	bmpCvt.AMedianFilter2d1c(21, 21, true);
	bmpCvt.Img2Bmp("./pic/H0302Gry_MedF_col_cal.bmp");
}

void hw3_1dGuass()
{
	bmpConverter bmpCvt("./pic/H0303Gry.bmp");  // H0303Gry.bmp
	bmpCvt.AGuassFilter2d1c(3, 19);
	bmpCvt.Img2Bmp("./pic/H0303Gry_Guass2.bmp");
}
// 这个函数是用来比较自己实现的高斯模糊和标准的高斯模糊的差距
// 因为自己实现的高斯模糊运用了快速的浮点运算转化为整数运算的技巧，存在误差
void opencv_guass_blur()
{
	cv::Mat src, dst;
	const char* filename = "./pic/H0303Gry.bmp";

	cv::imread(filename).copyTo(src);
	if (src.empty()) {
		throw("Faild open file.");
	}

	int ksize1 = 19;
	int ksize2 = 19;
	double sigma1 = 3;
	double sigma2 = 0;
	cv::GaussianBlur(src, dst, cv::Size(ksize1, ksize2), sigma1, sigma2);
cv::imshow("src", src);
	cv::imshow("dst", dst);
	cv::imwrite("./pic/H0303Gry_cvblur.bmp", dst);

	cv::waitKey();
	cout << getGaussianKernel(ksize1, sigma1, CV_64F);
	return ;
}
// Img.h
class Img
{
public:
	Img();
	Img(int width, int heigth, int channel = 1);
	Img(BYTE* p, int w, int h, int channel = 1);
	Img(Img && a);
	Img(Img & a);
	~Img();
protected:
	int width, height, channel;
	BYTE* pImg=nullptr;
	void T();

};
// bmpConverter.h

class bmpConverter : public Img
{
public:
	bmpConverter(const char * orgfile);
	bmpConverter();
	bmpConverter(Img);
	bmpConverter(bmpConverter &);
	bmpConverter(bmpConverter &&);
	~bmpConverter();
	// 灰度图像反转
	void InvertImg();
	// 读取bmp
	bool BmpFile2Img(const char * DstFile);
	// 保存bmp
	bool Img2Bmp(const char * DstFile, int bitCnt=0, char RGBMOD='\0');
	// 读取14bit raw数据，已经写死
	bool read14bitRaw(const char * DstFile);
	// RGB转灰度图
	void RGB2Gry(bool table_chk=true, bool inplace=true);
	// RGB转灰度图2，只用于测试
	void RGB2Gry2(bool table_chk=true, bool inplace=true);

	// 线性拉伸（仿射变换）
	void PAffine(double k, double b);
	// 均值标准差规定化
	void P2avgstd8Bit(double mean = 128.0, double stddev = 1);
	// 8bit直方图标准化实现
	void PHistogramEqualize8bit();
	// 24bit直方图标准化实现（三个通道分别实现）
	void PHistogramEqualize24bit();
	// 24bit直方图标准化实现（三个通道在一起实现）
	void PHistogramEqualize24bit1();
	// 24bit直方图标准化实现（三个通道的均值实现）
	void PHistogramEqualize24bit2();	

	// 二维维均值滤波单通道
	Img AavgFilter2d1c(int m, int n, bool inplace = true, char mod='c');
	// 灰度图像反转
	Img PInvert1c(char mod = 'n', bool inplace=true);
	// 二维中值滤波单通道
	Img AMedianFilter2d1c(int m, int n, bool inplace = true, char mod = 'c');
	// 二维高斯滤波单通道
	Img AGuassFilter2d1c(double dev, int m, bool inplace = true, char mod = 'c');



private:
	void PHistogramEqualize14bit(short * pRawImg);
	void PHistogramEqualize14bit2(short * pRawImg);
	void getHistGram8bit(int * hist);
	void getHistGram24bitavg(int * hist);

	void getHistGram24bit(int * hist);
	bool Img28bitBmp(const char * DstFile, char mod);
	bool Img224bitBmp(const char * DstFile);
	//void AavgFilter2d_row_cal(BYTE * pSrc, int m, int n, BYTE  * pDes);
	void AavgFilter2d8bit_col_cal(BYTE * pImg, int width, int height, int m, int n, BYTE  * pDes);
	void AgetCalGraph(BYTE * pImg, int width, int height, int m, int n, int * pSum);
	void AavgFilter2d8bit_calGraph(int  * pSum, int m, int n, BYTE  * pDes);
	void PInvert8bit_SSE(BYTE * pImg, int sum, BYTE * pDes);
	void PInvert8bit(BYTE * pImg, int sum, BYTE * pDes);
	void AMedianFilter8bit_col_cal(BYTE * pImg, int width, int height, int m, int n, BYTE  * pDes);
	void AGuassFilter1d(BYTE * pSrc, int width, int height, int * pFilter, int n, BYTE * pDes);
	Img T(BYTE * & pSrC, int w, int h, bool inplace = true);


	BITMAPFILEHEADER FileHeader;
	BITMAPINFOHEADER BmpHeader;


};



// bmpConverter.cpp

//_____________________hw3___________________________
// RGB转灰度的测试函数
void bmpConverter::RGB2Gry2(bool table_chk, bool inplace)
{
	if (channel != 3 || !pImg)return;
	int sum = width * height;
	BYTE * temp_save = new BYTE[sum];
	if (!temp_save)
	{
#ifdef DEBUG
		puts("程序错误，内存申请失败");
#endif // DEBUG
		return;
	}
#ifdef DEBUG
	//cout << (int)(temp_save) <<"113" <<sizeof(temp_save)<< endl;
	////cout << (int)pImg << endl;
#endif // DEBUG
	BYTE * p1 = temp_save, *p2 = pImg - 1;
	if (table_chk)
	{
		int r_ratio = 0.299 * 1024, g_ratio = 0.587 * 1024, b_ratio = 0.144 * 1024;
		while (sum--)*(p1++) = ((b_ratio  * int (*(++p2))) + g_ratio * (*(++p2)) + r_ratio * (*(++p2))) >> 10;//blue,green,red
	}
	else
	{
		while (sum--)*(p1++) = ((*(++p2)) * 0.114 + 0.587 * (*(++p2)) + 0.299 * (*(++p2)));//blue,green,red
	}
	if (inplace)
	{
		swap(temp_save, pImg);
		channel = 1;
	}

#ifdef DEBUG
	//cout << int(temp_save) << endl;
	//cout << (int)pImg << endl;
#endif // DEBUG
	delete temp_save;
	return;
}
// 二维均值滤波，列积分
void bmpConverter::AavgFilter2d8bit_col_cal(BYTE * pImg, int width, int height, int m, int n, BYTE  * pDes)
{
	BYTE *pAdd, *pDel, *pRes;
	int halfx, halfy;
	int x, y;
	int sum, c;
	int sumCol[1<<15]; //约定图像宽度不大于2^15

	// step.1------------初始化--------------------------//
	m = m | 1; //奇数化
	n = n | 1; //奇数化
	halfx = m / 2; //滤波器的半径x
	halfy = n / 2; //滤波器的半径y
	c = (1 << 23) / (m * n); //乘法因子
	memset(sumCol, 0, sizeof(int) * width);
	for (y = 0, pAdd = pImg; y <= halfy; y++)
	{
		for (x = 0; x < width; x++) sumCol[x] += *(pAdd++);
	}
	// step.2------------滤波----------------------------//
	for (y = 0, pRes = pDes, pDel = pImg; y < height; y++)
	{
		for (sum = 0, x = 0; x <= halfx; x++) sum += sumCol[x];
		//滤波
		//pRes += halfx; //跳过左侧
		for (x = 0; x < width; x++)
		{
			//求灰度均值
			*(pRes++) = sum * c >> 23; //用整数乘法和移位代替除法
			//换列,更新灰度和
			if(x >= halfx)sum -= sumCol[x - halfx]; //减左边列
			if(x < width - halfx )sum += sumCol[x + halfx + 1]; //加右边列
		}
		//pRes += halfx;//跳过右侧
		//换行,更新sumCol
		if (y >= halfy)
		{
			for (x = 0; x < width; x++)sumCol[x] -= *(pDel++); //减上一行
		}
		if (y < height - halfy - 1)
		{
			for (x = 0; x < width; x++)sumCol[x] += *(pAdd++); //加下一行
		}
	}
	return;
}
// 计算补充滤波器宽度的积分图
void bmpConverter::AgetCalGraph(BYTE * pImg, int width, int height, int m, int n, int * pSum)
{
	BYTE *pCur ;
	int *pRes;
	int x, y, halfx, halfy, w, i, rowsum;
	halfx = m / 2;
	halfy = n / 2;
	pCur = pImg;
	pRes = pSum;
	w = width + halfx * 2 + 1; // 由于积分图方块特性所以要多加1
	// 上侧padding
	for (i = 0; i < (halfy+ 1) * w; i++) *(pRes++) = 0;
	for (y = 0; y < height; y++)
	{
		// 左侧padding
		for (x = 0; x < halfx + 1; x++) *pRes++ = 0;
		// 正常处理
		for (x = 0, rowsum = 0; x < width; x++)
		{
			rowsum += *pCur++;
			*(pRes++) = *(pRes - w) + rowsum;

		}
		// 右侧padding
		for (x = 0; x < halfx; x++)*pRes++ = *(pRes - 1);
#ifdef DEBUG
		/*printf("%d %d\n", *(pRes - 1));*/
#endif // DEBUG
	}
	// 下侧padding
	for (i = 0; i < (halfy) * w; i++) *(pRes++) = *(pRes - w);
	return;
}
// 2d均值滤波 使用积分图
void bmpConverter::AavgFilter2d8bit_calGraph(int * pSum, int m, int n, BYTE * pDes)
{
	int *pY1, *pY2;
	BYTE *pRes;
	int halfx, halfy, w;
	int y, x1, x2;
	int sum, c;
	// step.1------------初始化--------------------------//
	m = m | 1; //奇数化
	n = n | 1; //奇数化
	halfx = m / 2; //滤波器的半径x
	halfy = n / 2; //滤波器的半径y
	w = width + 2 * halfx + 1;
	c = (1 << 23) / (m * n); //乘法因子
	// step.2------------滤波----------------------------//
	for (
		y = 0, pRes = pDes, pY1 = pSum, pY2 = pSum + (n) * w;
		y < height;
		y++, pY1 += w, pY2 += w
		)
	{
		for (x1 = 0, x2 = m; x1 < width; x1++, x2++) //可以简化如此，但不太容易读
		{
			sum = *(pY2 + x2) - *(pY2 + x1) - *(pY1 + x2) + *(pY1 + x1);
			*(pRes++) = (sum * c) >> 23; //用整数乘法和移位代替除法
#ifdef DEBUG
			//if (sum < 0)
			//{
			//	printf("%d  %d\n", y, x1);
			//	printf("%d  %d %d  %d\n", *(pY2 + x2), *(pY2 + x1), *(pY1 + x2), *(pY1 + x1));
			//	printf("%d\n", *(pY2 + x2 - 1));
			//}
#endif // DEBUG
		}
	}
	// step.3------------返回----------------------------//
	return;
}
/*
二维均值滤波
m: filter width
n: filter height
mod: col or row
inplace: inplace
*/ 
Img bmpConverter::AavgFilter2d1c(int m, int n, bool inplace, char mod)
{
	if (!pImg)
	{
#ifdef DEBUG
		puts("未载入图像，无法操作");
#endif // DEBUG
		return Img();
	}
	if (channel != 1)
	{
#ifdef DEBUG
		puts("不是单通道图像");
#endif // DEBUG
		return Img();
	}
	if (m > width || n > height)
	{
#ifdef DEBUG
		puts("滤波器大小错误");
#endif // DEBUG
		return Img();
	}
	BYTE* pSrc = new BYTE[width * height];
	switch (mod)
	{
	default:
	case 'c':
	case 'C':
		AavgFilter2d8bit_col_cal(pImg, width, height, m, n, pSrc);
		break;
	case 'G':
	case 'g':
	{
		int * pSum = new int[(width + (m | 1)) * (height + (n | 1))];
		AgetCalGraph(pImg, width, height, m, n, pSum);
		AavgFilter2d8bit_calGraph(pSum, m, n, pSrc);
		break;
	}
		
	}
	
	if (inplace)
	{
		delete pImg;
		pImg = pSrc;
		return Img();
	}
	else
	{
		return Img(pSrc, width, height);
	}
	
}
/* 单通道图像反转
* mod:  'n':正常
		's':使用SSE
*/
Img bmpConverter::PInvert1c(char mod, bool inplace)
{
	if (channel != 1)
	{
#ifdef DEBUG
		puts("非单通道，无法执行");
#endif // DEBUG
		return Img();
	}
	_declspec(align(16)) BYTE * pDes = new BYTE[((width * height) | 15) + 1];// 凑齐16的整数倍
	switch (mod)
		{
		default:
		case 'n':
		case 'N':
		case '0':
			PInvert8bit(pImg, width * height, pDes);
			break;
		case 's':
		case 'S':
		case '1':
			PInvert8bit_SSE(pImg, width * height, pDes);
			break;
		}
	if (inplace)
	{
		delete pImg;
		pImg = pDes;
		return Img();
	}
	else
	{
		return Img(pDes, width, height);
	}
}
// 不适用SSE的灰度图像反转
void bmpConverter::PInvert8bit(BYTE * pImg, int sum, BYTE * pDes)
{
	BYTE * pCur = pImg, * pEnd = pImg + sum, *pRes = pDes;
	while (pCur < pEnd) *(pRes++) = ~*pCur++;
}
// 使用SSE的灰度图像反转
void bmpConverter::PInvert8bit_SSE(BYTE * pImg, int sum, BYTE * pDes)
{
	BYTE * pCur, * pRes;
	__m128i * pCurSSE, *pDesSSE;
	__m128i inver;
	int res, t;
	inver = _mm_set_epi32(-1, -1, -1, -1);
	res = sum & 15, t = sum / 16;
	pCur = pImg;
	pCurSSE = (__m128i *)pCur;
	pDesSSE = (__m128i *)pDes;

	while (t--)*pDesSSE++ = _mm_sub_epi32(inver, *pCurSSE++);
	pCur = pImg + sum, pRes = pDes + sum;
	while (res--) *(pRes--) = ~*pCur--;
}
// 二维维均值滤波单通道
Img bmpConverter::AMedianFilter2d1c(int m, int n, bool inplace, char mod)
{
	if (!pImg)
	{
#ifdef DEBUG
		puts("未载入图像，无法操作");
#endif // DEBUG
		return Img();
	}
	if (channel != 1)
	{
#ifdef DEBUG
		puts("不是单通道图像");
#endif // DEBUG
		return Img();
	}
	if (m > width || n > height)
	{
#ifdef DEBUG
		puts("滤波器大小错误");
#endif // DEBUG
		return Img();
	}
	BYTE* pSrc;

	pSrc = new BYTE[width * height];
	switch (mod)
	{
		default:
		case 'c':
		case 'C':
			AMedianFilter8bit_col_cal(pImg, width, height, m, n, pSrc);
			break;
		case 'G':
		case 'g':
		{

			break;
		}
	}

	if (inplace)
	{
		delete pImg;
		pImg = pSrc;
		return Img();
	}
	else
	{
		return Img(pSrc, width, height);
	}
}
// 二维维均值滤波单通道使用列积分
void bmpConverter::AMedianFilter8bit_col_cal(BYTE * pImg, int width, int height, int m, int n, BYTE * pDes)
{
	BYTE *pCur, *pRes;
	int halfx, halfy, x, y, i, j, y1, y2, res;
	int histogram[256];
	int wSize, j1, j2;
	int num, med, v;
	int dbgCmpTimes = 0; //搜索中值所需比较次数的调试

	m = m | 1;  // 奇数化
	n = n | 1;  // 奇数化
	halfx = m / 2;  // x半径
	halfy = n / 2;  // y半径
	wSize = m * n;  // 邻域内像素总个数
	for (y = 0, pRes = pDes; y < height; y++)
	{
		// step.1----初始化直方图
		y1 = y - halfy;
		y2 = y + halfy + 1;
		memset(histogram, 0, sizeof(int) * 256);
		if (y1 < 0)			histogram[0] -= y1 * m, y1 = 0;
		if (y2 > height)	histogram[0] += (y2 - height) * m, y2 = height;
		for (i = y1, pCur = pImg + y1 * width; i < y2; i++, pCur += width)
		{
			for (j = 0; j <= halfx; j++)
			{
				histogram[pCur[j]]++;
			}
		}
		//step.2-----初始化中值
		num = 0; //记录着灰度值从0到中值的个数
		for (i = 0; i < 256; i++)
		{
			num += histogram[i];
			if (num * 2 > wSize)
			{
				med = i;
				break;
			}
		}
		// 滤波
		// pRes += halfx; // 没有处理图像左边界侧的像素
		res = n - y2 + y1;
		for (x = 0; x < width; x++)
		{
			// 赋值
			*(pRes++) = med;
#ifdef DEBUG
			//if (!x || x == 1 || x == 250)
			//{
			//	printf("%d \n", med);
			//	printf("num: %d\n", num);
			//	//int tot = 0;
			//	//for (int i = 0; i < 256; i++)tot += histogram[i];
			//	//printf("tot : %d\n", tot);
			//}
#endif // DEBUG

			// step.3-----直方图递推: 减去当前邻域最左边的一列,添加邻域右侧的一个新列
			j1 = x - halfx;  // 最左边列
			j2 = x + halfx + 1;  // 右边的新列
			if (j1 < 0)  // 如果左边超过了
			{
				histogram[0] -= n;
				num -= n;
			}
			else
			{
				for (i = y1, pCur = pImg + y1 * width; i < y2; i++, pCur += width)
				{
					// 减去最左边列
					v = pCur[j1];
					histogram[v]--;  //更新直方图
					if (v <= med) num--; //更新num
				}
				histogram[0] -= res; // 处理padding部分
				num -= res;
			}
			if (j2 >= width)  // 如果右边超过了
			{
				histogram[0] += n;
				num += n;
			}
			else
			{
				for (i = y1, pCur = pImg + y1 * width; i < y2; i++, pCur += width)
				{
					// 加上最右边列
					v = pCur[j2];
					histogram[v]++;  // 更新直方图
					if (v <= med) num++; // 更新num
				}
				histogram[0] += res; // 处理padding部分
				num += res;
			}
			// step.4-----更新中值
			if (num * 2 < wSize) // 到上次中值med的个数不够了,则med要变大
			{
				for (med = med + 1; med < 256; med++)
				{
					dbgCmpTimes += 2; //总的比较次数,调试用
					num += histogram[med];
					if (num * 2 >= wSize) break;
				}
				dbgCmpTimes += 1; //总的比较次数,调试用
			}
			else //到上次中值med的个数多了,则med要变小
			{
				while ((num - histogram[med]) * 2 > wSize)//若减去后,仍变小
				{
					dbgCmpTimes++; //总的比较次数,调试用
					num -= histogram[med--];
				}
				dbgCmpTimes += 2; //总的比较次数,调试用
			}
		}
		//pRes += halfx;//没有处理图像右边界侧的像素
	}
	printf("dbg: %lf \n", 1.0 * dbgCmpTimes / width / height);
	return;
}
// 一维维高斯滤波单通道
void bmpConverter::AGuassFilter1d(BYTE * pSrc, int width, int height, int * pFilter, int m, BYTE * pDes)
{
	int offset = 17;  
	// 偏移量设置为17的原因，将求和后再位移，因为先位移会损失精度很多次，按照比例来说会有50%的计算损失1亮度
	// 所以累积就是 m/2的亮度损失，m为滤波器的宽，在实验之后，放入PS也观察到了相似的结果，是8亮度，相对于m=19的滤波器
	// 偏移16的缺点，滤波器的精度下降，所有之和只为，0.999931，按照平均亮度是128算（实际上原图的平均亮度只有61），亮度损失只有1不到
	// 从宏观上看，相对于23的offset图片整体的亮度提升了
	int halfm, y,x, f, sum = 0;
	BYTE  *pCur, *pRes, *pY;

	halfm = m / 2;

	for (y = 0, pY = pSrc, pRes = pDes; y < height; y++, pY += width)
	{
		// 处理左侧
		for (x = 0, sum = 0; x < halfm; x++, sum = 0)
		{
			for (f = halfm - x, pCur = pY; f < m; f++)
			{
				sum += pFilter[f] * *pCur++ ;
			}
			sum >>= offset;
#ifdef DEBUG
			if (sum < 0 || sum > 255)
			{
				printf("1%d %d %d\n", sum, y, x);
			}
#endif // DEBUG
			*pRes++ = sum;
		}
		// 处理中间
		for (x = halfm, sum = 0; x < width - halfm; x++, sum = 0)
		{
			for (f = 0, pCur = pY + x - halfm; f < m; f++)
			{
				sum += pFilter[f] * *pCur++;
			}
			sum >>= offset;
			*pRes++ = sum;
#ifdef DEBUG
			if (sum < 0 || sum > 255)
			{
				printf("2%d %d %d\n", sum, y, x);
			}
#endif // DEBUG
		}
		// 处理右侧
		for (x = width - halfm, sum = 0; x < width; x++, sum = 0)
		{
			for (f = 0, pCur = pY + x - halfm; pCur < pY + width; f++)
			{
				sum += pFilter[f] * *pCur++;
			}
			sum >>= offset;
			*pRes++ = sum;
#ifdef DEBUG
			if (sum < 0 || sum > 255)
			{
				printf("2%d %d %d\n", sum, y, x);
			}
#endif // DEBUG
		}
	}
}
// 计算pSrc的转置
void bmpConverter::T(BYTE * pSrc, int w, int h, BYTE * pDes)
{
	BYTE * pX, *pCur;
	int x, y;

	pCur = pDes;

	for (x = 0; x < w; x++)
	{
		for (y = 0, pX = pSrc + x; y < h; y++, pX += w)
		{
			*pCur++ = *pX;
		}
	}

	return;
}
// 计算高斯核
void getGuassFilter(double dev, int m, int * pFilter, int offset=17)
{
	int halfm;
	double sum;
	double dF[1024];

	halfm = m / 2;
	sum = dF[halfm] = 1;

	for (int i = 1; i <= halfm; i++)
	{
		dF[halfm + i] = dF[halfm - i] = exp( - i * i / 2.0 / dev / dev);
		sum += dF[halfm + i] + dF[halfm + i];
	}
	for (int i = 0; i <= halfm; i++)
	{
		pFilter[halfm + i] = pFilter[halfm - i] = (1 << offset) * dF[halfm + i] / sum;
	}
}
// 二维高斯滤波单通道
Img bmpConverter::AGuassFilter2d1c(double dev, int m, bool inplace, char mod)
{
	if (!pImg)
	{
#ifdef DEBUG
		puts("未载入图像，无法操作");
#endif // DEBUG
		return Img();
	}
	if (channel != 1)
	{
#ifdef DEBUG
		puts("不是单通道图像");
#endif // DEBUG
		return Img();
	}
	if (m > width || m > height || m >= 80)
	{
#ifdef DEBUG
		puts("滤波器大小错误");
#endif // DEBUG
		return Img();
	}
	BYTE* pSrc, * pSrc2, * pSrcT, * pSrc2T;
	int pFilter[128];
	m |= 1;

	getGuassFilter(dev, m, pFilter);
	pSrc = new BYTE[width * height];


#ifdef DEBUG
	//double fsum = 0;
	//int offset = 17;
	//for (int i = 0; i < m; i++)
	//{
	//	fsum += 1.0 * pFilter[i] / (1 << offset);
	//	printf("%lf \n", 1.0 * pFilter[i] / (1 << offset));
	//}
	//cout << fsum << endl;
#endif // DEBUG
	switch (mod)
	{
	default:
	case 'c':
	case 'C':
	{
		pSrc2 = new BYTE[width * height];
		pSrcT = new BYTE[width * height];
		pSrc2T = new BYTE[width * height];

		AGuassFilter1d(pImg, width, height, pFilter, m, pSrc);
		T(pSrc, width, height, pSrcT);
		AGuassFilter1d(pSrcT, height, width, pFilter, m, pSrc2);
		T(pSrc2, height, width, pSrc2T);
		delete pSrc;
		delete pSrc2;
		delete pSrcT;
		pSrc = pSrc2T;
		break;
	}
		
	case 'G':
	case 'g':
	{

		break;
	}
	}

	if (inplace)
	{
		delete pImg;
		pImg = pSrc;
		return Img();
	}
	else
	{
		return Img(pSrc, width, height);
	}
}
// 第二次作业修改部分
// RGB转灰度图（将浮点乘法转化为整数运算）
void bmpConverter::RGB2Gry(bool table_chk, bool inplace)
{
	if (channel != 3 || !pImg)return;
	int sum = width * height;
	BYTE * temp_save = new BYTE[sum];
	if (!temp_save)
	{
#ifdef DEBUG
		// puts("程序错误，内存申请失败");
#endif // DEBUG
		return;
	}
#ifdef DEBUG
	//cout << (int)(temp_save) <<"113" <<sizeof(temp_save)<< endl;
	////cout << (int)pImg << endl;
#endif // DEBUG
	BYTE * p1 = temp_save, *p2 = pImg - 1;
	if (table_chk)
	{
		BYTE r8[256], g8[256], b8[256];
		int r_ratio = 0.299 * 1024, g_ratio = 0.587 * 1024;
		for (int i = 0; i < 256; i++)
		{
			r8[i] = r_ratio * i >> 10;
			g8[i] = g_ratio * i >> 10;
			b8[i] = i - r8[i] - g8[i];
		}
		while (sum--)*(p1++) = (b8[*(++p2)] + g8[*(++p2)] + r8[*(++p2)]);//blue,green,red
	}
	else
	{
		while (sum--)*(p1++) = ((*(++p2)) * 0.114 + 0.587 * (*(++p2)) + 0.299 * (*(++p2)));//blue,green,red
	}
	if (inplace)
	{
		swap(temp_save, pImg);
		channel = 1;
	}

#ifdef DEBUG
	//cout << int(temp_save) << endl;
	//cout << (int)pImg << endl;
#endif // DEBUG
	delete temp_save;
	return;
}
// 还有一个工作是去掉了函数中的输出语句。