OpenCV 4.5.3(日本語機械翻訳)
video/tracking.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) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16 // Third party copyrights are property of their respective owners.
17 //
18 // Redistribution and use in source and binary forms, with or without modification,
19 // are permitted provided that the following conditions are met:
20 //
21 // * Redistribution's of source code must retain the above copyright notice,
22 // this list of conditions and the following disclaimer.
23 //
24 // * Redistribution's in binary form must reproduce the above copyright notice,
25 // this list of conditions and the following disclaimer in the documentation
26 // and/or other materials provided with the distribution.
27 //
28 // * The name of the copyright holders may not be used to endorse or promote products
29 // derived from this software without specific prior written permission.
30 //
31 // This software is provided by the copyright holders and contributors "as is" and
32 // any express or implied warranties, including, but not limited to, the implied
33 // warranties of merchantability and fitness for a particular purpose are disclaimed.
34 // In no event shall the Intel Corporation or contributors be liable for any direct,
35 // indirect, incidental, special, exemplary, or consequential damages
36 // (including, but not limited to, procurement of substitute goods or services;
37 // loss of use, data, or profits; or business interruption) however caused
38 // and on any theory of liability, whether in contract, strict liability,
39 // or tort (including negligence or otherwise) arising in any way out of
40 // the use of this software, even if advised of the possibility of such damage.
41 //
42 //M*/
43
44 #ifndef OPENCV_TRACKING_HPP
45 #define OPENCV_TRACKING_HPP
46
47 #include "opencv2/core.hpp"
48 #include "opencv2/imgproc.hpp"
49
50 namespace cv
51{
52
55
56 enum { OPTFLOW_USE_INITIAL_FLOW = 4,
57 OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
58 OPTFLOW_FARNEBACK_GAUSSIAN = 256
59 };
60
79 CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window,
80 TermCriteria criteria );
104 CV_EXPORTS_W int meanShift( InputArray probImage, CV_IN_OUT Rect& window, TermCriteria criteria );
105
121 CV_EXPORTS_W int buildOpticalFlowPyramid( InputArray img, OutputArrayOfArrays pyramid,
122 Size winSize, int maxLevel, bool withDerivatives = true,
123 int pyrBorder = BORDER_REFLECT_101,
124 int derivBorder = BORDER_CONSTANT,
125 bool tryReuseInputImage = true );
126
178 CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
179 InputArray prevPts, InputOutputArray nextPts,
180 OutputArray status, OutputArray err,
181 Size winSize = Size(21,21), int maxLevel = 3,
182 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
183 int flags = 0, double minEigThreshold = 1e-4 );
184
223 CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next, InputOutputArray flow,
224 double pyr_scale, int levels, int winsize,
225 int iterations, int poly_n, double poly_sigma,
226 int flags );
227
258 CV_DEPRECATED CV_EXPORTS Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine );
259
260 enum
261{
262 MOTION_TRANSLATION = 0,
263 MOTION_EUCLIDEAN = 1,
264 MOTION_AFFINE = 2,
265 MOTION_HOMOGRAPHY = 3
266};
267
279 CV_EXPORTS_W double computeECC(InputArray templateImage, InputArray inputImage, InputArray inputMask = noArray());
280
336 CV_EXPORTS_W double findTransformECC( InputArray templateImage, InputArray inputImage,
337 InputOutputArray warpMatrix, int motionType,
338 TermCriteria criteria,
339 InputArray inputMask, int gaussFiltSize);
340
342CV_EXPORTS_W
343 double findTransformECC(InputArray templateImage, InputArray inputImage,
344 InputOutputArray warpMatrix, int motionType = MOTION_AFFINE,
345 TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001),
346 InputArray inputMask = noArray());
347
360 class CV_EXPORTS_W KalmanFilter
361{
362 public:
363 CV_WRAP KalmanFilter();
370 CV_WRAP KalmanFilter( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
371
379 void init( int dynamParams, int measureParams, int controlParams = 0, int type = CV_32F );
380
385 CV_WRAP const Mat& predict( const Mat& control = Mat() );
386
391 CV_WRAP const Mat& correct( const Mat& measurement );
392
393 CV_PROP_RW Mat statePre;
394 CV_PROP_RW Mat statePost;
395 CV_PROP_RW Mat transitionMatrix;
396 CV_PROP_RW Mat controlMatrix;
397 CV_PROP_RW Mat measurementMatrix;
398 CV_PROP_RW Mat processNoiseCov;
399 CV_PROP_RW Mat measurementNoiseCov;
400 CV_PROP_RW Mat errorCovPre;
401 CV_PROP_RW Mat gain;
402 CV_PROP_RW Mat errorCovPost;
403
404 // temporary matrices
405 Mat temp1;
406 Mat temp2;
407 Mat temp3;
408 Mat temp4;
409 Mat temp5;
410};
411
412
421 CV_EXPORTS_W Mat readOpticalFlow( const String& path );
431 CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow );
432
436 class CV_EXPORTS_W DenseOpticalFlow : public Algorithm
437{
438 public:
445 CV_WRAP virtual void calc( InputArray I0, InputArray I1, InputOutputArray flow ) = 0;
448 CV_WRAP virtual void collectGarbage() = 0;
449};
450
453 class CV_EXPORTS_W SparseOpticalFlow : public Algorithm
454{
455 public:
466 CV_WRAP virtual void calc(InputArray prevImg, InputArray nextImg,
467 InputArray prevPts, InputOutputArray nextPts,
468 OutputArray status,
469 OutputArray err = cv::noArray()) = 0;
470};
471
472
475 class CV_EXPORTS_W FarnebackOpticalFlow : public DenseOpticalFlow
476{
477 public:
478 CV_WRAP virtual int getNumLevels() const = 0;
479 CV_WRAP virtual void setNumLevels(int numLevels) = 0;
480
481 CV_WRAP virtual double getPyrScale() const = 0;
482 CV_WRAP virtual void setPyrScale(double pyrScale) = 0;
483
484 CV_WRAP virtual bool getFastPyramids() const = 0;
485 CV_WRAP virtual void setFastPyramids(bool fastPyramids) = 0;
486
487 CV_WRAP virtual int getWinSize() const = 0;
488 CV_WRAP virtual void setWinSize(int winSize) = 0;
489
490 CV_WRAP virtual int getNumIters() const = 0;
491 CV_WRAP virtual void setNumIters(int numIters) = 0;
492
493 CV_WRAP virtual int getPolyN() const = 0;
494 CV_WRAP virtual void setPolyN(int polyN) = 0;
495
496 CV_WRAP virtual double getPolySigma() const = 0;
497 CV_WRAP virtual void setPolySigma(double polySigma) = 0;
498
499 CV_WRAP virtual int getFlags() const = 0;
500 CV_WRAP virtual void setFlags(int flags) = 0;
501
502 CV_WRAP static Ptr<FarnebackOpticalFlow> create(
503 int numLevels = 5,
504 double pyrScale = 0.5,
505 bool fastPyramids = false,
506 int winSize = 13,
507 int numIters = 10,
508 int polyN = 5,
509 double polySigma = 1.1,
510 int flags = 0);
511};
512
523 class CV_EXPORTS_W VariationalRefinement : public DenseOpticalFlow
524{
525 public:
528 CV_WRAP virtual void calcUV(InputArray I0, InputArray I1, InputOutputArray flow_u, InputOutputArray flow_v) = 0;
529
532 CV_WRAP virtual int getFixedPointIterations() const = 0;
534 CV_WRAP virtual void setFixedPointIterations(int val) = 0;
535
539 CV_WRAP virtual int getSorIterations() const = 0;
541 CV_WRAP virtual void setSorIterations(int val) = 0;
542
545 CV_WRAP virtual float getOmega() const = 0;
547 CV_WRAP virtual void setOmega(float val) = 0;
548
551 CV_WRAP virtual float getAlpha() const = 0;
553 CV_WRAP virtual void setAlpha(float val) = 0;
554
557 CV_WRAP virtual float getDelta() const = 0;
559 CV_WRAP virtual void setDelta(float val) = 0;
560
563 CV_WRAP virtual float getGamma() const = 0;
565 CV_WRAP virtual void setGamma(float val) = 0;
566
569 CV_WRAP static Ptr<VariationalRefinement> create();
570};
571
584 class CV_EXPORTS_W DISOpticalFlow : public DenseOpticalFlow
585{
586 public:
587 enum
588 {
589 PRESET_ULTRAFAST = 0,
590 PRESET_FAST = 1,
591 PRESET_MEDIUM = 2
592 };
593
597 CV_WRAP virtual int getFinestScale() const = 0;
599 CV_WRAP virtual void setFinestScale(int val) = 0;
600
604 CV_WRAP virtual int getPatchSize() const = 0;
606 CV_WRAP virtual void setPatchSize(int val) = 0;
607
611 CV_WRAP virtual int getPatchStride() const = 0;
613 CV_WRAP virtual void setPatchStride(int val) = 0;
614
618 CV_WRAP virtual int getGradientDescentIterations() const = 0;
620 CV_WRAP virtual void setGradientDescentIterations(int val) = 0;
621
626 CV_WRAP virtual int getVariationalRefinementIterations() const = 0;
628 CV_WRAP virtual void setVariationalRefinementIterations(int val) = 0;
629
632 CV_WRAP virtual float getVariationalRefinementAlpha() const = 0;
634 CV_WRAP virtual void setVariationalRefinementAlpha(float val) = 0;
635
638 CV_WRAP virtual float getVariationalRefinementDelta() const = 0;
640 CV_WRAP virtual void setVariationalRefinementDelta(float val) = 0;
641
644 CV_WRAP virtual float getVariationalRefinementGamma() const = 0;
646 CV_WRAP virtual void setVariationalRefinementGamma(float val) = 0;
647
648
654 CV_WRAP virtual bool getUseMeanNormalization() const = 0;
656 CV_WRAP virtual void setUseMeanNormalization(bool val) = 0;
657
663 CV_WRAP virtual bool getUseSpatialPropagation() const = 0;
665 CV_WRAP virtual void setUseSpatialPropagation(bool val) = 0;
666
671 CV_WRAP static Ptr<DISOpticalFlow> create(int preset = DISOpticalFlow::PRESET_FAST);
672};
673
682 class CV_EXPORTS_W SparsePyrLKOpticalFlow : public SparseOpticalFlow
683{
684 public:
685 CV_WRAP virtual Size getWinSize() const = 0;
686 CV_WRAP virtual void setWinSize(Size winSize) = 0;
687
688 CV_WRAP virtual int getMaxLevel() const = 0;
689 CV_WRAP virtual void setMaxLevel(int maxLevel) = 0;
690
691 CV_WRAP virtual TermCriteria getTermCriteria() const = 0;
692 CV_WRAP virtual void setTermCriteria(TermCriteria& crit) = 0;
693
694 CV_WRAP virtual int getFlags() const = 0;
695 CV_WRAP virtual void setFlags(int flags) = 0;
696
697 CV_WRAP virtual double getMinEigThreshold() const = 0;
698 CV_WRAP virtual void setMinEigThreshold(double minEigThreshold) = 0;
699
700 CV_WRAP static Ptr<SparsePyrLKOpticalFlow> create(
701 Size winSize = Size(21, 21),
702 int maxLevel = 3, TermCriteria crit =
703 TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
704 int flags = 0,
705 double minEigThreshold = 1e-4);
706};
707
708
709
710
713 class CV_EXPORTS_W Tracker
714{
715 protected:
716 Tracker();
717 public:
718 virtual ~Tracker();
719
724 CV_WRAP virtual
725 void init(InputArray image, const Rect& boundingBox) = 0;
726
736 CV_WRAP virtual
737 bool update(InputArray image, CV_OUT Rect& boundingBox) = 0;
738};
739
740
741
750 class CV_EXPORTS_W TrackerMIL : public Tracker
751{
752 protected:
753 TrackerMIL(); // use ::create()
754 public:
755 virtual ~TrackerMIL() CV_OVERRIDE;
756
757 struct CV_EXPORTS_W_SIMPLE Params
758 {
759 CV_WRAP Params();
760 //parameters for sampler
761 CV_PROP_RW float samplerInitInRadius;
762 CV_PROP_RW int samplerInitMaxNegNum;
763 CV_PROP_RW float samplerSearchWinSize;
764 CV_PROP_RW float samplerTrackInRadius;
765 CV_PROP_RW int samplerTrackMaxPosNum;
766 CV_PROP_RW int samplerTrackMaxNegNum;
767 CV_PROP_RW int featureSetNumFeatures;
768 };
769
773 static CV_WRAP
774 Ptr<TrackerMIL> create(const TrackerMIL::Params &parameters = TrackerMIL::Params());
775
776 //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
777 //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
778};
779
780
781
797 class CV_EXPORTS_W TrackerGOTURN : public Tracker
798{
799 protected:
800 TrackerGOTURN(); // use ::create()
801 public:
802 virtual ~TrackerGOTURN() CV_OVERRIDE;
803
804 struct CV_EXPORTS_W_SIMPLE Params
805 {
806 CV_WRAP Params();
807 CV_PROP_RW std::string modelTxt;
808 CV_PROP_RW std::string modelBin;
809 };
810
814 static CV_WRAP
815 Ptr<TrackerGOTURN> create(const TrackerGOTURN::Params& parameters = TrackerGOTURN::Params());
816
817 //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
818 //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
819};
820
821 class CV_EXPORTS_W TrackerDaSiamRPN : public Tracker
822{
823 protected:
824 TrackerDaSiamRPN(); // use ::create()
825 public:
826 virtual ~TrackerDaSiamRPN() CV_OVERRIDE;
827
828 struct CV_EXPORTS_W_SIMPLE Params
829 {
830 CV_WRAP Params();
831 CV_PROP_RW std::string model;
832 CV_PROP_RW std::string kernel_cls1;
833 CV_PROP_RW std::string kernel_r1;
834 CV_PROP_RW int backend;
835 CV_PROP_RW int target;
836 };
837
841 static CV_WRAP
842 Ptr<TrackerDaSiamRPN> create(const TrackerDaSiamRPN::Params& parameters = TrackerDaSiamRPN::Params());
843
846 CV_WRAP virtual float getTrackingScore() = 0;
847
848 //void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
849 //bool update(InputArray image, CV_OUT Rect& boundingBox) CV_OVERRIDE;
850};
851
852
854
855} // cv
856
857 #endif
cv::_InputOutputArray
Definition: mat.hpp:386
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::DISOpticalFlow
DIS optical flow algorithm.
Definition: video/tracking.hpp:585
cv::DenseOpticalFlow
Definition: video/tracking.hpp:437
cv::FarnebackOpticalFlow
Class computing a dense optical flow using the Gunnar Farneback's algorithm.
Definition: video/tracking.hpp:476
cv::KalmanFilter
Kalman filter class.
Definition: video/tracking.hpp:361
cv::KalmanFilter::init
void init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F)
Re-initializes Kalman filter. The previous content is destroyed.
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::RotatedRect
The class represents rotated (i.e. not up-right) rectangles on a plane.
Definition: core/types.hpp:504
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::SparseOpticalFlow
Base interface for sparse optical flow algorithms.
Definition: video/tracking.hpp:454
cv::SparsePyrLKOpticalFlow
Class used for calculating a sparse optical flow.
Definition: video/tracking.hpp:683
cv::TermCriteria
The class defining termination criteria for iterative algorithms.
Definition: core/types.hpp:853
cv::TermCriteria::EPS
@ EPS
the desired accuracy or change in parameters at which the iterative algorithm stops
Definition: core/types.hpp:862
cv::TermCriteria::COUNT
@ COUNT
the maximum number of iterations or elements to compute
Definition: core/types.hpp:860
cv::TrackerDaSiamRPN
Definition: video/tracking.hpp:822
cv::TrackerDaSiamRPN::create
static CV_WRAP Ptr< TrackerDaSiamRPN > create(const TrackerDaSiamRPN::Params &parameters=TrackerDaSiamRPN::Params())
Constructor
cv::TrackerGOTURN
the GOTURN (Generic Object Tracking Using Regression Networks) tracker
Definition: video/tracking.hpp:798
cv::TrackerGOTURN::create
static CV_WRAP Ptr< TrackerGOTURN > create(const TrackerGOTURN::Params &parameters=TrackerGOTURN::Params())
Constructor
cv::Tracker
Base abstract class for the long-term tracker
Definition: video/tracking.hpp:714
cv::Tracker::update
virtual CV_WRAP bool update(InputArray image, CV_OUT Rect &boundingBox)=0
Update the tracker, find the new most likely bounding box for the target
cv::Tracker::init
virtual CV_WRAP void init(InputArray image, const Rect &boundingBox)=0
Initialize the tracker with a known bounding box that surrounded the target
cv::TrackerMIL
The MIL algorithm trains a classifier in an online manner to separate the object from the background.
Definition: video/tracking.hpp:751
cv::TrackerMIL::create
static CV_WRAP Ptr< TrackerMIL > create(const TrackerMIL::Params &parameters=TrackerMIL::Params())
Create MIL tracker instance
cv::VariationalRefinement
Variational optical flow refinement
Definition: video/tracking.hpp:524
cv::BORDER_REFLECT_101
@ BORDER_REFLECT_101
gfedcb|abcdefgh|gfedcba
Definition: base.hpp:273
cv::BORDER_CONSTANT
@ BORDER_CONSTANT
iiiiii|abcdefgh|iiiiiii with some specified i
Definition: base.hpp:269
cv::CamShift
CV_EXPORTS_W RotatedRect CamShift(InputArray probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
Finds an object center, size, and orientation.
cv::calcOpticalFlowFarneback
CV_EXPORTS_W void calcOpticalFlowFarneback(InputArray prev, InputArray next, InputOutputArray flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
Computes a dense optical flow using the Gunnar Farneback's algorithm.
cv::meanShift
CV_EXPORTS_W int meanShift(InputArray probImage, CV_IN_OUT Rect &window, TermCriteria criteria)
Finds an object on a back projection image.
cv::buildOpticalFlowPyramid
CV_EXPORTS_W int buildOpticalFlowPyramid(InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives=true, int pyrBorder=BORDER_REFLECT_101, int derivBorder=BORDER_CONSTANT, bool tryReuseInputImage=true)
Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
cv::findTransformECC
CV_EXPORTS_W double findTransformECC(InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix, int motionType, TermCriteria criteria, InputArray inputMask, int gaussFiltSize)
Finds the geometric transform (warp) between two images in terms of the ECC criterion .
cv::computeECC
CV_EXPORTS_W double computeECC(InputArray templateImage, InputArray inputImage, InputArray inputMask=noArray())
Computes the Enhanced Correlation Coefficient value between two images .
cv::readOpticalFlow
CV_EXPORTS_W Mat readOpticalFlow(const String &path)
Read a .flo file
cv::calcOpticalFlowPyrLK
CV_EXPORTS_W void calcOpticalFlowPyrLK(InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(21, 21), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags=0, double minEigThreshold=1e-4)
Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyra...
cv::writeOpticalFlow
CV_EXPORTS_W bool writeOpticalFlow(const String &path, InputArray flow)
Write a .flo to disk
cv::estimateRigidTransform
CV_DEPRECATED CV_EXPORTS Mat estimateRigidTransform(InputArray src, InputArray dst, bool fullAffine)
Computes an optimal affine transformation between two 2D point sets.
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::Ptr
Definition: cvstd_wrapper.hpp:74
cv::TrackerDaSiamRPN::Params
Definition: video/tracking.hpp:829
cv::TrackerGOTURN::Params
Definition: video/tracking.hpp:805
cv::TrackerMIL::Params
Definition: video/tracking.hpp:758
構築: doxygen 1.9.2