lyfz_repos/经典版源码/lyfzServer/branches/728/IMGCommon.cpp

#include "StdAfx.h"
#include "IMGCommon.h"
#include <strsafe.h>
#include <comutil.h>
#pragma comment(lib, "comsuppw.lib")

const ColorMatrix _ClrMatrix = 
{
	1.0, 0.0, 0.0, 0.0, 0.0, 
	0.0, 1.0, 0.0, 0.0, 0.0, 
	0.0, 0.0, 0.3, 0.0, 0.0, 
	0.0, 0.0, 0.0, 1.0, 0.0, 
	0.0, 0.0, 0.0, 0.0, 1.0, 
};

ULONG_PTR IMGCommon::m_gdiplusToken;

IMGCommon::IMGCommon(void)
{
	GdiplusStartupInput gdiplusStartupInput;
	GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);
}

IMGCommon::~IMGCommon(void)
{
	Gdiplus::GdiplusShutdown(m_gdiplusToken);
}

/************************************************************************/
/*  函数：IsCorrectExt[6/1/2016 IT];
/*  描述：扩展名是否正确;
/*  参数：;
/*  	[IN] fext：要判断的扩展名;
/*  	[OUT] lpMistakenExt：返回错误的扩展名;
/*  返回：扩展名错误返回-1、扩展名为*.*返回0、扩展符合要求返回1;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
INT IMGCommon::IsCorrectExt( IN const TString &fext, OUT TString* lpMistakenExt /* = NULL */ )
{
	if (fext.size() == 0) 
	{
		WriteTextLog(_T("要查找的扩展名字符空！"));
		return -1;
	}

	if (fext.find(_T("*.*")) != TString::npos) 
	{
		WriteTextLog(_T("要查找的扩展名为\"*.*\""));
		return 0;
	}

	TString ext = fext;
	if (ext[ext.length() - 1] != _T('|'))
		ext.append(_T("|"));

	INT bRet = 1;
	CONST TString sCorrectExt = _T("*.jpg|*.jpeg|*.png|*.bmp|*.cr2|*.nef|*.raw|*.ra2|*.ofr|*.pef|*.sr2");
	int nIndex = 0;
	do
	{
		nIndex = ext.find(_T('|'));
		if (nIndex != TString::npos)
		{
			if (sCorrectExt.find(ext.substr(0, nIndex)) == TString::npos)
			{
				if (lpMistakenExt)
					*lpMistakenExt = ext.substr(0, nIndex);
				bRet = -1;
				break;
			}

			ext = ext.substr(nIndex + 1);
		}
	} while (ext.find(_T('|')) != TString::npos);

	return bRet;
}

/************************************************************************/
/*  函数：ExtMerge[6/1/2016 IT];
/*  描述：合并扩展名;
/*  参数：;
/*  	[IN] ext1：要合并的扩展名1;
/*  	[IN] ext2：要合并的扩展名2;
/*  	[OUT] merge：合并后的扩展名;
/*  返回：只合并合法的扩展名,若两扩展名都非法,返回FALSE;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
BOOL IMGCommon::ExtMerge(IN CONST TString& ext1, IN CONST TString& ext2, OUT TString &merge) // 合并扩展名;
{
	// 1.判断扩展名1合法性;
	INT nRet = IsCorrectExt(ext1);
	if ( nRet == -1 ) 
	{
		nRet = IsCorrectExt(ext2);
		if ( nRet == -1)
			return FALSE;

		merge = ext2;
		return TRUE;
	}

	if (nRet == 0)
	{
		merge = _T("*.*");
		return TRUE;
	}

	merge = ext1;
	// 2.判断扩展名2合法性;
	nRet = IsCorrectExt(ext2);
	if (nRet != 1) return TRUE;

	// 3.合并2扩展名;
	if (merge[merge.length() - 1] != _T('|'))
		merge.append(_T("|"));
	merge.append(ext2);

	return TRUE;
}

/************************************************************************/
/*  函数：GetFileName[6/1/2016 IT];
/*  描述：根据参数,获取参数中的文件名;
/*  参数：;
/*  	[IN] strfile：要获取文件名的全路径名;
/*  返回：获取成功返回文件名,否则返回空;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
CString IMGCommon::GetFileName(IN CONST CString& strfile)
{
	CString name = _T("");
	int nIndex = strfile.ReverseFind(_T('\\'));
	if (nIndex == -1)
		return _T("");

	name = strfile.Mid(nIndex + 1);
	nIndex = name.ReverseFind(_T('.'));
	if (nIndex == -1)
		return _T("");

	name = name.Mid(0, nIndex);

	return name;
}

/************************************************************************/
/*  函数：GetFilteringImg[6/1/2016 IT];
/*  描述：过滤掉扩展名不符合要求的文件名;
/*  参数：;
/*  	[IN] AryImgs：要被过滤的文件名数组;
/*  	[IN] lpCopyExt：要保留的文件的扩展名;
/*  	[IN] bPickoutThumbnail：是否剔除缩略图;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void IMGCommon::GetFilteringImg(IN CStringArray &AryImgs, IN LPCTSTR lpCopyExt, IN BOOL bPickoutThumbnail /*= TRUE*/)
{
	if (AryImgs.GetSize() == 0 || lpCopyExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strCopyExt(lpCopyExt);
	if (strCopyExt.find(_T("*.*")) != TString::npos) return;

	strCopyExt.append(_T("|"));
	STR_VEC vtCopyExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strCopyExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strCopyExt.substr(0, nIndex);
			strCopyExt = strCopyExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtCopyExt.push_back(strtmp.substr(1));
		}
	} while (strCopyExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (int i = AryImgs.GetSize() - 1; i >= 0; i--)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtCopyExt.begin(); itExt != vtCopyExt.end(); itExt++)
		{
			if (AryImgs.ElementAt(i).MakeLower().Find(itExt->c_str()) != -1) {
				bExsit = TRUE;
				break;
			}
		}

		if (!bExsit) {
			AryImgs.RemoveAt(i);
			continue;
		}

		if (bPickoutThumbnail)
		{// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
			nIndex = AryImgs.ElementAt(i).ReverseFind(_T('\\'));
			if (nIndex != -1)
			{
				strtmp = AryImgs.ElementAt(i).Mid(nIndex + 1);
				if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
					AryImgs.RemoveAt(i);
					continue;
				}
			}
		}
	}
}

/************************************************************************/
/*  函数：GetFilteringImg[6/1/2016 IT];
/*  描述：过滤掉扩展名不符合要求的文件名;
/*  参数：;
/*  	[IN] vtImgs：要被过滤的文件名数组;
/*  	[IN] lpCopyExt：要保留的文件的扩展名;
/*  	[IN] bPickoutThumbnail：是否剔除缩略图;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void IMGCommon::GetFilteringImg(IN STR_VEC &vtImgs, IN LPCTSTR lpCopyExt, IN BOOL bPickoutThumbnail /*= TRUE*/)
{
	if (vtImgs.size() == 0 || lpCopyExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strCopyExt(lpCopyExt);
	if (strCopyExt.find(_T("*.*")) != TString::npos) return;

	strCopyExt.append(_T("|"));
	STR_VEC vtCopyExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strCopyExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strCopyExt.substr(0, nIndex);
			strCopyExt = strCopyExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtCopyExt.push_back(strtmp);
		}
	} while (strCopyExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtImgs.begin(); it != vtImgs.end();)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtCopyExt.begin(); itExt != vtCopyExt.end(); itExt++)
		{
			if (match(itExt->c_str(), it->c_str())) {
				bExsit = TRUE;
				break;
			}
		}

		if (!bExsit) {
			it = vtImgs.erase(it);
			continue;
		}

		if (bPickoutThumbnail)
		{// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
			nIndex = it->find_last_of(_T('\\'));
			if (nIndex != TString::npos) {
				strtmp = it->substr(nIndex + 1);
				if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
					it = vtImgs.erase(it);
					continue;
				}
			}
		}
		it++;
	}
}

/************************************************************************/
/*  函数：SubgroupExt[6/1/2016 IT];
/*  描述：将指定的扩展名文件分离出来;
/*  参数：;
/*  	[IN] vtAllImgs：源,要被分离指定扩展名的文件路径数组;
/*  	[IN] lpSubgroupExt：要分离出来的扩展名;
/*  	[OUT] AryImgs：返回分离出来的文件路径数组;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void IMGCommon::SubgroupExt(IN STR_VEC &vtAllImgs, IN LPCTSTR lpSubgroupExt, OUT CStringArray &AryImgs)
{
	if (vtAllImgs.size() == 0 || lpSubgroupExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strSubgroupExt(lpSubgroupExt);
	if (strSubgroupExt.find(_T("*.*")) != TString::npos)
	{
		for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
			AryImgs.Add(CString(it->c_str()));
		return;
	}

	strSubgroupExt.append(_T("|"));
	STR_VEC vtSubgroupExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strSubgroupExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strSubgroupExt.substr(0, nIndex);
			strSubgroupExt = strSubgroupExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtSubgroupExt.push_back(strtmp);
		}
	} while (strSubgroupExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtSubgroupExt.begin(); itExt != vtSubgroupExt.end(); itExt++)
		{
			if (match(itExt->c_str(), it->c_str()))
			{
#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
				nIndex = it->find_last_of(_T('\\'));
				if (nIndex != TString::npos)
				{
					strtmp = it->substr(nIndex + 1);
					if (strtmp[0] == _T('s') || strtmp[0] == _T('m'))
					{
						continue;
					}
				}
#endif

				AryImgs.Add(CString(it->c_str()));
				break;
			}
		}
	}
}

void IMGCommon::SubgroupExt(IN STR_VEC &vtAllImgs, IN LPCTSTR lpSubgroupExt, IN STR_VEC &vtImgs)
{
	if (vtAllImgs.size() == 0 || lpSubgroupExt == NULL) return;

	// 获取复制扩展名;
	int nIndex = 0;
	TString strtmp;
	TString strSubgroupExt(lpSubgroupExt);
	if (strSubgroupExt.find(_T("*.*")) != TString::npos)
	{
		for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
			vtImgs.push_back(*it);
		return;
	}

	strSubgroupExt.append(_T("|"));
	STR_VEC vtSubgroupExt;

	// 将所有扩展名解析到数组里;
	do
	{
		nIndex = strSubgroupExt.find(_T('|'));
		if (nIndex != TString::npos)
		{
			strtmp = strSubgroupExt.substr(0, nIndex);
			strSubgroupExt = strSubgroupExt.substr(nIndex + 1);

			if (strtmp.compare(_T("*.*")))
				vtSubgroupExt.push_back(strtmp);
		}
	} while (strSubgroupExt.find(_T('|')) != TString::npos);

	// 过滤非复制扩展名的文件,同时去掉缩略图,保留指定复制扩展名的文件;
	for (STR_VEC::iterator it = vtAllImgs.begin(); it != vtAllImgs.end(); it++)
	{
		BOOL bExsit = FALSE;
		for (STR_VEC::iterator itExt = vtSubgroupExt.begin(); itExt != vtSubgroupExt.end(); itExt++)
		{
			if (match(itExt->c_str(), it->c_str())) {
#if 1// 这里应该去除"s"和"m"开头的缩略图;// 但新的做法是在订单里创建缩略图子文件夹;// 总而言之,都要去掉缩略图;
				nIndex = it->find_last_of(_T('\\'));
				if (nIndex != TString::npos) {
					strtmp = it->substr(nIndex + 1);
					if (strtmp[0] == _T('s') || strtmp[0] == _T('m')) {
						continue;
					}
				}
#endif
				vtImgs.push_back(*it);
				break;
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////
BOOL IMGCommon::LoadImgFromFile(IN Image** pImg, LPCTSTR lpPath)
{
	if ( !PathFileExists(lpPath) )
		return FALSE;

	if ( *pImg )
		delete *pImg;

	*pImg  = NULL;

#ifdef UNICODE
	*pImg = Image::FromFile(lpPath);
#else
	BSTR strtmp = _bstr_t(lpPath);
	*pImg = Image::FromFile(strtmp, TRUE);
	SysFreeString(strtmp);
#endif

	return (*pImg ? TRUE : FALSE);
}

BOOL IMGCommon::LoadImgFromBuffer(IN Image** pImg, IN BYTE* pBuffer, IN CONST INT& nBufLen)
{
	if ( pBuffer == NULL )
		return FALSE;

	if ( *pImg )
		delete *pImg;

	*pImg  = NULL;
	HGLOBAL hMemery = GlobalAlloc(GMEM_MOVEABLE, nBufLen);
	if ( hMemery == NULL )
		return FALSE;

	BYTE *pMem = (BYTE*)GlobalLock(hMemery);
	memcpy(pMem, pBuffer, nBufLen);

	IStream *pstream = NULL;
	CreateStreamOnHGlobal(hMemery, TRUE, &pstream);
	*pImg = Image::FromStream(pstream);
	GlobalUnlock(hMemery);
	pstream->Release();

	return (*pImg ? TRUE : FALSE);
}

// 先以只读方式从文件中读取二进制流出来，可以做到不独占文件;
BOOL IMGCommon::LoadImgFromBuffer(IN Image** pImg, LPCTSTR lpPath)
{
	if ( !PathFileExists(lpPath) )
		return FALSE;

	if ( *pImg )
		delete *pImg;
	*pImg  = NULL;


	return LoadImgFromFile(pImg, lpPath);

	CFile fp;
	CFileException e;
	BOOL bRet = FALSE;
	if ( fp.Open(lpPath, CFile::modeRead, &e))
	{
		DWORD dwLength = (DWORD)fp.GetLength();
		BYTE *pData = new BYTE[dwLength];

		fp.Read(pData,dwLength);
		fp.Close();

		bRet = LoadImgFromBuffer(pImg, pData, dwLength);

		if( pData )
			delete []pData;
	}

	return bRet;
}

/************************************************************************/
/*  函数：LoadImgFromResource[9/21/2016 IT];
/*  描述：从资源中加载;
/*  参数：;
/*  	[IN] ：;
/*  	[OUT] ：;
/*  	[IN/OUT] ：;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
Image* IMGCommon::LoadImgFromResource(IN HMODULE hModule, IN LPCTSTR lpName, IN LPCTSTR lpType)
{
	HGLOBAL	hGlobal = NULL;
	HRSRC	hSource = NULL;
	LPVOID  lpBuffer = NULL;
	DWORD   dwSize = 0;
	// 1.定位我们的自定义资源，这里因为我们是从本模块定位资源，所以将句柄简单地置为NULL即可
	hSource = FindResource(hModule, lpName, lpType);
	if (hSource == NULL)
	{
		_tprintf(_T("载入资源失败:%s"), lpName);
		return NULL;
	}

	// 2.获取资源的大小;
	dwSize = (UINT)SizeofResource(NULL, hSource);

	// 3.加载资源;
	hGlobal = LoadResource(NULL, hSource);
	if (hGlobal == NULL)
	{
		_tprintf(_T("载入资源失败:%s"), lpName);
		return NULL;
	}

	// 4.锁定资源,获取buffer;
	lpBuffer = LockResource(hGlobal);
	if (lpBuffer == NULL)
	{
		_tprintf(_T("载入资源失败:%s"), lpName);
		return NULL;
	}

	// lpFileFullName需要先判断文件是否存在??不需要;
	Image *pImg = NULL;
	LoadImgFromBuffer(&pImg, (BYTE*)lpBuffer, dwSize);

	UnlockResource(hGlobal);
	FreeResource(hGlobal);

	return pImg;
}

BOOL IMGCommon::GetOrientation(IN Image *pImg)
{
	if (pImg == NULL) return FALSE;

	UINT totalBufferSize;
	UINT numProperties;
	pImg->GetPropertySize(&totalBufferSize, &numProperties);
	// Allocate the buffer that will receive the property items.
	PropertyItem* pAllItems = (PropertyItem*)malloc(totalBufferSize);
	// Fill the buffer.
	pImg->GetAllPropertyItems(totalBufferSize, numProperties, pAllItems);
	// Print the id data member of each property item.
	for (UINT j = 0; j < numProperties; ++j)
	{
		if (PropertyTagOrientation == pAllItems[j].id)
		{
			short* ptrLong = (short*)(pAllItems[j].value);
			int ret = (int)*ptrLong;
			free(pAllItems);
			return ret;
		}
	}
	free(pAllItems);

	return TRUE;
}


/************************************************************************/
/*
函数:GetEncoderClsid
描述:获取GDI+支持的图像格式编码器种类,以及所有种类编码器信息;
参数:
IN:  format 要获取的图像格式;
OUT: pClsid 返回符合条件的图像编码器信息;
返回:成功返回编码器索引,否则返回-1;
*/
/************************************************************************/
int IMGCommon::GetEncoderClsid(IN CONST WCHAR* format, OUT CLSID* pClsid)
{
	// GDI+支持的图像编码器数量;
	UINT  numEncoders = 0;
	// GDI+所有图像格式编码器详细信息所需要的空间大小;
	UINT  nSize = 0;

	ImageCodecInfo* pImageCodecInfo = NULL;

	// 2.获取GDI+支持的所有图像格式编码器详细信息所需要的空间大小;
	GetImageEncodersSize(&numEncoders, &nSize);
	if (nSize == 0)
		return -1;

	//3.为ImageCodecInfo数组分配足额空间;
	pImageCodecInfo = (ImageCodecInfo*)(malloc(nSize));
	if (pImageCodecInfo == NULL)
		return -1;

	//4.获取所有的图像编码器信息;
	GetImageEncoders(numEncoders, nSize, pImageCodecInfo);

	//5.查找符合的图像编码器的Clsid;
	for (UINT i = 0; i < numEncoders; ++i)
	{
		if (wcscmp(pImageCodecInfo[i].MimeType, format) == 0)
		{
			*pClsid = pImageCodecInfo[i].Clsid;
			free(pImageCodecInfo);
			return i;  // Success
		}
	}

	//6.释放步骤3分配的内存;
	free(pImageCodecInfo);

	return -1;
}

/************************************************************************/
/*
函数:SaveImg2newfile
描述:将Image对象另存为其他格式的文件;
参数:
IN:  pImg		GDI+ Image对象指针,需要保存的图像对象;
IN:	 lpnewfile	其他格式的新文件名(jpg,bmp,png,jpeg);
IN:  uQuality	另存为新文件时的图像质量值;
返回:

注意:Image::Save 若文件存在,会覆盖存在的文件;
*/
/************************************************************************/
BOOL IMGCommon::SaveImg2newfile(IN Image* pImg, IN CString strNewfile, IN ULONG uQuality)
{
	if (pImg == NULL) return FALSE;

	// 需要判断路径是否存在,不存在创建目录;
	int nIndex = strNewfile.ReverseFind(_T('\\'));
	if (nIndex == -1)
		return FALSE;

	if (!PathFileExists(strNewfile.Left(nIndex)))
	{
		// 如果文件夹不存在,创建;
		SHCreateDirectoryEx(NULL, strNewfile.Left(nIndex), NULL);
	}

	nIndex = strNewfile.ReverseFind(_T('.'));
	if (nIndex == -1)
		return FALSE;

	Status stat = GenericError;
	CLSID encoderClsid = { 0 };
	BSTR newfile = strNewfile.AllocSysString();

	strNewfile = strNewfile.Mid(nIndex + 1);
	if (strNewfile.CompareNoCase(_T("bmp")) == 0)
	{
		GetEncoderClsid(L"image/bmp", &encoderClsid);
		stat = pImg->Save(newfile, &encoderClsid, NULL);
	}
	else if (strNewfile.CompareNoCase(_T("png")) == 0)
	{
		GetEncoderClsid(L"image/png", &encoderClsid);
		stat = pImg->Save(newfile, &encoderClsid, NULL);
	}
	else// if ( strNewfile.CompareNoCase(_T("jpeg")) == 0 )
	{
		GetEncoderClsid(L"image/jpeg", &encoderClsid);

		EncoderParameters encoderParameters;
		encoderParameters.Count = 1;
		encoderParameters.Parameter[0].Guid = EncoderQuality;
		encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
		encoderParameters.Parameter[0].NumberOfValues = 1;
		// Save the image as a JPEG with quality level 100.
		encoderParameters.Parameter[0].Value = &uQuality;
		stat = pImg->Save(newfile, &encoderClsid, &encoderParameters);
	}

	SysFreeString(newfile);

	return stat == Ok ? TRUE : FALSE;
}

BOOL IMGCommon::SaveImg2newfile(IN Image* pImg, IN TString strNewfile, IN ULONG uQuality)
{
	if (pImg == NULL) return FALSE;

	// 需要判断路径是否存在,不存在创建目录;
	int nIndex = strNewfile.find_last_of(_T('\\'));
	if (nIndex == TString::npos)
		return FALSE;

	if (!PathFileExists(strNewfile.substr(0, nIndex).c_str()))
	{
		// 如果文件夹不存在,创建;
		SHCreateDirectoryEx(NULL, strNewfile.substr(0, nIndex).c_str(), NULL);
	}

	nIndex = strNewfile.find_last_of(_T('.'));
	if (nIndex == TString::npos)
		return FALSE;

	Status stat = GenericError;
	CLSID encoderClsid = { 0 };
	BSTR newfile = _bstr_t(strNewfile.c_str());

	strNewfile = strNewfile.substr(nIndex + 1);
	if (strNewfile.find(_T("bmp")) == 0)
	{
		GetEncoderClsid(L"image/bmp", &encoderClsid);
		stat = pImg->Save(newfile, &encoderClsid, NULL);
	}
	else if (strNewfile.find(_T("png")) == 0)
	{
		GetEncoderClsid(L"image/png", &encoderClsid);
		stat = pImg->Save(newfile, &encoderClsid, NULL);
	}
	else// if ( strNewfile.CompareNoCase(_T("jpeg")) == 0 )
	{
		GetEncoderClsid(L"image/jpeg", &encoderClsid);

		EncoderParameters encoderParameters;
		encoderParameters.Count = 1;
		encoderParameters.Parameter[0].Guid = EncoderQuality;
		encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
		encoderParameters.Parameter[0].NumberOfValues = 1;
		// Save the image as a JPEG with quality level 100.
		encoderParameters.Parameter[0].Value = &uQuality;
		stat = pImg->Save(newfile, &encoderClsid, &encoderParameters);
	}

	SysFreeString(newfile);

	return stat == Ok ? TRUE : FALSE;
}

/************************************************************************/
/*
函数:ZoomImg
描述:缩放到指定大小的区域中,返回缩放后的尺寸;
参数:
IN:		Imgrc			图像的大小;
IN:		dwDisplayPix	图像要显示的区域的大小;
OUT:	dwZoomPix		图像在显示区域内缩放后的尺寸;
返回:

注意:dwZoomPix的尺寸必须在dwDisplayPix内;
*/
/************************************************************************/
int IMGCommon::ZoomImg(IN CRect &Imgrc, IN CONST DWORD &dwDisplayPix, OUT DWORD &dwZoomPix)
{
	double fDisplayWidth = GET_XPIX(dwDisplayPix);
	double fDisplayHeight = GET_YPIX(dwDisplayPix);

	// 显示区域长宽比;
	double fDisplayAspectRatio = fDisplayWidth / fDisplayHeight;

	// 图片长宽比;
	double fImgAspectRatio = ((double)Imgrc.Width()) / ((double)Imgrc.Height());

	double fZoomWidth;
	double fZoomHeight;

	if (fDisplayAspectRatio > fImgAspectRatio)
	{
		fZoomWidth = fDisplayHeight*fImgAspectRatio;
		fZoomHeight = fDisplayHeight;
	}
	else
	{
		fZoomWidth = fDisplayWidth;
		fZoomHeight = fDisplayWidth / fImgAspectRatio;
	}

	dwZoomPix = SET_PIX((int)fZoomWidth, (int)fZoomHeight);

	//////////////////////////////////////////////////////////////////////////
	int nRetval = 0;
	if ((fDisplayWidth == Imgrc.Width()) && (fDisplayHeight == Imgrc.Height()))
	{
		nRetval = ZoomNull;
	}
	else if ((fDisplayWidth > Imgrc.Width()) && (fDisplayHeight > Imgrc.Height()))
	{
		nRetval = ZoomOut;
	}
	else
	{
		nRetval = ZoomIn;
	}

	return nRetval;
}

int IMGCommon::ZoomImg(IN CONST DWORD &dwImgPix, IN CONST DWORD &dwDisplayPix, OUT DWORD &dwZoomPix)
{
	double fDisplayWidth = GET_XPIX(dwDisplayPix);
	double fDisplayHeight = GET_YPIX(dwDisplayPix);

	// 显示区域长宽比;
	double fDisplayAspectRatio = fDisplayWidth / fDisplayHeight;

	// 图片长宽比;
	double fImgAspectRatio = ((double)GET_XPIX(dwImgPix)) / ((double)GET_YPIX(dwImgPix));

	double fZoomWidth;
	double fZoomHeight;

	if (fDisplayAspectRatio > fImgAspectRatio)
	{
		fZoomWidth = fDisplayHeight*fImgAspectRatio;
		fZoomHeight = fDisplayHeight;
	}
	else
	{
		fZoomWidth = fDisplayWidth;
		fZoomHeight = fDisplayWidth / fImgAspectRatio;
	}

	dwZoomPix = SET_PIX((int)fZoomWidth, (int)fZoomHeight);

	//////////////////////////////////////////////////////////////////////////
	int nRetval = 0;
	if ((fDisplayWidth == GET_XPIX(dwImgPix)) && (fDisplayHeight == GET_YPIX(dwImgPix)))
	{
		nRetval = ZoomNull;
	}
	else if ((fDisplayWidth > GET_XPIX(dwImgPix)) && (fDisplayHeight > GET_YPIX(dwImgPix)))
	{
		nRetval = ZoomOut;
	}
	else
	{
		nRetval = ZoomIn;
	}

	return nRetval;
}

/************************************************************************/
/*
函数:ImgThumbnail
描述:生成高质量的图像缩略图;
参数:
返回:

注意:为了健壮性,strNewfile的路径可以在函数内再次判断是否有效,防止在函数外没有进行经判断;
*/
/************************************************************************/
BOOL IMGCommon::ImgThumbnail(IN Image* pImg, IN CONST DWORD &dwDisplayPix, IN CString strNewfile, IN ULONG uQuality)
{
	if (pImg == NULL) return FALSE;

	DWORD dwZoomPix;
	int retval = ZoomImg(SET_PIX(pImg->GetWidth(), pImg->GetHeight()), dwDisplayPix, dwZoomPix);
	if (retval == ZoomOut)
	{
		WriteTextLog(_T("复制时放大图像，退出复制！"));
		return FALSE;
	}
	else if (retval == ZoomNull)
	{
		return SaveImg2newfile(pImg, strNewfile, uQuality);
	}

	// 绘制缩略图;
	Bitmap bitmap(GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	Graphics *graphic = Graphics::FromImage(&bitmap);
	graphic->Clear(Color(255, 255, 255, 255));

	// 设置缩放或旋转图片时的算法（图片质量）;
	graphic->SetInterpolationMode(InterpolationModeHighQualityBicubic);
	// 设置渲染图形对象的质量;
	graphic->SetSmoothingMode(SmoothingModeHighQuality);//SmoothingModeHighSpeed
	// 设置图形对象的像素偏移模式;
	graphic->SetPixelOffsetMode(PixelOffsetModeHighQuality);
	// 设置图形对象的合成模式;
	graphic->SetCompositingMode(CompositingModeSourceOver);
	// 设置图形对象的合成质量;
	graphic->SetCompositingQuality(CompositingQualityHighQuality);
	// 设置图形对象的文本渲染模式;
	graphic->SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
	graphic->DrawImage(pImg, 0, 0, GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));

	delete graphic;

	// 生成缩略图;
	return SaveImg2newfile(&bitmap, strNewfile, uQuality);
}

BOOL IMGCommon::ImgThumbnail(IN LPCTSTR lpImgpath, IN CONST DWORD &dwDisplayPix, IN CString strNewfile, IN ULONG uQuality)
{
	if (!PathFileExists(lpImgpath))
		return FALSE;

#ifdef UNICODE
	Image Img(lpImgpath);
#else
	BSTR strtmp = _bstr_t(lpImgpath);
	Image Img(strtmp);
	SysFreeString(strtmp);
#endif

	DWORD dwZoomPix;
	int retval = ZoomImg(SET_PIX(Img.GetWidth(), Img.GetHeight()), dwDisplayPix, dwZoomPix);
	if (retval == ZoomOut)
	{
		WriteTextLog(_T("复制时放大图像，退出复制！"));
		return FALSE;
	}
	else if (retval == ZoomNull)
	{
		return SaveImg2newfile(&Img, strNewfile, uQuality);
	}

	// 绘制缩略图;
	Bitmap bitmap(GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	Graphics *graphic = Graphics::FromImage(&bitmap);
	graphic->Clear(Color(255, 255, 255, 255));

	// 设置缩放或旋转图片时的算法（图片质量）;
	graphic->SetInterpolationMode(InterpolationModeHighQualityBicubic);
	// 设置渲染图形对象的质量;
	graphic->SetSmoothingMode(SmoothingModeHighQuality);//SmoothingModeHighSpeed
	// 设置图形对象的像素偏移模式;
	graphic->SetPixelOffsetMode(PixelOffsetModeHighQuality);
	// 设置图形对象的合成模式;
	graphic->SetCompositingMode(CompositingModeSourceOver);
	// 设置图形对象的合成质量;
	graphic->SetCompositingQuality(CompositingQualityHighQuality);
	// 设置图形对象的文本渲染模式;
	graphic->SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
	Status st = graphic->DrawImage(&Img, 0, 0, GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	if ( st != Ok  )
	{
		delete graphic;
		return FALSE;
	}

	delete graphic;
	// 生成缩略图;
	return SaveImg2newfile(&bitmap, strNewfile, uQuality);
}

BOOL IMGCommon::ImgThumbnail(IN CONST TString &strImgpath, IN CONST DWORD &dwDisplayPix, IN TString strNewfile, IN ULONG uQuality)
{
	if (!PathFileExists(strImgpath.c_str()))
	{
		SetLastError(GetLastError());
		return FALSE;
	}

#ifdef UNICODE
	BSTR strtmp = _bstr_t(strImgpath.c_str());
	Image Img(strtmp);
	SysFreeString(strtmp);
	//Image Img(strImgpath);
#else
	BSTR strtmp = _bstr_t(strImgpath.c_str());
	Image Img(strtmp);
	SysFreeString(strtmp);
#endif

	DWORD dwZoomPix;
	int retval = ZoomImg(SET_PIX(Img.GetWidth(), Img.GetHeight()), dwDisplayPix, dwZoomPix);
	if (retval == ZoomOut)
	{
		WriteTextLog(_T("复制时放大图像，退出复制！"));
		return FALSE;
	}
	else if (retval == ZoomNull)
	{
		return SaveImg2newfile(&Img, strNewfile, uQuality);
	}

	// 绘制缩略图;
	Bitmap bitmap(GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	Graphics *graphic = Graphics::FromImage(&bitmap);
	graphic->Clear(Color(255, 255, 255, 255));

	// 设置缩放或旋转图片时的算法（图片质量）;
	graphic->SetInterpolationMode(InterpolationModeHighQualityBicubic);
	// 设置渲染图形对象的质量;
	graphic->SetSmoothingMode(SmoothingModeHighQuality);//SmoothingModeHighSpeed
	// 设置图形对象的像素偏移模式;
	graphic->SetPixelOffsetMode(PixelOffsetModeHighQuality);
	// 设置图形对象的合成模式;
	graphic->SetCompositingMode(CompositingModeSourceOver);
	// 设置图形对象的合成质量;
	graphic->SetCompositingQuality(CompositingQualityHighQuality);
	// 设置图形对象的文本渲染模式;
	graphic->SetTextRenderingHint(TextRenderingHintAntiAliasGridFit);
	Status st = graphic->DrawImage(&Img, 0, 0, GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	if ( st != Ok  )
	{
		delete graphic;
		return FALSE;
	}

	delete graphic;
	// 生成缩略图;
	return SaveImg2newfile(&bitmap, strNewfile, uQuality);
}

BOOL IMGCommon::SimpleImgThumbnail(IN LPCTSTR lpImgpath, IN CONST DWORD &dwDisplayPix, IN CString strNewfile, IN ULONG uQuality)
{
	if (!PathFileExists(lpImgpath))
		return FALSE;

	DWORD dwZoomPix;
	Image *pImg = NULL;
	LoadImgFromFile(&pImg, lpImgpath);
	if ( pImg == NULL )
	{
		return FALSE;
	}

	int retval = ZoomImg(SET_PIX(pImg->GetWidth(), pImg->GetHeight()), dwDisplayPix, dwZoomPix);
	if (retval == ZoomOut)
	{
		WriteTextLog(_T("复制时放大图像，退出复制！"));
		if (pImg) delete pImg;

		return FALSE;
	}
	else if (retval == ZoomNull)
	{
		BOOL bRet = SaveImg2newfile(pImg, strNewfile, uQuality);
		if (pImg) delete pImg;

		return bRet;
	}

	Image *pThumbnailImg = pImg->GetThumbnailImage(GET_XPIX(dwZoomPix), GET_YPIX(dwZoomPix));
	if (pThumbnailImg)
	{
		// 提高缩略图质量;
		Graphics graphic(pThumbnailImg);
		graphic.DrawImage(pImg, 0, 0, pThumbnailImg->GetWidth(), pThumbnailImg->GetHeight());
		INT nRientation = GetOrientation(pImg);
		if ( nRientation == 8 )
		{
			pThumbnailImg->RotateFlip(Rotate270FlipNone);
		}
		else if (nRientation == 6)
		{
			pThumbnailImg->RotateFlip(Rotate90FlipNone);
		}
		SaveImg2newfile(pThumbnailImg, strNewfile, uQuality);
	}
	else
	{
		if (pImg) delete pImg;
		return FALSE;
	}

	if (pImg) delete pImg;
	if (pThumbnailImg) delete pThumbnailImg;

	return TRUE;
}