Renesas
openCV library for Renesas RZ/A
Dependents: RZ_A2M_Mbed_samples
Diff: include/opencv2/objdetect.hpp
- Revision:
- 0:0e0631af0305
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/include/opencv2/objdetect.hpp Fri Jan 29 04:53:38 2021 +0000
@@ -0,0 +1,466 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef OPENCV_OBJDETECT_HPP
+#define OPENCV_OBJDETECT_HPP
+
+#include "opencv2/core.hpp"
+
+/**
+@defgroup objdetect Object Detection
+
+Haar Feature-based Cascade Classifier for Object Detection
+----------------------------------------------------------
+
+The object detector described below has been initially proposed by Paul Viola @cite Viola01 and
+improved by Rainer Lienhart @cite Lienhart02 .
+
+First, a classifier (namely a *cascade of boosted classifiers working with haar-like features*) is
+trained with a few hundred sample views of a particular object (i.e., a face or a car), called
+positive examples, that are scaled to the same size (say, 20x20), and negative examples - arbitrary
+images of the same size.
+
+After a classifier is trained, it can be applied to a region of interest (of the same size as used
+during the training) in an input image. The classifier outputs a "1" if the region is likely to show
+the object (i.e., face/car), and "0" otherwise. To search for the object in the whole image one can
+move the search window across the image and check every location using the classifier. The
+classifier is designed so that it can be easily "resized" in order to be able to find the objects of
+interest at different sizes, which is more efficient than resizing the image itself. So, to find an
+object of an unknown size in the image the scan procedure should be done several times at different
+scales.
+
+The word "cascade" in the classifier name means that the resultant classifier consists of several
+simpler classifiers (*stages*) that are applied subsequently to a region of interest until at some
+stage the candidate is rejected or all the stages are passed. The word "boosted" means that the
+classifiers at every stage of the cascade are complex themselves and they are built out of basic
+classifiers using one of four different boosting techniques (weighted voting). Currently Discrete
+Adaboost, Real Adaboost, Gentle Adaboost and Logitboost are supported. The basic classifiers are
+decision-tree classifiers with at least 2 leaves. Haar-like features are the input to the basic
+classifiers, and are calculated as described below. The current algorithm uses the following
+Haar-like features:
+
+
+
+The feature used in a particular classifier is specified by its shape (1a, 2b etc.), position within
+the region of interest and the scale (this scale is not the same as the scale used at the detection
+stage, though these two scales are multiplied). For example, in the case of the third line feature
+(2c) the response is calculated as the difference between the sum of image pixels under the
+rectangle covering the whole feature (including the two white stripes and the black stripe in the
+middle) and the sum of the image pixels under the black stripe multiplied by 3 in order to
+compensate for the differences in the size of areas. The sums of pixel values over a rectangular
+regions are calculated rapidly using integral images (see below and the integral description).
+
+To see the object detector at work, have a look at the facedetect demo:
+<https://github.com/opencv/opencv/tree/master/samples/cpp/dbt_face_detection.cpp>
+
+The following reference is for the detection part only. There is a separate application called
+opencv_traincascade that can train a cascade of boosted classifiers from a set of samples.
+
+@note In the new C++ interface it is also possible to use LBP (local binary pattern) features in
+addition to Haar-like features. .. [Viola01] Paul Viola and Michael J. Jones. Rapid Object Detection
+using a Boosted Cascade of Simple Features. IEEE CVPR, 2001. The paper is available online at
+<http://research.microsoft.com/en-us/um/people/viola/Pubs/Detect/violaJones_CVPR2001.pdf>
+
+@{
+ @defgroup objdetect_c C API
+@}
+ */
+
+typedef struct CvHaarClassifierCascade CvHaarClassifierCascade;
+
+namespace cv
+{
+
+//! @addtogroup objdetect
+//! @{
+
+///////////////////////////// Object Detection ////////////////////////////
+
+//! class for grouping object candidates, detected by Cascade Classifier, HOG etc.
+//! instance of the class is to be passed to cv::partition (see cxoperations.hpp)
+class CV_EXPORTS SimilarRects
+{
+public:
+ SimilarRects(double _eps) : eps(_eps) {}
+ inline bool operator()(const Rect& r1, const Rect& r2) const
+ {
+ double delta = eps * ((std::min)(r1.width, r2.width) + (std::min)(r1.height, r2.height)) * 0.5;
+ return std::abs(r1.x - r2.x) <= delta &&
+ std::abs(r1.y - r2.y) <= delta &&
+ std::abs(r1.x + r1.width - r2.x - r2.width) <= delta &&
+ std::abs(r1.y + r1.height - r2.y - r2.height) <= delta;
+ }
+ double eps;
+};
+
+/** @brief Groups the object candidate rectangles.
+
+@param rectList Input/output vector of rectangles. Output vector includes retained and grouped
+rectangles. (The Python list is not modified in place.)
+@param groupThreshold Minimum possible number of rectangles minus 1. The threshold is used in a
+group of rectangles to retain it.
+@param eps Relative difference between sides of the rectangles to merge them into a group.
+
+The function is a wrapper for the generic function partition . It clusters all the input rectangles
+using the rectangle equivalence criteria that combines rectangles with similar sizes and similar
+locations. The similarity is defined by eps. When eps=0 , no clustering is done at all. If
+\f$\texttt{eps}\rightarrow +\inf\f$ , all the rectangles are put in one cluster. Then, the small
+clusters containing less than or equal to groupThreshold rectangles are rejected. In each other
+cluster, the average rectangle is computed and put into the output rectangle list.
+ */
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS_W void groupRectangles(CV_IN_OUT std::vector<Rect>& rectList, CV_OUT std::vector<int>& weights,
+ int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, int groupThreshold,
+ double eps, std::vector<int>* weights, std::vector<double>* levelWeights );
+/** @overload */
+CV_EXPORTS void groupRectangles(std::vector<Rect>& rectList, std::vector<int>& rejectLevels,
+ std::vector<double>& levelWeights, int groupThreshold, double eps = 0.2);
+/** @overload */
+CV_EXPORTS void groupRectangles_meanshift(std::vector<Rect>& rectList, std::vector<double>& foundWeights,
+ std::vector<double>& foundScales,
+ double detectThreshold = 0.0, Size winDetSize = Size(64, 128));
+
+template<> CV_EXPORTS void DefaultDeleter<CvHaarClassifierCascade>::operator ()(CvHaarClassifierCascade* obj) const;
+
+enum { CASCADE_DO_CANNY_PRUNING = 1,
+ CASCADE_SCALE_IMAGE = 2,
+ CASCADE_FIND_BIGGEST_OBJECT = 4,
+ CASCADE_DO_ROUGH_SEARCH = 8
+ };
+
+class CV_EXPORTS_W BaseCascadeClassifier : public Algorithm
+{
+public:
+ virtual ~BaseCascadeClassifier();
+ virtual bool empty() const = 0;
+ virtual bool load( const String& filename ) = 0;
+ virtual void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ double scaleFactor,
+ int minNeighbors, int flags,
+ Size minSize, Size maxSize ) = 0;
+
+ virtual void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ CV_OUT std::vector<int>& numDetections,
+ double scaleFactor,
+ int minNeighbors, int flags,
+ Size minSize, Size maxSize ) = 0;
+
+ virtual void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ CV_OUT std::vector<int>& rejectLevels,
+ CV_OUT std::vector<double>& levelWeights,
+ double scaleFactor,
+ int minNeighbors, int flags,
+ Size minSize, Size maxSize,
+ bool outputRejectLevels ) = 0;
+
+ virtual bool isOldFormatCascade() const = 0;
+ virtual Size getOriginalWindowSize() const = 0;
+ virtual int getFeatureType() const = 0;
+ virtual void* getOldCascade() = 0;
+
+ class CV_EXPORTS MaskGenerator
+ {
+ public:
+ virtual ~MaskGenerator() {}
+ virtual Mat generateMask(const Mat& src)=0;
+ virtual void initializeMask(const Mat& /*src*/) { }
+ };
+ virtual void setMaskGenerator(const Ptr<MaskGenerator>& maskGenerator) = 0;
+ virtual Ptr<MaskGenerator> getMaskGenerator() = 0;
+};
+
+/** @brief Cascade classifier class for object detection.
+ */
+class CV_EXPORTS_W CascadeClassifier
+{
+public:
+ CV_WRAP CascadeClassifier();
+ /** @brief Loads a classifier from a file.
+
+ @param filename Name of the file from which the classifier is loaded.
+ */
+ CV_WRAP CascadeClassifier(const String& filename);
+ ~CascadeClassifier();
+ /** @brief Checks whether the classifier has been loaded.
+ */
+ CV_WRAP bool empty() const;
+ /** @brief Loads a classifier from a file.
+
+ @param filename Name of the file from which the classifier is loaded. The file may contain an old
+ HAAR classifier trained by the haartraining application or a new cascade classifier trained by the
+ traincascade application.
+ */
+ CV_WRAP bool load( const String& filename );
+ /** @brief Reads a classifier from a FileStorage node.
+
+ @note The file may contain a new cascade classifier (trained traincascade application) only.
+ */
+ CV_WRAP bool read( const FileNode& node );
+
+ /** @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
+ of rectangles.
+
+ @param image Matrix of the type CV_8U containing an image where objects are detected.
+ @param objects Vector of rectangles where each rectangle contains the detected object, the
+ rectangles may be partially outside the original image.
+ @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+ @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+ to retain it.
+ @param flags Parameter with the same meaning for an old cascade as in the function
+ cvHaarDetectObjects. It is not used for a new cascade.
+ @param minSize Minimum possible object size. Objects smaller than that are ignored.
+ @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.
+
+ The function is parallelized with the TBB library.
+
+ @note
+ - (Python) A face detection example using cascade classifiers can be found at
+ opencv_source_code/samples/python/facedetect.py
+ */
+ CV_WRAP void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ double scaleFactor = 1.1,
+ int minNeighbors = 3, int flags = 0,
+ Size minSize = Size(),
+ Size maxSize = Size() );
+
+ /** @overload
+ @param image Matrix of the type CV_8U containing an image where objects are detected.
+ @param objects Vector of rectangles where each rectangle contains the detected object, the
+ rectangles may be partially outside the original image.
+ @param numDetections Vector of detection numbers for the corresponding objects. An object's number
+ of detections is the number of neighboring positively classified rectangles that were joined
+ together to form the object.
+ @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
+ @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
+ to retain it.
+ @param flags Parameter with the same meaning for an old cascade as in the function
+ cvHaarDetectObjects. It is not used for a new cascade.
+ @param minSize Minimum possible object size. Objects smaller than that are ignored.
+ @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.
+ */
+ CV_WRAP_AS(detectMultiScale2) void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ CV_OUT std::vector<int>& numDetections,
+ double scaleFactor=1.1,
+ int minNeighbors=3, int flags=0,
+ Size minSize=Size(),
+ Size maxSize=Size() );
+
+ /** @overload
+ if `outputRejectLevels` is `true` returns `rejectLevels` and `levelWeights`
+ */
+ CV_WRAP_AS(detectMultiScale3) void detectMultiScale( InputArray image,
+ CV_OUT std::vector<Rect>& objects,
+ CV_OUT std::vector<int>& rejectLevels,
+ CV_OUT std::vector<double>& levelWeights,
+ double scaleFactor = 1.1,
+ int minNeighbors = 3, int flags = 0,
+ Size minSize = Size(),
+ Size maxSize = Size(),
+ bool outputRejectLevels = false );
+
+ CV_WRAP bool isOldFormatCascade() const;
+ CV_WRAP Size getOriginalWindowSize() const;
+ CV_WRAP int getFeatureType() const;
+ void* getOldCascade();
+
+ CV_WRAP static bool convert(const String& oldcascade, const String& newcascade);
+
+ void setMaskGenerator(const Ptr<BaseCascadeClassifier::MaskGenerator>& maskGenerator);
+ Ptr<BaseCascadeClassifier::MaskGenerator> getMaskGenerator();
+
+ Ptr<BaseCascadeClassifier> cc;
+};
+
+CV_EXPORTS Ptr<BaseCascadeClassifier::MaskGenerator> createFaceDetectionMaskGenerator();
+
+//////////////// HOG (Histogram-of-Oriented-Gradients) Descriptor and Object Detector //////////////
+
+//! struct for detection region of interest (ROI)
+struct DetectionROI
+{
+ //! scale(size) of the bounding box
+ double scale;
+ //! set of requrested locations to be evaluated
+ std::vector<cv::Point> locations;
+ //! vector that will contain confidence values for each location
+ std::vector<double> confidences;
+};
+
+struct CV_EXPORTS_W HOGDescriptor
+{
+public:
+ enum { L2Hys = 0
+ };
+ enum { DEFAULT_NLEVELS = 64
+ };
+
+ CV_WRAP HOGDescriptor() : winSize(64,128), blockSize(16,16), blockStride(8,8),
+ cellSize(8,8), nbins(9), derivAperture(1), winSigma(-1),
+ histogramNormType(HOGDescriptor::L2Hys), L2HysThreshold(0.2), gammaCorrection(true),
+ free_coef(-1.f), nlevels(HOGDescriptor::DEFAULT_NLEVELS), signedGradient(false)
+ {}
+
+ CV_WRAP HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride,
+ Size _cellSize, int _nbins, int _derivAperture=1, double _winSigma=-1,
+ int _histogramNormType=HOGDescriptor::L2Hys,
+ double _L2HysThreshold=0.2, bool _gammaCorrection=false,
+ int _nlevels=HOGDescriptor::DEFAULT_NLEVELS, bool _signedGradient=false)
+ : winSize(_winSize), blockSize(_blockSize), blockStride(_blockStride), cellSize(_cellSize),
+ nbins(_nbins), derivAperture(_derivAperture), winSigma(_winSigma),
+ histogramNormType(_histogramNormType), L2HysThreshold(_L2HysThreshold),
+ gammaCorrection(_gammaCorrection), free_coef(-1.f), nlevels(_nlevels), signedGradient(_signedGradient)
+ {}
+
+ CV_WRAP HOGDescriptor(const String& filename)
+ {
+ load(filename);
+ }
+
+ HOGDescriptor(const HOGDescriptor& d)
+ {
+ d.copyTo(*this);
+ }
+
+ virtual ~HOGDescriptor() {}
+
+ CV_WRAP size_t getDescriptorSize() const;
+ CV_WRAP bool checkDetectorSize() const;
+ CV_WRAP double getWinSigma() const;
+
+ CV_WRAP virtual void setSVMDetector(InputArray _svmdetector);
+
+ virtual bool read(FileNode& fn);
+ virtual void write(FileStorage& fs, const String& objname) const;
+
+ CV_WRAP virtual bool load(const String& filename, const String& objname = String());
+ CV_WRAP virtual void save(const String& filename, const String& objname = String()) const;
+ virtual void copyTo(HOGDescriptor& c) const;
+
+ CV_WRAP virtual void compute(InputArray img,
+ CV_OUT std::vector<float>& descriptors,
+ Size winStride = Size(), Size padding = Size(),
+ const std::vector<Point>& locations = std::vector<Point>()) const;
+
+ //! with found weights output
+ CV_WRAP virtual void detect(const Mat& img, CV_OUT std::vector<Point>& foundLocations,
+ CV_OUT std::vector<double>& weights,
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(),
+ const std::vector<Point>& searchLocations = std::vector<Point>()) const;
+ //! without found weights output
+ virtual void detect(const Mat& img, CV_OUT std::vector<Point>& foundLocations,
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(),
+ const std::vector<Point>& searchLocations=std::vector<Point>()) const;
+
+ //! with result weights output
+ CV_WRAP virtual void detectMultiScale(InputArray img, CV_OUT std::vector<Rect>& foundLocations,
+ CV_OUT std::vector<double>& foundWeights, double hitThreshold = 0,
+ Size winStride = Size(), Size padding = Size(), double scale = 1.05,
+ double finalThreshold = 2.0,bool useMeanshiftGrouping = false) const;
+ //! without found weights output
+ virtual void detectMultiScale(InputArray img, CV_OUT std::vector<Rect>& foundLocations,
+ double hitThreshold = 0, Size winStride = Size(),
+ Size padding = Size(), double scale = 1.05,
+ double finalThreshold = 2.0, bool useMeanshiftGrouping = false) const;
+
+ CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
+ Size paddingTL = Size(), Size paddingBR = Size()) const;
+
+ CV_WRAP static std::vector<float> getDefaultPeopleDetector();
+ CV_WRAP static std::vector<float> getDaimlerPeopleDetector();
+
+ CV_PROP Size winSize;
+ CV_PROP Size blockSize;
+ CV_PROP Size blockStride;
+ CV_PROP Size cellSize;
+ CV_PROP int nbins;
+ CV_PROP int derivAperture;
+ CV_PROP double winSigma;
+ CV_PROP int histogramNormType;
+ CV_PROP double L2HysThreshold;
+ CV_PROP bool gammaCorrection;
+ CV_PROP std::vector<float> svmDetector;
+ UMat oclSvmDetector;
+ float free_coef;
+ CV_PROP int nlevels;
+ CV_PROP bool signedGradient;
+
+
+ //! evaluate specified ROI and return confidence value for each location
+ virtual void detectROI(const cv::Mat& img, const std::vector<cv::Point> &locations,
+ CV_OUT std::vector<cv::Point>& foundLocations, CV_OUT std::vector<double>& confidences,
+ double hitThreshold = 0, cv::Size winStride = Size(),
+ cv::Size padding = Size()) const;
+
+ //! evaluate specified ROI and return confidence value for each location in multiple scales
+ virtual void detectMultiScaleROI(const cv::Mat& img,
+ CV_OUT std::vector<cv::Rect>& foundLocations,
+ std::vector<DetectionROI>& locations,
+ double hitThreshold = 0,
+ int groupThreshold = 0) const;
+
+ //! read/parse Dalal's alt model file
+ void readALTModel(String modelfile);
+ void groupRectangles(std::vector<cv::Rect>& rectList, std::vector<double>& weights, int groupThreshold, double eps) const;
+};
+
+//! @} objdetect
+
+}
+
+#include "opencv2/objdetect/detection_based_tracker.hpp"
+
+#ifndef DISABLE_OPENCV_24_COMPATIBILITY
+#include "opencv2/objdetect/objdetect_c.h"
+#endif
+
+#endif