#include "stdafx.h"

#include "stdafx.h"
#include "OpencvImgShell.h"

#include "IntensityContrastDefinationControl.h" 

#include "IntensityControl.h"
#include "ContrastControl.h"
#include "DefinitionControl.h"


// 通用情报结构体亮度对比度清晰度控制
BOOL QBStru_ICD_Control(QBStru *qbData, int Idegree, int Cdegree, int Ddegree, BOOL bSrcFirst)
{
	// 空值判断
	if (qbData == NULL)
	{
		return FALSE;
	}

	// 图像数据无效，直接返回false
	if (qbData->imgValid == 0) 
	{
		return FALSE;
	}

	// 优先处理srcImg
	if (bSrcFirst == TRUE)
	{
		if (qbData->image.srcImg.buff != NULL &&
			qbData->image.srcImg.ImgWidth  > 0 && // srcImg 宽度验证
			qbData->image.srcImg.ImgHeight > 0 && // srcImg 高度验证
			(qbData->image.srcImg.bitcount == 24 || qbData->image.srcImg.bitcount == 8))
		{
			qbData->image.dstImg.ImgWidth  = qbData->image.srcImg.ImgWidth;
			qbData->image.dstImg.ImgHeight = qbData->image.srcImg.ImgHeight;
			qbData->image.dstImg.bitcount  = qbData->image.srcImg.bitcount;

			// 步长：每行像素所占字节数 
			int lineByte = (qbData->image.dstImg.ImgWidth * qbData->image.dstImg.bitcount / 8);

			// 位图数据缓冲区的大小，即图像大小
			int imgBufSize = qbData->image.dstImg.ImgHeight * lineByte;

			if (qbData->image.dstImg.buff != NULL)
			{
				delete [] qbData->image.dstImg.buff;
				qbData->image.dstImg.buff = NULL;
			}

			qbData->image.dstImg.buff = new unsigned char[imgBufSize];

			return ImgStru_ICD_Control(&qbData->image.srcImg, &qbData->image.dstImg, Idegree, Cdegree, Ddegree);
		}
		else
			if (qbData->image.dstImg.buff != NULL &&
				qbData->image.dstImg.ImgWidth  > 0 && // dstImg 宽度验证
				qbData->image.dstImg.ImgHeight > 0 && // dstImg 高度验证
				(qbData->image.dstImg.bitcount == 24 || qbData->image.dstImg.bitcount == 8))
			{
				// 输入dstImg，输出dstImg
				return ImgStru_ICD_Control(&qbData->image.dstImg, &qbData->image.dstImg, Idegree, Cdegree, Ddegree);
			}
			else // srcImg dstImg均无效
			{
				return FALSE;
			}
	}
	else
	{
		// 先看dstImg是否有效
		if (qbData->image.dstImg.buff != NULL &&
			qbData->image.dstImg.ImgWidth  > 0 && // dstImg 宽度验证
			qbData->image.dstImg.ImgHeight > 0 && // dstImg 高度验证
			(qbData->image.dstImg.bitcount == 24 || qbData->image.dstImg.bitcount == 8))
		{
			return ImgStru_ICD_Control(&qbData->image.dstImg, &qbData->image.dstImg, Idegree, Cdegree, Ddegree);
		}else 
			if (qbData->image.srcImg.buff != NULL &&
				qbData->image.srcImg.ImgWidth  > 0 && // srcImg 宽度验证
				qbData->image.srcImg.ImgHeight > 0 && // srcImg 高度验证
				(qbData->image.srcImg.bitcount == 24 || qbData->image.srcImg.bitcount == 8))
			{
				qbData->image.dstImg.ImgWidth = qbData->image.srcImg.ImgWidth;
				qbData->image.dstImg.ImgHeight = qbData->image.srcImg.ImgHeight;
				qbData->image.dstImg.bitcount = qbData->image.srcImg.bitcount;

				// 步长：每行像素所占字节数
				int lineByte = (qbData->image.dstImg.ImgWidth * qbData->image.dstImg.bitcount / 8);

				// 位图数据缓冲区的大小，即图像大小
				int imgBufSize = qbData->image.dstImg.ImgHeight * lineByte;

				qbData->image.dstImg.buff = new unsigned char[imgBufSize];

				return ImgStru_ICD_Control(&qbData->image.srcImg, &qbData->image.dstImg, Idegree, Cdegree, Ddegree);
			} 
			else // 情报结构体srcImg 和 dstImg 均无效
			{
				return FALSE;
			}
	}

	return TRUE;
}


// ImgStru结构下的图像亮度对比度清晰度控制
//功能：图像亮度对比度清晰度控制
BOOL ImgStru_ICD_Control(ImgStru* src, ImgStru* dst, int Idegree, int Cdegree, int Ddegree)
{
	// src dst 有效性验证
	if (src == NULL  || dst ==NULL ||
		src->ImgWidth <=0   ||
		src->ImgHeight <= 0 ||
		src->bitcount <= 0   ||
		src->buff == NULL)
	{
		return FALSE;
	}

	if(src->bitcount != 8 && src->bitcount != 24)
	{
		return FALSE;
	}

	// 属性复制
	dst->ImgWidth = src->ImgWidth;
	dst->ImgHeight = src->ImgHeight;
	dst->bitcount = src->bitcount;
	dst->BoundingBox = src->BoundingBox;


	// 构建输入、输出图像
	IplImage* src_Img = NULL;
	src_Img = cvCreateImage(cvSize(src->ImgWidth, src->ImgHeight), 8, src->bitcount/8);

	// 步长：每行像素所占字节数，必须扩展成4的倍数 
	int lineByte = (src->ImgWidth * src->bitcount / 8 + 3) / 4 * 4;

	// 位图数据缓冲区的大小，即图像大小
	unsigned int imgBufSize = static_cast<unsigned int>(src->ImgHeight * lineByte);

	if (src_Img != NULL)
	{
		// 图像数据复制
		int realLineByte = (src->ImgWidth * src->bitcount / 8);

		if (realLineByte == lineByte)
		{
			memcpy(src_Img->imageData, src->buff, imgBufSize);  
		} 
		else
		{
			for (int i = 0; i < src->ImgHeight; i++)
			{
				memcpy(src_Img->imageData + i * lineByte, src->buff + i * realLineByte, realLineByte);  
			}
		}
		
	}
	else
	{
		return FALSE;
	}

	IplImage* dst_Img = NULL;
	dst_Img = cvCreateImage(cvSize(dst->ImgWidth, dst->ImgHeight), 8, dst->bitcount/8);

	if (dst_Img == NULL)
	{
		cvReleaseImage(&src_Img);
		src_Img = NULL;

		return FALSE;
	}

	SAFE_DELETE_ARRAY(dst->buff);
	dst->buff = NULL;
	dst->buff = new unsigned char[imgBufSize];

	if (dst->buff == NULL)
	{
		cvReleaseImage(&src_Img);
		src_Img = NULL;

		cvReleaseImage(&dst_Img);
		dst_Img = NULL;

		return FALSE;
	}

	// 调用IplImageICDControl算法，实现亮度对比度清晰度控制
	if (IplImage_ICD_Control(src_Img, dst_Img, Idegree, Cdegree, Ddegree) == TRUE)
	{
		cvReleaseImage(&src_Img);
		src_Img = NULL;

		// 数据dst_Img->imageData 拷贝到 dst->buff
		memcpy(dst->buff, dst_Img->imageData, imgBufSize);

		cvReleaseImage(&dst_Img);
		dst_Img = NULL;
	}
	else
	{
		cvReleaseImage(&src_Img);
		src_Img = NULL;

		cvReleaseImage(&dst_Img);
		dst_Img = NULL;

		return FALSE;
	}

	return TRUE;
}



// OpenCV结构下的图像亮度对比度清晰度控制
BOOL IplImage_ICD_Control(IplImage* src, IplImage* dst, int Idegree, int Cdegree, int Ddegree)
{
	BOOL ret = FALSE;
	
	// 亮度控制程度 判断和裁断
	if(Idegree < 0)
	{
		Idegree = 0;
	}

	if(Idegree > 20)
	{
		Idegree = 20;
	}

	// 对比度控制程度 判断和裁断
	if(Cdegree < 0)
	{
		Cdegree = 0;
	}

	if(Cdegree > 20)
	{
		Cdegree = 20;
	}

	// 清晰度 判断和裁断
	if(Ddegree < 0)
	{
		Ddegree = 0;
	}

	if(Ddegree > 20)
	{
		Ddegree = 20;
	}

	// 排列组合
	int way = 0;

	if (Idegree == 10 && Cdegree == 10 && Ddegree == 10) // 000
	{
		way = 0;
	} 
	else if (Idegree == 10 && Cdegree == 10 && Ddegree != 10) // 001
	{
		way = 1;
	} 
	else if (Idegree == 10 && Cdegree != 10 && Ddegree == 10) // 010
	{
		way = 2;
	}
	else if (Idegree == 10 && Cdegree != 10 && Ddegree != 10) // 011
	{
		way = 3;
	}
	else if (Idegree != 10 && Cdegree == 10 && Ddegree == 10) // 100
	{
		way = 4;
	}
	else if (Idegree != 10 && Cdegree == 10 && Ddegree != 10) // 101
	{
		way = 5;
	}
	else if (Idegree != 10 && Cdegree != 10 && Ddegree == 10) // 110
	{
		way = 6;
	}
	else if (Idegree != 10 && Cdegree != 10 && Ddegree != 10) // 111
	{
		way = 7;
	}
	else
	{
		way = 8;
	}

	switch(way)
	{
	case 0:
		cvCopy(src, dst);
		ret = TRUE;
		break;

	case 1: // 只调节清晰度
		ret = IplImageDefinitionControl(src, dst, Ddegree);
		break;

	case 2: // 只调节对比度
		ret = IplImageContrastControl(src, dst, Cdegree);
		break;

	case 3:// 对比度 + 清晰度

		if (IplImageContrastControl(src, dst, Cdegree))
		{
			cvCopy(dst, src);
			ret = IplImageDefinitionControl(src, dst, Ddegree);
		}

		break;

	case 4: // 只调节亮度
		ret = IplImageIntensityControl(src, dst, Idegree);
		break;

	case 5: // 亮度 + 清晰度
		if (IplImageIntensityControl(src, dst, Idegree))
		{
			cvCopy(dst, src);
			ret = IplImageDefinitionControl(src, dst, Ddegree);
		}
		break;

	case 6: // 亮度 + 对比度
		if (IplImageIntensityControl(src, dst, Idegree))
		{
			cvCopy(dst, src);
			ret = IplImageContrastControl(src, dst, Cdegree);
		}
		break;

	case 7: // 亮度 + 对比度 + 清晰度
		if (IplImageIntensityControl(src, dst, Idegree))
		{
			if (IplImageContrastControl(dst, src, Cdegree))
			{
				ret = IplImageDefinitionControl(src, dst, Ddegree);
			}
		}
		break;

	default:
		break;
	}


	return ret;
}