Blame view

3rdparty/opencv-4.5.4/apps/traincascade/lbpfeatures.cpp 2.1 KB
f4334277   Hu Chunming   提交3rdparty
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
  #include "opencv2/core.hpp"
  #include "opencv2/imgproc.hpp"
  
  #include "lbpfeatures.h"
  #include "cascadeclassifier.h"
  
  using namespace cv;
  
  CvLBPFeatureParams::CvLBPFeatureParams()
  {
      maxCatCount = 256;
      name = LBPF_NAME;
  }
  
  void CvLBPEvaluator::init(const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize)
  {
      CV_Assert( _maxSampleCount > 0);
      sum.create((int)_maxSampleCount, (_winSize.width + 1) * (_winSize.height + 1), CV_32SC1);
      CvFeatureEvaluator::init( _featureParams, _maxSampleCount, _winSize );
  }
  
  void CvLBPEvaluator::setImage(const Mat &img, uchar clsLabel, int idx)
  {
      CV_DbgAssert( !sum.empty() );
      CvFeatureEvaluator::setImage( img, clsLabel, idx );
      Mat innSum(winSize.height + 1, winSize.width + 1, sum.type(), sum.ptr<int>((int)idx));
      integral( img, innSum );
  }
  
  void CvLBPEvaluator::writeFeatures( FileStorage &fs, const Mat& featureMap ) const
  {
      _writeFeatures( features, fs, featureMap );
  }
  
  void CvLBPEvaluator::generateFeatures()
  {
      int offset = winSize.width + 1;
      for( int x = 0; x < winSize.width; x++ )
          for( int y = 0; y < winSize.height; y++ )
              for( int w = 1; w <= winSize.width / 3; w++ )
                  for( int h = 1; h <= winSize.height / 3; h++ )
                      if ( (x+3*w <= winSize.width) && (y+3*h <= winSize.height) )
                          features.push_back( Feature(offset, x, y, w, h ) );
      numFeatures = (int)features.size();
  }
  
  CvLBPEvaluator::Feature::Feature()
  {
      rect = cvRect(0, 0, 0, 0);
  }
  
  CvLBPEvaluator::Feature::Feature( int offset, int x, int y, int _blockWidth, int _blockHeight )
  {
      Rect tr = rect = cvRect(x, y, _blockWidth, _blockHeight);
      CV_SUM_OFFSETS( p[0], p[1], p[4], p[5], tr, offset )
      tr.x += 2*rect.width;
      CV_SUM_OFFSETS( p[2], p[3], p[6], p[7], tr, offset )
      tr.y +=2*rect.height;
      CV_SUM_OFFSETS( p[10], p[11], p[14], p[15], tr, offset )
      tr.x -= 2*rect.width;
      CV_SUM_OFFSETS( p[8], p[9], p[12], p[13], tr, offset )
  }
  
  void CvLBPEvaluator::Feature::write(FileStorage &fs) const
  {
      fs << CC_RECT << "[:" << rect.x << rect.y << rect.width << rect.height << "]";
  }