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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
IntegralFeaturesSame.cpp
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：26k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

IntegralFeaturesSame.cpp：源码内容
  1. /**
  2.   * cubicles
  3.   *
  4.   * This is an implementation of the Viola-Jones object detection 
  5.   * method and some extensions.  The code is mostly platform-
  6.   * independent and uses only standard C and C++ libraries.  It
  7.   * can make use of MPI for parallel training and a few Windows
  8.   * MFC functions for classifier display.
  9.   *
  10.   * Mathias Kolsch, matz@cs.ucsb.edu
  11.   *
  12.   * $Id: IntegralFeaturesSame.cpp,v 1.29 2004/11/11 01:58:58 matz Exp $
  13. **/
  15. // IntegralFeatures describe the rectangular areas whose pixel
  16. // sums are compared to a weak classifier's threshold.  There
  17. // are many different types of IntegralFeatures.
  18. // IntegralFeaturesSame are features just as IntegralFeatures, 
  19. // but their rectangular regions observe more stringent constraints
  20. // during feature instance generation (see SetToNextIncarnation).
  21. // Functions for reading from files are flex/bison generated from
  22. // CascadeFileScanner.lex and CascadeFileParser.yy.
  23. //
  25. ////////////////////////////////////////////////////////////////////
  26. //
  27. // By downloading, copying, installing or using the software you 
  28. // agree to this license.  If you do not agree to this license, 
  29. // do not download, install, copy or use the software.
  30. //
  31. // Copyright (C) 2004, Mathias Kolsch, all rights reserved.
  32. // Third party copyrights are property of their respective owners.
  33. //
  34. // Redistribution and use in binary form, with or without 
  35. // modification, is permitted for non-commercial purposes only.
  36. // Redistribution in source, with or without modification, is 
  37. // prohibited without prior written permission.
  38. // If granted in writing in another document, personal use and 
  39. // modification are permitted provided that the following two
  40. // conditions are met:
  41. //
  42. // 1.Any modification of source code must retain the above 
  43. //   copyright notice, this list of conditions and the following 
  44. //   disclaimer.
  45. //
  46. // 2.Redistribution's in binary form must reproduce the above 
  47. //   copyright notice, this list of conditions and the following 
  48. //   disclaimer in the documentation and/or other materials provided
  49. //   with the distribution.
  50. //
  51. // This software is provided by the copyright holders and 
  52. // contributors "as is" and any express or implied warranties, 
  53. // including, but not limited to, the implied warranties of 
  54. // merchantability and fitness for a particular purpose are 
  55. // disclaimed.  In no event shall the copyright holder or 
  56. // contributors be liable for any direct, indirect, incidental, 
  57. // special, exemplary, or consequential damages (including, but not 
  58. // limited to, procurement of substitute goods or services; loss of 
  59. // use, data, or profits; or business interruption) however caused
  60. // and on any theory of liability, whether in contract, strict 
  61. // liability, or tort (including negligence or otherwise) arising 
  62. // in any way out of the use of this software, even if advised of 
  63. // the possibility of such damage.
  64. //
  65. ////////////////////////////////////////////////////////////////////
  68. #include "cubicles.hpp"
  69. #include "IntegralFeatures.h"
  70. #include "Exceptions.h"
  71. #include <iostream>
  75. #ifdef _DEBUG
  76. #ifdef USE_MFC
  77. #define new DEBUG_NEW
  78. #undef THIS_FILE
  79. static char THIS_FILE[] = __FILE__;
  80. #endif // USE_MFC
  81. #endif // _DEBUG
  84. #ifdef WIN32
  85. #include <malloc.h>
  86. #define alloca _alloca
  87. #endif
  91. /////////////////////////////////////////////////////////////////////////////
  92. //
  93. // CLeftRightSameIF classes implementation
  94. //
  95. /////////////////////////////////////////////////////////////////////////////
  97. CLeftRightSameIF::CLeftRightSameIF(int templateWidth, int templateHeight)
  98.   : CLeftRightIF(templateWidth, templateHeight) 
  99. {
  100. }
  102. CLeftRightSameIF::CLeftRightSameIF(const CLeftRightSameIF& frm)
  103.   : CLeftRightIF(frm) 
  104. {
  105. }
  107. CLeftRightSameIF::CLeftRightSameIF(int templateWidth, int templateHeight,
  108.                            int _toprow, int _bottomrow,
  109.                            int _leftrect_leftcol, int _centercol,
  110.                            int _rightrect_rightcol)
  111.   : CLeftRightIF(templateWidth, templateHeight) 
  112. {
  113.   toprow = _toprow;
  114.   bottomrow = _bottomrow;
  115.   leftrect_leftcol = _leftrect_leftcol;
  116.   centercol = _centercol;
  117.   rightrect_rightcol = _rightrect_rightcol;
  118.   SetNonOverlap();
  119. }
  121. CLeftRightSameIF::CLeftRightSameIF(istream& is, int template_width, int template_height)
  122.   : CLeftRightIF(template_width, template_height)
  123. {
  124.   char a, b, c;
  125.   string str;
  126.   is >> toprow >> a >> bottomrow >> str
  127.      >> leftrect_leftcol >> b >> centercol >> c >> rightrect_rightcol;
  128.   if (a!=',' || b!=',' || c!=',' || str!="x") {
  129.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  130.     sprintf(buf, "error during construction of LeftRightSameIF (%c|%c|%c|%s)n",
  131.    a, b, c, str.c_str());
  132.     throw ITException(buf);
  133.   }
  134.   SetNonOverlap();
  135. }
  137. bool CLeftRightSameIF::SetToNextIncarnation()
  138. {
  139. if (m_is_partial) {
  140. if (m_remaining_incarnations) {
  141. m_remaining_incarnations--;
  142. } else {
  143. return false;
  144. }
  145. }
  146. rightrect_rightcol+=2;
  147. centercol++;
  148. if (rightrect_rightcol>=m_template_width) {
  149. leftrect_leftcol++;
  150. if (leftrect_leftcol==m_template_width-2) {
  151. bottomrow++;
  152. if (bottomrow==m_template_height) {
  153. toprow++;
  154. if (toprow==m_template_height-1) {
  155. return false;
  156. }
  157. bottomrow=toprow+1;
  158. }
  159. leftrect_leftcol=-1;
  160. }
  161. centercol=leftrect_leftcol+1;
  162. rightrect_rightcol=centercol+1;
  163. }
  164.     SetNonOverlap();
  165. return true;
  166. }
  168. CIntegralFeature* CLeftRightSameIF::Copy() const
  169. {
  170. return new CLeftRightSameIF(*this);
  171. }
  173. ostream& CLeftRightSameIF::output(ostream& os) const
  174. {
  175.   os << "LeftRightSame " << toprow << "," << bottomrow << " x ";
  176.   os << leftrect_leftcol << "," << centercol << "," << rightrect_rightcol;
  177.   return os;
  178. }
  185. /////////////////////////////////////////////////////////////////////////////
  186. //
  187. // CUpDownSameIF classes implementation
  188. //
  189. /////////////////////////////////////////////////////////////////////////////
  191. CUpDownSameIF::CUpDownSameIF(int templateWidth, int templateHeight)
  192.   : CUpDownIF(templateWidth, templateHeight) 
  193. {
  194. }
  196. CUpDownSameIF::CUpDownSameIF(const CUpDownSameIF& frm)
  197.   : CUpDownIF(frm) 
  198. {
  199. }
  201. CUpDownSameIF::CUpDownSameIF(int templateWidth, int templateHeight,
  202.                      int _toprect_toprow, int _centerrow,
  203.                      int _bottomrect_bottomrow,
  204.                      int _leftcol, int _rightcol)
  205.   : CUpDownIF(templateWidth, templateHeight) 
  206. {
  207.   toprect_toprow = _toprect_toprow;
  208.   centerrow = _centerrow;
  209.   bottomrect_bottomrow = _bottomrect_bottomrow;
  210.   leftcol = _leftcol;
  211.   rightcol = _rightcol;
  212.   SetNonOverlap();
  213. }
  215. CUpDownSameIF::CUpDownSameIF(istream& is, int templateWidth, int templateHeight)
  216.   : CUpDownIF(templateWidth, templateHeight) 
  217. {
  218.   char a, b, c;
  219.   string str;
  220.   is >> toprect_toprow >> a >> centerrow >> b
  221.      >> bottomrect_bottomrow >> str >> leftcol >> c >> rightcol;
  222.   if (a!=',' || b!=',' || c!=',' || str!="x") {
  223.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  224.     sprintf(buf, "error during construction of UpDownSameIF (%c|%c|%c|%s)n",
  225.    a, b, c, str.c_str());
  226.     throw ITException(buf);
  227.   }
  228.   SetNonOverlap();
  229. }
  231. bool CUpDownSameIF::SetToNextIncarnation()
  232. {
  233. if (m_is_partial) {
  234. if (m_remaining_incarnations) {
  235. m_remaining_incarnations--;
  236. } else {
  237. return false;
  238. }
  239. }
  240. bottomrect_bottomrow+=2;
  241. centerrow++;
  242. if (bottomrect_bottomrow>=m_template_height) {
  243. toprect_toprow++;
  244. if (toprect_toprow==m_template_height-2) {
  245. rightcol++;
  246. if (rightcol==m_template_width) {
  247. leftcol++;
  248. if (leftcol==m_template_width-1) {
  249. return false;
  250. }
  251. rightcol=leftcol+1;
  252. }
  253. toprect_toprow=-1;
  254. }
  255. centerrow=toprect_toprow+1;
  256. bottomrect_bottomrow=centerrow+1;
  257. }
  258.     SetNonOverlap();
  259. return true;
  260. }
  262. CIntegralFeature* CUpDownSameIF::Copy() const
  263. {
  264. return new CUpDownSameIF(*this);
  265. }
  267. ostream& CUpDownSameIF::output(ostream& os) const
  268. {
  269.   os << "UpDownSame " << toprect_toprow << "," << centerrow 
  270.      << "," << bottomrect_bottomrow << " x ";
  271.   os << leftcol << "," << rightcol;
  272.   return os;
  273. }
  281. /////////////////////////////////////////////////////////////////////////////
  282. //
  283. // CLeftCenterRightSameIF classes implementation
  284. //
  285. /////////////////////////////////////////////////////////////////////////////
  287. CLeftCenterRightSameIF::CLeftCenterRightSameIF(int templateWidth, int templateHeight)
  288.   : CLeftCenterRightIF(templateWidth, templateHeight) 
  289. {
  290. }
  292. CLeftCenterRightSameIF::CLeftCenterRightSameIF(int templateWidth, int templateHeight,
  293.                                        int _toprow, int _bottomrow,
  294.                                        int _leftrect_leftcol, int _leftrect_rightcol,
  295.                                        int _rightrect_leftcol,
  296.                                        int _rightrect_rightcol)
  297.   : CLeftCenterRightIF(templateWidth, templateHeight) 
  298. {
  299.   toprow = _toprow;
  300.   bottomrow = _bottomrow;
  301.   leftrect_leftcol = _leftrect_leftcol;
  302.   leftrect_rightcol = _leftrect_rightcol;
  303.   rightrect_leftcol = _rightrect_leftcol;
  304.   rightrect_rightcol = _rightrect_rightcol;
  305.   SetNonOverlap();
  306. }
  308. CLeftCenterRightSameIF::CLeftCenterRightSameIF(const CLeftCenterRightSameIF& frm)
  309.   : CLeftCenterRightIF(frm) 
  310. {
  311. }
  313. CLeftCenterRightSameIF::CLeftCenterRightSameIF(istream& is, int templateWidth, int templateHeight)
  314.   : CLeftCenterRightIF(templateWidth, templateHeight) 
  315. {
  316.   char a, b, c;
  317.   string strx, strslash;
  318.   is >> toprow >> a >> bottomrow >> strx 
  319.      >> leftrect_leftcol >> b >> leftrect_rightcol >> strslash
  320.      >> rightrect_leftcol >> c >> rightrect_rightcol;
  321.   if (a!=',' || b!=',' || c!=',' || strx!="x" || strslash!="/") {
  322.     char* buf = (char*) alloca((256+strx.length()+strslash.length())*sizeof(char));
  323.     sprintf(buf, "error during construction of LeftCenterRightSameIF (%c|%c|%c|%s|%s)n",
  324.    a, b, c, strx.c_str(), strslash.c_str());
  325.     throw ITException(buf);
  326.   }
  327.   SetNonOverlap();
  328. }
  330. bool CLeftCenterRightSameIF::SetToNextIncarnation()
  331. {
  332. if (m_is_partial) {
  333. if (m_remaining_incarnations) {
  334. m_remaining_incarnations--;
  335. } else {
  336. return false;
  337. }
  338. }
  339. rightrect_rightcol+=3;
  340. rightrect_leftcol+=2;
  341. leftrect_rightcol++;
  342. if (rightrect_rightcol>=m_template_width) {
  343. leftrect_leftcol++;
  344. if (leftrect_leftcol==m_template_width-3) {
  345. bottomrow++;
  346. if (bottomrow==m_template_height) {
  347. toprow++;
  348. if (toprow==m_template_height-1) {
  349. return false;
  350. }
  351. bottomrow=toprow+1;
  352. }
  353. leftrect_leftcol=0;
  354. }
  355. leftrect_rightcol=leftrect_leftcol+1;
  356. rightrect_leftcol=leftrect_rightcol+1;
  357. rightrect_rightcol=rightrect_leftcol+1;
  358. }
  359.     SetNonOverlap();
  360. return true;
  361. }
  363. CIntegralFeature* CLeftCenterRightSameIF::Copy() const 
  364. {
  365.   return new CLeftCenterRightSameIF(*this);
  366. }
  368. ostream& CLeftCenterRightSameIF::output(ostream& os) const
  369. {
  370.   os << "LeftCenterRightSame " << toprow << "," << bottomrow << " x ";
  371.   os << leftrect_leftcol << "," << leftrect_rightcol << " / ";
  372.   os << rightrect_leftcol << "," << rightrect_rightcol;
  373.   return os;
  374. }
  379. /////////////////////////////////////////////////////////////////////////////
  380. //
  381. // CSevenColumnsSameIF classes implementation
  382. //
  383. /////////////////////////////////////////////////////////////////////////////
  385. CSevenColumnsSameIF::CSevenColumnsSameIF(int templateWidth, int templateHeight)
  386.   : CSevenColumnsIF(templateWidth, templateHeight) 
  387. {
  388. }
  390. CSevenColumnsSameIF::CSevenColumnsSameIF(int templateWidth, int templateHeight,
  391.                                  int _toprow, int _bottomrow,
  392.                                  int _1, int _2, int _3, int _4, int _5, int _6,
  393.                                  int _7, int _8)
  394.   : CSevenColumnsIF(templateWidth, templateHeight) 
  395. {
  396.   toprow = _toprow;
  397.   bottomrow = _bottomrow;
  398.   col1_left = _1;
  399.   col2_left = _2;
  400.   col3_left = _3;
  401.   col4_left = _4;
  402.   col5_left = _5;
  403.   col6_left = _6;
  404.   col7_left = _7;
  405.   col7_right = _8;
  406.   SetNonOverlap();
  407. }
  409. CSevenColumnsSameIF::CSevenColumnsSameIF(const CSevenColumnsSameIF& frm)
  410.   : CSevenColumnsIF(frm) 
  411. {
  412. }
  414. CSevenColumnsSameIF::CSevenColumnsSameIF(istream& is, int template_width, int template_height)
  415.   : CSevenColumnsIF(is, template_width, template_height)
  416. {
  417. }
  419. bool CSevenColumnsSameIF::SetToNextIncarnation()
  420. {
  421. if (m_is_partial) {
  422. if (m_remaining_incarnations) {
  423. m_remaining_incarnations--;
  424. } else {
  425. return false;
  426. }
  427. }
  428. col1_left += 1;
  429. col2_left += 2;
  430. col3_left += 3;
  431. col4_left += 4;
  432. col5_left += 5;
  433. col6_left += 6;
  434. col7_left += 7;
  435. col7_right += 8;
  436. if (col7_right>=m_template_width) {
  437.     col1_left ++;
  438.     if (col1_left>=m_template_width-7) {
  439.   bottomrow++;
  440.   if (bottomrow==m_template_height) {
  441.   toprow++;
  442.   if (toprow==m_template_height-1) {
  443.   return false;
  444.   }
  445.   bottomrow=toprow+1;
  446.   }
  447.       col1_left = -1;
  448.     }
  449.     col2_left = col1_left+1;
  450.     col3_left = col2_left+1;
  451.     col4_left = col3_left+1;
  452.     col5_left = col4_left+1;
  453.     col6_left = col5_left+1;
  454.     col7_left = col6_left+1;
  455.     col7_right= col7_left+1;
  456. }
  457.   SetNonOverlap();
  458. return true;
  459. }
  461. CIntegralFeature* CSevenColumnsSameIF::Copy() const
  462. {
  463. return new CSevenColumnsSameIF(*this);
  464. }
  466. ostream& CSevenColumnsSameIF::output(ostream& os) const
  467. {
  468.   os << "SevenColumnsSame " << toprow << "," << bottomrow << " x ";
  469.   os << col1_left << "," << col2_left << "," << col3_left << "," << col4_left << ",";
  470.   os << col5_left << "," << col6_left << "," << col7_left << "," << col7_right;
  471.   return os;
  472. }
  477. /////////////////////////////////////////////////////////////////////////////
  478. //
  479. // CSevenColumnsSimilarIF classes implementation
  480. //
  481. /////////////////////////////////////////////////////////////////////////////
  483. CSevenColumnsSimilarIF::CSevenColumnsSimilarIF(int templateWidth, int templateHeight)
  484.   : CSevenColumnsIF(templateWidth, templateHeight) 
  485. {
  486. }
  488. CSevenColumnsSimilarIF::CSevenColumnsSimilarIF(int templateWidth, int templateHeight,
  489.                                  int _toprow, int _bottomrow,
  490.                                  int _1, int _2, int _3, int _4, int _5, int _6,
  491.                                  int _7, int _8)
  492.   : CSevenColumnsIF(templateWidth, templateHeight) 
  493. {
  494.   toprow = _toprow;
  495.   bottomrow = _bottomrow;
  496.   col1_left = _1;
  497.   col2_left = _2;
  498.   col3_left = _3;
  499.   col4_left = _4;
  500.   col5_left = _5;
  501.   col6_left = _6;
  502.   col7_left = _7;
  503.   col7_right = _8;
  504.   SetNonOverlap();
  505. }
  507. CSevenColumnsSimilarIF::CSevenColumnsSimilarIF(const CSevenColumnsSimilarIF& frm)
  508.   : CSevenColumnsIF(frm) 
  509. {
  510. }
  512. CSevenColumnsSimilarIF::CSevenColumnsSimilarIF(istream& is, int template_width, int template_height)
  513.   : CSevenColumnsIF(is, template_width, template_height)
  514. {
  515. }
  517. bool CSevenColumnsSimilarIF::SetToNextIncarnation()
  518. {
  519. if (m_is_partial) {
  520. if (m_remaining_incarnations) {
  521. m_remaining_incarnations--;
  522. } else {
  523. return false;
  524. }
  525. }
  526. col2_left += 1;
  527. col3_left += 1;
  528. col4_left += 2;
  529. col5_left += 2;
  530. col6_left += 3;
  531. col7_left += 3;
  532. col7_right+= 4;
  533. if (col7_right>=m_template_width) {
  534. int new_even_width = col3_left-col2_left+1;
  535. col2_left = col1_left+1;
  536. col3_left = col2_left+new_even_width;
  537. col4_left = col3_left+1;
  538. col5_left = col4_left+new_even_width;
  539. col6_left = col5_left+1;
  540. col7_left = col6_left+new_even_width;
  541. col7_right= col7_left+1;
  542. if (col7_right>=m_template_width) {
  543. col1_left += 1;
  544. if (col1_left>=m_template_width-7) {
  545. bottomrow++;
  546. if (bottomrow==m_template_height) {
  547. toprow++;
  548. if (toprow==m_template_height-1) {
  549. return false;
  550. }
  551. bottomrow = toprow+1;
  552. }
  553. col1_left = -1;
  554. }
  555. col2_left = col1_left+1;
  556. col3_left = col2_left+1;
  557. col4_left = col3_left+1;
  558. col5_left = col4_left+1;
  559. col6_left = col5_left+1;
  560. col7_left = col6_left+1;
  561. col7_right = col7_left+1;
  562. }
  563. }
  564. SetNonOverlap();
  565. return true;
  566. }
  568. CIntegralFeature* CSevenColumnsSimilarIF::Copy() const
  569. {
  570. return new CSevenColumnsSimilarIF(*this);
  571. }
  573. ostream& CSevenColumnsSimilarIF::output(ostream& os) const
  574. {
  575.   os << "SevenColumnsSimilar " << toprow << "," << bottomrow << " x ";
  576.   os << col1_left << "," << col2_left << "," << col3_left << "," << col4_left << ",";
  577.   os << col5_left << "," << col6_left << "," << col7_left << "," << col7_right;
  578.   return os;
  579. }
  585. /////////////////////////////////////////////////////////////////////////////
  586. //
  587. // CDiagSameIF classes implementation
  588. //
  589. /////////////////////////////////////////////////////////////////////////////
  591. CDiagSameIF::CDiagSameIF(int templateWidth, int templateHeight)
  592.   : CDiagIF(templateWidth, templateHeight) 
  593. {
  594. }
  596. CDiagSameIF::CDiagSameIF(int templateWidth, int templateHeight,
  597.         int _toprect_toprow, int _centerrow,
  598.         int _bottomrect_bottomrow,
  599.         int _leftrect_leftcol, int _centercol,
  600.         int _rightrect_rightcol)
  601.   : CDiagIF(templateWidth, templateHeight) 
  602. {
  603.   toprect_toprow = _toprect_toprow;
  604.   centerrow = _centerrow;
  605.   bottomrect_bottomrow = _bottomrect_bottomrow;
  606.   leftrect_leftcol = _leftrect_leftcol;
  607.   centercol = _centercol;
  608.   rightrect_rightcol = _rightrect_rightcol;
  609.   SetNonOverlap();
  610. }
  612. CDiagSameIF::CDiagSameIF(const CDiagSameIF& frm)
  613.   : CDiagIF(frm) 
  614. {
  615. }
  617. CDiagSameIF::CDiagSameIF(istream& is, int templateWidth, int templateHeight)
  618.   : CDiagIF(templateWidth, templateHeight) 
  619. {
  620.   char a, b, c, d;
  621.   string str;
  622.   is >> toprect_toprow >> a >> centerrow >> b
  623.      >> bottomrect_bottomrow >> str
  624.      >> leftrect_leftcol >> c >> centercol >> d
  625.      >> rightrect_rightcol;
  626.   if (a!=',' || b!=',' || str!="x" || c!=',' || d!=',') {
  627.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  628.     sprintf(buf, "error during construction of DiagSameIF (%c|%c|%s|%c|%c)n",
  629.    a, b, str.c_str(), c, d);
  630.     throw ITException(buf);
  631.   }
  632.   SetNonOverlap();
  633. }
  635. bool CDiagSameIF::SetToNextIncarnation()
  636. {
  637.   if (m_is_partial) {
  638.     if (m_remaining_incarnations) {
  639.       m_remaining_incarnations--;
  640.     } else {
  641.       return false;
  642.     }
  643.   }
  644.   bottomrect_bottomrow+=2;
  645.   centerrow++;
  646.   if (bottomrect_bottomrow>=m_template_height) {
  647.     toprect_toprow++;
  648.     if (toprect_toprow==m_template_height-2) {
  649.       rightrect_rightcol+=2;
  650.       centercol++;
  651.       if (rightrect_rightcol>=m_template_width) {
  652. leftrect_leftcol++;
  653. if (leftrect_leftcol==m_template_width-2) {
  654.   return false;
  655. }
  656. centercol=leftrect_leftcol+1;
  657. rightrect_rightcol=centercol+1;
  658.       }
  659.       toprect_toprow=-1;
  660.     }
  661.     centerrow=toprect_toprow+1;
  662.     bottomrect_bottomrow=centerrow+1;
  663.   }
  664.   SetNonOverlap();
  665.   return true;
  666. }
  668. CIntegralFeature* CDiagSameIF::Copy() const
  669. {
  670.   return new CDiagSameIF(*this);
  671. }
  673. ostream& CDiagSameIF::output(ostream& os) const
  674. {
  675.   os << "DiagSame " << toprect_toprow << "," << centerrow 
  676.      << "," << bottomrect_bottomrow << " x ";
  677.   os << leftrect_leftcol << "," << centercol
  678.      << "," << rightrect_rightcol;
  679.   return os;
  680. }
  688. /////////////////////////////////////////////////////////////////////////////
  689. //
  690. // CDiagSimilarIF classes implementation
  691. //
  692. /////////////////////////////////////////////////////////////////////////////
  694. CDiagSimilarIF::CDiagSimilarIF(int templateWidth, int templateHeight)
  695.   : CDiagIF(templateWidth, templateHeight) 
  696. {
  697. }
  699. CDiagSimilarIF::CDiagSimilarIF(int templateWidth, int templateHeight,
  700.         int _toprect_toprow, int _centerrow,
  701.         int _bottomrect_bottomrow,
  702.         int _leftrect_leftcol, int _centercol,
  703.         int _rightrect_rightcol)
  704.   : CDiagIF(templateWidth, templateHeight) 
  705. {
  706.   toprect_toprow = _toprect_toprow;
  707.   centerrow = _centerrow;
  708.   bottomrect_bottomrow = _bottomrect_bottomrow;
  709.   leftrect_leftcol = _leftrect_leftcol;
  710.   centercol = _centercol;
  711.   rightrect_rightcol = _rightrect_rightcol;
  712.   SetNonOverlap();
  713. }
  715. CDiagSimilarIF::CDiagSimilarIF(const CDiagSimilarIF& frm)
  716.   : CDiagIF(frm) 
  717. {
  718. }
  720. CDiagSimilarIF::CDiagSimilarIF(istream& is, int templateWidth, int templateHeight)
  721.   : CDiagIF(templateWidth, templateHeight) 
  722. {
  723.   char a, b, c, d;
  724.   string str;
  725.   is >> toprect_toprow >> a >> centerrow >> b
  726.      >> bottomrect_bottomrow >> str
  727.      >> leftrect_leftcol >> c >> centercol >> d
  728.      >> rightrect_rightcol;
  729.   if (a!=',' || b!=',' || str!="x" || c!=',' || d!=',') {
  730.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  731.     sprintf(buf, "error during construction of DiagSimilarIF (%c|%c|%s|%c|%c)n",
  732.    a, b, str.c_str(), c, d);
  733.     throw ITException(buf);
  734.   }
  735.   SetNonOverlap();
  736. }
  738. bool CDiagSimilarIF::SetToNextIncarnation()
  739. {
  740.   if (m_is_partial) {
  741.     if (m_remaining_incarnations) {
  742.       m_remaining_incarnations--;
  743.     } else {
  744.       return false;
  745.     }
  746.   }
  747.   bottomrect_bottomrow+=2;
  748.   centerrow++;
  749.   if (bottomrect_bottomrow>=m_template_height) {
  750.     toprect_toprow++;
  751.     if (toprect_toprow==m_template_height-2) {
  752.       rightrect_rightcol++;
  753.       if (rightrect_rightcol==m_template_width) {
  754. centercol++;
  755. if (centercol==m_template_width-1) {
  756.   leftrect_leftcol++;
  757.   if (leftrect_leftcol==m_template_width-2) {
  758.     return false;
  759.   }
  760.   centercol=leftrect_leftcol+1;
  761. }
  762. rightrect_rightcol=centercol+1;
  763.       }
  764.       toprect_toprow=-1;
  765.     }
  766.     centerrow=toprect_toprow+1;
  767.     bottomrect_bottomrow=centerrow+1;
  768.   }
  769.   SetNonOverlap();
  770.   return true;
  771. }
  773. CIntegralFeature* CDiagSimilarIF::Copy() const
  774. {
  775.   return new CDiagSimilarIF(*this);
  776. }
  778. ostream& CDiagSimilarIF::output(ostream& os) const
  779. {
  780.   os << "DiagSimilar " << toprect_toprow << "," << centerrow 
  781.      << "," << bottomrect_bottomrow << " x ";
  782.   os << leftrect_leftcol << "," << centercol
  783.      << "," << rightrect_rightcol;
  784.   return os;
  785. }
  788. /////////////////////////////////////////////////////////////////////////////
  789. //
  790. // CFourBoxesSameIF classes implementation
  791. //
  792. /////////////////////////////////////////////////////////////////////////////
  794. CFourBoxesSameIF::CFourBoxesSameIF(int templateWidth, int templateHeight)
  795.   : CFourBoxesIF(templateWidth, templateHeight) 
  796. {
  797. }
  799. CFourBoxesSameIF::CFourBoxesSameIF(int templateWidth, int templateHeight,
  800.              const CRect* pB1, const CRect* pB2,
  801.              const CRect* pB3, const CRect* pB4)
  802.   : CFourBoxesIF(templateWidth, templateHeight) 
  803. {
  804.   b1_left = pB1->left;  b1_top = pB1->top;
  805.   b1_right = pB1->right;  b1_bottom = pB1->bottom;
  806.   b2_left = pB2->left;  b2_top = pB2->top;
  807.   b2_right = pB2->right;  b2_bottom = pB2->bottom;
  808.   b3_left = pB3->left;  b3_top = pB3->top;
  809.   b3_right = pB3->right;  b3_bottom = pB3->bottom;
  810.   b4_left = pB4->left;  b4_top = pB4->top;
  811.   b4_right = pB4->right;  b4_bottom = pB4->bottom;
  812.   SetNonOverlap();
  813. }
  815. CFourBoxesSameIF::CFourBoxesSameIF(const CFourBoxesSameIF& frm)
  816.   : CFourBoxesIF(frm)
  817. {
  818. }
  820. CFourBoxesSameIF::CFourBoxesSameIF(istream& is, int template_width, int template_height)
  821.   : CFourBoxesIF(template_width, template_height)
  822. {
  823.   char a, b, c, d, e, f;
  824.   is >> e >> b1_left >> a >> b1_top >> b >> b1_right >> c >> b1_bottom >> f >> d;
  825.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  826.     char* buf = (char*) alloca(256*sizeof(char));
  827.     sprintf(buf, "error during construction of FourBoxesSameIF (%c|%c|%c|%c|%c)n",
  828.    e, a, b, c, f);
  829.     throw ITException(buf);
  830.   }
  831.   is >> e >> b2_left >> a >> b2_top >> b >> b2_right >> c >> b2_bottom >> f >> d;
  832.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  833.     char* buf = (char*) alloca(256*sizeof(char));
  834.     sprintf(buf, "error during construction of FourBoxesSameIF (%c|%c|%c|%c|%c)n",
  835.    e, a, b, c, f);
  836.     throw ITException(buf);
  837.   }
  838.   is >> e >> b3_left >> a >> b3_top >> b >> b3_right >> c >> b3_bottom >> f >> d;
  839.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  840.     char* buf = (char*) alloca(256*sizeof(char));
  841.     sprintf(buf, "error during construction of FourBoxesSameIF (%c|%c|%c|%c|%c)n",
  842.    e, a, b, c, f);
  843.     throw ITException(buf);
  844.   }
  845.   is >> e >> b4_left >> a >> b4_top >> b >> b4_right >> c >> b4_bottom >> f;
  846.   if (a!=',' || b!=',' || c!=',' || e!='(' || f!=')') {
  847.     char* buf = (char*) alloca(256*sizeof(char));
  848.     sprintf(buf, "error during construction of FourBoxesSameIF (%c|%c|%c|%c|%c)n",
  849.    e, a, b, c, f);
  850.     throw ITException(buf);
  851.   }
  852.   SetNonOverlap();
  853. }
  855. void CFourBoxesSameIF::SetToFirstIncarnation()
  856. {
  857.   if (m_is_partial) {
  858.     b1_left = start_b1_left;  b1_top = start_b1_top;
  859.     b1_right = start_b1_right;  b1_bottom = start_b1_bottom;
  860.     b2_left = start_b2_left;  b2_top = start_b2_top;
  861.     b2_right = start_b2_right;  b2_bottom = start_b2_bottom;
  862.     b3_left = start_b3_left;  b3_top = start_b3_top;
  863.     b3_right = start_b3_right;  b3_bottom = start_b3_bottom;
  864.     b4_left = start_b4_left;  b4_top = start_b4_top;
  865.     b4_right = start_b4_right;  b4_bottom = start_b4_bottom;
  866.     m_remaining_incarnations = m_stop_after_num_incarnations;
  867.   } else {
  868.     b1_left  =-1;  b1_top    = 0;
  869.     b1_right = 1;  b1_bottom = 2;
  870.     b2_left  = 0;  b2_top    = 2;
  871.     b2_right = 2;  b2_bottom = 4;
  872.     b3_left  = 0;  b3_top    =-1;
  873.     b3_right = 2;  b3_bottom = 1;
  874.     b4_left  = 1;  b4_top    = 0;
  875.     b4_right = 3;  b4_bottom = 2;
  876.   }
  877.   SetNonOverlap();
  878. }
  880. bool CFourBoxesSameIF::SetToNextIncarnation()
  881. {
  882. if (m_is_partial) {
  883. if (m_remaining_incarnations) {
  884. m_remaining_incarnations--;
  885. } else {
  886. return false;
  887. }
  888. }
  889.         
  890.   int width = b1_right-b1_left;
  891.   b2_right++;
  892.   b2_left++;
  893.   b3_right++;
  894.   b3_left++;
  895.   if (b3_right>=m_template_width-2 || b3_left>=b1_right) {
  896.     b1_right++;
  897.     b1_left++;
  898.     b4_right++;
  899.     b4_left++;
  900.     if (b1_right>=m_template_width-3) {
  901.       int height = b1_bottom-b1_top;
  902.       b3_bottom++;
  903.       b3_top++;
  904.       b4_bottom++;
  905.       b4_top++;
  906.       if (b3_bottom>=m_template_height-3) {
  907.         b1_bottom++;
  908.         b1_top++;
  909.         b2_bottom++;
  910.         b2_top++;
  911.         if (b1_bottom>=m_template_height-2 || b1_top>=b3_bottom) {
  912.           width++;
  913.           if (width>m_template_width-3) {
  914.             height++;
  915.             if (height>m_template_height-2) {
  916.               return false;
  917.             }
  918.             width = 2;
  919.           }
  920.           b1_top = 0; b1_bottom = b1_top+height;
  921.           b2_top = 1; b2_bottom = b2_top+height;
  922.         }
  923.         b3_top =-1; b3_bottom = b3_top+height;
  924.         b4_top = 1; b4_bottom = b4_top+height;
  925.       }
  926.       b1_left =-1; b1_right = b1_left+width;
  927.       b4_left = 1; b4_right = b4_left+width;
  928.     }
  929.     b3_left = 0; b3_right = b3_left+width;
  930.     b2_left = 0; b2_right = b2_left+width;
  931.   }
  932.   SetNonOverlap();
  933. return true;
  934. }
  936. CIntegralFeature* CFourBoxesSameIF::Copy() const
  937. {
  938. return new CFourBoxesSameIF(*this);
  939. }
  941. ostream& CFourBoxesSameIF::output(ostream& os) const
  942. {
  943.   os << "FourBoxesSame " 
  944.      << "(" << b1_left << "," << b1_top << "," << b1_right << "," << b1_bottom << "),"
  945.      << "(" << b2_left << "," << b2_top << "," << b2_right << "," << b2_bottom << "),"
  946.      << "(" << b3_left << "," << b3_top << "," << b3_right << "," << b3_bottom << "),"
  947.      << "(" << b4_left << "," << b4_top << "," << b4_right << "," << b4_bottom << ")";
  948.   return os;
  949. }