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

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

视频捕捉/采集

开发平台：

MultiPlatform

IntegralFeatures.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: IntegralFeatures.cpp,v 1.61 2005/10/28 17:47:04 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. // Functions for reading from files are flex/bison generated from
  19. // CascadeFileScanner.lex and CascadeFileParser.yy.
  20. //
  22. ////////////////////////////////////////////////////////////////////
  23. //
  24. // By downloading, copying, installing or using the software you 
  25. // agree to this license.  If you do not agree to this license, 
  26. // do not download, install, copy or use the software.
  27. //
  28. // Copyright (C) 2004, Mathias Kolsch, all rights reserved.
  29. // Third party copyrights are property of their respective owners.
  30. //
  31. // Redistribution and use in binary form, with or without 
  32. // modification, is permitted for non-commercial purposes only.
  33. // Redistribution in source, with or without modification, is 
  34. // prohibited without prior written permission.
  35. // If granted in writing in another document, personal use and 
  36. // modification are permitted provided that the following two
  37. // conditions are met:
  38. //
  39. // 1.Any modification of source code must retain the above 
  40. //   copyright notice, this list of conditions and the following 
  41. //   disclaimer.
  42. //
  43. // 2.Redistribution's in binary form must reproduce the above 
  44. //   copyright notice, this list of conditions and the following 
  45. //   disclaimer in the documentation and/or other materials provided
  46. //   with the distribution.
  47. //
  48. // This software is provided by the copyright holders and 
  49. // contributors "as is" and any express or implied warranties, 
  50. // including, but not limited to, the implied warranties of 
  51. // merchantability and fitness for a particular purpose are 
  52. // disclaimed.  In no event shall the copyright holder or 
  53. // contributors be liable for any direct, indirect, incidental, 
  54. // special, exemplary, or consequential damages (including, but not 
  55. // limited to, procurement of substitute goods or services; loss of 
  56. // use, data, or profits; or business interruption) however caused
  57. // and on any theory of liability, whether in contract, strict 
  58. // liability, or tort (including negligence or otherwise) arising 
  59. // in any way out of the use of this software, even if advised of 
  60. // the possibility of such damage.
  61. //
  62. ////////////////////////////////////////////////////////////////////
  65. #include "cubicles.hpp"
  66. #include "IntegralFeatures.h"
  67. #include "Exceptions.h"
  68. #include <math.h>
  69. #include <iostream>
  72. #ifdef _DEBUG
  73. #ifdef USE_MFC
  74. #define new DEBUG_NEW
  75. #undef THIS_FILE
  76. static char THIS_FILE[] = __FILE__;
  77. #endif // USE_MFC
  78. #endif // _DEBUG
  80. #if defined(WIN32) && defined(DEBUG)
  81. #include <streams.h>
  82. #endif
  85. #ifdef USE_MFC
  86. CBrush* g_pBlackbrush = NULL;
  87. CBrush* g_pWhitebrush = NULL;
  88. #endif // USE_MFC
  91. int g_verbose = 0;
  92. FILE* g_ostream = stdout;
  94. #ifdef WIN32
  95. #include <malloc.h>
  96. #define alloca _alloca
  97. #endif
  100. /////////////////////////////////////////////////////////////////////////////
  101. //
  102. // CIntegralFeature implementation
  103. //
  104. /////////////////////////////////////////////////////////////////////////////
  106. const II_TYPE CIntegralFeature::SCALE_DIFFERENCE_EPSILON = .000000001;
  108. CIntegralFeature::CIntegralFeature(int templateWidth, int templateHeight,
  109.                                    featnum num_incarnations, bool is_partial,
  110.                                    int cost)
  111. : m_template_width(templateWidth),
  112. m_template_height(templateHeight),
  113. m_num_incarnations(num_incarnations),
  114. m_is_partial(is_partial),
  115.   m_cost(cost)
  116. {
  117. #ifdef USE_MFC
  118.   if (g_pBlackbrush==NULL) {
  119.     ASSERT(g_pWhitebrush==NULL);
  120.     g_pWhitebrush = new CBrush(RGB(255, 255, 255));
  121.     g_pBlackbrush = new CBrush(RGB(0, 0, 0));
  122.   }
  123. #endif // USE_MFC
  124. }
  126. ostream& operator<<(ostream& os, const CIntegralFeature& clsf)
  127. {
  128.   return clsf.output(os);
  129. }
  131. CIntegralFeature* CIntegralFeature::CreateFrom(istream& is,
  132.        int template_width, int template_height)
  133. {
  134.   CIntegralFeature* feature = NULL;
  135.   string subclass;
  136.   is >> subclass;
  137.   if (subclass=="LeftRight") {
  138.     feature = new CLeftRightIF(is, template_width, template_height);
  140.   } else if (subclass=="UpDown") {
  141.     feature = new CUpDownIF(is, template_width, template_height);
  143.   } else if (subclass=="LeftCenterRight") {
  144.     feature = new CLeftCenterRightIF(is, template_width, template_height);
  146.   } else if (subclass=="SevenColumns") {
  147.     feature = new CSevenColumnsIF(is, template_width, template_height);
  149.   } else if (subclass=="Diag") {
  150.     feature = new CDiagIF(is, template_width, template_height);
  152.   } else if (subclass=="LeftRightSame") {
  153.     feature = new CLeftRightSameIF(is, template_width, template_height);
  155.   } else if (subclass=="UpDownSame") {
  156.     feature = new CUpDownSameIF(is, template_width, template_height);
  158.   } else if (subclass=="LeftCenterRightSame") {
  159.     feature = new CLeftCenterRightSameIF(is, template_width, template_height);
  161.   } else if (subclass=="SevenColumnsSame") {
  162.     feature = new CSevenColumnsSameIF(is, template_width, template_height);
  164.   } else if (subclass=="SevenColumnsSimilar") {
  165.     feature = new CSevenColumnsSimilarIF(is, template_width, template_height);
  167.   } else if (subclass=="DiagSame") {
  168.     feature = new CDiagSameIF(is, template_width, template_height);
  170.   } else if (subclass=="DiagSimilar") {
  171.     feature = new CDiagSimilarIF(is, template_width, template_height);
  173.   } else if (subclass=="FourBoxes") {
  174.     feature = new CFourBoxesIF(is, template_width, template_height);
  176.   } else if (subclass=="FourBoxesSame") {
  177.     feature = new CFourBoxesSameIF(is, template_width, template_height);
  179.   } else {
  180.     // error
  181.     VERBOSE1(1, "can not create IntegralFeature from string '%s'.", 
  182.      subclass.c_str());
  183.     ASSERT(0);
  184.   }
  185.   return feature;
  186. }
  189. /* use ScaleEvenly to scale by non-integer values, otherwise use
  190. * Scale
  191. */
  192. void CIntegralFeature::ScaleEvenly(II_TYPE scale_x, II_TYPE scale_y, 
  193.                                    int scaled_template_width, int scaled_template_height)
  194. {
  195.   Scale(scale_x, scale_y);
  196.   EvenOutScales(&scale_x, &scale_y, scaled_template_width, scaled_template_height);
  197.   m_global_scale = scale_x*scale_y;
  198. }
  200. featnum CIntegralFeature::GetNumIncarnations() const
  201. {
  202.   if (m_num_incarnations==IT_INVALID_FEATURE) {
  203.     // count some other feature, we don't want to change
  204.     // this one at all.
  205.     CIntegralFeature* counter = this->Copy();
  206.     counter->SetToFirstIncarnation();
  207.     featnum cnt = 0;
  208.     bool has_more_incarnations = true;
  209.     do {
  210.       cnt++;
  211.       if (cnt==IT_MAX_VALID_FEATURE) {
  212.         throw ITException("int overflow in GetNumIncarnations()");
  213.       }
  214.       has_more_incarnations = counter->SetToNextIncarnation();
  215.     } while (has_more_incarnations);
  216.     ((CIntegralFeature*) this)->m_num_incarnations = cnt;
  217.     delete counter;
  218.   }
  219.   ASSERT(m_num_incarnations>=0 && 
  220.  m_num_incarnations!=IT_INVALID_FEATURE);
  221.   return m_num_incarnations;
  222. }
  227. /////////////////////////////////////////////////////////////////////////////
  228. //
  229. // CLeftRightIF classes implementation
  230. //
  231. /////////////////////////////////////////////////////////////////////////////
  233. CLeftRightIF::CLeftRightIF(int templateWidth, int templateHeight)
  234.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, 
  235.      false, 6*COST_GET+7*COST_ADD) 
  236. {
  237. }
  239. CLeftRightIF::CLeftRightIF(const CLeftRightIF& frm)
  240.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  241.      frm.m_num_incarnations, frm.m_is_partial, 6*COST_GET+7*COST_ADD) 
  242. {
  243.   toprow = frm.toprow;
  244.   bottomrow = frm.bottomrow;
  245.   leftrect_leftcol = frm.leftrect_leftcol;
  246.   centercol = frm.centercol;
  247.   rightrect_rightcol = frm.rightrect_rightcol;
  248.   if (m_is_partial) {
  249.     start_toprow = frm.start_toprow;
  250.     start_bottomrow = frm.start_bottomrow;
  251.     start_leftrect_leftcol = frm.start_leftrect_leftcol;
  252.     start_centercol = frm.start_centercol;
  253.     start_rightrect_rightcol = frm.start_rightrect_rightcol;
  254.     m_remaining_incarnations = frm.m_remaining_incarnations;
  255.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  256.   }
  257.   SetNonOverlap();
  258. }
  260. CLeftRightIF::CLeftRightIF(int template_width, int template_height,
  261.                            int _toprow, int _bottomrow,
  262.                            int _leftrect_leftcol, int _centercol,
  263.                            int _rightrect_rightcol)
  264.   : CIntegralFeature(template_width, template_height, IT_INVALID_FEATURE, 0, 6*COST_GET+7*COST_ADD)
  265. {
  266.   toprow = _toprow;
  267.   bottomrow = _bottomrow;
  268.   leftrect_leftcol = _leftrect_leftcol;
  269.   centercol = _centercol;
  270.   rightrect_rightcol = _rightrect_rightcol;
  271.   SetNonOverlap();
  272. }
  274. CLeftRightIF::CLeftRightIF(istream& is, int template_width, int template_height)
  275.   : CIntegralFeature(template_width, template_height, IT_INVALID_FEATURE, 0, 6*COST_GET+7*COST_ADD)
  276. {
  277.   char a, b, c;
  278.   string str;
  279.   is >> toprow >> a >> bottomrow >> str
  280.      >> leftrect_leftcol >> b >> centercol >> c >> rightrect_rightcol;
  281.   if (a!=',' || b!=',' || c!=',' || str!="x") {
  282.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  283.     sprintf(buf, "error during construction of LeftRightIF (%c|%c|%c|%s)n",
  284.    a, b, c, str.c_str());
  285.     throw ITException(buf);
  286.   }
  287.   SetNonOverlap();
  288. }
  290. bool CLeftRightIF::Equals(const CLeftRightIF& frm) const
  291. {
  292.   bool equal = 
  293.     (toprow == frm.toprow &&
  294.      bottomrow == frm.bottomrow &&
  295.      leftrect_leftcol == frm.leftrect_leftcol &&
  296.      centercol == frm.centercol &&
  297.      rightrect_rightcol == frm.rightrect_rightcol);
  298.   return equal;
  299. }
  301. void CLeftRightIF::SetNonOverlap() {
  302.   m_non_overlap =
  303.     ((centercol-leftrect_leftcol) - (rightrect_rightcol-centercol))
  304.     * (bottomrow-toprow);
  305. }
  307. II_TYPE CLeftRightIF::Compute(const CIntegralImage& image) const
  308. {
  309. II_TYPE botcen = image.GetElement(centercol, bottomrow);
  310. ASSERT(!isnan(botcen));
  311. II_TYPE topcen = image.GetElement(centercol, toprow);
  312. ASSERT(!isnan(topcen));
  314. II_TYPE val_leftrect = 
  315. botcen
  316. - image.GetElement(leftrect_leftcol, bottomrow)
  317. - topcen
  318. + image.GetElement(leftrect_leftcol, toprow);
  319. ASSERT(!isnan(val_leftrect));
  321. II_TYPE val_rightrect = 
  322. image.GetElement(rightrect_rightcol, bottomrow)
  323. - botcen
  324. - image.GetElement(rightrect_rightcol, toprow)
  325. + topcen;
  326. ASSERT(!isnan(val_rightrect));
  328. ASSERT(!isnan(val_leftrect-val_rightrect));
  329. return val_leftrect-val_rightrect;
  330. }
  332. II_TYPE CLeftRightIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  333. {
  334. int placed_toprow = top + scaled_toprow;
  335. int placed_bottomrow = top + scaled_bottomrow;
  336. int placed_leftrect_leftcol = left + scaled_leftrect_leftcol;
  337. int placed_centercol = left + scaled_centercol;
  338. int placed_rightrect_rightcol = left + scaled_rightrect_rightcol;
  340. II_TYPE botcen = image.GetElement(placed_centercol, placed_bottomrow);
  341. II_TYPE topcen = image.GetElement(placed_centercol, placed_toprow);
  343. II_TYPE val_leftrect = 
  344. botcen
  345. - image.GetElement(placed_leftrect_leftcol, placed_bottomrow)
  346. - topcen
  347. + image.GetElement(placed_leftrect_leftcol, placed_toprow);
  349. II_TYPE val_rightrect = 
  350. image.GetElement(placed_rightrect_rightcol, placed_bottomrow)
  351. - botcen
  352. - image.GetElement(placed_rightrect_rightcol, placed_toprow)
  353. + topcen;
  355. II_TYPE val = val_leftrect-val_rightrect;
  356. II_TYPE scaled_val = val/m_global_scale;
  357. II_TYPE mean_adjust = m_non_overlap*mean;
  359.   return scaled_val-mean_adjust;
  360. }
  362. void CLeftRightIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  363. {
  364.   if (toprow==-1) {
  365.     scaled_toprow = -1;
  366.     scaled_bottomrow = (int)((II_TYPE)(bottomrow+1)*scale_y) - 1;
  367.   } else {
  368.     scaled_toprow = (int)((II_TYPE)toprow*scale_y);
  369.     scaled_bottomrow = (int)((II_TYPE)bottomrow*scale_y);
  370.   }
  371.   if (leftrect_leftcol==-1) {
  372.     scaled_leftrect_leftcol = -1;
  373.     scaled_centercol = (int)((II_TYPE)(centercol+1)*scale_x) - 1;
  374.     scaled_rightrect_rightcol =
  375.       (int)((II_TYPE)(rightrect_rightcol-centercol)*scale_x) + scaled_centercol;
  376.   } else {
  377.     scaled_leftrect_leftcol = (int)((II_TYPE)leftrect_leftcol*scale_x);
  378.     scaled_centercol = (int)((II_TYPE)centercol*scale_x);
  379.     scaled_rightrect_rightcol = (int)((II_TYPE)rightrect_rightcol*scale_x);
  380.   }
  382.   m_global_scale = scale_x*scale_y;
  383. }
  385. void CLeftRightIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  386.         int scaled_template_width, int /*scaled_template_height*/)
  387. {
  388.   int leftrect = centercol-leftrect_leftcol;
  389.   int rightrect = rightrect_rightcol-centercol;
  390.   II_TYPE ratio = (II_TYPE)leftrect/(II_TYPE)rightrect;
  391.   int sleftrect = scaled_centercol-scaled_leftrect_leftcol;
  392.   int srightrect = scaled_rightrect_rightcol-scaled_centercol;
  393.   II_TYPE sratio = (II_TYPE)sleftrect/(II_TYPE)srightrect;
  395.   int scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  396.   bool too_wide = scaled_width > scaled_template_width;
  398.   while (!too_wide && fabs(ratio-sratio)>=SCALE_DIFFERENCE_EPSILON) {
  399.     if (ratio<sratio) {
  400.       scaled_rightrect_rightcol++;
  401.       srightrect++;
  402.     } else {
  403.       scaled_centercol++;
  404.       scaled_rightrect_rightcol++;
  405.       sleftrect++;
  406.     }
  407.     scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  408.     too_wide = scaled_width > scaled_template_width;
  410.     sratio = (II_TYPE)sleftrect/(II_TYPE)srightrect;
  411.   }
  413.   int overlap = scaled_rightrect_rightcol-scaled_template_width+1;
  414.   // overlap: by how much is rightmost too far to the right? 
  415.   // it must not be larger than scaled_template_width-1
  416.   if (overlap>0) {
  417.     // went outside template boundaries
  418.     if (too_wide) {
  419.       // feature too big, use int scale
  420.       *pScale_x = floor(*pScale_x);
  421.       Scale(*pScale_x, *pScale_y);
  422.     } else {
  423.       // shift feature by overlap
  424.       scaled_leftrect_leftcol -= overlap;
  425.       scaled_centercol -= overlap;
  426.       scaled_rightrect_rightcol -= overlap;
  427.       *pScale_x = sratio;
  428.     }
  429.   } else {
  430.     *pScale_x = sratio;
  431.   }
  432. }
  434. void CLeftRightIF::SetToFirstIncarnation()
  435. {
  436.   if (m_is_partial) {
  437.     toprow=start_toprow;
  438.     bottomrow=start_bottomrow;
  439.     leftrect_leftcol=start_leftrect_leftcol;
  440.     centercol=start_centercol;
  441.     rightrect_rightcol=start_rightrect_rightcol;
  442.     m_remaining_incarnations=m_stop_after_num_incarnations;
  443.   } else {
  444.     toprow=-1;
  445.     bottomrow=0;
  446.     leftrect_leftcol=-1;
  447.     centercol=0;
  448.     rightrect_rightcol=1;
  449.   }
  450.   SetNonOverlap();
  451. }
  453. bool CLeftRightIF::SetToNextIncarnation()
  454. {
  455.   if (m_is_partial) {
  456.     if (m_remaining_incarnations) {
  457.       m_remaining_incarnations--;
  458.     } else {
  459.       return false;
  460.     }
  461.   }
  462.   rightrect_rightcol++;
  463.   if (rightrect_rightcol>=m_template_width) {
  464.     centercol++;
  465.     if (centercol>=m_template_width-1) {
  466.       leftrect_leftcol++;
  467.       if (leftrect_leftcol==m_template_width-2) {
  468. bottomrow++;
  469. if (bottomrow==m_template_height) {
  470.   toprow++;
  471.   if (toprow==m_template_height-1) {
  472.     return false;
  473.   }
  474.   bottomrow=toprow+1;
  475. }
  476. leftrect_leftcol=-1;
  477.       }
  478.       centercol=leftrect_leftcol+1;
  479.     }
  480.     rightrect_rightcol=centercol+1;
  481.   }
  482.   SetNonOverlap();
  483.   return true;
  484. }
  486. CIntegralFeature* CLeftRightIF::Copy() const
  487. {
  488.   return new CLeftRightIF(*this);
  489. }
  491. void CLeftRightIF::MakePartialFromCurrentForNumIncarnations(
  492.   featnum num)
  493. {
  494.   m_is_partial=true;
  495.   m_num_incarnations=num+1;
  496.   start_toprow=toprow;
  497.   start_bottomrow=bottomrow;
  498.   start_leftrect_leftcol=leftrect_leftcol;
  499.   start_centercol=centercol;
  500.   start_rightrect_rightcol=rightrect_rightcol;
  501.   m_remaining_incarnations=m_stop_after_num_incarnations=num;
  502. }
  504. /*
  505. void CLeftRightIF::Transform(const CFeatureTransformer& transformer)
  506. {
  507.   ASSERT(!m_is_partial);
  508.   transformer.TransformWidthHeight(&m_template_width, &m_template_height);
  509.   transformer.TransformCoordinate();
  510.   transformer.FeatureDone();
  512.   toprow=start_toprow;
  513.   bottomrow=start_bottomrow;
  514.   leftrect_leftcol=start_leftrect_leftcol;
  515.   centercol=start_centercol;
  516.   rightrect_rightcol=start_rightrect_rightcol;
  517. }
  518. */
  520. #ifdef USE_MFC
  521. void CLeftRightIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  522. {
  523.   int ll = x_off + zoomfactor + leftrect_leftcol*zoomfactor;
  524.   int tr = y_off + zoomfactor + toprow*zoomfactor;
  525.   int cl = x_off + zoomfactor + centercol*zoomfactor;
  526.   int br = y_off + zoomfactor + bottomrow*zoomfactor;
  527.   int rr = x_off + zoomfactor + rightrect_rightcol*zoomfactor;
  528.   pDC->FillRect(CRect(ll, tr, cl, br), g_pBlackbrush);
  529.   pDC->Rectangle(cl, tr, rr, br);
  530. }
  531. #endif // USE_MFC
  533. ostream& CLeftRightIF::output(ostream& os) const
  534. {
  535.   os << "LeftRight " << toprow << "," << bottomrow << " x "
  536.      << leftrect_leftcol << "," << centercol << "," << rightrect_rightcol;
  537.   return os;
  538. }
  544. /////////////////////////////////////////////////////////////////////////////
  545. //
  546. // CUpDownIF classes implementation
  547. //
  548. /////////////////////////////////////////////////////////////////////////////
  550. CUpDownIF::CUpDownIF(int templateWidth, int templateHeight)
  551.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 
  552.      6*COST_GET+7*COST_ADD) 
  553. {
  554. }
  556. CUpDownIF::CUpDownIF(int templateWidth, int templateHeight,
  557.                      int _toprect_toprow, int _centerrow,
  558.                      int _bottomrect_bottomrow,
  559.                      int _leftcol, int _rightcol)
  560.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false,
  561.      6*COST_GET+7*COST_ADD) 
  562. {
  563.   toprect_toprow = _toprect_toprow;
  564.   centerrow = _centerrow;
  565.   bottomrect_bottomrow = _bottomrect_bottomrow;
  566.   leftcol = _leftcol;
  567.   rightcol = _rightcol;
  568.   SetNonOverlap();
  569. }
  571. CUpDownIF::CUpDownIF(const CUpDownIF& frm)
  572.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  573.      frm.m_num_incarnations, frm.m_is_partial, 
  574.      6*COST_GET+7*COST_ADD) 
  575. {
  576.   toprect_toprow=frm.toprect_toprow;
  577.   centerrow=frm.centerrow;
  578.   bottomrect_bottomrow=frm.bottomrect_bottomrow;
  579.   leftcol=frm.leftcol;
  580.   rightcol=frm.rightcol;
  581.   if (m_is_partial) {
  582.     start_toprect_toprow=frm.start_toprect_toprow;
  583.     start_centerrow=frm.start_centerrow;
  584.     start_bottomrect_bottomrow=frm.start_bottomrect_bottomrow;
  585.     start_leftcol=frm.start_leftcol;
  586.     start_rightcol=frm.start_rightcol;
  587.     m_remaining_incarnations = frm.m_remaining_incarnations;
  588.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  589.   }
  590.   SetNonOverlap();
  591. }
  593. CUpDownIF::CUpDownIF(istream& is, int templateWidth, int templateHeight)
  594.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 
  595.      6*COST_GET+7*COST_ADD) 
  596. {
  597.   char a, b, c;
  598.   string str;
  599.   is >> toprect_toprow >> a >> centerrow >> b
  600.      >> bottomrect_bottomrow >> str >> leftcol >> c >> rightcol;
  601.   if (a!=',' || b!=',' || c!=',' || str!="x") {
  602.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  603.     sprintf(buf, "error during construction of UpDownIF (%c|%c|%c|%s)n",
  604.    a, b, c, str.c_str());
  605.     throw ITException(buf);
  606.   }
  607.   SetNonOverlap();
  608. }
  610. bool CUpDownIF::Equals(const CUpDownIF& frm) const
  611. {
  612.   bool equal = 
  613.     (toprect_toprow == frm.toprect_toprow &&
  614.      centerrow == frm.centerrow &&
  615.      bottomrect_bottomrow == frm.bottomrect_bottomrow &&
  616.      leftcol == frm.leftcol &&
  617.      rightcol == frm.rightcol);
  618.   return equal;
  619. }
  621. void CUpDownIF::SetNonOverlap() {
  622.   m_non_overlap =
  623.     ((centerrow-toprect_toprow) - (bottomrect_bottomrow-centerrow))
  624.     * (rightcol-leftcol);
  625. }
  627. II_TYPE CUpDownIF::Compute(const CIntegralImage& image) const
  628. {
  629. II_TYPE ceri = image.GetElement(rightcol, centerrow);
  630. II_TYPE cele = image.GetElement(leftcol, centerrow);
  632. II_TYPE val_toprect = 
  633. ceri
  634. - cele
  635. - image.GetElement(rightcol, toprect_toprow)
  636. + image.GetElement(leftcol, toprect_toprow);
  638. II_TYPE val_bottomrect = 
  639. image.GetElement(rightcol, bottomrect_bottomrow)
  640. - image.GetElement(leftcol, bottomrect_bottomrow)
  641. - ceri
  642. + cele;
  644. return val_toprect-val_bottomrect;
  645. }
  647. II_TYPE CUpDownIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  648. {
  649. int placed_leftcol = left + scaled_leftcol;
  650. int placed_rightcol = left + scaled_rightcol;
  651. int placed_toprect_toprow = top + scaled_toprect_toprow;
  652. int placed_centerrow = top + scaled_centerrow;
  653. int placed_bottomrect_bottomrow = top + scaled_bottomrect_bottomrow;
  655. II_TYPE ceri = image.GetElement(placed_rightcol, placed_centerrow);
  656. II_TYPE cele = image.GetElement(placed_leftcol, placed_centerrow);
  658. II_TYPE val_toprect = 
  659. ceri
  660. - cele
  661. - image.GetElement(placed_rightcol, placed_toprect_toprow)
  662. + image.GetElement(placed_leftcol, placed_toprect_toprow);
  664. II_TYPE val_bottomrect = 
  665. image.GetElement(placed_rightcol, placed_bottomrect_bottomrow)
  666. - image.GetElement(placed_leftcol, placed_bottomrect_bottomrow)
  667. - ceri
  668. + cele;
  670. II_TYPE val = val_toprect-val_bottomrect;
  671. II_TYPE scaled_val = val/m_global_scale;
  672. II_TYPE mean_adjust = m_non_overlap*mean;
  674. return scaled_val-mean_adjust;
  675. }
  677. void CUpDownIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  678. {
  679. if (leftcol==-1) {
  680. scaled_leftcol = -1;
  681. scaled_rightcol = (int)((II_TYPE)(rightcol+1)*scale_x) - 1;
  682. } else {
  683. scaled_leftcol = (int)((II_TYPE)leftcol*scale_x);
  684. scaled_rightcol = (int)((II_TYPE)rightcol*scale_x);
  685. }
  686. if (toprect_toprow==-1) {
  687. scaled_toprect_toprow = -1;
  688. scaled_centerrow = (int)((II_TYPE)(centerrow+1)*scale_y) - 1;
  689. scaled_bottomrect_bottomrow = (int)((II_TYPE)(bottomrect_bottomrow-centerrow)*scale_y) + scaled_centerrow;
  690. } else {
  691. scaled_toprect_toprow = (int)((II_TYPE)toprect_toprow*scale_y);
  692. scaled_centerrow = (int)((II_TYPE)centerrow*scale_y);
  693. scaled_bottomrect_bottomrow = (int)((II_TYPE)bottomrect_bottomrow*scale_y);
  694. }
  696.   m_global_scale = scale_x*scale_y;
  697. }
  699. void CUpDownIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  700.         int /*scaled_template_width*/, int scaled_template_height)
  701. {
  702.   int toprect = centerrow-toprect_toprow;
  703.   int bottomrect = bottomrect_bottomrow-centerrow;
  704.   II_TYPE ratio = (II_TYPE)toprect/(II_TYPE)bottomrect;
  705.   int stoprect = scaled_centerrow-scaled_toprect_toprow;
  706.   int sbottomrect = scaled_bottomrect_bottomrow-scaled_centerrow;
  707.   II_TYPE sratio = (II_TYPE)stoprect/(II_TYPE)sbottomrect;
  709.   int scaled_height = scaled_bottomrect_bottomrow-toprect_toprow;
  710.   bool too_high = scaled_height > scaled_template_height;
  712.   while (!too_high && fabs(ratio-sratio)>=SCALE_DIFFERENCE_EPSILON) {
  713.     if (ratio<sratio) {
  714.       scaled_bottomrect_bottomrow++;
  715.       sbottomrect++;
  716.     } else {
  717.       scaled_centerrow++;
  718.       scaled_bottomrect_bottomrow++;
  719.       stoprect++;
  720.     }
  721.     scaled_height = scaled_bottomrect_bottomrow-toprect_toprow;
  722.     too_high = scaled_height > scaled_template_height;
  724.     sratio = (II_TYPE)stoprect/(II_TYPE)sbottomrect;
  725.   }
  727.   int overlap = scaled_bottomrect_bottomrow-scaled_template_height+1;
  728.   // overlap: by how much is bottommost too far down? 
  729.   // it must not be larger than scaled_template_height-1
  730.   if (overlap>0) {
  731.     // went outside template boundaries
  732.     if (too_high) {
  733.       // feature too big, use int scale
  734.       *pScale_y = floor(*pScale_y);
  735.       Scale(*pScale_x, *pScale_y);
  736.     } else {
  737.       // shift feature by overlap
  738.       scaled_toprect_toprow -= overlap;
  739.       scaled_centerrow -= overlap;
  740.       scaled_bottomrect_bottomrow -= overlap;
  741.       *pScale_y = sratio;
  742.     }
  743.   } else {
  744.     *pScale_y = sratio;
  745.   }
  746. }
  748. void CUpDownIF::SetToFirstIncarnation()
  749. {
  750.   if (m_is_partial) {
  751.     toprect_toprow=start_toprect_toprow;
  752.     centerrow=start_centerrow;
  753.     bottomrect_bottomrow=start_bottomrect_bottomrow;
  754.     leftcol=start_leftcol;
  755.     rightcol=start_rightcol;
  756.     m_remaining_incarnations=m_stop_after_num_incarnations;
  757.   } else {
  758.     toprect_toprow=-1;
  759.     centerrow=0;
  760.     bottomrect_bottomrow=1;
  761.     leftcol=-1;
  762.     rightcol=0;
  763.   }
  764.   SetNonOverlap();
  765. }
  767. bool CUpDownIF::SetToNextIncarnation()
  768. {
  769. if (m_is_partial) {
  770. if (m_remaining_incarnations) {
  771. m_remaining_incarnations--;
  772. } else {
  773. return false;
  774. }
  775. }
  776. bottomrect_bottomrow++;
  777. if (bottomrect_bottomrow>=m_template_height) {
  778. centerrow++;
  779. if (centerrow>=m_template_height-1) {
  780. toprect_toprow++;
  781. if (toprect_toprow==m_template_height-2) {
  782. rightcol++;
  783. if (rightcol==m_template_width) {
  784. leftcol++;
  785. if (leftcol==m_template_width-1) {
  786. return false;
  787. }
  788. rightcol=leftcol+1;
  789. }
  790. toprect_toprow=-1;
  791. }
  792. centerrow=toprect_toprow+1;
  793. }
  794. bottomrect_bottomrow=centerrow+1;
  795. }
  796.     SetNonOverlap();
  797. return true;
  798. }
  800. CIntegralFeature* CUpDownIF::Copy() const
  801. {
  802. return new CUpDownIF(*this);
  803. }
  805. void CUpDownIF::MakePartialFromCurrentForNumIncarnations(
  806.   featnum num)
  807. {
  808.   m_is_partial=true;
  809.   m_num_incarnations=num+1;
  810.   start_toprect_toprow=toprect_toprow;
  811.   start_centerrow=centerrow;
  812.   start_bottomrect_bottomrow=bottomrect_bottomrow;
  813.   start_leftcol=leftcol;
  814.   start_rightcol=rightcol;
  815.   m_remaining_incarnations=m_stop_after_num_incarnations=num;
  816. }
  818. #ifdef USE_MFC
  819. void CUpDownIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  820. {
  821. int lc = x_off + zoomfactor + leftcol*zoomfactor;
  822. int tt = y_off + zoomfactor + toprect_toprow*zoomfactor;
  823. int rc = x_off + zoomfactor + rightcol*zoomfactor;
  824. int cr = y_off + zoomfactor + centerrow*zoomfactor;
  825. int bb = y_off + zoomfactor + bottomrect_bottomrow*zoomfactor;
  826. pDC->FillRect(CRect(lc, tt, rc, cr), g_pBlackbrush);
  827. pDC->Rectangle(lc, cr, rc, bb);
  828. }
  829. #endif // USE_MFC
  831. ostream& CUpDownIF::output(ostream& os) const
  832. {
  833.   os << "UpDown " << toprect_toprow << "," << centerrow 
  834.      << "," << bottomrect_bottomrow << " x "
  835.      << leftcol << "," << rightcol;
  836.   return os;
  837. }
  843. /////////////////////////////////////////////////////////////////////////////
  844. //
  845. // CLeftCenterRightIF classes implementation
  846. //
  847. /////////////////////////////////////////////////////////////////////////////
  849. CLeftCenterRightIF::CLeftCenterRightIF(int templateWidth, int templateHeight)
  850.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 8*COST_GET+10*COST_ADD) 
  851. {
  852. }
  854. CLeftCenterRightIF::CLeftCenterRightIF(int templateWidth, int templateHeight,
  855.                                        int _toprow, int _bottomrow,
  856.                                        int _leftrect_leftcol, int _leftrect_rightcol,
  857.                                        int _rightrect_leftcol,
  858.                                        int _rightrect_rightcol)
  859.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 8*COST_GET+10*COST_ADD) 
  860. {
  861.   toprow = _toprow;
  862.   bottomrow = _bottomrow;
  863.   leftrect_leftcol = _leftrect_leftcol;
  864.   leftrect_rightcol = _leftrect_rightcol;
  865.   rightrect_leftcol = _rightrect_leftcol;
  866.   rightrect_rightcol = _rightrect_rightcol;
  867.   SetNonOverlap();
  868. }
  870. CLeftCenterRightIF::CLeftCenterRightIF(const CLeftCenterRightIF& frm)
  871.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  872.      frm.m_num_incarnations, frm.m_is_partial, 8*COST_GET+10*COST_ADD) 
  873. {
  874.   toprow=frm.toprow;
  875.   bottomrow=frm.bottomrow;
  876.   leftrect_leftcol=frm.leftrect_leftcol;
  877.   leftrect_rightcol=frm.leftrect_rightcol;
  878.   rightrect_leftcol=frm.rightrect_leftcol;
  879.   rightrect_rightcol=frm.rightrect_rightcol;
  880.   if (m_is_partial) {
  881.     start_toprow=frm.start_toprow;
  882.     start_bottomrow=frm.start_bottomrow;
  883.     start_leftrect_leftcol=frm.start_leftrect_leftcol;
  884.     start_leftrect_rightcol=frm.start_leftrect_rightcol;
  885.     start_rightrect_leftcol=frm.start_rightrect_leftcol;
  886.     start_rightrect_rightcol=frm.start_rightrect_rightcol;
  887.     m_remaining_incarnations = frm.m_remaining_incarnations;
  888.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  889.   }
  890.   SetNonOverlap();
  891. }
  893. CLeftCenterRightIF::CLeftCenterRightIF(istream& is, int templateWidth, int templateHeight)
  894.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 8*COST_GET+10*COST_ADD) 
  895. {
  896.   char a, b, c;
  897.   string strx, strslash;
  898.   is >> toprow >> a >> bottomrow >> strx 
  899.      >> leftrect_leftcol >> b >> leftrect_rightcol >> strslash
  900.      >> rightrect_leftcol >> c >> rightrect_rightcol;
  901.   if (a!=',' || b!=',' || c!=',' || strx!="x" || strslash!="/") {
  902.     char* buf = (char*) alloca((256+strx.length()+strslash.length())*sizeof(char));
  903.     sprintf(buf, "error during construction of LeftCenterRightIF (%c|%c|%c|%s|%s)n",
  904.    a, b, c, strx.c_str(), strslash.c_str());
  905.     throw ITException(buf);
  906.   }
  907.   SetNonOverlap();
  908. }
  910. bool CLeftCenterRightIF::Equals(const CLeftCenterRightIF& frm) const
  911. {
  912.   bool equal = 
  913.     (toprow == frm.toprow &&
  914.      bottomrow == frm.bottomrow &&
  915.      leftrect_leftcol == frm.leftrect_leftcol &&
  916.      leftrect_rightcol == frm.leftrect_rightcol &&
  917.      rightrect_leftcol == frm.rightrect_leftcol &&
  918.      rightrect_rightcol == frm.rightrect_rightcol);
  919.   return equal;
  920. }
  922. void CLeftCenterRightIF::SetNonOverlap() {
  923.   m_non_overlap = 
  924.     ((leftrect_rightcol-leftrect_leftcol) 
  925.      - (rightrect_leftcol-leftrect_rightcol)
  926.      + (rightrect_rightcol-rightrect_leftcol)) * (bottomrow-toprow);
  927. }
  929. II_TYPE CLeftCenterRightIF::Compute(const CIntegralImage& image) const
  930. {
  931. II_TYPE botleri = image.GetElement(leftrect_rightcol, bottomrow);
  932. II_TYPE topleri = image.GetElement(leftrect_rightcol, toprow);
  933. II_TYPE botrile = image.GetElement(rightrect_leftcol, bottomrow);
  934. II_TYPE toprile = image.GetElement(rightrect_leftcol, toprow);
  936. II_TYPE val_leftrect = 
  937. botleri
  938. - image.GetElement(leftrect_leftcol, bottomrow)
  939. - topleri
  940. + image.GetElement(leftrect_leftcol, toprow);
  942. II_TYPE val_centerrect = 
  943. botrile
  944. - botleri
  945. - toprile
  946. + topleri;
  948. II_TYPE val_rightrect = 
  949. image.GetElement(rightrect_rightcol, bottomrow)
  950. - botrile
  951. - image.GetElement(rightrect_rightcol, toprow)
  952. + toprile;
  954. return val_leftrect-val_centerrect+val_rightrect;
  955. }
  957. II_TYPE CLeftCenterRightIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  958. {
  959. int placed_leftrect_leftcol = left + scaled_leftrect_leftcol;
  960. int placed_leftrect_rightcol = left + scaled_leftrect_rightcol;
  961. int placed_rightrect_leftcol= left + scaled_rightrect_leftcol;
  962. int placed_rightrect_rightcol = left + scaled_rightrect_rightcol;
  963. int placed_toprow = top + scaled_toprow;
  964. int placed_bottomrow = top + scaled_bottomrow;
  966. II_TYPE botleri = image.GetElement(placed_leftrect_rightcol, placed_bottomrow);
  967. II_TYPE topleri = image.GetElement(placed_leftrect_rightcol, placed_toprow);
  968. II_TYPE botrile = image.GetElement(placed_rightrect_leftcol, placed_bottomrow);
  969. II_TYPE toprile = image.GetElement(placed_rightrect_leftcol, placed_toprow);
  971. II_TYPE val_leftrect = 
  972. botleri
  973. - image.GetElement(placed_leftrect_leftcol, placed_bottomrow)
  974. - topleri
  975. + image.GetElement(placed_leftrect_leftcol, placed_toprow);
  977. II_TYPE val_centerrect = 
  978. botrile
  979. - botleri
  980. - toprile
  981. + topleri;
  983. II_TYPE val_rightrect = 
  984. image.GetElement(placed_rightrect_rightcol, placed_bottomrow)
  985. - botrile
  986. - image.GetElement(placed_rightrect_rightcol, placed_toprow)
  987. + toprile;
  989. II_TYPE val = val_leftrect-val_centerrect+val_rightrect;
  990. II_TYPE scaled_val = val/m_global_scale;
  991. II_TYPE mean_adjust = m_non_overlap*mean;
  993. return scaled_val-mean_adjust;
  994. }
  996. void CLeftCenterRightIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  997. {
  998. if (leftrect_leftcol==-1) {
  999. scaled_leftrect_leftcol = -1;
  1000. scaled_leftrect_rightcol = (int)((II_TYPE)(leftrect_rightcol+1)*scale_x) -1;
  1001. scaled_rightrect_leftcol= (int)((II_TYPE)(rightrect_leftcol-leftrect_rightcol)*scale_x) + scaled_leftrect_rightcol;
  1002. scaled_rightrect_rightcol = (int)((II_TYPE)(rightrect_rightcol-rightrect_leftcol)*scale_x) + scaled_rightrect_leftcol;
  1003. } else {
  1004. scaled_leftrect_leftcol = (int)((II_TYPE)leftrect_leftcol*scale_x);
  1005. scaled_leftrect_rightcol = (int)((II_TYPE)leftrect_rightcol*scale_x);
  1006. scaled_rightrect_leftcol= (int)((II_TYPE)rightrect_leftcol*scale_x);
  1007. scaled_rightrect_rightcol = (int)((II_TYPE)rightrect_rightcol*scale_x);
  1008. }
  1009. if (toprow==-1) {
  1010. scaled_toprow = (int)((II_TYPE)(toprow+1)*scale_y) -1;
  1011. scaled_bottomrow = (int)((II_TYPE)(bottomrow-toprow)*scale_y) + scaled_toprow;
  1012. } else {
  1013. scaled_toprow = (int)((II_TYPE)toprow*scale_y);
  1014. scaled_bottomrow = (int)((II_TYPE)bottomrow*scale_y);
  1015. }
  1017.   m_global_scale = scale_x*scale_y;
  1018. }
  1020. void CLeftCenterRightIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  1021.         int scaled_template_width, int /*scaled_template_height*/)
  1022. {
  1023.   int leftrect = leftrect_rightcol-leftrect_leftcol;
  1024.   int midrect = rightrect_leftcol-leftrect_rightcol;
  1025.   int rightrect = rightrect_rightcol-rightrect_leftcol;
  1026.   II_TYPE ratio1 = (II_TYPE)leftrect/(II_TYPE)midrect;
  1027.   II_TYPE ratio2 = (II_TYPE)midrect/(II_TYPE)rightrect;
  1028.   int sleftrect = scaled_leftrect_rightcol-scaled_leftrect_leftcol;
  1029.   int smidrect = scaled_rightrect_leftcol-scaled_leftrect_rightcol;
  1030.   int srightrect = scaled_rightrect_rightcol-scaled_rightrect_leftcol;
  1031.   II_TYPE sratio1 = (II_TYPE)sleftrect/(II_TYPE)smidrect;
  1032.   II_TYPE sratio2 = (II_TYPE)smidrect/(II_TYPE)srightrect;
  1034.   int scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  1035.   bool too_wide = scaled_width > scaled_template_width;
  1037.   while (!too_wide && 
  1038.  (fabs(ratio1-sratio1)>=SCALE_DIFFERENCE_EPSILON
  1039.   || fabs(ratio2-sratio2)>=SCALE_DIFFERENCE_EPSILON)) {
  1040.     if (ratio1<sratio1) {
  1041.       scaled_rightrect_leftcol++;
  1042.       scaled_rightrect_rightcol++;
  1043.       smidrect++;
  1044.     } else if (ratio1>sratio1) {
  1045.       scaled_leftrect_rightcol++;
  1046.       scaled_rightrect_leftcol++;
  1047.       scaled_rightrect_rightcol++;
  1048.       sleftrect++;
  1049.     } else if (ratio2<sratio2) {
  1050.       scaled_rightrect_rightcol++;
  1051.       srightrect++;
  1052.     } else {
  1053.       ASSERT(ratio2>sratio2);
  1054.       scaled_rightrect_leftcol++;
  1055.       scaled_rightrect_rightcol++;
  1056.       smidrect++;
  1057.     }
  1058.     scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  1059.     too_wide = scaled_width > scaled_template_width;
  1061.     sratio1 = (II_TYPE)sleftrect/(II_TYPE)smidrect;
  1062.     sratio2 = (II_TYPE)smidrect/(II_TYPE)srightrect;
  1063.   }
  1064.   ASSERT(too_wide || fabs((II_TYPE)leftrect/(II_TYPE)rightrect
  1065.               -(II_TYPE)sleftrect/(II_TYPE)srightrect)<SCALE_DIFFERENCE_EPSILON);
  1067.   int overlap = scaled_rightrect_rightcol-scaled_template_width+1;
  1068.   // overlap: by how much is rightmost too far to the right? 
  1069.   // it must not be larger than scaled_template_width-1
  1070.   if (overlap>0) {
  1071.     // went outside template boundaries
  1072.     if (too_wide) {
  1073.       // feature too big, use int scale
  1074.       *pScale_x = floor(*pScale_x);
  1075.       Scale(*pScale_x, *pScale_y);
  1076.     } else {
  1077.       // shift feature by overlap
  1078.       scaled_leftrect_leftcol -= overlap;
  1079.       scaled_leftrect_rightcol -= overlap;
  1080.       scaled_rightrect_leftcol -= overlap;
  1081.       scaled_rightrect_rightcol -= overlap;
  1082.       *pScale_x = sratio1;
  1083.     }
  1084.   } else {
  1085.     *pScale_x = sratio1;
  1086.   }
  1087. }
  1089. void CLeftCenterRightIF::SetToFirstIncarnation()
  1090. {
  1091.   if (m_is_partial) {
  1092.     toprow=start_toprow;
  1093.     bottomrow=start_bottomrow;
  1094.     leftrect_leftcol=start_leftrect_leftcol;
  1095.     leftrect_rightcol=start_leftrect_rightcol;
  1096.     rightrect_leftcol=start_rightrect_leftcol;
  1097.     rightrect_rightcol=start_rightrect_rightcol;
  1098.     m_remaining_incarnations=m_stop_after_num_incarnations;
  1099.   } else {
  1100.     toprow=-1;
  1101.     bottomrow=0;
  1102.     leftrect_leftcol=-1;
  1103.     leftrect_rightcol=0;
  1104.     rightrect_leftcol=1;
  1105.     rightrect_rightcol=2;
  1106.   }
  1107.   SetNonOverlap();
  1108. }
  1110. bool CLeftCenterRightIF::SetToNextIncarnation()
  1111. {
  1112. if (m_is_partial) {
  1113. if (m_remaining_incarnations) {
  1114. m_remaining_incarnations--;
  1115. } else {
  1116. return false;
  1117. }
  1118. }
  1119. rightrect_rightcol++;
  1120. if (rightrect_rightcol>=m_template_width) {
  1121. rightrect_leftcol++;
  1122. if (rightrect_leftcol>=m_template_width-1) {
  1123. leftrect_rightcol++;
  1124. if (leftrect_rightcol>=m_template_width-2) {
  1125. leftrect_leftcol++;
  1126. if (leftrect_leftcol==m_template_width-3) {
  1127. bottomrow++;
  1128. if (bottomrow==m_template_height) {
  1129. toprow++;
  1130. if (toprow==m_template_height-1) {
  1131. return false;
  1132. }
  1133. bottomrow=toprow+1;
  1134. }
  1135. leftrect_leftcol=0;
  1136. }
  1137. leftrect_rightcol=leftrect_leftcol+1;
  1138. }
  1139. rightrect_leftcol=leftrect_rightcol+1;
  1140. }
  1141. rightrect_rightcol=rightrect_leftcol+1;
  1142. }
  1143.     SetNonOverlap();
  1144. return true;
  1145. }
  1147. void CLeftCenterRightIF::MakePartialFromCurrentForNumIncarnations(
  1148.   featnum num)
  1149. {
  1150.   m_is_partial=true;
  1151.   m_num_incarnations=num+1;
  1152.   start_toprow=toprow;
  1153.   start_bottomrow=bottomrow;
  1154.   start_leftrect_leftcol=leftrect_leftcol;
  1155.   start_leftrect_rightcol=leftrect_rightcol;
  1156.   start_rightrect_leftcol=rightrect_leftcol;
  1157.   start_rightrect_rightcol=rightrect_rightcol;
  1158.   m_remaining_incarnations=m_stop_after_num_incarnations=num;
  1159. }
  1161. CIntegralFeature* CLeftCenterRightIF::Copy() const 
  1162. {
  1163.   return new CLeftCenterRightIF(*this);
  1164. }
  1166. #ifdef USE_MFC
  1167. void CLeftCenterRightIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  1168. {
  1169.   int tr = y_off + zoomfactor + toprow*zoomfactor;
  1170.   int br = y_off + zoomfactor + bottomrow*zoomfactor;
  1171.   int ll = x_off + zoomfactor + leftrect_leftcol*zoomfactor;
  1172.   int lr = x_off + zoomfactor + leftrect_rightcol*zoomfactor;
  1173.   int rl = x_off + zoomfactor + rightrect_leftcol*zoomfactor;
  1174.   int rr = x_off + zoomfactor + rightrect_rightcol*zoomfactor;
  1175. pDC->FillRect(CRect(ll, tr, lr, br), g_pBlackbrush);
  1176. pDC->Rectangle(lr, tr, rl, br);
  1177. pDC->FillRect(CRect(rl, tr, rr, br), g_pBlackbrush);
  1178. }
  1179. #endif // USE_MFC
  1181. ostream& CLeftCenterRightIF::output(ostream& os) const
  1182. {
  1183.   os << "LeftCenterRight " << toprow << "," << bottomrow << " x "
  1184.      << leftrect_leftcol << "," << leftrect_rightcol << " / "
  1185.      << rightrect_leftcol << "," << rightrect_rightcol;
  1186.   return os;
  1187. }
  1192. /////////////////////////////////////////////////////////////////////////////
  1193. //
  1194. // CSevenColumnsIF classes implementation
  1195. //
  1196. /////////////////////////////////////////////////////////////////////////////
  1198. CSevenColumnsIF::CSevenColumnsIF(int templateWidth, int templateHeight)
  1199.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+27*COST_ADD) 
  1200. {
  1201. }
  1203. CSevenColumnsIF::CSevenColumnsIF(int templateWidth, int templateHeight,
  1204.                                  int _toprow, int _bottomrow,
  1205.                                  int _1, int _2, int _3, int _4, int _5, int _6,
  1206.                                  int _7, int _8)
  1207.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+27*COST_ADD) 
  1208. {
  1209.   toprow = _toprow;
  1210.   bottomrow = _bottomrow;
  1211.   col1_left = _1;
  1212.   col2_left = _2;
  1213.   col3_left = _3;
  1214.   col4_left = _4;
  1215.   col5_left = _5;
  1216.   col6_left = _6;
  1217.   col7_left = _7;
  1218.   col7_right = _8;
  1219.   SetNonOverlap();
  1220. }
  1222. CSevenColumnsIF::CSevenColumnsIF(const CSevenColumnsIF& frm)
  1223.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  1224.      frm.m_num_incarnations, frm.m_is_partial, 16*COST_GET+27*COST_ADD) 
  1225. {
  1226.   toprow = frm.toprow;
  1227.   bottomrow = frm.bottomrow;
  1228.   col1_left = frm.col1_left;
  1229.   col2_left = frm.col2_left;
  1230.   col3_left = frm.col3_left;
  1231.   col4_left = frm.col4_left;
  1232.   col5_left = frm.col5_left;
  1233.   col6_left = frm.col6_left;
  1234.   col7_left = frm.col7_left;
  1235.   col7_right = frm.col7_right;
  1236.   if (m_is_partial) {
  1237.     start_toprow = frm.start_toprow;
  1238.     start_bottomrow = frm.start_bottomrow;
  1239.     start_col1_left = frm.start_col1_left;
  1240.     start_col2_left = frm.start_col2_left;
  1241.     start_col3_left = frm.start_col3_left;
  1242.     start_col4_left = frm.start_col4_left;
  1243.     start_col5_left = frm.start_col5_left;
  1244.     start_col6_left = frm.start_col6_left;
  1245.     start_col7_left = frm.start_col7_left;
  1246.     start_col7_right = frm.start_col7_right;
  1247.     m_remaining_incarnations = frm.m_remaining_incarnations;
  1248.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  1249.   }
  1250.   SetNonOverlap();
  1251. }
  1253. CSevenColumnsIF::CSevenColumnsIF(istream& is, int template_width, int template_height)
  1254.   : CIntegralFeature(template_width, template_height, IT_INVALID_FEATURE, 0, 16*COST_GET+27*COST_ADD)
  1255. {
  1256.   char a, b, c, d, e, f, g, h;
  1257.   string str;
  1258.   is >> toprow >> a >> bottomrow >> str
  1259.      >> col1_left >> b >> col2_left >> c >> col3_left >> d >> col4_left >> e
  1260.      >> col5_left >> f >> col6_left >> g >> col7_left >> h >> col7_right; 
  1261.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!=',' || f!=',' || g!=',' || h!=',' || str!="x") {
  1262.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  1263.     sprintf(buf, "error during construction of SevenColumnsIF (%c|%c|%c|%c|%c|%c|%c|%c|%s)n",
  1264.    a, b, c, d, e, f, g, h, str.c_str());
  1265.     throw ITException(buf);
  1266.   }
  1267.   SetNonOverlap();
  1268. }
  1270. bool CSevenColumnsIF::Equals(const CSevenColumnsIF& frm) const
  1271. {
  1272.   bool equal = 
  1273.     (toprow == frm.toprow &&
  1274.      bottomrow == frm.bottomrow &&
  1275.      col1_left == frm.col1_left &&
  1276.      col2_left == frm.col2_left &&
  1277.      col3_left == frm.col3_left &&
  1278.      col4_left == frm.col4_left &&
  1279.      col5_left == frm.col5_left &&
  1280.      col6_left == frm.col6_left &&
  1281.      col7_left == frm.col7_left &&
  1282.      col7_right == frm.col7_right);
  1283.   return equal;
  1284. }
  1286. void CSevenColumnsIF::SetNonOverlap() {
  1287.   m_non_overlap =
  1288.     ((col2_left-col1_left) - (col3_left-col2_left) 
  1289.      + (col4_left-col3_left) - (col5_left-col4_left)
  1290.      + (col6_left-col5_left) - (col7_left-col6_left)
  1291.      + (col7_right-col7_left)
  1292.      )
  1293.     * (bottomrow-toprow);
  1294. }
  1296. II_TYPE CSevenColumnsIF::Compute(const CIntegralImage& image) const
  1297. {
  1298. II_TYPE bot_col1_left = image.GetElement(col1_left, bottomrow);
  1299. II_TYPE top_col1_left = image.GetElement(col1_left, toprow);
  1300. II_TYPE bot_col2_left = image.GetElement(col2_left, bottomrow);
  1301. II_TYPE top_col2_left = image.GetElement(col2_left, toprow);
  1302. II_TYPE bot_col3_left = image.GetElement(col3_left, bottomrow);
  1303. II_TYPE top_col3_left = image.GetElement(col3_left, toprow);
  1304. II_TYPE bot_col4_left = image.GetElement(col4_left, bottomrow);
  1305. II_TYPE top_col4_left = image.GetElement(col4_left, toprow);
  1306. II_TYPE bot_col5_left = image.GetElement(col5_left, bottomrow);
  1307. II_TYPE top_col5_left = image.GetElement(col5_left, toprow);
  1308. II_TYPE bot_col6_left = image.GetElement(col6_left, bottomrow);
  1309. II_TYPE top_col6_left = image.GetElement(col6_left, toprow);
  1310. II_TYPE bot_col7_left = image.GetElement(col7_left, bottomrow);
  1311. II_TYPE top_col7_left = image.GetElement(col7_left, toprow);
  1312. II_TYPE bot_col7_right= image.GetElement(col7_right,bottomrow);
  1313. II_TYPE top_col7_right= image.GetElement(col7_right,toprow);
  1315. II_TYPE val_col1 = bot_col2_left - bot_col1_left - top_col2_left + top_col1_left;
  1316. II_TYPE val_col2 = bot_col3_left - bot_col2_left - top_col3_left + top_col2_left;
  1317. II_TYPE val_col3 = bot_col4_left - bot_col3_left - top_col4_left + top_col3_left;
  1318. II_TYPE val_col4 = bot_col5_left - bot_col4_left - top_col5_left + top_col4_left;
  1319. II_TYPE val_col5 = bot_col6_left - bot_col5_left - top_col6_left + top_col5_left;
  1320. II_TYPE val_col6 = bot_col7_left - bot_col6_left - top_col7_left + top_col6_left;
  1321. II_TYPE val_col7 = bot_col7_right- bot_col7_left - top_col7_right+ top_col7_left;
  1323. return val_col1-val_col2+val_col3-val_col4+val_col5-val_col6+val_col7;
  1324. }
  1326. II_TYPE CSevenColumnsIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  1327. {
  1328. int placed_toprow = top + scaled_toprow;
  1329. int placed_bottomrow = top + scaled_bottomrow;
  1330. int placed_col1_left = left + scaled_col1_left;
  1331. int placed_col2_left = left + scaled_col2_left;
  1332. int placed_col3_left = left + scaled_col3_left;
  1333. int placed_col4_left = left + scaled_col4_left;
  1334. int placed_col5_left = left + scaled_col5_left;
  1335. int placed_col6_left = left + scaled_col6_left;
  1336. int placed_col7_left = left + scaled_col7_left;
  1337. int placed_col7_right= left + scaled_col7_right;
  1339. II_TYPE bot_col1_left = image.GetElement(placed_col1_left, placed_bottomrow);
  1340. II_TYPE top_col1_left = image.GetElement(placed_col1_left, placed_toprow);
  1341. II_TYPE bot_col2_left = image.GetElement(placed_col2_left, placed_bottomrow);
  1342. II_TYPE top_col2_left = image.GetElement(placed_col2_left, placed_toprow);
  1343. II_TYPE bot_col3_left = image.GetElement(placed_col3_left, placed_bottomrow);
  1344. II_TYPE top_col3_left = image.GetElement(placed_col3_left, placed_toprow);
  1345. II_TYPE bot_col4_left = image.GetElement(placed_col4_left, placed_bottomrow);
  1346. II_TYPE top_col4_left = image.GetElement(placed_col4_left, placed_toprow);
  1347. II_TYPE bot_col5_left = image.GetElement(placed_col5_left, placed_bottomrow);
  1348. II_TYPE top_col5_left = image.GetElement(placed_col5_left, placed_toprow);
  1349. II_TYPE bot_col6_left = image.GetElement(placed_col6_left, placed_bottomrow);
  1350. II_TYPE top_col6_left = image.GetElement(placed_col6_left, placed_toprow);
  1351. II_TYPE bot_col7_left = image.GetElement(placed_col7_left, placed_bottomrow);
  1352. II_TYPE top_col7_left = image.GetElement(placed_col7_left, placed_toprow);
  1353. II_TYPE bot_col7_right= image.GetElement(placed_col7_right,placed_bottomrow);
  1354. II_TYPE top_col7_right= image.GetElement(placed_col7_right,placed_toprow);
  1356. II_TYPE val_col1 = bot_col2_left - bot_col1_left - top_col2_left + top_col1_left;
  1357. II_TYPE val_col2 = bot_col3_left - bot_col2_left - top_col3_left + top_col2_left;
  1358. II_TYPE val_col3 = bot_col4_left - bot_col3_left - top_col4_left + top_col3_left;
  1359. II_TYPE val_col4 = bot_col5_left - bot_col4_left - top_col5_left + top_col4_left;
  1360. II_TYPE val_col5 = bot_col6_left - bot_col5_left - top_col6_left + top_col5_left;
  1361. II_TYPE val_col6 = bot_col7_left - bot_col6_left - top_col7_left + top_col6_left;
  1362. II_TYPE val_col7 = bot_col7_right- bot_col7_left - top_col7_right+ top_col7_left;
  1364. II_TYPE val = val_col1-val_col2+val_col3-val_col4+val_col5-val_col6+val_col7;
  1365. II_TYPE scaled_val = val/m_global_scale;
  1366. II_TYPE mean_adjust = m_non_overlap*mean;
  1368. return scaled_val-mean_adjust;
  1369. }
  1371. void CSevenColumnsIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  1372. {
  1373. if (toprow==-1) {
  1374. scaled_toprow = -1;
  1375. scaled_bottomrow = (int)((II_TYPE)(bottomrow+1)*scale_y) - 1;
  1376. } else {
  1377. scaled_toprow = (int)((II_TYPE)toprow*scale_y);
  1378. scaled_bottomrow = (int)((II_TYPE)bottomrow*scale_y);
  1379. }
  1380. if (col1_left==-1) {
  1381. scaled_col1_left = -1;
  1382. scaled_col2_left = (int)((II_TYPE)(col2_left+1)*scale_x) - 1;
  1383. scaled_col3_left = (int)((II_TYPE)(col3_left-col2_left)*scale_x) + scaled_col2_left;
  1384. scaled_col4_left = (int)((II_TYPE)(col4_left-col3_left)*scale_x) + scaled_col3_left;
  1385. scaled_col5_left = (int)((II_TYPE)(col5_left-col4_left)*scale_x) + scaled_col4_left;
  1386. scaled_col6_left = (int)((II_TYPE)(col6_left-col5_left)*scale_x) + scaled_col5_left;
  1387. scaled_col7_left = (int)((II_TYPE)(col7_left-col6_left)*scale_x) + scaled_col6_left;
  1388. scaled_col7_right= (int)((II_TYPE)(col7_right-col7_left)*scale_x) + scaled_col7_left;
  1389. } else {
  1390. scaled_col1_left = (int)((II_TYPE)col1_left*scale_x);
  1391. scaled_col2_left = (int)((II_TYPE)col2_left*scale_x);
  1392. scaled_col3_left = (int)((II_TYPE)col3_left*scale_x);
  1393. scaled_col4_left = (int)((II_TYPE)col4_left*scale_x);
  1394. scaled_col5_left = (int)((II_TYPE)col5_left*scale_x);
  1395. scaled_col6_left = (int)((II_TYPE)col6_left*scale_x);
  1396. scaled_col7_left = (int)((II_TYPE)col7_left*scale_x);
  1397. scaled_col7_right= (int)((II_TYPE)col7_right*scale_x);
  1398. }
  1400.   m_global_scale = scale_x*scale_y;
  1401. }
  1403. void CSevenColumnsIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  1404.         int scaled_template_width, int /*scaled_template_height*/)
  1405. {
  1406.   int rect1 = col2_left-col1_left;
  1407.   int rect2 = col3_left-col2_left;
  1408.   int rect3 = col4_left-col3_left;
  1409.   int rect4 = col5_left-col4_left;
  1410.   int rect5 = col6_left-col5_left;
  1411.   int rect6 = col7_left-col6_left;
  1412.   int rect7 = col7_right-col7_left;
  1413.   II_TYPE ratio1 = (II_TYPE)rect1/(II_TYPE)rect2;
  1414.   II_TYPE ratio2 = (II_TYPE)rect2/(II_TYPE)rect3;
  1415.   II_TYPE ratio3 = (II_TYPE)rect3/(II_TYPE)rect4;
  1416.   II_TYPE ratio4 = (II_TYPE)rect4/(II_TYPE)rect5;
  1417.   II_TYPE ratio5 = (II_TYPE)rect5/(II_TYPE)rect6;
  1418.   II_TYPE ratio6 = (II_TYPE)rect6/(II_TYPE)rect7;
  1419.   int srect1 = scaled_col2_left-scaled_col1_left;
  1420.   int srect2 = scaled_col3_left-scaled_col2_left;
  1421.   int srect3 = scaled_col4_left-scaled_col3_left;
  1422.   int srect4 = scaled_col5_left-scaled_col4_left;
  1423.   int srect5 = scaled_col6_left-scaled_col5_left;
  1424.   int srect6 = scaled_col7_left-scaled_col6_left;
  1425.   int srect7 = scaled_col7_right-scaled_col7_left;
  1426.   II_TYPE sratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  1427.   II_TYPE sratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  1428.   II_TYPE sratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  1429.   II_TYPE sratio4 = (II_TYPE)srect4/(II_TYPE)srect5;
  1430.   II_TYPE sratio5 = (II_TYPE)srect5/(II_TYPE)srect6;
  1431.   II_TYPE sratio6 = (II_TYPE)srect6/(II_TYPE)srect7;
  1433.   int scaled_width = scaled_col7_right-scaled_col1_left;
  1434.   bool too_wide = scaled_width > scaled_template_width;
  1436.   while (!too_wide && 
  1437.  (fabs(ratio1-sratio1)>=SCALE_DIFFERENCE_EPSILON
  1438.   || fabs(ratio2-sratio2)>=SCALE_DIFFERENCE_EPSILON
  1439.   || fabs(ratio3-sratio3)>=SCALE_DIFFERENCE_EPSILON
  1440.   || fabs(ratio4-sratio4)>=SCALE_DIFFERENCE_EPSILON
  1441.   || fabs(ratio5-sratio5)>=SCALE_DIFFERENCE_EPSILON
  1442.   || fabs(ratio6-sratio6)>=SCALE_DIFFERENCE_EPSILON)) {
  1443.     if (ratio1>sratio1) {
  1444.       scaled_col2_left++;
  1445.       scaled_col3_left++;
  1446.       scaled_col4_left++;
  1447.       scaled_col5_left++;
  1448.       scaled_col6_left++;
  1449.       scaled_col7_left++;
  1450.       scaled_col7_right++;
  1451.       srect1++;
  1452.     } else if (ratio1<sratio1 || ratio2>sratio2) {
  1453.       scaled_col3_left++;
  1454.       scaled_col4_left++;
  1455.       scaled_col5_left++;
  1456.       scaled_col6_left++;
  1457.       scaled_col7_left++;
  1458.       scaled_col7_right++;
  1459.       srect2++;
  1460.     } else if (ratio2<sratio2 || ratio3>sratio3) {
  1461.       scaled_col4_left++;
  1462.       scaled_col5_left++;
  1463.       scaled_col6_left++;
  1464.       scaled_col7_left++;
  1465.       scaled_col7_right++;
  1466.       srect3++;
  1467.     } else if (ratio3<sratio3 || ratio4>sratio4) {
  1468.       scaled_col5_left++;
  1469.       scaled_col6_left++;
  1470.       scaled_col7_left++;
  1471.       scaled_col7_right++;
  1472.       srect4++;
  1473.     } else if (ratio4<sratio4 || ratio5>sratio5) {
  1474.       scaled_col6_left++;
  1475.       scaled_col7_left++;
  1476.       scaled_col7_right++;
  1477.       srect5++;
  1478.     } else if (ratio5<sratio5 || ratio6>sratio6) {
  1479.       scaled_col7_left++;
  1480.       scaled_col7_right++;
  1481.       srect6++;
  1482.     } else if (ratio6<sratio6) {
  1483.       scaled_col7_right++;
  1484.       srect7++;
  1485.     } else {
  1486.       throw ITException("error during CSevenColumnsIF scaling - e too small?");
  1487.     }
  1488.     scaled_width = scaled_col7_right-scaled_col1_left;
  1489.     too_wide = scaled_width > scaled_template_width;
  1491.     sratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  1492.     sratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  1493.     sratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  1494.     sratio4 = (II_TYPE)srect4/(II_TYPE)srect5;
  1495.     sratio5 = (II_TYPE)srect5/(II_TYPE)srect6;
  1496.     sratio6 = (II_TYPE)srect6/(II_TYPE)srect7;
  1497.   }
  1498.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect3
  1499.               -(II_TYPE)srect1/(II_TYPE)srect3)<SCALE_DIFFERENCE_EPSILON);
  1500.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect4
  1501.               -(II_TYPE)srect1/(II_TYPE)srect4)<SCALE_DIFFERENCE_EPSILON);
  1502.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect5
  1503.               -(II_TYPE)srect1/(II_TYPE)srect5)<SCALE_DIFFERENCE_EPSILON);
  1504.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect6
  1505.               -(II_TYPE)srect1/(II_TYPE)srect6)<SCALE_DIFFERENCE_EPSILON);
  1506.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect7
  1507.               -(II_TYPE)srect1/(II_TYPE)srect7)<SCALE_DIFFERENCE_EPSILON);
  1509.   int overlap = scaled_col7_right-scaled_template_width+1;
  1510.   // overlap: by how much is rightmost too far to the right? 
  1511.   // it must not be larger than scaled_template_width-1
  1512.   if (overlap>0) {
  1513.     // went outside template boundaries
  1514.     if (too_wide) {
  1515.       // feature too big, use int scale
  1516.       *pScale_x = floor(*pScale_x);
  1517.       Scale(*pScale_x, *pScale_y);
  1518.     } else {
  1519.       // shift feature by overlap
  1520.       scaled_col1_left -= overlap;
  1521.       scaled_col2_left -= overlap;
  1522.       scaled_col3_left -= overlap;
  1523.       scaled_col4_left -= overlap;
  1524.       scaled_col5_left -= overlap;
  1525.       scaled_col6_left -= overlap;
  1526.       scaled_col7_left -= overlap;
  1527.       scaled_col7_right -= overlap;
  1528.       *pScale_x = sratio1;
  1529.     }
  1530.   } else {
  1531.     *pScale_x = sratio1;
  1532.   }
  1533. }
  1535. void CSevenColumnsIF::SetToFirstIncarnation()
  1536. {
  1537.   if (m_is_partial) {
  1538.     toprow=start_toprow;
  1539.     bottomrow=start_bottomrow;
  1540.     col1_left = start_col1_left;
  1541.     col2_left = start_col2_left;
  1542.     col3_left = start_col3_left;
  1543.     col4_left = start_col4_left;
  1544.     col5_left = start_col5_left;
  1545.     col6_left = start_col6_left;
  1546.     col7_left = start_col7_left;
  1547.     col7_right= start_col7_right;
  1548.     m_remaining_incarnations=m_stop_after_num_incarnations;
  1549.   } else {
  1550.     toprow=-1;
  1551.     bottomrow=0;
  1552.     col1_left = -1;
  1553.     col2_left = 0;
  1554.     col3_left = 1;
  1555.     col4_left = 2;
  1556.     col5_left = 3;
  1557.     col6_left = 4;
  1558.     col7_left = 5;
  1559.     col7_right= 6;
  1560.   }
  1561.   SetNonOverlap();
  1562. }
  1564. bool CSevenColumnsIF::SetToNextIncarnation()
  1565. {
  1566. if (m_is_partial) {
  1567. if (m_remaining_incarnations) {
  1568. m_remaining_incarnations--;
  1569. } else {
  1570. return false;
  1571. }
  1572. }
  1573.   col7_right++;
  1574.   if (col7_right>=m_template_width) {
  1575.     col7_left++;
  1576.     if (col7_left>=m_template_width-1) {
  1577.       col6_left++;
  1578.       if (col6_left>=m_template_width-2) {
  1579.         col5_left++;
  1580.       if (col5_left>=m_template_width-3) {
  1581.             col4_left++;
  1582.             if (col4_left>=m_template_width-4) {
  1583.             col3_left++;
  1584.                 if (col3_left>=m_template_width-5) {
  1585.                   col2_left++;
  1586.                   if (col2_left>=m_template_width-6) {
  1587.                     col1_left++;
  1588.                     if (col1_left>=m_template_width-7) {
  1589.                       bottomrow++;
  1590.                       if (bottomrow==m_template_height) {
  1591.                         toprow++;
  1592.                         if (toprow==m_template_height-1) {
  1593.                           return false;
  1594.                         }
  1595.                         bottomrow = toprow+1;
  1596.                       }
  1597.                       col1_left = -1;
  1598.                     }
  1599.                     col2_left = col1_left+1;
  1600.                   }
  1601.                   col3_left = col2_left+1;
  1602.                 }
  1603.                 col4_left = col3_left+1;
  1604.             }
  1605.             col5_left = col4_left+1;
  1606.           }
  1607.           col6_left = col5_left+1;
  1608.       }
  1609.       col7_left = col6_left+1;
  1610.     }
  1611.     col7_right = col7_left+1;
  1612.   }
  1613.   SetNonOverlap();
  1614. return true;
  1615. }
  1617. CIntegralFeature* CSevenColumnsIF::Copy() const
  1618. {
  1619. return new CSevenColumnsIF(*this);
  1620. }
  1622. void CSevenColumnsIF::MakePartialFromCurrentForNumIncarnations(
  1623.   featnum num)
  1624. {
  1625.   m_is_partial = true;
  1626.   m_num_incarnations=num+1;
  1627.   start_toprow = toprow;
  1628.   start_bottomrow = bottomrow;
  1629.   start_col1_left = col1_left;
  1630.   start_col2_left = col2_left;
  1631.   start_col3_left = col3_left;
  1632.   start_col4_left = col4_left;
  1633.   start_col5_left = col5_left;
  1634.   start_col6_left = col6_left;
  1635.   start_col7_left = col7_left;
  1636.   start_col7_right= col7_right;
  1637.   m_remaining_incarnations = m_stop_after_num_incarnations=num;
  1638. }
  1640. #ifdef USE_MFC
  1641. void CSevenColumnsIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  1642. {
  1643. int tr = y_off + zoomfactor + toprow*zoomfactor;
  1644. int br = y_off + zoomfactor + bottomrow*zoomfactor;
  1645. int c1 = x_off + zoomfactor + col1_left*zoomfactor;
  1646. int c2 = x_off + zoomfactor + col2_left*zoomfactor;
  1647. int c3 = x_off + zoomfactor + col3_left*zoomfactor;
  1648. int c4 = x_off + zoomfactor + col4_left*zoomfactor;
  1649. int c5 = x_off + zoomfactor + col5_left*zoomfactor;
  1650. int c6 = x_off + zoomfactor + col6_left*zoomfactor;
  1651. int c7 = x_off + zoomfactor + col7_left*zoomfactor;
  1652. int cr = x_off + zoomfactor + col7_right*zoomfactor;
  1653. pDC->FillRect(CRect(c1, tr, c2, br), g_pBlackbrush);
  1654. pDC->Rectangle(c2, tr, c3, br);
  1655. pDC->FillRect(CRect(c3, tr, c4, br), g_pBlackbrush);
  1656. pDC->Rectangle(c4, tr, c5, br);
  1657. pDC->FillRect(CRect(c5, tr, c6, br), g_pBlackbrush);
  1658. pDC->Rectangle(c6, tr, c7, br);
  1659. pDC->FillRect(CRect(c7, tr, cr, br), g_pBlackbrush);
  1660. }
  1661. #endif // USE_MFC
  1663. ostream& CSevenColumnsIF::output(ostream& os) const
  1664. {
  1665.   os << "SevenColumns " << toprow << "," << bottomrow << " x "
  1666.      << col1_left << "," << col2_left << "," << col3_left << "," << col4_left << ","
  1667.      << col5_left << "," << col6_left << "," << col7_left << "," << col7_right;
  1668.   return os;
  1669. }
  1675. /////////////////////////////////////////////////////////////////////////////
  1676. //
  1677. // CDiagIF classes implementation
  1678. //
  1679. /////////////////////////////////////////////////////////////////////////////
  1681. CDiagIF::CDiagIF(int templateWidth, int templateHeight)
  1682.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 9*COST_GET+15*COST_ADD) 
  1683. {
  1684. }
  1686. CDiagIF::CDiagIF(int templateWidth, int templateHeight,
  1687.         int _toprect_toprow, int _centerrow,
  1688.         int _bottomrect_bottomrow,
  1689.         int _leftrect_leftcol, int _centercol,
  1690.         int _rightrect_rightcol)
  1691.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 9*COST_GET+15*COST_ADD) 
  1692. {
  1693.   toprect_toprow = _toprect_toprow;
  1694.   centerrow = _centerrow;
  1695.   bottomrect_bottomrow = _bottomrect_bottomrow;
  1696.   leftrect_leftcol = _leftrect_leftcol;
  1697.   centercol = _centercol;
  1698.   rightrect_rightcol = _rightrect_rightcol;
  1699.   SetNonOverlap();
  1700. }
  1702. CDiagIF::CDiagIF(const CDiagIF& frm)
  1703.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  1704.      frm.m_num_incarnations, frm.m_is_partial, 9*COST_GET+15*COST_ADD) 
  1705. {
  1706.   toprect_toprow=frm.toprect_toprow;
  1707.   centerrow=frm.centerrow;
  1708.   bottomrect_bottomrow=frm.bottomrect_bottomrow;
  1709.   leftrect_leftcol = frm.leftrect_leftcol;
  1710.   centercol = frm.centercol;
  1711.   rightrect_rightcol = frm.rightrect_rightcol;
  1712.   if (m_is_partial) {
  1713.     start_toprect_toprow=frm.start_toprect_toprow;
  1714.     start_centerrow=frm.start_centerrow;
  1715.     start_bottomrect_bottomrow=frm.start_bottomrect_bottomrow;
  1716.     start_leftrect_leftcol = frm.start_leftrect_leftcol;
  1717.     start_centercol = frm.start_centercol;
  1718.     start_rightrect_rightcol = frm.start_rightrect_rightcol;
  1719.     m_remaining_incarnations = frm.m_remaining_incarnations;
  1720.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  1721.   }
  1722.   SetNonOverlap();
  1723. }
  1725. CDiagIF::CDiagIF(istream& is, int templateWidth, int templateHeight)
  1726.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 9*COST_GET+15*COST_ADD) 
  1727. {
  1728.   char a, b, c, d;
  1729.   string str;
  1730.   is >> toprect_toprow >> a >> centerrow >> b
  1731.      >> bottomrect_bottomrow >> str
  1732.      >> leftrect_leftcol >> c >> centercol >> d
  1733.      >> rightrect_rightcol;
  1734.   if (a!=',' || b!=',' || str!="x" || c!=',' || d!=',') {
  1735.     char* buf = (char*) alloca((256+str.length())*sizeof(char));
  1736.     sprintf(buf, "error during construction of DiagIF (%c|%c|%s|%c|%c)n",
  1737.    a, b, str.c_str(), c, d);
  1738.     throw ITException(buf);
  1739.   }
  1740.   SetNonOverlap();
  1741. }
  1743. bool CDiagIF::Equals(const CDiagIF& frm) const
  1744. {
  1745.   bool equal = 
  1746.     (toprect_toprow == frm.toprect_toprow &&
  1747.      centerrow == frm.centerrow &&
  1748.      bottomrect_bottomrow == frm.bottomrect_bottomrow &&
  1749.      leftrect_leftcol  ==  frm.leftrect_leftcol &&
  1750.      centercol  ==  frm.centercol &&
  1751.      rightrect_rightcol  ==  frm.rightrect_rightcol);
  1752.   return equal;
  1753. }
  1755. void CDiagIF::SetNonOverlap() {
  1756.   // left_upper - right_upper - left_lower + right_lower
  1757.   m_non_overlap =
  1758.     (centercol-leftrect_leftcol)*(centerrow-toprect_toprow)
  1759.     - (rightrect_rightcol-centercol)*(centerrow-toprect_toprow)
  1760.     - (centercol-leftrect_leftcol)*(bottomrect_bottomrow-centerrow)
  1761.     + (rightrect_rightcol-centercol)*(bottomrect_bottomrow-centerrow);
  1762. }
  1764. II_TYPE CDiagIF::Compute(const CIntegralImage& image) const
  1765. {
  1766.   II_TYPE ceri = image.GetElement(rightrect_rightcol, centerrow);
  1767.   II_TYPE cele = image.GetElement(leftrect_leftcol, centerrow);
  1768.   II_TYPE cecen = image.GetElement(centercol, centerrow);
  1769.   II_TYPE topcen = image.GetElement(centercol, toprect_toprow);
  1770.   II_TYPE botcen = image.GetElement(centercol, bottomrect_bottomrow);
  1771.   
  1772.   II_TYPE val_topleft = 
  1773.     cecen
  1774.     - cele
  1775.     - topcen
  1776.     + image.GetElement(leftrect_leftcol, toprect_toprow);
  1777.   
  1778.   II_TYPE val_topright = 
  1779.     ceri
  1780.     - cecen
  1781.     - image.GetElement(rightrect_rightcol, toprect_toprow)
  1782.     + topcen;
  1783.   
  1784.   II_TYPE val_bottomleft = 
  1785.     botcen
  1786.     - image.GetElement(leftrect_leftcol, bottomrect_bottomrow)
  1787.     - cecen
  1788.     + cele;
  1789.   
  1790.   II_TYPE val_bottomright = 
  1791.     image.GetElement(rightrect_rightcol, bottomrect_bottomrow)
  1792.     - botcen
  1793.     - ceri
  1794.     + cecen;
  1795.   
  1796.   return val_topleft-val_topright-val_bottomleft+val_bottomright;
  1797. }
  1799. II_TYPE CDiagIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  1800. {
  1801.   int placed_leftrect_leftcol = left + scaled_leftrect_leftcol;
  1802.   int placed_centercol = left + scaled_centercol;
  1803.   int placed_rightrect_rightcol = left + scaled_rightrect_rightcol;
  1804.   int placed_toprect_toprow = top + scaled_toprect_toprow;
  1805.   int placed_centerrow = top + scaled_centerrow;
  1806.   int placed_bottomrect_bottomrow = top + scaled_bottomrect_bottomrow;
  1807.   
  1808.   II_TYPE ceri = image.GetElement(placed_rightrect_rightcol, placed_centerrow);
  1809.   II_TYPE cele = image.GetElement(placed_leftrect_leftcol, placed_centerrow);
  1810.   II_TYPE cecen = image.GetElement(placed_centercol, placed_centerrow);
  1811.   II_TYPE topcen = image.GetElement(placed_centercol, placed_toprect_toprow);
  1812.   II_TYPE botcen = image.GetElement(placed_centercol, placed_bottomrect_bottomrow);
  1813.   
  1814.   II_TYPE val_topleft = 
  1815.     cecen
  1816.     - cele
  1817.     - topcen
  1818.     + image.GetElement(placed_leftrect_leftcol, placed_toprect_toprow);
  1819.   
  1820.   II_TYPE val_topright = 
  1821.     ceri
  1822.     - cecen
  1823.     - image.GetElement(placed_rightrect_rightcol, placed_toprect_toprow)
  1824.     + topcen;
  1825.   
  1826.   II_TYPE val_bottomleft = 
  1827.     botcen
  1828.     - image.GetElement(placed_leftrect_leftcol, placed_bottomrect_bottomrow)
  1829.     - cecen
  1830.     + cele;
  1831.   
  1832.   II_TYPE val_bottomright = 
  1833.     image.GetElement(placed_rightrect_rightcol, placed_bottomrect_bottomrow)
  1834.     - botcen
  1835.     - ceri
  1836.     + cecen;
  1837.   
  1838.   II_TYPE val = val_topleft-val_topright-val_bottomleft+val_bottomright;
  1839.   II_TYPE scaled_val = val/m_global_scale;
  1840.   II_TYPE mean_adjust = m_non_overlap*mean;
  1842.   return scaled_val-mean_adjust;
  1843. }
  1845. void CDiagIF::ScaleX(II_TYPE scale_x)
  1846. {
  1847.   if (leftrect_leftcol==-1) {
  1848.     scaled_leftrect_leftcol = -1;
  1849.     scaled_centercol = (int)((II_TYPE)(centercol+1)*scale_x) - 1;
  1850.     scaled_rightrect_rightcol =
  1851.       (int)((II_TYPE)(rightrect_rightcol-centercol)*scale_x) + scaled_centercol;
  1852.   } else {
  1853.     scaled_leftrect_leftcol = (int)((II_TYPE)leftrect_leftcol*scale_x);
  1854.     scaled_centercol = (int)((II_TYPE)centercol*scale_x);
  1855.     scaled_rightrect_rightcol = (int)((II_TYPE)rightrect_rightcol*scale_x);
  1856.   }
  1857. }
  1859. void CDiagIF::ScaleY(II_TYPE scale_y)
  1860. {
  1861.   if (toprect_toprow==-1) {
  1862.     scaled_toprect_toprow = -1;
  1863.     scaled_centerrow = (int)((II_TYPE)(centerrow+1)*scale_y) - 1;
  1864.     scaled_bottomrect_bottomrow =
  1865.       (int)((II_TYPE)(bottomrect_bottomrow-centerrow)*scale_y)
  1866.       + scaled_centerrow;
  1867.   } else {
  1868.     scaled_toprect_toprow = (int)((II_TYPE)toprect_toprow*scale_y);
  1869.     scaled_centerrow = (int)((II_TYPE)centerrow*scale_y);
  1870.     scaled_bottomrect_bottomrow = (int)((II_TYPE)bottomrect_bottomrow*scale_y);
  1871.   }
  1872. }
  1874. void CDiagIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  1875. {
  1876.   ScaleX(scale_x);
  1877.   ScaleY(scale_y);
  1878.   m_global_scale = scale_x*scale_y;
  1879. }
  1881. void CDiagIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  1882.         int scaled_template_width, int scaled_template_height)
  1883. {
  1884.   int leftrect = centercol-leftrect_leftcol;
  1885.   int rightrect = rightrect_rightcol-centercol;
  1886.   II_TYPE ratio = (II_TYPE)leftrect/(II_TYPE)rightrect;
  1887.   int sleftrect = scaled_centercol-scaled_leftrect_leftcol;
  1888.   int srightrect = scaled_rightrect_rightcol-scaled_centercol;
  1889.   II_TYPE sratio = (II_TYPE)sleftrect/(II_TYPE)srightrect;
  1891.   int scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  1892.   bool too_wide = scaled_width > scaled_template_width;
  1894.   while (!too_wide && fabs(ratio-sratio)>=SCALE_DIFFERENCE_EPSILON) {
  1895.     if (ratio<sratio) {
  1896.       scaled_rightrect_rightcol++;
  1897.       srightrect++;
  1898.     } else {
  1899.       scaled_centercol++;
  1900.       scaled_rightrect_rightcol++;
  1901.       sleftrect++;
  1902.     }
  1903.     scaled_width = scaled_rightrect_rightcol-scaled_leftrect_leftcol;
  1904.     too_wide = scaled_width > scaled_template_width;
  1906.     sratio = (II_TYPE)sleftrect/(II_TYPE)srightrect;
  1907.   }
  1909.   int overlap = scaled_rightrect_rightcol-scaled_template_width+1;
  1910.   // overlap: by how much is rightmost too far to the right? 
  1911.   // it must not be larger than scaled_template_width-1
  1912.   if (overlap>0) {
  1913.     // went outside template boundaries
  1914.     if (too_wide) {
  1915.       // feature too big, use int scale
  1916.       *pScale_x = floor(*pScale_x);
  1917.       ScaleX(*pScale_x);
  1918.     } else {
  1919.       // shift feature by overlap
  1920.       scaled_leftrect_leftcol -= overlap;
  1921.       scaled_centercol -= overlap;
  1922.       scaled_rightrect_rightcol -= overlap;
  1923.       *pScale_x = sratio;
  1924.     }
  1925.   } else {
  1926.     *pScale_x = sratio;
  1927.   }
  1929.   int toprect = centerrow-toprect_toprow;
  1930.   int bottomrect = bottomrect_bottomrow-centerrow;
  1931.   ratio = (II_TYPE)toprect/(II_TYPE)bottomrect;
  1932.   int stoprect = scaled_centerrow-scaled_toprect_toprow;
  1933.   int sbottomrect = scaled_bottomrect_bottomrow-scaled_centerrow;
  1934.   sratio = (II_TYPE)stoprect/(II_TYPE)sbottomrect;
  1936.   int scaled_height = scaled_bottomrect_bottomrow-toprect_toprow;
  1937.   bool too_high = scaled_height > scaled_template_height;
  1939.   while (!too_high && fabs(ratio-sratio)>=SCALE_DIFFERENCE_EPSILON) {
  1940.     if (ratio<sratio) {
  1941.       scaled_bottomrect_bottomrow++;
  1942.       sbottomrect++;
  1943.     } else {
  1944.       scaled_centerrow++;
  1945.       scaled_bottomrect_bottomrow++;
  1946.       stoprect++;
  1947.     }
  1948.     scaled_height = scaled_bottomrect_bottomrow-toprect_toprow;
  1949.     too_high = scaled_height > scaled_template_height;
  1951.     sratio = (II_TYPE)stoprect/(II_TYPE)sbottomrect;
  1952.   }
  1954.   overlap = scaled_bottomrect_bottomrow-scaled_template_height+1;
  1955.   // overlap: by how much is bottommost too far down? 
  1956.   // it must not be larger than scaled_template_height-1
  1957.   if (overlap>0) {
  1958.     // went outside template boundaries
  1959.     if (too_high) {
  1960.       // feature too big, use int scale
  1961.       *pScale_y = floor(*pScale_y);
  1962.       ScaleY(*pScale_y);
  1963.     } else {
  1964.       // shift feature by overlap
  1965.       scaled_toprect_toprow -= overlap;
  1966.       scaled_centerrow -= overlap;
  1967.       scaled_bottomrect_bottomrow -= overlap;
  1968.       *pScale_y = sratio;
  1969.     }
  1970.   } else {
  1971.     *pScale_y = sratio;
  1972.   }
  1973. }
  1975. void CDiagIF::SetToFirstIncarnation()
  1976. {
  1977.   if (m_is_partial) {
  1978.     toprect_toprow=start_toprect_toprow;
  1979.     centerrow=start_centerrow;
  1980.     bottomrect_bottomrow=start_bottomrect_bottomrow;
  1981.     leftrect_leftcol=start_leftrect_leftcol;
  1982.     centercol=start_centercol;
  1983.     rightrect_rightcol=start_rightrect_rightcol;
  1984.     m_remaining_incarnations=m_stop_after_num_incarnations;
  1985.   } else {
  1986.     toprect_toprow=-1;
  1987.     centerrow=0;
  1988.     bottomrect_bottomrow=1;
  1989.     leftrect_leftcol=-1;
  1990.     centercol=0;
  1991.     rightrect_rightcol=1;
  1992.   }
  1993.   SetNonOverlap();
  1994. }
  1996. bool CDiagIF::SetToNextIncarnation()
  1997. {
  1998.   if (m_is_partial) {
  1999.     if (m_remaining_incarnations) {
  2000.       m_remaining_incarnations--;
  2001.     } else {
  2002.       return false;
  2003.     }
  2004.   }
  2005.   bottomrect_bottomrow++;
  2006.   if (bottomrect_bottomrow>=m_template_height) {
  2007.     centerrow++;
  2008.     if (centerrow>=m_template_height-1) {
  2009.       toprect_toprow++;
  2010.       if (toprect_toprow==m_template_height-2) {
  2011. rightrect_rightcol++;
  2012. if (rightrect_rightcol==m_template_width) {
  2013.   centercol++;
  2014.   if (centercol==m_template_width-1) {
  2015.     leftrect_leftcol++;
  2016.     if (leftrect_leftcol==m_template_width-2) {
  2017.       return false;
  2018.     }
  2019.     centercol=leftrect_leftcol+1;
  2020.   }
  2021.   rightrect_rightcol=centercol+1;
  2022. }
  2023. toprect_toprow=-1;
  2024.       }
  2025.       centerrow=toprect_toprow+1;
  2026.     }
  2027.     bottomrect_bottomrow=centerrow+1;
  2028.   }
  2029.   SetNonOverlap();
  2030.   return true;
  2031. }
  2033. CIntegralFeature* CDiagIF::Copy() const
  2034. {
  2035. return new CDiagIF(*this);
  2036. }
  2038. void CDiagIF::MakePartialFromCurrentForNumIncarnations(
  2039.   featnum num)
  2040. {
  2041.   m_is_partial=true;
  2042.   m_num_incarnations=num+1;
  2043.   start_toprect_toprow=toprect_toprow;
  2044.   start_centerrow=centerrow;
  2045.   start_bottomrect_bottomrow=bottomrect_bottomrow;
  2046.   start_leftrect_leftcol=leftrect_leftcol;
  2047.   start_centercol=centercol;
  2048.   start_rightrect_rightcol=rightrect_rightcol;
  2049.   m_remaining_incarnations=m_stop_after_num_incarnations=num;
  2050. }
  2052. #ifdef USE_MFC
  2053. void CDiagIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  2054. {
  2055.   int lc = x_off + zoomfactor + leftrect_leftcol*zoomfactor;
  2056.   int cc = x_off + zoomfactor + centercol*zoomfactor;
  2057.   int rc = x_off + zoomfactor + rightrect_rightcol*zoomfactor;
  2058.   int tr = y_off + zoomfactor + toprect_toprow*zoomfactor;
  2059.   int cr = y_off + zoomfactor + centerrow*zoomfactor;
  2060.   int br = y_off + zoomfactor + bottomrect_bottomrow*zoomfactor;
  2061.   pDC->FillRect(CRect(lc, tr, cc, cr), g_pBlackbrush);
  2062.   pDC->Rectangle(cc, tr, rc, cr);
  2063.   pDC->Rectangle(lc, cr, cc, br);
  2064.   pDC->FillRect(CRect(cc, cr, rc, br), g_pBlackbrush);
  2065. }
  2066. #endif // USE_MFC
  2068. ostream& CDiagIF::output(ostream& os) const
  2069. {
  2070.   os << "Diag " << toprect_toprow << "," << centerrow 
  2071.      << "," << bottomrect_bottomrow << " x "
  2072.      << leftrect_leftcol << "," << centerrow
  2073.      << "," << rightrect_rightcol;
  2074.   return os;
  2075. }
  2078. /////////////////////////////////////////////////////////////////////////////
  2079. //
  2080. // CFourBoxesIF classes implementation
  2081. //
  2082. /////////////////////////////////////////////////////////////////////////////
  2084. /* they look like this:
  2085. *   b3
  2086. * b1  b4
  2087. *   b2
  2088. * 
  2089. * b1,b4 can't overlap,
  2090. * b2,b3 can't overlap,
  2091. * b1_left must be left of b2_left and b3_left
  2092. * b1_right must be right of b2_left and b3_left
  2093. * ... and so on, see SetToNextIncarnation
  2094. */
  2095. CFourBoxesIF::CFourBoxesIF(int templateWidth, int templateHeight)
  2096.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+15*COST_ADD) 
  2097. {
  2098. }
  2100. CFourBoxesIF::CFourBoxesIF(int templateWidth, int templateHeight,
  2101.              const CRect* pB1, const CRect* pB2,
  2102.              const CRect* pB3, const CRect* pB4)
  2103.   : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+15*COST_ADD) 
  2104. {
  2105.   b1_left = pB1->left;  b1_top = pB1->top;
  2106.   b1_right = pB1->right;  b1_bottom = pB1->bottom;
  2107.   b2_left = pB2->left;  b2_top = pB2->top;
  2108.   b2_right = pB2->right;  b2_bottom = pB2->bottom;
  2109.   b3_left = pB3->left;  b3_top = pB3->top;
  2110.   b3_right = pB3->right;  b3_bottom = pB3->bottom;
  2111.   b4_left = pB4->left;  b4_top = pB4->top;
  2112.   b4_right = pB4->right;  b4_bottom = pB4->bottom;
  2113.   SetNonOverlap();
  2114. }
  2116. CFourBoxesIF::CFourBoxesIF(const CFourBoxesIF& frm)
  2117.   : CIntegralFeature(frm.m_template_width, frm.m_template_height,
  2118.      frm.m_num_incarnations, frm.m_is_partial, 16*COST_GET+15*COST_ADD) 
  2119. {
  2120.   b1_left = frm.b1_left;  b1_top = frm.b1_top;
  2121.   b1_right = frm.b1_right;  b1_bottom = frm.b1_bottom;
  2122.   b2_left = frm.b2_left;  b2_top = frm.b2_top;
  2123.   b2_right = frm.b2_right;  b2_bottom = frm.b2_bottom;
  2124.   b3_left = frm.b3_left;  b3_top = frm.b3_top;
  2125.   b3_right = frm.b3_right;  b3_bottom = frm.b3_bottom;
  2126.   b4_left = frm.b4_left;  b4_top = frm.b4_top;
  2127.   b4_right = frm.b4_right;  b4_bottom = frm.b4_bottom;
  2128.   if (m_is_partial) {
  2129.     start_b1_left = frm.start_b1_left;  start_b1_top = frm.start_b1_top;
  2130.     start_b1_right = frm.start_b1_right;  start_b1_bottom = frm.start_b1_bottom;
  2131.     start_b2_left = frm.start_b2_left;  start_b2_top = frm.start_b2_top;
  2132.     start_b2_right = frm.start_b2_right;  start_b2_bottom = frm.start_b2_bottom;
  2133.     start_b3_left = frm.start_b3_left;  start_b3_top = frm.start_b3_top;
  2134.     start_b3_right = frm.start_b3_right;  start_b3_bottom = frm.start_b3_bottom;
  2135.     start_b4_left = frm.start_b4_left;  start_b4_top = frm.start_b4_top;
  2136.     start_b4_right = frm.start_b4_right;  start_b4_bottom = frm.start_b4_bottom;
  2137.     m_remaining_incarnations = frm.m_remaining_incarnations;
  2138.     m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  2139.   }
  2140.   SetNonOverlap();
  2141. }
  2143. CFourBoxesIF::CFourBoxesIF(istream& is, int template_width, int template_height)
  2144.   : CIntegralFeature(template_width, template_height, IT_INVALID_FEATURE, 0, 16*COST_GET+15*COST_ADD)
  2145. {
  2146.   char a, b, c, d, e, f;
  2147.   is >> e >> b1_left >> a >> b1_top >> b >> b1_right >> c >> b1_bottom >> f >> d;
  2148.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  2149.     char* buf = (char*) alloca(256*sizeof(char));
  2150.     sprintf(buf, "error during construction of FourBoxesIF (%c|%c|%c|%c|%c)n",
  2151.    e, a, b, c, f);
  2152.     throw ITException(buf);
  2153.   }
  2154.   is >> e >> b2_left >> a >> b2_top >> b >> b2_right >> c >> b2_bottom >> f >> d;
  2155.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  2156.     char* buf = (char*) alloca(256*sizeof(char));
  2157.     sprintf(buf, "error during construction of FourBoxesIF (%c|%c|%c|%c|%c)n",
  2158.    e, a, b, c, f);
  2159.     throw ITException(buf);
  2160.   }
  2161.   is >> e >> b3_left >> a >> b3_top >> b >> b3_right >> c >> b3_bottom >> f >> d;
  2162.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  2163.     char* buf = (char*) alloca(256*sizeof(char));
  2164.     sprintf(buf, "error during construction of FourBoxesIF (%c|%c|%c|%c|%c)n",
  2165.    e, a, b, c, f);
  2166.     throw ITException(buf);
  2167.   }
  2168.   is >> e >> b4_left >> a >> b4_top >> b >> b4_right >> c >> b4_bottom >> f;
  2169.   if (a!=',' || b!=',' || c!=',' || d!=',' || e!='(' || f!=')') {
  2170.     char* buf = (char*) alloca(256*sizeof(char));
  2171.     sprintf(buf, "error during construction of FourBoxesIF (%c|%c|%c|%c|%c)n",
  2172.    e, a, b, c, f);
  2173.     throw ITException(buf);
  2174.   }
  2175.   SetNonOverlap();
  2176. }
  2178. bool CFourBoxesIF::Equals(const CFourBoxesIF& frm) const
  2179. {
  2180.   bool equal =
  2181.     (b1_left == frm.b1_left &&  b1_top == frm.b1_top &&
  2182.      b1_right == frm.b1_right &&  b1_bottom == frm.b1_bottom &&
  2183.      b2_left == frm.b2_left &&  b2_top == frm.b2_top &&
  2184.      b2_right == frm.b2_right &&  b2_bottom == frm.b2_bottom &&
  2185.      b3_left == frm.b3_left &&  b3_top == frm.b3_top &&
  2186.      b3_right == frm.b3_right &&  b3_bottom == frm.b3_bottom &&
  2187.      b4_left == frm.b4_left &&  b4_top == frm.b4_top &&
  2188.      b4_right == frm.b4_right &&  b4_bottom == frm.b4_bottom);
  2189.   return equal;
  2190. }
  2191.     
  2192. void CFourBoxesIF::SetNonOverlap() {
  2193.   m_non_overlap =
  2194.     (b1_right-b1_left) * (b1_bottom-b1_top) 
  2195.     + (b2_right-b2_left) * (b2_bottom-b2_top)
  2196.     - (b3_right-b3_left) * (b3_bottom-b3_top)
  2197.     - (b4_right-b4_left) * (b4_bottom-b4_top);
  2198. }
  2200. II_TYPE CFourBoxesIF::Compute(const CIntegralImage& image) const
  2201. {
  2202.   // b1 is the left-top positive box, b2 is the right-bottom positive box,
  2203.   // b3 is the left-top negative box, b4 is the right-bottom positive box 
  2204. II_TYPE val_b1 = 
  2205.     image.GetElement(b1_right, b1_bottom)
  2206.     - image.GetElement(b1_left, b1_bottom)
  2207.     - image.GetElement(b1_right, b1_top)
  2208.     + image.GetElement(b1_left, b1_top);
  2209. II_TYPE val_b2 = 
  2210.     image.GetElement(b2_right, b2_bottom)
  2211.     - image.GetElement(b2_left, b2_bottom)
  2212.     - image.GetElement(b2_right, b2_top)
  2213.     + image.GetElement(b2_left, b2_top);
  2214. II_TYPE val_b3 = 
  2215.     image.GetElement(b3_right, b3_bottom)
  2216.     - image.GetElement(b3_left, b3_bottom)
  2217.     - image.GetElement(b3_right, b3_top)
  2218.     + image.GetElement(b3_left, b3_top);
  2219. II_TYPE val_b4 = 
  2220.     image.GetElement(b4_right, b4_bottom)
  2221.     - image.GetElement(b4_left, b4_bottom)
  2222.     - image.GetElement(b4_right, b4_top)
  2223.     + image.GetElement(b4_left, b4_top);
  2225. return val_b1+val_b2-val_b3-val_b4;
  2226. }
  2228. II_TYPE CFourBoxesIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
  2229. {
  2230. int placed_b1_left   = left + scaled_b1_left;
  2231. int placed_b1_right  = left + scaled_b1_right;
  2232. int placed_b1_top    = top  + scaled_b1_top;
  2233. int placed_b1_bottom = top  + scaled_b1_bottom;
  2234. int placed_b2_left   = left + scaled_b2_left;
  2235. int placed_b2_right  = left + scaled_b2_right;
  2236. int placed_b2_top    = top  + scaled_b2_top;
  2237. int placed_b2_bottom = top  + scaled_b2_bottom;
  2238. int placed_b3_left   = left + scaled_b3_left;
  2239. int placed_b3_right  = left + scaled_b3_right;
  2240. int placed_b3_top    = top  + scaled_b3_top;
  2241. int placed_b3_bottom = top  + scaled_b3_bottom;
  2242. int placed_b4_left   = left + scaled_b4_left;
  2243. int placed_b4_right  = left + scaled_b4_right;
  2244. int placed_b4_top    = top  + scaled_b4_top;
  2245. int placed_b4_bottom = top  + scaled_b4_bottom;
  2247.   // b1 is the left-top positive box, b2 is the right-bottom positive box,
  2248.   // b3 is the left-top negative box, b4 is the right-bottom positive box 
  2249. II_TYPE val_b1 = 
  2250.     image.GetElement(placed_b1_right, placed_b1_bottom)
  2251.     - image.GetElement(placed_b1_left, placed_b1_bottom)
  2252.     - image.GetElement(placed_b1_right, placed_b1_top)
  2253.     + image.GetElement(placed_b1_left, placed_b1_top);
  2254. II_TYPE val_b2 = 
  2255.     image.GetElement(placed_b2_right, placed_b2_bottom)
  2256.     - image.GetElement(placed_b2_left, placed_b2_bottom)
  2257.     - image.GetElement(placed_b2_right, placed_b2_top)
  2258.     + image.GetElement(placed_b2_left, placed_b2_top);
  2259. II_TYPE val_b3 = 
  2260.     image.GetElement(placed_b3_right, placed_b3_bottom)
  2261.     - image.GetElement(placed_b3_left, placed_b3_bottom)
  2262.     - image.GetElement(placed_b3_right, placed_b3_top)
  2263.     + image.GetElement(placed_b3_left, placed_b3_top);
  2264. II_TYPE val_b4 = 
  2265.     image.GetElement(placed_b4_right, placed_b4_bottom)
  2266.     - image.GetElement(placed_b4_left, placed_b4_bottom)
  2267.     - image.GetElement(placed_b4_right, placed_b4_top)
  2268.     + image.GetElement(placed_b4_left, placed_b4_top);
  2270. II_TYPE val = val_b1+val_b2-val_b3-val_b4;
  2271. II_TYPE scaled_val = val/m_global_scale;
  2272. II_TYPE mean_adjust = m_non_overlap*mean;
  2274. #ifdef DEBUG
  2275. if (g_printlots) {
  2276.   VERBOSE4(1, "val_b1 %f, val_b2 %f, val_b3 %f, val_b4 %f",
  2277.             val_b1, val_b1, val_b1, val_b1);
  2278.   VERBOSE2(1, "scaled_val %f, mean_adjust %f", 
  2279.             scaled_val, mean_adjust);
  2280.   VERBOSE4(1, "b1 scaled: left %f, top %f, right %f, bottom %f",
  2281.             scaled_b1_left, scaled_b1_top, scaled_b1_right, scaled_b1_bottom);
  2282.   VERBOSE4(1, "b2 scaled: left %f, top %f, right %f, bottom %f",
  2283.             scaled_b2_left, scaled_b2_top, scaled_b2_right, scaled_b2_bottom);
  2284.   VERBOSE4(1, "b3 scaled: left %f, top %f, right %f, bottom %f",
  2285.             scaled_b3_left, scaled_b3_top, scaled_b3_right, scaled_b3_bottom);
  2286.   VERBOSE4(1, "b4 scaled: left %f, top %f, right %f, bottom %f",
  2287.             scaled_b4_left, scaled_b4_top, scaled_b4_right, scaled_b4_bottom);
  2288. }
  2289. #endif // DEBUG
  2290. return scaled_val-mean_adjust;
  2291. }
  2293. void CFourBoxesIF::ScaleX(II_TYPE scale_x)
  2294. {
  2295.   if (b1_left==-1) {
  2296.     scaled_b1_left = -1;
  2297.     scaled_b1_right = (int)((II_TYPE)(b1_right+1)*scale_x) - 1;
  2298.   } else {
  2299.     scaled_b1_left = (int)((II_TYPE)b1_left*scale_x);
  2300.     scaled_b1_right = (int)((II_TYPE)b1_right*scale_x);
  2301.   }
  2302.   if (b2_left==-1) {
  2303.     scaled_b2_left = -1;
  2304.     scaled_b2_right = (int)((II_TYPE)(b2_right+1)*scale_x) - 1;
  2305.   } else {
  2306.     scaled_b2_left = (int)((II_TYPE)b2_left*scale_x);
  2307.     scaled_b2_right = (int)((II_TYPE)b2_right*scale_x);
  2308.   }
  2309.   if (b3_left==-1) {
  2310.     scaled_b3_left = -1;
  2311.     scaled_b3_right = (int)((II_TYPE)(b3_right+1)*scale_x) - 1;
  2312.   } else {
  2313.     scaled_b3_left = (int)((II_TYPE)b3_left*scale_x);
  2314.     scaled_b3_right = (int)((II_TYPE)b3_right*scale_x);
  2315.   }
  2316.   if (b4_left==-1) {
  2317.     scaled_b4_left = -1;
  2318.     scaled_b4_right = (int)((II_TYPE)(b4_right+1)*scale_x) - 1;
  2319.   } else {
  2320.     scaled_b4_left = (int)((II_TYPE)b4_left*scale_x);
  2321.     scaled_b4_right = (int)((II_TYPE)b4_right*scale_x);
  2322.   }
  2323.   ASSERT(-1<=scaled_b1_left);
  2324.   ASSERT(scaled_b1_right<(int)((II_TYPE)m_template_width*scale_x));
  2325.   ASSERT(-1<=scaled_b2_left);
  2326.   ASSERT(scaled_b2_right<(int)((II_TYPE)m_template_width*scale_x));
  2327.   ASSERT(-1<=scaled_b3_left);
  2328.   ASSERT(scaled_b3_right<(int)((II_TYPE)m_template_width*scale_x));
  2329.   ASSERT(-1<=scaled_b4_left);
  2330.   ASSERT(scaled_b4_right<(int)((II_TYPE)m_template_width*scale_x));
  2331. }
  2333. void CFourBoxesIF::ScaleY(II_TYPE scale_y)
  2334. {
  2335.   if (b1_top==-1) {
  2336.     scaled_b1_top = -1;
  2337.     scaled_b1_bottom = (int)((II_TYPE)(b1_bottom+1)*scale_y) - 1;
  2338.   } else {
  2339.     scaled_b1_top = (int)((II_TYPE)b1_top*scale_y);
  2340.     scaled_b1_bottom = (int)((II_TYPE)b1_bottom*scale_y);
  2341.   }
  2342.   if (b2_top==-1) {
  2343.     scaled_b2_top = -1;
  2344.     scaled_b2_bottom = (int)((II_TYPE)(b2_bottom+1)*scale_y) - 1;
  2345.   } else {
  2346.     scaled_b2_top = (int)((II_TYPE)b2_top*scale_y);
  2347.     scaled_b2_bottom = (int)((II_TYPE)b2_bottom*scale_y);
  2348.   }
  2349.   if (b3_top==-1) {
  2350.     scaled_b3_top = -1;
  2351.     scaled_b3_bottom = (int)((II_TYPE)(b3_bottom+1)*scale_y) - 1;
  2352.   } else {
  2353.     scaled_b3_top = (int)((II_TYPE)b3_top*scale_y);
  2354.     scaled_b3_bottom = (int)((II_TYPE)b3_bottom*scale_y);
  2355.   }
  2356.   if (b4_top==-1) {
  2357.     scaled_b4_top = -1;
  2358.     scaled_b4_bottom = (int)((II_TYPE)(b4_bottom+1)*scale_y) - 1;
  2359.   } else {
  2360.     scaled_b4_top = (int)((II_TYPE)b4_top*scale_y);
  2361.     scaled_b4_bottom = (int)((II_TYPE)b4_bottom*scale_y);
  2362.   }
  2363.   ASSERT(-1<=scaled_b1_top);
  2364.   ASSERT(scaled_b1_bottom<(int)((II_TYPE)m_template_height*scale_y));
  2365.   ASSERT(-1<=scaled_b2_top);
  2366.   ASSERT(scaled_b2_bottom<(int)((II_TYPE)m_template_height*scale_y));
  2367.   ASSERT(-1<=scaled_b3_top);
  2368.   ASSERT(scaled_b3_bottom<(int)((II_TYPE)m_template_height*scale_y));
  2369.   ASSERT(-1<=scaled_b4_top);
  2370.   ASSERT(scaled_b4_bottom<(int)((II_TYPE)m_template_height*scale_y));
  2371. }
  2373. void CFourBoxesIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
  2374. {
  2375.   ScaleX(scale_x);
  2376.   ScaleY(scale_y);
  2377.   m_global_scale = scale_x*scale_y;
  2378. }
  2380. void CFourBoxesIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
  2381.         int scaled_template_width, int scaled_template_height)
  2382. {
  2383.   int rect1 = b1_right-b1_left;
  2384.   int rect2 = b2_right-b2_left;
  2385.   int rect3 = b3_right-b3_left;
  2386.   int rect4 = b4_right-b4_left;
  2387.   II_TYPE xratio1 = (II_TYPE)rect1/(II_TYPE)rect2;
  2388.   II_TYPE xratio2 = (II_TYPE)rect2/(II_TYPE)rect3;
  2389.   II_TYPE xratio3 = (II_TYPE)rect3/(II_TYPE)rect4;
  2390.   int srect1 = scaled_b1_right-scaled_b1_left;
  2391.   int srect2 = scaled_b2_right-scaled_b2_left;
  2392.   int srect3 = scaled_b3_right-scaled_b3_left;
  2393.   int srect4 = scaled_b4_right-scaled_b4_left;
  2394.   II_TYPE xsratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  2395.   II_TYPE xsratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  2396.   II_TYPE xsratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  2398.   int rightmost = max(scaled_b2_right, scaled_b4_right);
  2399.   int leftmost = min(scaled_b1_left, scaled_b3_left);
  2400.   bool too_wide = rightmost-leftmost > scaled_template_width;
  2402.   while (!too_wide && 
  2403.  (fabs(xratio1-xsratio1)>=SCALE_DIFFERENCE_EPSILON
  2404.   || fabs(xratio2-xsratio2)>=SCALE_DIFFERENCE_EPSILON
  2405.   || fabs(xratio3-xsratio3)>=SCALE_DIFFERENCE_EPSILON)) {
  2406.     if (xratio1>xsratio1) {
  2407.       scaled_b1_right++;
  2408.       if (scaled_b4_left<scaled_b1_right) {
  2409.         scaled_b4_left++;
  2410.         scaled_b4_right++;
  2411.       }
  2412.       srect1++;
  2413.     } else if (xratio1<xsratio1 || xratio2>xsratio2) {
  2414.       scaled_b2_right++;
  2415.       srect2++;
  2416.     } else if (xratio2<xsratio2 || xratio3>xsratio3) {
  2417.       scaled_b3_right++;
  2418.       srect3++;
  2419.     } else if (xratio3<xsratio3) {
  2420.       scaled_b4_right++;
  2421.       srect4++;
  2422.     } else {
  2423.       throw ITException("error during CFourBoxesIF xscaling - e too small?");
  2424.     }
  2426.     rightmost = max(scaled_b2_right, scaled_b4_right);
  2427.     leftmost = min(scaled_b1_left, scaled_b3_left);
  2428.     too_wide = rightmost-leftmost > scaled_template_width;
  2430.     xsratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  2431.     xsratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  2432.     xsratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  2433.   }
  2434.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect3
  2435.               -(II_TYPE)srect1/(II_TYPE)srect3)<SCALE_DIFFERENCE_EPSILON);
  2436.   ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect4
  2437.               -(II_TYPE)srect1/(II_TYPE)srect4)<SCALE_DIFFERENCE_EPSILON);
  2440.   int overlap = rightmost-scaled_template_width+1; 
  2441.   // overlap: by how much is rightmost too far to the right? 
  2442.   // it must not be larger than scaled_template_width-1
  2443.   if (overlap>0) {
  2444.     // went outside template boundaries
  2445.     if (too_wide) {
  2446.       // feature too big, use int scale
  2447.       *pScale_x = floor(*pScale_x);
  2448.       ScaleX(*pScale_x);
  2449.     } else {
  2450.       // shift feature by overlap
  2451.       scaled_b1_left -= overlap;
  2452.       scaled_b1_right -= overlap;
  2453.       scaled_b2_left -= overlap;
  2454.       scaled_b2_right -= overlap;
  2455.       scaled_b3_left -= overlap;
  2456.       scaled_b3_right -= overlap;
  2457.       scaled_b4_left -= overlap;
  2458.       scaled_b4_right -= overlap;
  2459.       *pScale_x = xsratio1;
  2460.     }
  2461.   } else {
  2462.     *pScale_x = xsratio1;
  2463.   }
  2464.   ASSERT(-1<=scaled_b1_left && scaled_b1_right<scaled_template_width);
  2465.   ASSERT(-1<=scaled_b2_left && scaled_b2_right<scaled_template_width);
  2466.   ASSERT(-1<=scaled_b3_left && scaled_b3_right<scaled_template_width);
  2467.   ASSERT(-1<=scaled_b4_left && scaled_b4_right<scaled_template_width);
  2469.   rect1 = b1_bottom-b1_top;
  2470.   rect2 = b2_bottom-b2_top;
  2471.   rect3 = b3_bottom-b3_top;
  2472.   rect4 = b4_bottom-b4_top;
  2473.   II_TYPE yratio1 = (II_TYPE)rect1/(II_TYPE)rect2;
  2474.   II_TYPE yratio2 = (II_TYPE)rect2/(II_TYPE)rect3;
  2475.   II_TYPE yratio3 = (II_TYPE)rect3/(II_TYPE)rect4;
  2476.   srect1 = scaled_b1_bottom-scaled_b1_top;
  2477.   srect2 = scaled_b2_bottom-scaled_b2_top;
  2478.   srect3 = scaled_b3_bottom-scaled_b3_top;
  2479.   srect4 = scaled_b4_bottom-scaled_b4_top;
  2480.   II_TYPE ysratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  2481.   II_TYPE ysratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  2482.   II_TYPE ysratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  2483.   
  2484.   int bottommost = max(scaled_b2_bottom, scaled_b4_bottom);
  2485.   int topmost = min(scaled_b1_top, scaled_b3_top);
  2486.   bool too_high = bottommost-topmost > scaled_template_height;
  2488.   while (!too_high 
  2489.  && (fabs(yratio1-ysratio1)>=SCALE_DIFFERENCE_EPSILON
  2490.      || fabs(yratio2-ysratio2)>=SCALE_DIFFERENCE_EPSILON
  2491.      || fabs(yratio3-ysratio3)>=SCALE_DIFFERENCE_EPSILON)) 
  2492.   {
  2493.     if (yratio1>ysratio1) {
  2494.       scaled_b1_bottom++;
  2495.       if (scaled_b2_top<scaled_b1_bottom) {
  2496.         scaled_b2_top++;
  2497.         scaled_b2_bottom++;
  2498.       }
  2499.       srect1++;
  2500.     } else if (yratio1<ysratio1 || yratio2>ysratio2) {
  2501.       scaled_b2_bottom++;
  2502.       srect2++;
  2503.     } else if (yratio2<ysratio2 || yratio3>ysratio3) {
  2504.       scaled_b3_bottom++;
  2505.       if (scaled_b4_top<scaled_b3_bottom) {
  2506.         scaled_b4_top++;
  2507.         scaled_b4_bottom++;
  2508.       }
  2509.       srect3++;
  2510.     } else if (yratio3<ysratio3) {
  2511.       scaled_b4_bottom++;
  2512.       srect4++;
  2513.     } else {
  2514.       throw ITException("error during CFourBoxesIF yscaling - e too small?");
  2515.     }
  2517.     bottommost = max(scaled_b2_bottom, scaled_b4_bottom);
  2518.     topmost = min(scaled_b1_top, scaled_b3_top);
  2519.     too_high = bottommost-topmost > scaled_template_height;
  2521.     ysratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  2522.     ysratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  2523.     ysratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  2524.   }
  2525.   ASSERT(too_high || fabs((II_TYPE)rect1/(II_TYPE)rect3
  2526.               -(II_TYPE)srect1/(II_TYPE)srect3)<SCALE_DIFFERENCE_EPSILON);
  2527.   ASSERT(too_high || fabs((II_TYPE)rect1/(II_TYPE)rect4
  2528.               -(II_TYPE)srect1/(II_TYPE)srect4)<SCALE_DIFFERENCE_EPSILON);
  2530.   overlap = bottommost-scaled_template_height+1;
  2531.   // overlap: by how much is bottommost too far down? 
  2532.   // it must not be larger than scaled_template_height-1
  2533.   if (overlap>0) {
  2534.     // went outside template boundaries
  2535.     if (too_high) {
  2536.       // feature too big, use int scale
  2537.       *pScale_y = floor(*pScale_y);
  2538.       ScaleY(*pScale_y);
  2539.     } else {
  2540.       // shift feature by overlap
  2541.       scaled_b1_top -= overlap;
  2542.       scaled_b1_bottom -= overlap;
  2543.       scaled_b2_top -= overlap;
  2544.       scaled_b2_bottom -= overlap;
  2545.       scaled_b3_top -= overlap;
  2546.       scaled_b3_bottom -= overlap;
  2547.       scaled_b4_top -= overlap;
  2548.       scaled_b4_bottom -= overlap;
  2549.       *pScale_y = ysratio1;
  2550.     }
  2551.   } else {
  2552.     *pScale_y = ysratio1;
  2553.   }
  2555.   ASSERT(-1<=scaled_b1_top && scaled_b1_bottom<scaled_template_height);
  2556.   ASSERT(-1<=scaled_b2_top && scaled_b2_bottom<scaled_template_height);
  2557.   ASSERT(-1<=scaled_b3_top && scaled_b3_bottom<scaled_template_height);
  2558.   ASSERT(-1<=scaled_b4_top && scaled_b4_bottom<scaled_template_height);
  2559. }
  2561. void CFourBoxesIF::SetToFirstIncarnation()
  2562. {
  2563.   if (m_is_partial) {
  2564.     b1_left = start_b1_left;  b1_top = start_b1_top;
  2565.     b1_right = start_b1_right;  b1_bottom = start_b1_bottom;
  2566.     b2_left = start_b2_left;  b2_top = start_b2_top;
  2567.     b2_right = start_b2_right;  b2_bottom = start_b2_bottom;
  2568.     b3_left = start_b3_left;  b3_top = start_b3_top;
  2569.     b3_right = start_b3_right;  b3_bottom = start_b3_bottom;
  2570.     b4_left = start_b4_left;  b4_top = start_b4_top;
  2571.     b4_right = start_b4_right;  b4_bottom = start_b4_bottom;
  2572.     m_remaining_incarnations = m_stop_after_num_incarnations;
  2573.   } else {
  2574.     b1_left  =-1;  b1_top    = 0;
  2575.     b1_right = 1;  b1_bottom = 2;
  2576.     b2_left  = 0;  b2_top    = 2;
  2577.     b2_right = 2;  b2_bottom = 4;
  2578.     b3_left  = 0;  b3_top    =-1;
  2579.     b3_right = 2;  b3_bottom = 1;
  2580.     b4_left  = 1;  b4_top    = 1;
  2581.     b4_right = 3;  b4_bottom = 3;
  2582.   }
  2583.   SetNonOverlap();
  2584. }
  2586. bool CFourBoxesIF::SetToNextIncarnation()
  2587. {
  2588. if (m_is_partial) {
  2589. if (m_remaining_incarnations) {
  2590. m_remaining_incarnations--;
  2591. } else {
  2592. return false;
  2593. }
  2594. }
  2595.   b4_right++;
  2596.   if (b4_right>=m_template_width) {
  2597.     b2_right++;
  2598.     b3_right++;
  2599.     if (b2_right>=m_template_width-1) {
  2600.       b1_right++;
  2601.       b4_left++;
  2602.       if (b1_right>=m_template_width-2) {
  2603.         b2_left++;
  2604.         b3_left++;
  2605.         if (b2_left>=m_template_width-3) {
  2606.           b1_left++;
  2607.           if (b1_left>=m_template_width-4) {
  2608.             b2_bottom++;
  2609.             if (b2_bottom>=m_template_height) {
  2610.               b4_bottom++;
  2611.               if (b4_bottom>=m_template_height-1) {
  2612.                 b1_bottom++;
  2613.                 b2_top++;
  2614.                 if (b1_bottom>=m_template_height-2) {
  2615.                   b3_bottom++;
  2616.                   b4_top++;
  2617.                   if (b3_bottom>=m_template_height-3) {
  2618.                     b1_top++;
  2619.                     if (b1_top>=m_template_height-4) {
  2620.                       b3_top++;
  2621.                       if (b3_top>=m_template_height-5) {
  2622.                         return false;
  2623.                       }
  2624.                       b1_top = b3_top+1;
  2625.                     }
  2626.                     b3_bottom = b1_top+1;
  2627.                     b4_top = b3_bottom;
  2628.                   }
  2629.                   b1_bottom = b3_bottom+1;
  2630.                   b2_top = b1_bottom;
  2631.                 }
  2632.                 b4_bottom = b1_bottom+1;
  2633.               }
  2634.               b2_bottom = b4_bottom+1;
  2635.             }
  2636.             b1_left = -1;
  2637.           }
  2638.           b2_left = b1_left+1;
  2639.           b3_left = b2_left;
  2640.         }
  2641.         b1_right = b2_left+1;
  2642.         b4_left = b1_right;
  2643.       }
  2644.       b2_right = b1_right+1;
  2645.       b3_right = b2_right;
  2646.     }
  2647.     b4_right = b2_right+1;
  2648.   }
  2649.   SetNonOverlap();
  2650. return true;
  2651. }
  2653. CIntegralFeature* CFourBoxesIF::Copy() const
  2654. {
  2655. return new CFourBoxesIF(*this);
  2656. }
  2658. void CFourBoxesIF::MakePartialFromCurrentForNumIncarnations(
  2659.   featnum num)
  2660. {
  2661.   m_is_partial = true;
  2662.   m_num_incarnations=num+1;
  2663.   start_b1_left = b1_left;  start_b1_top = b1_top;
  2664.   start_b1_right = b1_right;  start_b1_bottom = b1_bottom;
  2665.   start_b2_left = b2_left;  start_b2_top = b2_top;
  2666.   start_b2_right = b2_right;  start_b2_bottom = b2_bottom;
  2667.   start_b3_left = b3_left;  start_b3_top = b3_top;
  2668.   start_b3_right = b3_right;  start_b3_bottom = b3_bottom;
  2669.   start_b4_left = b4_left;  start_b4_top = b4_top;
  2670.   start_b4_right = b4_right;  start_b4_bottom = b4_bottom;
  2671.   m_remaining_incarnations = m_stop_after_num_incarnations = num;
  2672. }
  2674. #ifdef USE_MFC
  2675. void CFourBoxesIF::Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const
  2676. {
  2677. int l1 = x_off + zoomfactor + b1_left*zoomfactor;
  2678. int t1 = y_off + zoomfactor + b1_top*zoomfactor;
  2679. int r1 = x_off + zoomfactor + b1_right*zoomfactor;
  2680. int b1 = y_off + zoomfactor + b1_bottom*zoomfactor;
  2681. int l2 = x_off + zoomfactor + b2_left*zoomfactor;
  2682. int t2 = y_off + zoomfactor + b2_top*zoomfactor;
  2683. int r2 = x_off + zoomfactor + b2_right*zoomfactor;
  2684. int b2 = y_off + zoomfactor + b2_bottom*zoomfactor;
  2685. int l3 = x_off + zoomfactor + b3_left*zoomfactor;
  2686. int t3 = y_off + zoomfactor + b3_top*zoomfactor;
  2687. int r3 = x_off + zoomfactor + b3_right*zoomfactor;
  2688. int b3 = y_off + zoomfactor + b3_bottom*zoomfactor;
  2689. int l4 = x_off + zoomfactor + b4_left*zoomfactor;
  2690. int t4 = y_off + zoomfactor + b4_top*zoomfactor;
  2691. int r4 = x_off + zoomfactor + b4_right*zoomfactor;
  2692. int b4 = y_off + zoomfactor + b4_bottom*zoomfactor;
  2693.   // box 1 and 2 in black
  2694. pDC->FillRect(CRect(l1, t1, r1, b1), g_pBlackbrush);
  2695. pDC->FillRect(CRect(l2, t2, r2, b2), g_pBlackbrush);
  2696.   // box 3 and 4 in outline, XOR the screen
  2697.   unsigned char bits[9];
  2698.   bits[0] = bits[1] = bits[3] = bits[4] = bits[6] = bits[7] = 0;
  2699.   bits[2] = bits[5] = bits[8] = 255;
  2700.   CBitmap bmp;
  2701.   bmp.CreateBitmap(3, 3, 1, 8, &bits);
  2702.   CBrush brush;
  2703.   brush.CreatePatternBrush(&bmp);
  2704.   pDC->FrameRect(CRect(l3, t3, r3, b3), &brush);
  2705.   pDC->FrameRect(CRect(l4, t4, r4, b4), &brush);
  2706. }
  2707. #endif // USE_MFC
  2709. ostream& CFourBoxesIF::output(ostream& os) const
  2710. {
  2711.   os << "FourBoxes " 
  2712.      << "(" << b1_left << "," << b1_top << "," << b1_right << "," << b1_bottom << "),"
  2713.      << "(" << b2_left << "," << b2_top << "," << b2_right << "," << b2_bottom << "),"
  2714.      << "(" << b3_left << "," << b3_top << "," << b3_right << "," << b3_bottom << "),"
  2715.      << "(" << b4_left << "," << b4_top << "," << b4_right << "," << b4_bottom << ")";
  2716.   return os;
  2717. }