#include "stdafx.h"
#include "DecreaseHazeControl.h"
#include "omp.h" // 多核编程

#include "histProject.h"
//#include "DarkChannelDehaze.h"

// 计算暗通道最大值:A_MAX
double GetDarkChannelMaxVal(const cv::Mat &img)
{
	try
	{
		// 输入有效性验证
		if (img.empty() == true || img.type() != 16 || img.cols <= 0 || img.rows <= 0)
		{
			return 0;
		}


		const int patch = 8;

		// 图像尺寸
		int imgWidth = img.cols;
		int imgHeight = img.rows;

		//  边界扩展图像
		cv::Mat Mid(imgHeight + 2 * patch, imgWidth + 2 * patch, CV_8UC3); 
		cv::copyMakeBorder(img, Mid, patch, patch, patch, patch, IPL_BORDER_REFLECT);

		// 暗通道图像
		cv::Mat DarkChannel(imgHeight, imgWidth, CV_8UC1);
		for (int i = 0; i < imgHeight; ++i)
		{
			for (int j = 0; j < imgWidth; ++j)
			{
				// 局部区域
				cv::Mat patchRegion = Mid(cv::Rect(j, i, 2 * patch, 2 * patch));

				// 通道分离
				std::vector<cv::Mat> planes;
				cv::split(patchRegion, planes);

				// 求取三个通道的最小值
				double minB = 0, minG = 0, minR = 0; 
				cv::minMaxLoc(planes[0], &minB);
				cv::minMaxLoc(planes[1], &minG);
				cv::minMaxLoc(planes[2], &minR);

				// 给暗通道复制
				double minVal = min(min(minB, minG), minR);
				DarkChannel.at<unsigned char>(i,j) = static_cast<unsigned char>(minVal);

				// 内存释放
				planes.clear();
			}
		}

		// 计算暗通道最大值
		double minDarkChannel = 0.0;
		double maxDarkChannel = 0.0;
		cv::minMaxLoc(DarkChannel, &minDarkChannel, &maxDarkChannel);

		// 释放暗通道图像
		DarkChannel.release();

		return maxDarkChannel;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return 0;
	}
	catch(...)
	{
		return 0;
	}
}


//求取三个通道中最小值，然后以最小值组成一幅灰度图
bool GetMinChannel(const cv::Mat &img, cv::Mat& dark)
{
	try
	{
		// 输入有效性判断
		if (img.empty() == true || img.type() != CV_8UC3)
		{
			return false;
		}

		std::vector<cv::Mat> planes;
		cv::split(img, planes);

		cv::min(planes[0], planes[1], dark);
		cv::min(planes[2], dark, dark);

		planes.clear();

		return true;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}



// 计算图像V
bool GetImgV(const cv::Mat &MinChannel,const cv::Mat &Diff, const cv::Mat &Smooth, cv::Mat & DstV, double degree = 0.78)
{
	try
	{
		// 输入有效性判断

		// 1空值判断
		if (MinChannel.empty() == true || Diff.empty() == true || Smooth.empty() == true)
		{
			return false;
		}

		// 2图像类型判断
		if (MinChannel.type() != CV_8UC1 || Diff.type() != CV_8UC1 || Smooth.type() != CV_8UC1)
		{
			return false;
		}

		// 3图像尺寸判断
		if (MinChannel.cols <= 0 || MinChannel.cols != Diff.cols || Diff.cols != Smooth.cols || 
			MinChannel.rows <= 0 || MinChannel.rows != Diff.rows || Diff.rows != Smooth.rows)
		{
			return false;
		}

		if (degree < 0)
		{
			degree = 0;
		}
		else if (degree > 1)
		{
			degree = 1;
		}

		// 图像属性
		int ImgWidth = MinChannel.cols;
		int ImgHeight = MinChannel.rows;

		// 创建：DstV
		DstV.create(cv::Size(ImgWidth, ImgHeight), CV_8UC1);

		// DstV 检查
		if (DstV.empty() == true)
		{
			return false;
		}

		// 连续性判断以提高速度
		if (DstV.isContinuous())
		{
			ImgWidth *= ImgHeight;
			ImgHeight = 1;
		}

		// 计算DstV值
		for(int i = 0; i < ImgHeight; ++i)
		{
			const uchar* pMinChannel = MinChannel.ptr<uchar>(i);
			const uchar* pDiff = Diff.ptr<uchar>(i);
			const uchar* pSmooth = Smooth.ptr<uchar>(i);
			uchar* pDstV = DstV.ptr<uchar>(i);

			for(int j = 0; j < ImgWidth; ++j)   
			{ 
				double val = degree * max(uchar(min(uchar((*pMinChannel++) - (*pDiff++)), (*pSmooth++))), uchar(0));
				(*pDstV++) = static_cast<uchar>(val); 
			}
		}

		return true;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}


// 获取无雾图像
bool GetHazeFreeImg(const cv::Mat& img, const cv::Mat &ImgV, double A_MAX, cv::Mat &HazeFree)
{
	try
	{
		// 输入有效性判断
		if (img.empty() == true || img.type() != CV_8UC3 || img.cols <= 0 || img.rows <= 0
			|| ImgV.empty() == true || ImgV.type() != CV_8UC1 || ImgV.cols <= 0 || ImgV.rows <= 0
			|| A_MAX < 0 || A_MAX > 255 || img.cols != ImgV.cols || img.rows != ImgV.rows)
		{
			return false;
		}

		// 图像尺寸
		int imgWidth = img.cols;
		int imgHeight = img.rows;

		// 创建输出图像
		HazeFree.create(imgHeight, imgWidth, CV_8UC3);
		if (HazeFree.empty() == true)
		{
			return false;
		}

#pragma omp parallel for
		for (int j = 0; j < imgWidth; ++j)
		{
			for (int i = 0; i < imgHeight; i++)
			{
				double V = ImgV.at<unsigned char>(i, j);
				cv::Vec3b vec = img.at<cv::Vec3b>(i, j);

				for (int k = 0; k < 3; k++)
				{
					double VAB = 0;
					if (V != A_MAX)
					{
						VAB = fabs(vec[k] - V)/(fabs(1 - V/A_MAX));
					}

					if (VAB > 255)
					{
						vec[k] = 255;
					}
					else
					{
						vec[k] = static_cast<unsigned char>(VAB);
					}
				}

				HazeFree.at<cv::Vec3b>(i, j) = vec;	
			}		
		}

		return true;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}




//功能：图像去雾控制
//输入：	1. img 输入图像
//		    2. A_MAX  控制去雾效果, A_MAX < 0 时，自适应计算(特别耗时)； 有效范围【0,255】，异常值自适应
//		    3. degree 控制去雾效果, 有效范围【0,1】，异常值自适应

//输出：	1. HazeFree 输出图像
//          2. 返回值：处理成功返回true，失败返回false
bool DeHazeImg(const cv::Mat &img, cv::Mat &HazeFree, double A_MAX, double degree)
{
	try
	{
		// 单通道 红外图像细节增强  作者：王家星
		if (img.type() == CV_8UC1)
		{
			if (A_MAX != 0)
			{
				// 高斯无约束
				return GNRHP(HazeFree,img, false);
			} 
			else
			{
				// 高斯约束
				return GRHP(HazeFree, img, true);
			}
		}
		else
		{
			// 王家星算法
			      // 三通道
			if (A_MAX < 0)
			{
				A_MAX = GetDarkChannelMaxVal(img);
			}
			
			if (A_MAX > 255)
			{
				A_MAX = 255;
			}
			
			cv::Mat Dark;
			cv::Mat Smooth;
			cv::Mat Diff;
			cv::Mat V;
			
			// 获取暗通道
			if (GetMinChannel(img, Dark) == false)
			{
				return false;
			}
			
			// 高斯模糊
			cv::GaussianBlur(Dark, Smooth, cv::Size(5, 5), 1.667);
			
			// 计算Diff
			cv::absdiff(Dark, Smooth, Diff);
			
			// 计算V
			if (GetImgV(Dark, Diff, Smooth, V, degree) == false)
			{
				return false;
			}  
			
			// 计算HazeFree
			if (GetHazeFreeImg(img, V, A_MAX, HazeFree) == false)
			{
				return false;
			}
			
			return true;
		}
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}

// ImgStru结构下的图像去雾控制

//功能：图像去雾控制
//输入：	1. src 输入图像结构体
//		    2. A_MAX  控制去雾效果, A_MAX < 0 时，自适应计算(特别耗时)； 有效范围【0,255】，异常值自适应
//		    3. degree 控制去雾效果, 有效范围【0,1】，异常值自适应

//输出：	1. dst 输出图像结构体
//          2. 返回值：处理成功返回true，失败返回false
bool ImgStruDeHazeControl(ImgStru* src, ImgStru* dst, int A_MAX, double degree)
{
	try
	{
		// src dst 有效性验证
		if (src == NULL || dst == NULL || 
			src->ImgWidth <=0   ||
			src->ImgHeight <= 0 ||
			src->buff == NULL)
		{
			return false;
		}


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

		// 构建输入、输出图像
		cv::Mat src_Img; // 

		if (src->bitcount == 8)
		{
			src_Img = cv::Mat(src->ImgHeight, src->ImgWidth, CV_8UC1);
		}
		else if (src->bitcount == 24)
		{
			src_Img = cv::Mat(src->ImgHeight, src->ImgWidth, CV_8UC3);
		}
		else
		{
			return false;
		}


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

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

		if (!src_Img.empty())
		{
			// 图像数据复制
			memcpy(src_Img.data, src->buff, imgBufSize);  
		}
		else
		{
			return false;
		}

		//  构建输出图像
		cv::Mat dst_Img;

		// 调用DeHazeImg算法，实现去雾控制
		if (DeHazeImg(src_Img, dst_Img, A_MAX, degree) == true)
		{
			if (src == dst)
			{
				memcpy(dst->buff, dst_Img.data, imgBufSize);
			}
			else
			{
				SAFE_DELETE_ARRAY(dst->buff);
				dst->buff = new unsigned char[imgBufSize];
				memcpy(dst->buff, dst_Img.data, imgBufSize);
			}
		}
		else
		{
			return false;
		}

		return true;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}

//功能：图像去雾控制
//输入：	1. qbData 通用情报数据结构体
//		    2. A_MAX  控制去雾效果, A_MAX < 0 时，自适应计算(特别耗时)； 有效范围【0,255】
//		    3. degree 控制去雾效果, 有效范围【0,1】
//          3. bSrcFirst 默认时，优先处理srcImg, srcImg-->dstImg
//                         否则，优先处理dstImg，dstImg——>dstImg                         

//输出：	1. qbData 含图像去雾后图像的情报数据结构体
//          2. 返回值：处理成功返回true，失败返回false
//说明: 首先判断图像数据有效性标识位，无效时直接返回，不做任何处理;
bool QBStruDeHazeControl(QBStru *qbData, int A_MAX, double degree, bool bSrcFirst)
{
	try
	{
		// 空值判断
		if (qbData == NULL)
		{
			return false;
		}

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

		// 优先处理srcImg
		if (bSrcFirst == true)
		{
			if (qbData->image.srcImg.buff != NULL &&
				qbData->image.srcImg.ImgWidth  > 0 && // srcImg 宽度验证
				qbData->image.srcImg.ImgHeight > 0 )  // srcImg 高度验证
			{
				return ImgStruDeHazeControl(&qbData->image.srcImg, &qbData->image.dstImg, A_MAX, degree);
			}
			else
				if (qbData->image.dstImg.buff != NULL &&
					qbData->image.dstImg.ImgWidth  > 0 && // dstImg 宽度验证
					qbData->image.dstImg.ImgHeight > 0 )   // dstImg 高度验证
					
				{
					// 输入dstImg，输出dstImg
					return ImgStruDeHazeControl(&qbData->image.dstImg, &qbData->image.dstImg, A_MAX, degree);
				}
				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 高度验证
			{
				return ImgStruDeHazeControl(&qbData->image.dstImg, &qbData->image.dstImg, A_MAX, degree);
			}else 
				if (qbData->image.srcImg.buff != NULL &&
					qbData->image.srcImg.ImgWidth  > 0 && // srcImg 宽度验证
					qbData->image.srcImg.ImgHeight > 0 ) // srcImg 高度验证
				{
					return ImgStruDeHazeControl(&qbData->image.srcImg, &qbData->image.dstImg, A_MAX, degree);
				} 
				else // 情报结构体srcImg 和 dstImg 均无效
				{
					return false;
				}
		}

		return true;
	}
	catch(cv::Exception &e)
	{
		e.msg;
		return false;
	}
	catch(...)
	{
		return false;
	}
}