OpenCV 4.5.3(日本語機械翻訳)
all_layers.hpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of the copyright holders may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #ifndef OPENCV_DNN_DNN_ALL_LAYERS_HPP
43 #define OPENCV_DNN_DNN_ALL_LAYERS_HPP
44 #include <opencv2/dnn.hpp>
45
46 namespace cv {
47 namespace dnn {
48CV__DNN_INLINE_NS_BEGIN
51
74 class CV_EXPORTS BlankLayer : public Layer
75 {
76 public:
77 static Ptr<Layer> create(const LayerParams &params);
78 };
79
83 class CV_EXPORTS ConstLayer : public Layer
84 {
85 public:
86 static Ptr<Layer> create(const LayerParams &params);
87 };
88
90 class CV_EXPORTS LSTMLayer : public Layer
91 {
92 public:
94 static Ptr<LSTMLayer> create(const LayerParams& params);
95
128 CV_DEPRECATED virtual void setWeights(const Mat &Wh, const Mat &Wx, const Mat &b) = 0;
129
134 virtual void setOutShape(const MatShape &outTailShape = MatShape()) = 0;
135
145 CV_DEPRECATED virtual void setUseTimstampsDim(bool use = true) = 0;
146
151 CV_DEPRECATED virtual void setProduceCellOutput(bool produce = false) = 0;
152
153 /* In common case it use single input with @f$x_t@f$ values to compute output(s) @f$h_t@f$ (and @f$c_t@f$).
154 * @param input should contain packed values @f$x_t@f$
155 * @param output contains computed outputs: @f$h_t@f$ (and @f$c_t@f$ if setProduceCellOutput() flag was set to true).
156 *
157 * If setUseTimstampsDim() is set to true then @p input[0] should has at least two dimensions with the following shape: [`T`, `N`, `[data dims]`],
158 * where `T` specifies number of timestamps, `N` is number of independent streams (i.e. @f$ x_{t_0 + t}^{stream} @f$ is stored inside @p input[0][t, stream, ...]).
159 *
160 * If setUseTimstampsDim() is set to false then @p input[0] should contain single timestamp, its shape should has form [`N`, `[data dims]`] with at least one dimension.
161 * (i.e. @f$ x_{t}^{stream} @f$ is stored inside @p input[0][stream, ...]).
162 */
163
164 int inputNameToIndex(String inputName) CV_OVERRIDE;
165 int outputNameToIndex(const String& outputName) CV_OVERRIDE;
166 };
167
181 class CV_EXPORTS RNNLayer : public Layer
182 {
183 public:
185 static Ptr<RNNLayer> create(const LayerParams& params);
186
201 virtual void setWeights(const Mat &Wxh, const Mat &bh, const Mat &Whh, const Mat &Who, const Mat &bo) = 0;
202
206 virtual void setProduceHiddenOutput(bool produce = false) = 0;
207
208 };
209
210 class CV_EXPORTS BaseConvolutionLayer : public Layer
211 {
212 public:
213 CV_DEPRECATED_EXTERNAL Size kernel, stride, pad, dilation, adjustPad;
214 std::vector<size_t> adjust_pads;
215 std::vector<size_t> kernel_size, strides, dilations;
216 std::vector<size_t> pads_begin, pads_end;
217 String padMode;
218 int numOutput;
219 };
220
221 class CV_EXPORTS ConvolutionLayer : public BaseConvolutionLayer
222 {
223 public:
224 static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
225 };
226
227 class CV_EXPORTS DeconvolutionLayer : public BaseConvolutionLayer
228 {
229 public:
230 static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
231 };
232
233 class CV_EXPORTS LRNLayer : public Layer
234 {
235 public:
236 int type;
237
238 int size;
239 float alpha, beta, bias;
240 bool normBySize;
241
242 static Ptr<LRNLayer> create(const LayerParams& params);
243 };
244
245 class CV_EXPORTS PoolingLayer : public Layer
246 {
247 public:
248 int type;
249 std::vector<size_t> kernel_size, strides;
250 std::vector<size_t> pads_begin, pads_end;
251 bool globalPooling;
252 std::vector<bool> isGlobalPooling;
253 bool computeMaxIdx;
254 String padMode;
255 bool ceilMode;
256 // If true for average pooling with padding, divide an every output region
257 // by a whole kernel area. Otherwise exclude zero padded values and divide
258 // by number of real values.
259 bool avePoolPaddedArea;
260 // ROIPooling parameters.
261 Size pooledSize;
262 float spatialScale;
263 // PSROIPooling parameters.
264 int psRoiOutChannels;
265
266 static Ptr<PoolingLayer> create(const LayerParams& params);
267 };
268
269 class CV_EXPORTS SoftmaxLayer : public Layer
270 {
271 public:
272 bool logSoftMax;
273
274 static Ptr<SoftmaxLayer> create(const LayerParams& params);
275 };
276
277 class CV_EXPORTS InnerProductLayer : public Layer
278 {
279 public:
280 int axis;
281 static Ptr<InnerProductLayer> create(const LayerParams& params);
282 };
283
284 class CV_EXPORTS MVNLayer : public Layer
285 {
286 public:
287 float eps;
288 bool normVariance, acrossChannels;
289
290 static Ptr<MVNLayer> create(const LayerParams& params);
291 };
292
293 /* Reshaping */
294
295 class CV_EXPORTS ReshapeLayer : public Layer
296 {
297 public:
298 MatShape newShapeDesc;
299 Range newShapeRange;
300
301 static Ptr<ReshapeLayer> create(const LayerParams& params);
302 };
303
304 class CV_EXPORTS FlattenLayer : public Layer
305 {
306 public:
307 static Ptr<FlattenLayer> create(const LayerParams &params);
308 };
309
310 class CV_EXPORTS ConcatLayer : public Layer
311 {
312 public:
313 int axis;
320 bool padding;
321
322 static Ptr<ConcatLayer> create(const LayerParams &params);
323 };
324
325 class CV_EXPORTS SplitLayer : public Layer
326 {
327 public:
328 int outputsCount;
329
330 static Ptr<SplitLayer> create(const LayerParams &params);
331 };
332
357 class CV_EXPORTS SliceLayer : public Layer
358 {
359 public:
366 std::vector<std::vector<Range> > sliceRanges;
367 std::vector<std::vector<int> > sliceSteps;
368 int axis;
369 int num_split;
370
371 static Ptr<SliceLayer> create(const LayerParams &params);
372 };
373
374 class CV_EXPORTS PermuteLayer : public Layer
375 {
376 public:
377 static Ptr<PermuteLayer> create(const LayerParams& params);
378 };
379
389 class CV_EXPORTS ShuffleChannelLayer : public Layer
390 {
391 public:
392 static Ptr<Layer> create(const LayerParams& params);
393
394 int group;
395 };
396
417 class CV_EXPORTS PaddingLayer : public Layer
418 {
419 public:
420 static Ptr<PaddingLayer> create(const LayerParams& params);
421 };
422
423 /* Activations */
424 class CV_EXPORTS ActivationLayer : public Layer
425 {
426 public:
427 virtual void forwardSlice(const float* src, float* dst, int len,
428 size_t outPlaneSize, int cn0, int cn1) const = 0;
429 };
430
431 class CV_EXPORTS ReLULayer : public ActivationLayer
432 {
433 public:
434 float negativeSlope;
435
436 static Ptr<ReLULayer> create(const LayerParams &params);
437 };
438
439 class CV_EXPORTS ReLU6Layer : public ActivationLayer
440 {
441 public:
442 float minValue, maxValue;
443
444 static Ptr<ReLU6Layer> create(const LayerParams &params);
445 };
446
447 class CV_EXPORTS ChannelsPReLULayer : public ActivationLayer
448 {
449 public:
450 static Ptr<Layer> create(const LayerParams& params);
451 };
452
453 class CV_EXPORTS ELULayer : public ActivationLayer
454 {
455 public:
456 static Ptr<ELULayer> create(const LayerParams &params);
457 };
458
459 class CV_EXPORTS TanHLayer : public ActivationLayer
460 {
461 public:
462 static Ptr<TanHLayer> create(const LayerParams &params);
463 };
464
465 class CV_EXPORTS SwishLayer : public ActivationLayer
466 {
467 public:
468 static Ptr<SwishLayer> create(const LayerParams &params);
469 };
470
471 class CV_EXPORTS MishLayer : public ActivationLayer
472 {
473 public:
474 static Ptr<MishLayer> create(const LayerParams &params);
475 };
476
477 class CV_EXPORTS SigmoidLayer : public ActivationLayer
478 {
479 public:
480 static Ptr<SigmoidLayer> create(const LayerParams &params);
481 };
482
483 class CV_EXPORTS BNLLLayer : public ActivationLayer
484 {
485 public:
486 static Ptr<BNLLLayer> create(const LayerParams &params);
487 };
488
489 class CV_EXPORTS AbsLayer : public ActivationLayer
490 {
491 public:
492 static Ptr<AbsLayer> create(const LayerParams &params);
493 };
494
495 class CV_EXPORTS PowerLayer : public ActivationLayer
496 {
497 public:
498 float power, scale, shift;
499
500 static Ptr<PowerLayer> create(const LayerParams &params);
501 };
502
503 class CV_EXPORTS ExpLayer : public ActivationLayer
504 {
505 public:
506 float base, scale, shift;
507
508 static Ptr<ExpLayer> create(const LayerParams &params);
509 };
510
511 /* Layers used in semantic segmentation */
512
513 class CV_EXPORTS CropLayer : public Layer
514 {
515 public:
516 static Ptr<Layer> create(const LayerParams &params);
517 };
518
526 class CV_EXPORTS EltwiseLayer : public Layer
527 {
528 public:
529 static Ptr<EltwiseLayer> create(const LayerParams &params);
530 };
531
532 class CV_EXPORTS BatchNormLayer : public ActivationLayer
533 {
534 public:
535 bool hasWeights, hasBias;
536 float epsilon;
537
538 static Ptr<BatchNormLayer> create(const LayerParams &params);
539 };
540
541 class CV_EXPORTS MaxUnpoolLayer : public Layer
542 {
543 public:
544 Size poolKernel;
545 Size poolPad;
546 Size poolStride;
547
548 static Ptr<MaxUnpoolLayer> create(const LayerParams &params);
549 };
550
551 class CV_EXPORTS ScaleLayer : public Layer
552 {
553 public:
554 bool hasBias;
555 int axis;
556
557 static Ptr<ScaleLayer> create(const LayerParams& params);
558 };
559
560 class CV_EXPORTS ShiftLayer : public Layer
561 {
562 public:
563 static Ptr<Layer> create(const LayerParams& params);
564 };
565
566 class CV_EXPORTS DataAugmentationLayer : public Layer
567 {
568 public:
569 static Ptr<DataAugmentationLayer> create(const LayerParams& params);
570 };
571
572 class CV_EXPORTS CorrelationLayer : public Layer
573 {
574 public:
575 static Ptr<CorrelationLayer> create(const LayerParams& params);
576 };
577
578 class CV_EXPORTS AccumLayer : public Layer
579 {
580 public:
581 static Ptr<AccumLayer> create(const LayerParams& params);
582 };
583
584 class CV_EXPORTS FlowWarpLayer : public Layer
585 {
586 public:
587 static Ptr<FlowWarpLayer> create(const LayerParams& params);
588 };
589
590 class CV_EXPORTS PriorBoxLayer : public Layer
591 {
592 public:
593 static Ptr<PriorBoxLayer> create(const LayerParams& params);
594 };
595
596 class CV_EXPORTS ReorgLayer : public Layer
597 {
598 public:
599 static Ptr<ReorgLayer> create(const LayerParams& params);
600 };
601
602 class CV_EXPORTS RegionLayer : public Layer
603 {
604 public:
605 float nmsThreshold;
606
607 static Ptr<RegionLayer> create(const LayerParams& params);
608 };
609
618 class CV_EXPORTS DetectionOutputLayer : public Layer
619 {
620 public:
621 static Ptr<DetectionOutputLayer> create(const LayerParams& params);
622 };
623
649 class CV_EXPORTS NormalizeBBoxLayer : public Layer
650 {
651 public:
652 float pnorm, epsilon;
653 CV_DEPRECATED_EXTERNAL bool acrossSpatial;
654
655 static Ptr<NormalizeBBoxLayer> create(const LayerParams& params);
656 };
657
663 class CV_EXPORTS ResizeLayer : public Layer
664 {
665 public:
666 static Ptr<ResizeLayer> create(const LayerParams& params);
667 };
668
674 class CV_EXPORTS InterpLayer : public Layer
675 {
676 public:
677 static Ptr<Layer> create(const LayerParams& params);
678 };
679
680 class CV_EXPORTS ProposalLayer : public Layer
681 {
682 public:
683 static Ptr<ProposalLayer> create(const LayerParams& params);
684 };
685
686 class CV_EXPORTS CropAndResizeLayer : public Layer
687 {
688 public:
689 static Ptr<Layer> create(const LayerParams& params);
690 };
691
694CV__DNN_INLINE_NS_END
695}
696}
697 #endif
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Range
Template class specifying a continuous subsequence (slice) of a sequence.
Definition: core/types.hpp:590
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::dnn::AbsLayer
Definition: all_layers.hpp:490
cv::dnn::AccumLayer
Definition: all_layers.hpp:579
cv::dnn::ActivationLayer
Definition: all_layers.hpp:425
cv::dnn::BNLLLayer
Definition: all_layers.hpp:484
cv::dnn::BaseConvolutionLayer
Definition: all_layers.hpp:211
cv::dnn::BatchNormLayer
Definition: all_layers.hpp:533
cv::dnn::BlankLayer
Definition: all_layers.hpp:75
cv::dnn::ChannelsPReLULayer
Definition: all_layers.hpp:448
cv::dnn::ConcatLayer
Definition: all_layers.hpp:311
cv::dnn::ConcatLayer::padding
bool padding
Add zero padding in case of concatenation of blobs with different spatial sizes.
Definition: all_layers.hpp:320
cv::dnn::ConstLayer
Definition: all_layers.hpp:84
cv::dnn::ConvolutionLayer
Definition: all_layers.hpp:222
cv::dnn::CorrelationLayer
Definition: all_layers.hpp:573
cv::dnn::CropAndResizeLayer
Definition: all_layers.hpp:687
cv::dnn::CropLayer
Definition: all_layers.hpp:514
cv::dnn::DataAugmentationLayer
Definition: all_layers.hpp:567
cv::dnn::DeconvolutionLayer
Definition: all_layers.hpp:228
cv::dnn::DetectionOutputLayer
Detection output layer.
Definition: all_layers.hpp:619
cv::dnn::ELULayer
Definition: all_layers.hpp:454
cv::dnn::EltwiseLayer
Element wise operation on inputs
Definition: all_layers.hpp:527
cv::dnn::ExpLayer
Definition: all_layers.hpp:504
cv::dnn::FlattenLayer
Definition: all_layers.hpp:305
cv::dnn::FlowWarpLayer
Definition: all_layers.hpp:585
cv::dnn::InnerProductLayer
Definition: all_layers.hpp:278
cv::dnn::InterpLayer
Bilinear resize layer from https://github.com/cdmh/deeplab-public-ver2
Definition: all_layers.hpp:675
cv::dnn::LRNLayer
Definition: all_layers.hpp:234
cv::dnn::LSTMLayer
LSTM recurrent layer
Definition: all_layers.hpp:91
cv::dnn::LSTMLayer::create
static Ptr< LSTMLayer > create(const LayerParams &params)
cv::dnn::LSTMLayer::setOutShape
virtual void setOutShape(const MatShape &outTailShape=MatShape())=0
Specifies shape of output blob which will be [[T], N] + outTailShape.
cv::dnn::LSTMLayer::outputNameToIndex
int outputNameToIndex(const String &outputName) CV_OVERRIDE
Returns index of output blob in output array.
cv::dnn::LSTMLayer::inputNameToIndex
int inputNameToIndex(String inputName) CV_OVERRIDE
Returns index of input blob into the input array.
cv::dnn::Layer
This interface class allows to build new Layers - are building blocks of networks.
Definition: dnn/dnn.hpp:196
cv::dnn::LayerParams
This class provides all data needed to initialize layer.
Definition: dnn/dnn.hpp:121
cv::dnn::MVNLayer
Definition: all_layers.hpp:285
cv::dnn::MaxUnpoolLayer
Definition: all_layers.hpp:542
cv::dnn::MishLayer
Definition: all_layers.hpp:472
cv::dnn::NormalizeBBoxLayer
- normalization layer.
Definition: all_layers.hpp:650
cv::dnn::PaddingLayer
Adds extra values for specific axes.
Definition: all_layers.hpp:418
cv::dnn::PermuteLayer
Definition: all_layers.hpp:375
cv::dnn::PoolingLayer
Definition: all_layers.hpp:246
cv::dnn::PoolingLayer::globalPooling
bool globalPooling
Flag is true if at least one of the axes is global pooled.
Definition: all_layers.hpp:251
cv::dnn::PowerLayer
Definition: all_layers.hpp:496
cv::dnn::PriorBoxLayer
Definition: all_layers.hpp:591
cv::dnn::ProposalLayer
Definition: all_layers.hpp:681
cv::dnn::RNNLayer
Classical recurrent layer
Definition: all_layers.hpp:182
cv::dnn::RNNLayer::setWeights
virtual void setWeights(const Mat &Wxh, const Mat &bh, const Mat &Whh, const Mat &Who, const Mat &bo)=0
cv::dnn::RNNLayer::setProduceHiddenOutput
virtual void setProduceHiddenOutput(bool produce=false)=0
If this flag is set to true then layer will produce as second output.
cv::dnn::RNNLayer::create
static Ptr< RNNLayer > create(const LayerParams &params)
cv::dnn::ReLU6Layer
Definition: all_layers.hpp:440
cv::dnn::ReLULayer
Definition: all_layers.hpp:432
cv::dnn::RegionLayer
Definition: all_layers.hpp:603
cv::dnn::ReorgLayer
Definition: all_layers.hpp:597
cv::dnn::ReshapeLayer
Definition: all_layers.hpp:296
cv::dnn::ResizeLayer
Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
Definition: all_layers.hpp:664
cv::dnn::ScaleLayer
Definition: all_layers.hpp:552
cv::dnn::ShiftLayer
Definition: all_layers.hpp:561
cv::dnn::ShuffleChannelLayer
Definition: all_layers.hpp:390
cv::dnn::SigmoidLayer
Definition: all_layers.hpp:478
cv::dnn::SliceLayer
Definition: all_layers.hpp:358
cv::dnn::SliceLayer::sliceRanges
std::vector< std::vector< Range > > sliceRanges
Vector of slice ranges.
Definition: all_layers.hpp:366
cv::dnn::SoftmaxLayer
Definition: all_layers.hpp:270
cv::dnn::SplitLayer
Definition: all_layers.hpp:326
cv::dnn::SplitLayer::outputsCount
int outputsCount
Number of copies that will be produced (is ignored when negative).
Definition: all_layers.hpp:328
cv::dnn::SwishLayer
Definition: all_layers.hpp:466
cv::dnn::TanHLayer
Definition: all_layers.hpp:460
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::power
DualQuat< T > power(const DualQuat< T > &dq, const T t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
Definition: dualquaternion.inl.hpp:358
cv::Ptr
Definition: cvstd_wrapper.hpp:74
構築: doxygen 1.9.2