开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
GuessWidth.cpp
资源名称：QuickImage.rar　[点击查看]
上传用户：gzboli
上传日期：2013-04-10
资源大小：471k
文件大小：9k
源码类别：

图片显示

开发平台：

Visual C++

GuessWidth.cpp：源码内容
  1. // WidthCor.cpp: implementation of the CGuessWidth class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "GuessWidth.h"
  7. #include <math.h>
  8. //#include <LIMITS.H>
  9. #include <FLOAT.H>
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. //////////////////////////////////////////////////////////////////////
  18. // Construction/Destruction
  19. //////////////////////////////////////////////////////////////////////
  21. CGuessWidth::CGuessWidth()
  22. {
  23. // m_iMinWidth=100;
  24. // m_iMaxWidth=6000;
  25. // m_iWidth=m_iHeight=-1;
  26. }
  28. CGuessWidth::~CGuessWidth()
  29. {
  30. }
  32. double CGuessWidth::WidthDetect(DWORD &iWidth,DWORD &iHeight,LPCTSTR lpszFile, short iBytes, DWORD wHeaderSize)
  33. {
  34. ASSERT(NULL != lpszFile);
  35. char *pExt=strrchr(lpszFile,'.');
  36. char cExt[10];
  37. strcpy(cExt,++pExt);
  38. _strlwr(cExt);
  40. if(strcmp(cExt,"cpx")==0)
  41. {
  42. // return FindWidth(iWidth,iHeight,lpszFile,(short)sizeof(short));
  43. return CPXDetect(iWidth, iHeight, lpszFile);
  44. }
  45. else if(strcmp(cExt,"raw")==0)
  46. {
  47. return FindWidth(iWidth, iHeight, lpszFile, (BYTE)sizeof(BYTE));
  48. }
  49. else if(strcmp(cExt,"int")==0)
  50. {
  51. return FindWidth(iWidth, iHeight, lpszFile, (float)sizeof(float), wHeaderSize);
  52. }
  53. else
  54. {
  55. return -1.0;
  56. }
  58. }
  60. double CGuessWidth::CPXDetect(DWORD &iWidth,DWORD &iHeight,LPCTSTR lpszFile)
  61. {
  62. CFile f;
  63. if(!f.Open(lpszFile,CFile::modeRead | CFile::shareExclusive))
  64. {
  65. return -1.0;
  66. }
  67. DWORD filesize=f.GetLength();
  68. iWidth = (DWORD)sqrt(filesize);
  70. DWORD iMaxLength, iMinLength;
  71. iMaxLength = (filesize/100) > (iWidth*100) ? iWidth*100 : filesize/100;
  72. iMinLength = iMaxLength / 100;
  74. HANDLE hHeap=NULL;
  75. short *pByte1=NULL;
  76. short *pByte2=NULL;
  77. hHeap=HeapCreate(HEAP_NO_SERIALIZE,iMaxLength*sizeof(short)*4,0);
  78. if(hHeap==NULL)
  79. {
  80. return -1.0;
  81. }
  82. HeapLock(hHeap);
  83. pByte1=(short*)HeapAlloc(hHeap , HEAP_NO_SERIALIZE , iMaxLength*sizeof(short)*2);
  84. if(pByte1==NULL)
  85. {
  86. HeapUnlock(hHeap);
  87. HeapDestroy(hHeap);
  88. return -1.0;
  89. }
  90. pByte2=(short*)HeapAlloc(hHeap , HEAP_NO_SERIALIZE , iMaxLength*sizeof(short)*2);
  91. if(pByte2==NULL)
  92. {
  93. HeapFree(hHeap,HEAP_NO_SERIALIZE,pByte1);
  94. HeapUnlock(hHeap);
  95. HeapDestroy(hHeap);
  96. return -1.0;
  97. }
  98. DWORD wMax=iWidth;
  99. double dMax=-1.0;
  100. double dTemp;
  101. int k;
  102. short iReal,iVirtual;
  103. double dGray1,dGray2;
  104. DWORD i, j;
  105. double iG1G2,iG12,iG22;
  106. DWORD wRowSize, iSkip;;
  107. for(i=iWidth; i<iMaxLength; i++)
  108. {
  109. wRowSize = i * sizeof(short) * 2;
  110. if((filesize % wRowSize) == 0)
  111. {
  112. iSkip = filesize/wRowSize/6;
  113. if(iSkip == 0) iSkip = 1;
  114. iG1G2=iG12=iG22=0.0;
  115. for(k=1;k<6;k++)
  116. {
  117. f.Seek(k * iSkip * wRowSize, CFile::begin);
  118. f.Read(pByte1, wRowSize);
  119. f.Read(pByte2, wRowSize);
  120. for(j=0;j<i;j++)
  121. {
  122. iReal = pByte1[2*j];
  123. iVirtual = pByte1[2*j+1];
  124. dGray1 = (sqrt((double)iReal*iReal + (double)iVirtual*iVirtual)/i);
  125. iReal = pByte2[2*j];
  126. iVirtual = pByte2[2*j+1];
  127. dGray2 = (sqrt((double)iReal*iReal + (double)iVirtual*iVirtual)/i);
  128. iG1G2 += dGray1*dGray2;
  129. iG12 += dGray1*dGray1;
  130. iG22 += dGray2*dGray2;
  131. }
  133. if((dTemp = iG1G2/iG12*iG1G2/iG22) > dMax)
  134. {
  135. dMax=dTemp;
  136. wMax=i;
  137. }
  138. }
  139. }
  140. }
  141. for(i=iWidth-1; i>iMinLength; i--)
  142. {
  143. wRowSize = i * sizeof(short) * 2;
  144. if((filesize % wRowSize) == 0)
  145. {
  146. iSkip = filesize/wRowSize/6;
  147. if(iSkip == 0) iSkip = 1;
  148. iG1G2=iG12=iG22=0.0;
  149. for(k=1;k<6;k++)
  150. {
  151. f.Seek(k * iSkip * wRowSize, CFile::begin);
  152. f.Read(pByte1, wRowSize);
  153. f.Read(pByte2, wRowSize);
  154. for(j=0;j<i;j++)
  155. {
  156. iReal = pByte1[2*j];
  157. iVirtual = pByte1[2*j+1];
  158. dGray1 = (sqrt((double)iReal*iReal + (double)iVirtual*iVirtual)/i);
  159. iReal = pByte2[2*j];
  160. iVirtual = pByte2[2*j+1];
  161. dGray2 = (sqrt((double)iReal*iReal + (double)iVirtual*iVirtual)/i);
  162. iG1G2 += dGray1*dGray2;
  163. iG12 += dGray1*dGray1;
  164. iG22 += dGray2*dGray2;
  165. }
  167. if((dTemp = iG1G2/iG12*iG1G2/iG22) > dMax)
  168. {
  169. dMax=dTemp;
  170. wMax=i;
  171. }
  172. }
  173. }
  174. }
  175. f.Close();
  176. try
  177. {
  178. HeapFree(hHeap,HEAP_GENERATE_EXCEPTIONS,pByte1);
  179. HeapFree(hHeap,HEAP_GENERATE_EXCEPTIONS,pByte2);
  180. HeapUnlock(hHeap);
  181. HeapDestroy(hHeap);
  182. }
  183. catch(CMemoryException *e)
  184. {
  185. char msg[256];
  186. e->GetErrorMessage(msg,255);
  187. e->ReportError();
  188. e->Delete();
  189. return -0.1;
  190. }
  191. iWidth=wMax;
  192. iHeight=filesize/iWidth/sizeof(DWORD);
  193. return dMax;
  194. }
  196. template <class T> double CGuessWidth::FindWidth
  197. (DWORD &iWidth,DWORD &iHeight,LPCTSTR lpszFile,T iDepth, DWORD wHeaderSize)
  198. //double CGuessWidth::FindWidth
  199. // (DWORD &iWidth,DWORD &iHeight,LPCTSTR lpszFile,BYTE iDepth)
  200. {
  201. CFile f;
  202. if(!f.Open(lpszFile,CFile::modeRead | CFile::shareExclusive))
  203. {
  204. return -1.0;
  205. }
  206. const DWORD filesize = f.GetLength() - wHeaderSize;
  207. iWidth = (DWORD)sqrt(filesize);
  209. DWORD iMaxLength, iMinLength;
  210. iMaxLength = (filesize/100) > (iWidth*100) ? iWidth*100 : filesize/100;
  211. iMinLength = iMaxLength / 100;
  213. HANDLE hHeap=NULL;
  214. T *pByte1=NULL;
  215. T *pByte2=NULL;
  216. HGLOBAL hByte1 = NULL;
  217. HGLOBAL hByte2 = NULL;
  218. hByte1 = GlobalAlloc(GHND, iMaxLength * sizeof(T));
  219. if(hByte1==NULL)
  220. {
  221. return -1.0;
  222. }
  223. hByte2 = GlobalAlloc(GHND, iMaxLength * sizeof(T));
  224. if(hByte2==NULL)
  225. {
  226. GlobalFree(hByte1);
  227. return -1.0;
  228. }
  229. pByte1 = (T*)GlobalLock(hByte1);
  230. if(pByte1 == NULL)
  231. {
  232. GlobalFree(hByte1);
  233. GlobalFree(hByte2);
  234. return -1.0;
  235. }
  236. pByte2 = (T*)GlobalLock(hByte2);
  237. if(pByte2 == NULL)
  238. {
  239. GlobalUnlock(hByte1);
  240. GlobalFree(hByte1);
  241. GlobalFree(hByte2);
  242. return -1.0;
  243. }
  245. DWORD wMax = iWidth;
  246. double dMax = -FLT_MAX;
  247. double dTemp;
  248. int k;
  249. DWORD i, j;
  250. double iG1G2, iG12, iG22;
  251. int iSkip;
  252. for(i = iWidth; i < iMaxLength; i++)
  253. {
  254. if((filesize % i) == 0)
  255. {
  256. iSkip = filesize/i/6;
  257. if(iSkip == 0) iSkip = 1;
  258. iG1G2=iG12=iG22=0.0;
  259. for(k=1;k<6;k++)
  260. {
  261. f.Seek(k * iSkip * i * sizeof(T), CFile::begin);
  262. f.Read(pByte1, i * sizeof(T));
  263. f.Read(pByte2, i * sizeof(T));
  264. for(j=0;j<i;j++)
  265. {
  266. iG1G2 += ((double)pByte1[j]*pByte2[j] / i);
  267. iG12 += ((double)pByte1[j]*pByte1[j] / i);
  268. iG22 += ((double)pByte2[j]*pByte2[j] / i);
  269. }
  271. }
  272. if((dTemp = iG1G2/iG12*iG1G2/iG22) > dMax)
  273. {
  274. dMax=dTemp;
  275. wMax=i;
  276. }
  277. }
  278. }
  279. for(i=iWidth-1; i>iMinLength; i--)
  280. {
  281. if((filesize % i) == 0)
  282. {
  283. iSkip = filesize/i/6;
  284. if(iSkip == 0) iSkip = 1;
  285. iG1G2=iG12=iG22=0.0;
  286. for(k=1;k<6;k++)
  287. {
  288. f.Seek(k * iSkip * i * sizeof(T), CFile::begin);
  289. f.Read(pByte1, i * sizeof(T));
  290. f.Read(pByte2, i * sizeof(T));
  292. for(j=0;j<i;j++)
  293. {
  294. iG1G2 += ((double)pByte1[j]*pByte2[j] / i);
  295. iG12 += ((double)pByte1[j]*pByte1[j] / i);
  296. iG22 += ((double)pByte2[j]*pByte2[j] / i);
  297. }
  299. }
  300. if((dTemp = iG1G2/iG12*iG1G2/iG22) > dMax)
  301. {
  302. dMax=dTemp;
  303. wMax=i;
  304. }
  305. }
  306. }
  307. f.Close();
  309. GlobalUnlock(hByte1);
  310. GlobalFree(hByte1);
  311. GlobalUnlock(hByte2);
  312. GlobalFree(hByte2);
  314. iWidth=wMax;
  315. iHeight=filesize / iWidth / int(iDepth + 0.5);
  316. return dMax;
  317. }
  318. /*
  319. double CGuessWidth::FindWidth(DWORD &iWidth,DWORD &iHeight,LPCTSTR lpszFile,BYTE iDepth)
  320. {
  321. CFile f;
  322. if(!f.Open(lpszFile,CFile::modeRead | CFile::shareExclusive))
  323. {
  324. return -1.0;
  325. }
  326. DWORD filesize=f.GetLength();
  327. if(m_iMaxWidth > filesize)
  328. {
  329. m_iMaxWidth = filesize;
  330. }
  331. int iCount=filesize/m_iMaxWidth/10/iDepth;
  332. if(iCount==0)
  333. {
  334. iCount=1;
  335. }
  336. HANDLE hHeap=NULL;
  337. BYTE *pByte1=NULL;
  338. BYTE *pByte2=NULL;
  339. hHeap=HeapCreate(HEAP_NO_SERIALIZE,m_iMaxWidth*sizeof(BYTE)*2,0);
  340. if(hHeap==NULL)
  341. {
  342. return -1.0;
  343. }
  344. HeapLock(hHeap);
  345. pByte1=(BYTE*)HeapAlloc(hHeap , HEAP_NO_SERIALIZE , m_iMaxWidth*sizeof(BYTE));
  346. if(pByte1==NULL)
  347. {
  348. HeapUnlock(hHeap);
  349. HeapDestroy(hHeap);
  350. return -1.0;
  351. }
  352. pByte2=(BYTE*)HeapAlloc(hHeap , HEAP_NO_SERIALIZE , m_iMaxWidth*sizeof(BYTE));
  353. if(pByte2==NULL)
  354. {
  355. HeapFree(hHeap,HEAP_NO_SERIALIZE,pByte1);
  356. HeapUnlock(hHeap);
  357. HeapDestroy(hHeap);
  358. return -1.0;
  359. }
  360. DWORD wMax=m_iMinWidth;
  361. double dMax=-FLT_MAX;
  362. double dTemp;
  363. int k;
  364. DWORD j;
  365. double iG1G2,iG12,iG22;
  366. for(k=1;k<6;k++)
  367. {
  368. for(DWORD i=m_iMinWidth;i<m_iMaxWidth;i++)
  369. {
  370. if((filesize % i) != 0)continue;
  371. f.Seek(k*iCount*i*sizeof(BYTE),CFile::begin);
  372. f.Read(pByte1,i*sizeof(BYTE));
  373. f.Read(pByte2,i*sizeof(BYTE));
  375. iG1G2=iG12=iG22=0.0;
  376. for(j=0;j<i;j++)
  377. {
  378. iG1G2+=(double)pByte1[i]*pByte2[i];
  379. iG12+=(double)pByte1[i]*pByte1[i];
  380. iG22+=(double)pByte2[i]*pByte2[i];
  381. }
  383. if((dTemp = iG1G2/iG12*iG1G2/iG22) > dMax)
  384. {
  385. dMax=dTemp;
  386. wMax=i;
  387. }
  388. }
  389. }
  390. f.Close();
  391. try
  392. {
  393. HeapFree(hHeap,HEAP_GENERATE_EXCEPTIONS,pByte1);
  394. HeapFree(hHeap,HEAP_GENERATE_EXCEPTIONS,pByte2);
  395. HeapUnlock(hHeap);
  396. HeapDestroy(hHeap);
  397. }
  398. catch(CMemoryException *e)
  399. {
  400. char msg[256];
  401. e->GetErrorMessage(msg,255);
  402. e->ReportError();
  403. e->Delete();
  404. return -0.1;
  405. }
  406. iWidth=wMax;
  407. iHeight=filesize/iWidth/iDepth;
  408. return dMax;
  409. }*/