Blame view

3rdparty/opencv-4.5.4/modules/gapi/samples/kernel_api_snippets.cpp 4.73 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
  // [filter2d_api]
  #include <opencv2/gapi.hpp>
  
  G_TYPED_KERNEL(GFilter2D,
                 <cv::GMat(cv::GMat,int,cv::Mat,cv::Point,double,int,cv::Scalar)>,
                 "org.opencv.imgproc.filters.filter2D")
  {
      static cv::GMatDesc                 // outMeta's return value type
      outMeta(cv::GMatDesc    in       ,  // descriptor of input GMat
              int             ddepth   ,  // depth parameter
              cv::Mat      /* coeffs */,  // (unused)
              cv::Point    /* anchor */,  // (unused)
              double       /* scale  */,  // (unused)
              int          /* border */,  // (unused)
              cv::Scalar   /* bvalue */ ) // (unused)
      {
          return in.withDepth(ddepth);
      }
  };
  // [filter2d_api]
  
  cv::GMat filter2D(cv::GMat  ,
                    int       ,
                    cv::Mat   ,
                    cv::Point ,
                    double    ,
                    int       ,
                    cv::Scalar);
  
  // [filter2d_wrap]
  cv::GMat filter2D(cv::GMat   in,
                    int        ddepth,
                    cv::Mat    k,
                    cv::Point  anchor  = cv::Point(-1,-1),
                    double     scale   = 0.,
                    int        border  = cv::BORDER_DEFAULT,
                    cv::Scalar bval    = cv::Scalar(0))
  {
      return GFilter2D::on(in, ddepth, k, anchor, scale, border, bval);
  }
  // [filter2d_wrap]
  
  // [compound]
  #include <opencv2/gapi/gcompoundkernel.hpp>       // GAPI_COMPOUND_KERNEL()
  
  using PointArray2f = cv::GArray<cv::Point2f>;
  
  G_TYPED_KERNEL(HarrisCorners,
                 <PointArray2f(cv::GMat,int,double,double,int,double)>,
                 "org.opencv.imgproc.harris_corner")
  {
      static cv::GArrayDesc outMeta(const cv::GMatDesc &,
                                    int,
                                    double,
                                    double,
                                    int,
                                    double)
      {
          // No special metadata for arrays in G-API (yet)
          return cv::empty_array_desc();
      }
  };
  
  // Define Fluid-backend-local kernels which form GoodFeatures
  G_TYPED_KERNEL(HarrisResponse,
                 <cv::GMat(cv::GMat,double,int,double)>,
                 "org.opencv.fluid.harris_response")
  {
      static cv::GMatDesc outMeta(const cv::GMatDesc &in,
                                  double,
                                  int,
                                  double)
      {
          return in.withType(CV_32F, 1);
      }
  };
  
  G_TYPED_KERNEL(ArrayNMS,
                 <PointArray2f(cv::GMat,int,double)>,
                 "org.opencv.cpu.nms_array")
  {
      static cv::GArrayDesc outMeta(const cv::GMatDesc &,
                                    int,
                                    double)
      {
          return cv::empty_array_desc();
      }
  };
  
  GAPI_COMPOUND_KERNEL(GFluidHarrisCorners, HarrisCorners)
  {
      static PointArray2f
      expand(cv::GMat in,
             int      maxCorners,
             double   quality,
             double   minDist,
             int      blockSize,
             double   k)
      {
          cv::GMat response = HarrisResponse::on(in, quality, blockSize, k);
          return ArrayNMS::on(response, maxCorners, minDist);
      }
  };
  
  // Then implement HarrisResponse as Fluid kernel and NMSresponse
  // as a generic (OpenCV) kernel
  // [compound]
  
  // [filter2d_ocv]
  #include <opencv2/gapi/cpu/gcpukernel.hpp>     // GAPI_OCV_KERNEL()
  #include <opencv2/imgproc.hpp>                 // cv::filter2D()
  
  GAPI_OCV_KERNEL(GCPUFilter2D, GFilter2D)
  {
      static void
      run(const cv::Mat    &in,       // in - derived from GMat
          const int         ddepth,   // opaque (passed as-is)
          const cv::Mat    &k,        // opaque (passed as-is)
          const cv::Point  &anchor,   // opaque (passed as-is)
          const double      delta,    // opaque (passed as-is)
          const int         border,   // opaque (passed as-is)
          const cv::Scalar &,         // opaque (passed as-is)
          cv::Mat          &out)      // out - derived from GMat (retval)
      {
          cv::filter2D(in, out, ddepth, k, anchor, delta, border);
      }
  };
  // [filter2d_ocv]
  
  int main(int, char *[])
  {
      std::cout << "This sample is non-complete. It is used as code snippents in documentation." << std::endl;
  
  cv::Mat conv_kernel_mat;
  
  {
  // [filter2d_on]
  cv::GMat in;
  cv::GMat out = GFilter2D::on(/* GMat    */  in,
                               /* int     */  -1,
                               /* Mat     */  conv_kernel_mat,
                               /* Point   */  cv::Point(-1,-1),
                               /* double  */  0.,
                               /* int     */  cv::BORDER_DEFAULT,
                               /* Scalar  */  cv::Scalar(0));
  // [filter2d_on]
  }
  
  {
  // [filter2d_wrap_call]
  cv::GMat in;
  cv::GMat out = filter2D(in, -1, conv_kernel_mat);
  // [filter2d_wrap_call]
  }
  
  return 0;
  }