integralfeatures.cpp

tracciatore di mani con webcam

	pDC->FillRect(CRect(rl, tr, rr, br), g_pBlackbrush);
}
#endif // USE_MFC

ostream& CLeftCenterRightIF::output(ostream& os) const
{
  os << "LeftCenterRight " << toprow << "," << bottomrow << " x "
     << leftrect_leftcol << "," << leftrect_rightcol << " / "
     << rightrect_leftcol << "," << rightrect_rightcol;
  return os;
}




/////////////////////////////////////////////////////////////////////////////
//
// CSevenColumnsIF classes implementation
//
/////////////////////////////////////////////////////////////////////////////

CSevenColumnsIF::CSevenColumnsIF(int templateWidth, int templateHeight)
  : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+27*COST_ADD) 
{
}

CSevenColumnsIF::CSevenColumnsIF(int templateWidth, int templateHeight,
                                 int _toprow, int _bottomrow,
                                 int _1, int _2, int _3, int _4, int _5, int _6,
                                 int _7, int _8)
  : CIntegralFeature(templateWidth, templateHeight, IT_INVALID_FEATURE, false, 16*COST_GET+27*COST_ADD) 
{
  toprow = _toprow;
  bottomrow = _bottomrow;
  col1_left = _1;
  col2_left = _2;
  col3_left = _3;
  col4_left = _4;
  col5_left = _5;
  col6_left = _6;
  col7_left = _7;
  col7_right = _8;
  SetNonOverlap();
}

CSevenColumnsIF::CSevenColumnsIF(const CSevenColumnsIF& frm)
  : CIntegralFeature(frm.m_template_width, frm.m_template_height,
		     frm.m_num_incarnations, frm.m_is_partial, 16*COST_GET+27*COST_ADD) 
{
  toprow = frm.toprow;
  bottomrow = frm.bottomrow;
  col1_left = frm.col1_left;
  col2_left = frm.col2_left;
  col3_left = frm.col3_left;
  col4_left = frm.col4_left;
  col5_left = frm.col5_left;
  col6_left = frm.col6_left;
  col7_left = frm.col7_left;
  col7_right = frm.col7_right;
  if (m_is_partial) {
    start_toprow = frm.start_toprow;
    start_bottomrow = frm.start_bottomrow;
    start_col1_left = frm.start_col1_left;
    start_col2_left = frm.start_col2_left;
    start_col3_left = frm.start_col3_left;
    start_col4_left = frm.start_col4_left;
    start_col5_left = frm.start_col5_left;
    start_col6_left = frm.start_col6_left;
    start_col7_left = frm.start_col7_left;
    start_col7_right = frm.start_col7_right;
    m_remaining_incarnations = frm.m_remaining_incarnations;
    m_stop_after_num_incarnations = frm.m_stop_after_num_incarnations;
  }
  SetNonOverlap();
}

CSevenColumnsIF::CSevenColumnsIF(istream& is, int template_width, int template_height)
  : CIntegralFeature(template_width, template_height, IT_INVALID_FEATURE, 0, 16*COST_GET+27*COST_ADD)
{
  char a, b, c, d, e, f, g, h;
  string str;
  is >> toprow >> a >> bottomrow >> str
     >> col1_left >> b >> col2_left >> c >> col3_left >> d >> col4_left >> e
     >> col5_left >> f >> col6_left >> g >> col7_left >> h >> col7_right; 
  if (a!=',' || b!=',' || c!=',' || d!=',' || e!=',' || f!=',' || g!=',' || h!=',' || str!="x") {
    char* buf = (char*) alloca((256+str.length())*sizeof(char));
    sprintf(buf, "error during construction of SevenColumnsIF (%c|%c|%c|%c|%c|%c|%c|%c|%s)\n",
	   a, b, c, d, e, f, g, h, str.c_str());
    throw ITException(buf);
  }
  SetNonOverlap();
}

bool CSevenColumnsIF::Equals(const CSevenColumnsIF& frm) const
{
  bool equal = 
    (toprow == frm.toprow &&
     bottomrow == frm.bottomrow &&
     col1_left == frm.col1_left &&
     col2_left == frm.col2_left &&
     col3_left == frm.col3_left &&
     col4_left == frm.col4_left &&
     col5_left == frm.col5_left &&
     col6_left == frm.col6_left &&
     col7_left == frm.col7_left &&
     col7_right == frm.col7_right);
  return equal;
}

void CSevenColumnsIF::SetNonOverlap() {
  m_non_overlap =
    ((col2_left-col1_left) - (col3_left-col2_left) 
     + (col4_left-col3_left) - (col5_left-col4_left)
     + (col6_left-col5_left) - (col7_left-col6_left)
     + (col7_right-col7_left)
     )
    * (bottomrow-toprow);
}

II_TYPE CSevenColumnsIF::Compute(const CIntegralImage& image) const
{
	II_TYPE bot_col1_left = image.GetElement(col1_left, bottomrow);
	II_TYPE top_col1_left = image.GetElement(col1_left, toprow);
	II_TYPE bot_col2_left = image.GetElement(col2_left, bottomrow);
	II_TYPE top_col2_left = image.GetElement(col2_left, toprow);
	II_TYPE bot_col3_left = image.GetElement(col3_left, bottomrow);
	II_TYPE top_col3_left = image.GetElement(col3_left, toprow);
	II_TYPE bot_col4_left = image.GetElement(col4_left, bottomrow);
	II_TYPE top_col4_left = image.GetElement(col4_left, toprow);
	II_TYPE bot_col5_left = image.GetElement(col5_left, bottomrow);
	II_TYPE top_col5_left = image.GetElement(col5_left, toprow);
	II_TYPE bot_col6_left = image.GetElement(col6_left, bottomrow);
	II_TYPE top_col6_left = image.GetElement(col6_left, toprow);
	II_TYPE bot_col7_left = image.GetElement(col7_left, bottomrow);
	II_TYPE top_col7_left = image.GetElement(col7_left, toprow);
	II_TYPE bot_col7_right= image.GetElement(col7_right,bottomrow);
	II_TYPE top_col7_right= image.GetElement(col7_right,toprow);

	II_TYPE val_col1 = bot_col2_left - bot_col1_left - top_col2_left + top_col1_left;
	II_TYPE val_col2 = bot_col3_left - bot_col2_left - top_col3_left + top_col2_left;
	II_TYPE val_col3 = bot_col4_left - bot_col3_left - top_col4_left + top_col3_left;
	II_TYPE val_col4 = bot_col5_left - bot_col4_left - top_col5_left + top_col4_left;
	II_TYPE val_col5 = bot_col6_left - bot_col5_left - top_col6_left + top_col5_left;
	II_TYPE val_col6 = bot_col7_left - bot_col6_left - top_col7_left + top_col6_left;
	II_TYPE val_col7 = bot_col7_right- bot_col7_left - top_col7_right+ top_col7_left;

	return val_col1-val_col2+val_col3-val_col4+val_col5-val_col6+val_col7;
}

II_TYPE CSevenColumnsIF::ComputeScaled(const CIntegralImage& image, II_TYPE mean, int left, int top) const
{
	int placed_toprow = top + scaled_toprow;
	int placed_bottomrow = top + scaled_bottomrow;
	int placed_col1_left = left + scaled_col1_left;
	int placed_col2_left = left + scaled_col2_left;
	int placed_col3_left = left + scaled_col3_left;
	int placed_col4_left = left + scaled_col4_left;
	int placed_col5_left = left + scaled_col5_left;
	int placed_col6_left = left + scaled_col6_left;
	int placed_col7_left = left + scaled_col7_left;
	int placed_col7_right= left + scaled_col7_right;

	II_TYPE bot_col1_left = image.GetElement(placed_col1_left, placed_bottomrow);
	II_TYPE top_col1_left = image.GetElement(placed_col1_left, placed_toprow);
	II_TYPE bot_col2_left = image.GetElement(placed_col2_left, placed_bottomrow);
	II_TYPE top_col2_left = image.GetElement(placed_col2_left, placed_toprow);
	II_TYPE bot_col3_left = image.GetElement(placed_col3_left, placed_bottomrow);
	II_TYPE top_col3_left = image.GetElement(placed_col3_left, placed_toprow);
	II_TYPE bot_col4_left = image.GetElement(placed_col4_left, placed_bottomrow);
	II_TYPE top_col4_left = image.GetElement(placed_col4_left, placed_toprow);
	II_TYPE bot_col5_left = image.GetElement(placed_col5_left, placed_bottomrow);
	II_TYPE top_col5_left = image.GetElement(placed_col5_left, placed_toprow);
	II_TYPE bot_col6_left = image.GetElement(placed_col6_left, placed_bottomrow);
	II_TYPE top_col6_left = image.GetElement(placed_col6_left, placed_toprow);
	II_TYPE bot_col7_left = image.GetElement(placed_col7_left, placed_bottomrow);
	II_TYPE top_col7_left = image.GetElement(placed_col7_left, placed_toprow);
	II_TYPE bot_col7_right= image.GetElement(placed_col7_right,placed_bottomrow);
	II_TYPE top_col7_right= image.GetElement(placed_col7_right,placed_toprow);

	II_TYPE val_col1 = bot_col2_left - bot_col1_left - top_col2_left + top_col1_left;
	II_TYPE val_col2 = bot_col3_left - bot_col2_left - top_col3_left + top_col2_left;
	II_TYPE val_col3 = bot_col4_left - bot_col3_left - top_col4_left + top_col3_left;
	II_TYPE val_col4 = bot_col5_left - bot_col4_left - top_col5_left + top_col4_left;
	II_TYPE val_col5 = bot_col6_left - bot_col5_left - top_col6_left + top_col5_left;
	II_TYPE val_col6 = bot_col7_left - bot_col6_left - top_col7_left + top_col6_left;
	II_TYPE val_col7 = bot_col7_right- bot_col7_left - top_col7_right+ top_col7_left;

	II_TYPE val = val_col1-val_col2+val_col3-val_col4+val_col5-val_col6+val_col7;
	II_TYPE scaled_val = val/m_global_scale;
	II_TYPE mean_adjust = m_non_overlap*mean;

	return scaled_val-mean_adjust;
}

void CSevenColumnsIF::Scale(II_TYPE scale_x, II_TYPE scale_y)
{
	if (toprow==-1) {
		scaled_toprow = -1;
		scaled_bottomrow = (int)((II_TYPE)(bottomrow+1)*scale_y) - 1;
	} else {
		scaled_toprow = (int)((II_TYPE)toprow*scale_y);
		scaled_bottomrow = (int)((II_TYPE)bottomrow*scale_y);
	}
	if (col1_left==-1) {
		scaled_col1_left = -1;
		scaled_col2_left = (int)((II_TYPE)(col2_left+1)*scale_x) - 1;
		scaled_col3_left = (int)((II_TYPE)(col3_left-col2_left)*scale_x) + scaled_col2_left;
		scaled_col4_left = (int)((II_TYPE)(col4_left-col3_left)*scale_x) + scaled_col3_left;
		scaled_col5_left = (int)((II_TYPE)(col5_left-col4_left)*scale_x) + scaled_col4_left;
		scaled_col6_left = (int)((II_TYPE)(col6_left-col5_left)*scale_x) + scaled_col5_left;
		scaled_col7_left = (int)((II_TYPE)(col7_left-col6_left)*scale_x) + scaled_col6_left;
		scaled_col7_right= (int)((II_TYPE)(col7_right-col7_left)*scale_x) + scaled_col7_left;
	} else {
		scaled_col1_left = (int)((II_TYPE)col1_left*scale_x);
		scaled_col2_left = (int)((II_TYPE)col2_left*scale_x);
		scaled_col3_left = (int)((II_TYPE)col3_left*scale_x);
		scaled_col4_left = (int)((II_TYPE)col4_left*scale_x);
		scaled_col5_left = (int)((II_TYPE)col5_left*scale_x);
		scaled_col6_left = (int)((II_TYPE)col6_left*scale_x);
		scaled_col7_left = (int)((II_TYPE)col7_left*scale_x);
		scaled_col7_right= (int)((II_TYPE)col7_right*scale_x);
	}

  m_global_scale = scale_x*scale_y;
}

void CSevenColumnsIF::EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y,
        int scaled_template_width, int /*scaled_template_height*/)
{
  int rect1 = col2_left-col1_left;
  int rect2 = col3_left-col2_left;
  int rect3 = col4_left-col3_left;
  int rect4 = col5_left-col4_left;
  int rect5 = col6_left-col5_left;
  int rect6 = col7_left-col6_left;
  int rect7 = col7_right-col7_left;
  II_TYPE ratio1 = (II_TYPE)rect1/(II_TYPE)rect2;
  II_TYPE ratio2 = (II_TYPE)rect2/(II_TYPE)rect3;
  II_TYPE ratio3 = (II_TYPE)rect3/(II_TYPE)rect4;
  II_TYPE ratio4 = (II_TYPE)rect4/(II_TYPE)rect5;
  II_TYPE ratio5 = (II_TYPE)rect5/(II_TYPE)rect6;
  II_TYPE ratio6 = (II_TYPE)rect6/(II_TYPE)rect7;
  int srect1 = scaled_col2_left-scaled_col1_left;
  int srect2 = scaled_col3_left-scaled_col2_left;
  int srect3 = scaled_col4_left-scaled_col3_left;
  int srect4 = scaled_col5_left-scaled_col4_left;
  int srect5 = scaled_col6_left-scaled_col5_left;
  int srect6 = scaled_col7_left-scaled_col6_left;
  int srect7 = scaled_col7_right-scaled_col7_left;
  II_TYPE sratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
  II_TYPE sratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
  II_TYPE sratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
  II_TYPE sratio4 = (II_TYPE)srect4/(II_TYPE)srect5;
  II_TYPE sratio5 = (II_TYPE)srect5/(II_TYPE)srect6;
  II_TYPE sratio6 = (II_TYPE)srect6/(II_TYPE)srect7;

  int scaled_width = scaled_col7_right-scaled_col1_left;
  bool too_wide = scaled_width > scaled_template_width;

  while (!too_wide && 
	 (fabs(ratio1-sratio1)>=SCALE_DIFFERENCE_EPSILON
	  || fabs(ratio2-sratio2)>=SCALE_DIFFERENCE_EPSILON
	  || fabs(ratio3-sratio3)>=SCALE_DIFFERENCE_EPSILON
	  || fabs(ratio4-sratio4)>=SCALE_DIFFERENCE_EPSILON
	  || fabs(ratio5-sratio5)>=SCALE_DIFFERENCE_EPSILON
	  || fabs(ratio6-sratio6)>=SCALE_DIFFERENCE_EPSILON)) {
    if (ratio1>sratio1) {
      scaled_col2_left++;
      scaled_col3_left++;
      scaled_col4_left++;
      scaled_col5_left++;
      scaled_col6_left++;
      scaled_col7_left++;
      scaled_col7_right++;
      srect1++;
    } else if (ratio1<sratio1 || ratio2>sratio2) {
      scaled_col3_left++;
      scaled_col4_left++;
      scaled_col5_left++;
      scaled_col6_left++;
      scaled_col7_left++;
      scaled_col7_right++;
      srect2++;
    } else if (ratio2<sratio2 || ratio3>sratio3) {
      scaled_col4_left++;
      scaled_col5_left++;
      scaled_col6_left++;
      scaled_col7_left++;
      scaled_col7_right++;
      srect3++;
    } else if (ratio3<sratio3 || ratio4>sratio4) {
      scaled_col5_left++;
      scaled_col6_left++;
      scaled_col7_left++;
      scaled_col7_right++;
      srect4++;
    } else if (ratio4<sratio4 || ratio5>sratio5) {
      scaled_col6_left++;
      scaled_col7_left++;
      scaled_col7_right++;
      srect5++;
    } else if (ratio5<sratio5 || ratio6>sratio6) {
      scaled_col7_left++;
      scaled_col7_right++;
      srect6++;
    } else if (ratio6<sratio6) {
      scaled_col7_right++;
      srect7++;
    } else {
      throw ITException("error during CSevenColumnsIF scaling - e too small?");
    }
    scaled_width = scaled_col7_right-scaled_col1_left;
    too_wide = scaled_width > scaled_template_width;

    sratio1 = (II_TYPE)srect1/(II_TYPE)srect2;
    sratio2 = (II_TYPE)srect2/(II_TYPE)srect3;
    sratio3 = (II_TYPE)srect3/(II_TYPE)srect4;
    sratio4 = (II_TYPE)srect4/(II_TYPE)srect5;
    sratio5 = (II_TYPE)srect5/(II_TYPE)srect6;
    sratio6 = (II_TYPE)srect6/(II_TYPE)srect7;
  }
  ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect3
              -(II_TYPE)srect1/(II_TYPE)srect3)<SCALE_DIFFERENCE_EPSILON);
  ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect4
              -(II_TYPE)srect1/(II_TYPE)srect4)<SCALE_DIFFERENCE_EPSILON);
  ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect5
              -(II_TYPE)srect1/(II_TYPE)srect5)<SCALE_DIFFERENCE_EPSILON);
  ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect6
              -(II_TYPE)srect1/(II_TYPE)srect6)<SCALE_DIFFERENCE_EPSILON);
  ASSERT(too_wide || fabs((II_TYPE)rect1/(II_TYPE)rect7
              -(II_TYPE)srect1/(II_TYPE)srect7)<SCALE_DIFFERENCE_EPSILON);

  int overlap = scaled_col7_right-scaled_template_width+1;
  // overlap: by how much is rightmost too far to the right? 
  // it must not be larger than scaled_template_width-1
  if (overlap>0) {
    // went outside template boundaries
    if (too_wide) {
      // feature too big, use int scale
      *pScale_x = floor(*pScale_x);
      Scale(*pScale_x, *pScale_y);
    } else {
      // shift feature by overlap
      scaled_col1_left -= overlap;
      scaled_col2_left -= overlap;
      scaled_col3_left -= overlap;
      scaled_col4_left -= overlap;
      scaled_col5_left -= overlap;
      scaled_col6_left -= overlap;
      scaled_col7_left -= overlap;
      scaled_col7_right -= overlap;
      *pScale_x = sratio1;
    }
  } else {
    *pScale_x = sratio1;
  }
}

void CSevenColumnsIF::SetToFirstIncarnation()
{
  if (m_is_partial) {
    toprow=start_toprow;
    bottomrow=start_bottomrow;
    col1_left = start_col1_left;
    col2_left = start_col2_left;
    col3_left = start_col3_left;
    col4_left = start_col4_left;
    col5_left = start_col5_left;
    col6_left = start_col6_left;
    col7_left = start_col7_left;
    col7_right= start_col7_right;
    m_remaining_incarnations=m_stop_after_num_incarnations;
  } else {
    toprow=-1;
    bottomrow=0;
    col1_left = -1;
    col2_left = 0;
    col3_left = 1;
    col4_left = 2;
    col5_left = 3;
    col6_left = 4;
    col7_left = 5;
    col7_right= 6;
  }
  SetNonOverlap();
}

bool CSevenColumnsIF::SetToNextIncarnation()
{
	if (m_is_partial) {
		if (m_remaining_incarnations) {
			m_remaining_incarnations--;