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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 控制台编程 > 查看源码
VQ.cpp
资源名称：hmmPlatform.rar　[点击查看]
上传用户：goak128
上传日期：2013-07-17
资源大小：155k
文件大小：9k
源码类别：

控制台编程

开发平台：

C/C++

VQ.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include ".vq.h"
  3. #include <math.h>
  5. //////////////////////////////////////////////////////////////////////////
  6. // 构造函数
  7. // 
  8. // 创建人: 陈文凯
  9. // 创建日期: 2005-06-07
  10. // 修改人:
  11. // 修改日期:
  12. CVQ::CVQ(void)
  13. {
  14. }
  16. //////////////////////////////////////////////////////////////////////////
  17. // 析造函数
  18. // 
  19. // 创建人: 陈文凯
  20. // 创建日期: 2005-06-07
  21. // 修改人:
  22. // 修改日期:
  23. CVQ::~CVQ(void)
  24. {
  25. }
  27. ////////////////////////////////////////////////////////////////////////////
  28. //// 采用LGB算法进行VQ
  29. //// 
  30. //// 创建人: 陈文凯
  31. //// 创建日期: 2005-06-07
  32. //// 修改人:
  33. //// 修改日期:
  34. //void CVQ::LGB( 
  35. //   const double* pInVector, // 输入样本序列
  36. //   unsigned int nInLen, // 输入样本序列长度
  37. //   const double* pInCodeBook, // 输入码本，可为空
  38. //   double* pOutCodeBook, // 输出码本
  39. //   unsigned int nCodeNums, // 码本长度
  40. //   unsigned int nMaxReapt, // 最大迭代次数
  41. //   double fMinChange, // 畸变改进阈值
  42. //   double fInitDistortion // 初始畸变
  43. //   )
  44. //{
  45. // // 当前总畸变
  46. // double fCurDistortion = fInitDistortion;
  47. // // 调用LGBRepeat返回的总畸变
  48. // double fRetDistortion = 0;
  49. // // 当前迭代次数
  50. // unsigned int nCurRepeat = 0;
  51. // // 当前畸变改进量
  52. // double fCurChange = fInitDistortion;
  53. //
  54. // // 若初始码本为空，则用输入序列的前nCodeNums个样本为初始码本
  55. // if (pInCodeBook == NULL)
  56. // {
  57. // memcpy(pOutCodeBook, pInVector, sizeof(double) * nCodeNums);
  58. // }
  59. //
  60. // // 调用LGBRepeat进行迭代
  61. // while (nCurRepeat < nMaxReapt && fMinChange < fCurChange)
  62. // {
  63. // fRetDistortion = CVQ::LGBRepeat(pInVector, nInLen, pOutCodeBook, nCodeNums);
  64. //
  65. // // 计算当前畸变改进量
  66. // fCurChange = abs(fCurDistortion - fRetDistortion) / fCurDistortion;
  67. // fCurDistortion = fRetDistortion;
  68. // }
  69. //}
  70. //
  71. ////////////////////////////////////////////////////////////////////////////
  72. //// 进行LGB算法迭代，输出总畸变
  73. //// 
  74. //// 创建人: 陈文凯
  75. //// 创建日期: 2005-06-07
  76. //// 修改人:
  77. //// 修改日期:
  78. //double CVQ::LGBRepeat( 
  79. // const double* pInVector, // 输入样本序列
  80. // unsigned int nInLen, // 输入样本序列长度
  81. // double* pCodeBook, // 输入/出码本
  82. // unsigned int nCodeNums // 码本长度
  83. // )
  84. //{
  85. // // 聚类时每个码矢代表的样本数
  86. // unsigned int pnSampleNums[nCodeNums];
  87. // // 聚类时进行样本叠加值
  88. // double pfSampleSums[nCodeNums];
  89. // // 保存总畸变
  90. // double fDistortion = 0;
  91. // // 保存相邻的码矢下标
  92. // unsigned int nNearCode = 0;
  93. // // 保存样本与码矢距离
  94. // double fDistance = 0;
  95. //
  96. // // 初始化聚类时每个码矢代表的样本数
  97. // memset(pnSampleNums, 0, sizeof(unsigned int) * nCodeNums);
  98. // // 初始化聚类时进行样本叠加值
  99. // memset(pfSampleSums, 0, sizeof(double) * nCodeNums);
  100. //
  101. // // 按照输入码本对输入样本序列进行分段
  102. // for (int i = 0; i < nInLen; i++)
  103. // {
  104. // fDistance = CVQ_MAXIMUN;
  105. //
  106. // for(int j = 0; j < nCodeNums; j++)
  107. // {
  108. // if (abs(pInVector[i] - pCodeBook[j]) < fDistance)
  109. // {
  110. // fDistance = abs(pInVector[i] - pCodeBook[j]);
  111. //
  112. // nNearCode = j;
  113. // }
  114. // }
  115. //
  116. // pfSampleSums[nNearCode] += pInVector[i];
  117. // pnSampleNums[nNearCode] ++;
  118. // }
  119. //
  120. // // 计算总畸变
  121. // for (int i = 0; i < nCodeNums; i++)
  122. // {
  123. // for (int j = 0; j < pnSamplesNums)
  124. // }
  125. //
  126. // // 计算码本
  127. //
  128. // return fDistortion;
  129. //}
  131. //////////////////////////////////////////////////////////////////////////
  132. // 对输入样本进行简单聚类
  133. // 先对输入样本进行分段，然后简单的求每个分段的均值作为码本
  134. // 产生的码本与时间t相关
  135. //
  136. // 创建人: 陈文凯
  137. // 创建日期: 2005-06-07
  138. // 修改人:
  139. // 修改日期:
  140. void CVQ::EasyCluster(
  141.   const double* pInVector, // 输入样本序列
  142.   unsigned int nInLen, // 输入样本序列长度
  143.   double* pCodeBook, // 输入/出码本
  144.   unsigned int nCodeNums // 码本长度
  145.   )
  146. {
  147. unsigned int nSegLen = nInLen / nCodeNums;
  148. unsigned int nOffSet = 0;
  150. // 初始化码本
  151. memset(pCodeBook, 0, sizeof(double) * nCodeNums);
  153. for (unsigned int i = 0; i < nCodeNums; i++)
  154. {
  155. nOffSet = i * nSegLen;
  157. for (unsigned int j = 0; j < nSegLen; j++)
  158. {
  159. pCodeBook[i] += pInVector[nOffSet + j];
  160. }
  162. // 对码矢求均值
  163. pCodeBook[i] /= nSegLen;
  164. }
  165. }
  167. //////////////////////////////////////////////////////////////////////////
  168. // 实现K均值聚类
  169. //
  170. // 创建人: 陈文凯
  171. // 创建日期: 2005-06-07
  172. // 修改人:
  173. // 修改日期:
  174. void CVQ::KMeansCluster(
  175. const double* pInVector, // 输入样本序列
  176. unsigned int nInLen, // 输入样本序列长度
  177. double* pCodeBook, // 输出码本
  178. unsigned int nCodeNums // 码本长度
  179. )
  180. {
  181. // pInVector(i)是否属于pCodeBook(j)
  182. unsigned int* pFlag = NULL;
  183. // 迭代中使用到的码本
  184. double* pNewCodeBook = NULL;
  186. // 循环变量
  187. unsigned int i = 0;
  188. unsigned int j = 0;
  189. // 迭代返回的畸变
  190. double fDistortion = 0;
  192. // 对码本进行升序排序
  193. double fMinCode = 0;
  194. unsigned int nMinIndex = 0;
  196. if (pInVector != NULL && pCodeBook != NULL)
  197. {
  198. // 分配化标志矩阵
  199. pFlag = new unsigned int[nCodeNums * nInLen];
  200. // 分配迭代码本
  201. pNewCodeBook = new double[nCodeNums];
  203. // 使用EasyCluster设定初始码本
  204. CVQ::EasyCluster(pInVector, nInLen, pCodeBook, nCodeNums);
  205. for (i = 0; i < nCodeNums; i++)
  206. {
  207. TRACE("%fn", pCodeBook[i]);
  208. }
  210. // 迭代聚类
  211. fDistortion = 1;
  212. while (fDistortion > 0)
  213. {
  214. fDistortion = CVQ::KMeansClusterRepeat(
  215. pInVector, nInLen, pCodeBook, nCodeNums, pFlag, pNewCodeBook);
  217. // 拷贝新码本
  218. memcpy(pCodeBook, pNewCodeBook, sizeof(double) * nCodeNums);
  220. for (i = 0; i < nCodeNums; i++)
  221. {
  222. TRACE("%fn", pCodeBook[i]);
  223. }
  224. TRACE("#####################n");
  225. }
  227. // 对码本进行升序排序
  228. for (i = 0; i < nCodeNums; i++)
  229. {
  230. fMinCode = pCodeBook[i];
  231. nMinIndex = i;
  233. for (j = i + 1; j < nCodeNums; j++)
  234. {
  235. if (pCodeBook[j] < fMinCode)
  236. {
  237. fMinCode =  pCodeBook[j];
  238. nMinIndex = j;
  239. }
  240. }
  242. pCodeBook[nMinIndex] = pCodeBook[i];
  243. pCodeBook[i] = fMinCode;
  244. }
  246. // 释放所占资源
  247. delete[] pNewCodeBook;
  248. delete[] pFlag;
  249. }
  250. }
  252. //////////////////////////////////////////////////////////////////////////
  253. // 实现K均值聚类的迭代过程， 输出码书的畸变程度
  254. //
  255. // 创建人: 陈文凯
  256. // 创建日期: 2005-06-12
  257. // 修改人:
  258. // 修改日期:
  259. double CVQ::KMeansClusterRepeat(
  260. const double* pInVector, // 输入样本序列
  261. unsigned int nInLen, // 输入样本序列长度
  262. double* pCodeBook, // 输入码本
  263. unsigned int nCodeNums, // 码本长度
  264. unsigned int* pFlag, // 用于分类的数组，再KMeansCluster中分配
  265. double* pNewCodeBook // 输出新码本
  266. )
  267. {
  268. // 畸变
  269. double fDistortion = 0;
  270. // 样本和码本的最小距离
  271. double fMinDis = 0;
  272. // 计算样本和码本的距离
  273. double fDis = 0;
  274. // 最小距离对应的码本下标
  275. unsigned int nIndex = 0;
  277. // 码本包含样本数
  278. unsigned int nSamplesCount = 0;
  279. // 码本中样本累积
  280. double fSamplesSum = 0;
  282. // 循环变量
  283. unsigned int i = 0;
  284. unsigned int j = 0;
  286. if (pInVector != NULL)
  287. {
  288. // 初始化输出新码本
  289. memset(pNewCodeBook, 0, sizeof(double) * nCodeNums);
  290. // 初始化标志矩阵
  291. memset(pFlag, 0, sizeof(unsigned int) * nCodeNums * nInLen);
  293. // 聚类
  294. for (i = 0; i < nInLen; i++)
  295. {
  296. // 初始最小值
  297. fMinDis = abs(pInVector[i] - pCodeBook[0]);
  298. nIndex = 0;
  300. for (j = 0; j < nCodeNums; j++)
  301. {
  302. fDis = abs(pInVector[i] - pCodeBook[j]);
  304. if (fDis < fMinDis)
  305. {
  306. fMinDis = fDis;
  307. nIndex = j;
  308. }
  309. }
  311. // 设定pInVector[i]属于中心pCodeBook[nIndex];
  312. pFlag[nIndex * nInLen + i] = 1;
  313. }
  315. // 计算新码本
  316. for (i = 0; i < nCodeNums; i++)
  317. {
  318. fSamplesSum = 0;
  319. nSamplesCount = 0;
  321. for (j = 0; j < nInLen; j++)
  322. {
  323. if (pFlag[i * nInLen + j] == 1)
  324. {
  325. nSamplesCount++;
  326. fSamplesSum += pInVector[j];
  327. }
  328. }
  330. // 当堆大小为0时，对应码矢为0
  331. pNewCodeBook[i] = 
  332. (nSamplesCount == 0 ? 0 : (fSamplesSum / nSamplesCount));
  333. fDistortion += abs(pCodeBook[i] - pNewCodeBook[i]);
  334. }
  336. // 计算畸变
  337. fDistortion /= nCodeNums;
  338. }
  340. return fDistortion;
  341. }
  343. //////////////////////////////////////////////////////////////////////////
  344. // 对输入码本，按照标准码本进行分类
  345. //
  346. // 创建人: 陈文凯
  347. // 创建日期: 2005-06-12
  348. // 修改人:
  349. // 修改日期:
  350. void CVQ::Classify(
  351.    const double* pInCodeBook, // 输入码本
  352.    unsigned int nInNums, // 输入码本中码字数量
  353.    const double* pCodeBook, // 模板码本
  354.    unsigned int nCodeNums, // 模板码本中码字数量
  355.    unsigned int* pKinds // 输入码本中的码字对应的模板码本中码字的下标
  356.    )
  357. {
  358. // 码本的最小距离
  359. double fMinDis = 0;
  360. // 最小距离对应的模板码字的下标
  361. unsigned int nMinIndex = 0;
  362. // 计算码本距离
  363. double fDis = 0;
  365. if (pInCodeBook != NULL && pCodeBook != NULL)
  366. {
  367. // 初始化码字下标
  368. memset(pKinds, 0, sizeof(unsigned int) * nInNums);
  370. for (unsigned int i = 0; i < nInNums; i++)
  371. {
  372. // 初始化最小距离
  373. fMinDis = abs(pInCodeBook[i] - pCodeBook[0]);
  374. nMinIndex = 0;
  376. // 计算最小距离
  377. for (unsigned int j = 0; j < nCodeNums; j++)
  378. {
  379. fDis = abs(pInCodeBook[i] - pCodeBook[j]);
  381. if (fDis < fMinDis)
  382. {
  383. fMinDis = fDis;
  384. nMinIndex = j;
  385. }
  386. }
  388. // 保存码字下标
  389. pKinds[i] = nMinIndex;
  390. TRACE("pKinds[%d]: %dn", i, nMinIndex);
  391. }
  392. }
  393. }
  395. //////////////////////////////////////////////////////////////////////////
  396. // 计算两个码本的欧式距离
  397. double CVQ::GetDistance( const double* pCode1, const double* pCode2, unsigned int nCodeNums )
  398. {
  399. double fSum = 0;
  401. for (unsigned int i = 0; i < nCodeNums; i++)
  402. {
  403. fSum += (pCode1[i] - pCode2[i]) * (pCode1[i] - pCode2[i]);
  404. }
  406. return sqrt(fSum);
  407. }