integralfeatures.h

tracciatore di mani con webcam

                  int _toprow, int _bottomrow,
                  int _1, int _2, int _3, int _4, int _5, int _6,
                  int _7, int _8);
  CSevenColumnsIF(const CSevenColumnsIF& frm);
  CSevenColumnsIF(istream& is, int template_width, int template_height);
  
  virtual II_TYPE Compute(const CIntegralImage& image) const;
  virtual II_TYPE ComputeScaled(const CIntegralImage& image, 
                               II_TYPE mean, int left, int top) const;
  virtual void SetToFirstIncarnation();
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual void MakePartialFromCurrentForNumIncarnations(featnum num);
  virtual bool Equals(const CSevenColumnsIF& from) const;
#ifdef USE_MFC
  virtual void Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const;
#endif // USE_MFC

  virtual ostream& output(ostream& os) const;
  
 protected:
  virtual void Scale(II_TYPE scale_x, II_TYPE scale_y);
  virtual void SetNonOverlap();
  virtual void EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y, 
                             int scaled_template_width, 
                             int scaled_template_height);

  
 protected:
  int bottomrow, toprow;
  int col1_left, col2_left, col3_left, col4_left, 
    col5_left, col6_left, col7_left, col7_right;
  int start_bottomrow, start_toprow;
  int start_col1_left, start_col2_left, start_col3_left, start_col4_left, 
    start_col5_left, start_col6_left, start_col7_left, start_col7_right;
  int scaled_bottomrow, scaled_toprow;
  int scaled_col1_left, scaled_col2_left, scaled_col3_left, scaled_col4_left, 
    scaled_col5_left, scaled_col6_left, scaled_col7_left, scaled_col7_right;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CDiagIF
//

class CDiagIF : public CIntegralFeature {
 public:
  CDiagIF(int templateWidth, int templateHeight);
  CDiagIF(int templateWidth, int templateHeight,
          int _toprect_toprow, int _centerrow,
          int _bottomrect_bottomrow,
          int _leftrect_leftcol, int _centercol,
          int _rightrect_rightcol);
  CDiagIF(const CDiagIF& frm);
  CDiagIF(istream& is, int template_width, int template_height);
  
  virtual II_TYPE Compute(const CIntegralImage& image) const;
  virtual II_TYPE ComputeScaled(const CIntegralImage& image, 
                               II_TYPE mean, int left, int top) const;
  virtual void SetToFirstIncarnation();
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual void MakePartialFromCurrentForNumIncarnations(featnum num);
  void ScaleX(II_TYPE scale_x);
  void ScaleY(II_TYPE scale_y);
  virtual bool Equals(const CDiagIF& from) const;
  //virtual void Transform(const CFeatureTransformer& transformer);
#ifdef USE_MFC
  virtual void Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const;
#endif // USE_MFC
  
  virtual ostream& output(ostream& os) const;
  
 protected:
  virtual void Scale(II_TYPE scale_x, II_TYPE scale_y);
  virtual void SetNonOverlap();
  virtual void EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y, 
                             int scaled_template_width, 
                             int scaled_template_height);
  
  
 protected:
  int toprect_toprow, centerrow, bottomrect_bottomrow;
  int leftrect_leftcol, centercol, rightrect_rightcol;
  int start_toprect_toprow, start_centerrow, start_bottomrect_bottomrow;
  int start_leftrect_leftcol, start_centercol, start_rightrect_rightcol;
  int scaled_toprect_toprow, scaled_centerrow, scaled_bottomrect_bottomrow;
  int scaled_leftrect_leftcol, scaled_centercol, scaled_rightrect_rightcol;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CFourBoxesIF
//

class CFourBoxesIF : public CIntegralFeature {
 public:
  CFourBoxesIF(int templateWidth, int templateHeight);
  CFourBoxesIF(int templateWidth, int templateHeight,
               const CRect* pB1, const CRect* pB2,
               const CRect* pB3, const CRect* pB4);
  CFourBoxesIF(const CFourBoxesIF& frm);
  CFourBoxesIF(istream& is, int template_width, int template_height);
  
  virtual II_TYPE Compute(const CIntegralImage& image) const;
  virtual II_TYPE ComputeScaled(const CIntegralImage& image, 
                               II_TYPE mean, int left, int top) const;
  virtual void SetToFirstIncarnation();
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual void MakePartialFromCurrentForNumIncarnations(featnum num);
  void ScaleX(II_TYPE scale_x);
  void ScaleY(II_TYPE scale_y);
  virtual bool Equals(const CFourBoxesIF& from) const;
  //virtual voiad Transform(const CFeatureTransformer& transformer);
#ifdef USE_MFC
  virtual void Draw(CDC* pDC, int x_off, int y_off, int zoomfactor) const;
#endif // USE_MFC
  
  virtual ostream& output(ostream& os) const;
  
 protected:
  virtual void Scale(II_TYPE scale_x, II_TYPE scale_y);
  virtual void SetNonOverlap();
  virtual void EvenOutScales(II_TYPE* pScale_x, II_TYPE* pScale_y, 
                             int scaled_template_width, 
                             int scaled_template_height);
  
 protected:
  int b1_left, b1_top, b1_right, b1_bottom;
  int b2_left, b2_top, b2_right, b2_bottom;
  int b3_left, b3_top, b3_right, b3_bottom;
  int b4_left, b4_top, b4_right, b4_bottom;
  int start_b1_left, start_b1_top, start_b1_right, start_b1_bottom;
  int start_b2_left, start_b2_top, start_b2_right, start_b2_bottom;
  int start_b3_left, start_b3_top, start_b3_right, start_b3_bottom;
  int start_b4_left, start_b4_top, start_b4_right, start_b4_bottom;
  int scaled_b1_left, scaled_b1_top, scaled_b1_right, scaled_b1_bottom;
  int scaled_b2_left, scaled_b2_top, scaled_b2_right, scaled_b2_bottom;
  int scaled_b3_left, scaled_b3_top, scaled_b3_right, scaled_b3_bottom;
  int scaled_b4_left, scaled_b4_top, scaled_b4_right, scaled_b4_bottom;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CLeftRightSameIF
//

class CLeftRightSameIF : public CLeftRightIF {
 public:
  CLeftRightSameIF(int templateWidth, int templateHeight);
  CLeftRightSameIF(int templateWidth, int templateHeight,
                   int _toprow, int _bottomrow,
                   int _leftrect_leftcol, int _centercol,
                   int _rightrect_rightcol);
  CLeftRightSameIF(const CLeftRightSameIF& frm);
  CLeftRightSameIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CUpDownSameIF
//

class CUpDownSameIF : public CUpDownIF {
 public:
  CUpDownSameIF(int templateWidth, int templateHeight);
  CUpDownSameIF(int templateWidth, int templateHeight,
                int _toprect_toprow, int _centerrow,
                int _bottomrect_bottomrow,
                int _leftcol, int _rightcol);
  CUpDownSameIF(const CUpDownSameIF& frm);
  CUpDownSameIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CLeftCenterRightSameIF
//

class CLeftCenterRightSameIF : public CLeftCenterRightIF {
 public:
  CLeftCenterRightSameIF(int templateWidth, int templateHeight);
  CLeftCenterRightSameIF(int templateWidth, int templateHeight,
                         int _toprow, int _bottomrow,
                         int _leftrect_leftcol, int _leftrect_rightcol,
                         int _rightrect_leftcol,
                         int _rightrect_rightcol);
  CLeftCenterRightSameIF(const CLeftCenterRightSameIF& frm);
  CLeftCenterRightSameIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CSevenColumnsSameIF
//

class CSevenColumnsSameIF : public CSevenColumnsIF {
 public:
  CSevenColumnsSameIF(int templateWidth, int templateHeight);
  CSevenColumnsSameIF(int templateWidth, int templateHeight,
                      int _toprow, int _bottomrow,
                      int _1, int _2, int _3, int _4, int _5, int _6,
                      int _7, int _8);
  CSevenColumnsSameIF(const CSevenColumnsSameIF& frm);
  CSevenColumnsSameIF(istream& is, int template_width, int template_height);
  
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CSevenColumnsSimilarIF
//

class CSevenColumnsSimilarIF : public CSevenColumnsIF {
 public:
  CSevenColumnsSimilarIF(int templateWidth, int templateHeight);
  CSevenColumnsSimilarIF(int templateWidth, int templateHeight,
                         int _toprow, int _bottomrow,
                         int _1, int _2, int _3, int _4, int _5, int _6,
                         int _7, int _8);
  CSevenColumnsSimilarIF(const CSevenColumnsSimilarIF& frm);
  CSevenColumnsSimilarIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CDiagSameIF
//

class CDiagSameIF : public CDiagIF {
 public:
  CDiagSameIF(int templateWidth, int templateHeight);
  CDiagSameIF(int templateWidth, int templateHeight,
              int _toprect_toprow, int _centerrow,
              int _bottomrect_bottomrow,
              int _leftrect_leftcol, int _centercol,
              int _rightrect_rightcol);
  CDiagSameIF(const CDiagSameIF& frm);
  CDiagSameIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CDiagSimilarIF
//

class CDiagSimilarIF : public CDiagIF {
 public:
  CDiagSimilarIF(int templateWidth, int templateHeight);
  CDiagSimilarIF(int templateWidth, int templateHeight,
                 int _toprect_toprow, int _centerrow,
                 int _bottomrect_bottomrow,
                 int _leftrect_leftcol, int _centercol,
                 int _rightrect_rightcol);
  CDiagSimilarIF(const CDiagSimilarIF& frm);
  CDiagSimilarIF(istream& is, int template_width, int template_height);
  
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};


/////////////////////////////////////////////////////////////////////////////
//
// class CFourBoxesSameIF
//

class CFourBoxesSameIF : public CFourBoxesIF {
 public:
  CFourBoxesSameIF(int templateWidth, int templateHeight);
  CFourBoxesSameIF(int templateWidth, int templateHeight,
                   const CRect* pB1, const CRect* pB2,
                   const CRect* pB3, const CRect* pB4);
  CFourBoxesSameIF(const CFourBoxesSameIF& frm);
  CFourBoxesSameIF(istream& is, int template_width, int template_height);
  
  virtual void SetToFirstIncarnation();
  virtual bool SetToNextIncarnation();
  virtual CIntegralFeature* Copy() const;
  virtual ostream& output(ostream& os) const;
};

//} // namespace cubicles 

/////////////////////////////////////////////////////////////////////////////

#pragma warning (default: 1125)

#endif // !defined(_INTEGRALFEATURES_H__INCLUDED_)