> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/opencv/opencv/llms.txt > Use this file to discover all available pages before exploring further. # Cascade Classifier > API reference for CascadeClassifier and HOGDescriptor classes for object detection # Cascade Classifier API reference for cascade-based object detection and HOG descriptor computation. ## CascadeClassifier Cascade classifier class for object detection using Haar or LBP features. ### Constructor ```cpp theme={null} cv::CascadeClassifier::CascadeClassifier() cv::CascadeClassifier::CascadeClassifier(const String& filename) ``` Path to the classifier file (e.g., haarcascade\_frontalface\_default.xml) ### Methods #### load Loads a classifier from a file. ```cpp theme={null} bool load(const String& 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. **Returns:** `true` if the classifier was loaded successfully #### detectMultiScale Detects objects of different sizes in the input image. ```cpp theme={null} void detectMultiScale( InputArray image, std::vector& objects, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size() ) ``` Matrix of type CV\_8U containing an image where objects are detected Output vector of rectangles where each rectangle contains a detected object Parameter specifying how much the image size is reduced at each image scale Parameter specifying how many neighbors each candidate rectangle should have to retain it Parameter with the same meaning for an old cascade as in cvHaarDetectObjects. Not used for new cascades. Minimum possible object size. Objects smaller than this are ignored. Maximum possible object size. Objects larger than this are ignored. If maxSize == minSize, model is evaluated on single scale. The function does not correct lens distortion. If camera parameters are known, it's recommended to undistort the input image first. #### detectMultiScale (with detection counts) ```cpp theme={null} void detectMultiScale( InputArray image, std::vector& objects, std::vector& numDetections, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size() ) ``` 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. #### detectMultiScale (with confidence levels) ```cpp theme={null} void detectMultiScale( InputArray image, std::vector& objects, std::vector& rejectLevels, std::vector& levelWeights, double scaleFactor = 1.1, int minNeighbors = 3, int flags = 0, Size minSize = Size(), Size maxSize = Size(), bool outputRejectLevels = false ) ``` Output vector of reject levels for each detection Output vector containing the certainty of classification at the final stage for each detection Set to true to retrieve the final stage decision certainty of classification #### empty Checks whether the classifier has been loaded. ```cpp theme={null} bool empty() const ``` **Returns:** `true` if the classifier is empty ### Example Usage ```cpp theme={null} #include #include // Load the cascade classifier cv::CascadeClassifier face_cascade; face_cascade.load("haarcascade_frontalface_default.xml"); // Detect faces cv::Mat gray; cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY); std::vector faces; face_cascade.detectMultiScale(gray, faces, 1.1, 3); // Draw rectangles around detected faces for (const auto& face : faces) { cv::rectangle(image, face, cv::Scalar(255, 0, 0), 2); } ``` ```python theme={null} import cv2 # Load the cascade classifier face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Detect faces faces = face_cascade.detectMultiScale(gray, 1.1, 3) # Draw rectangles around detected faces for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2) ``` *** ## HOGDescriptor Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector. Based on the algorithm introduced by Navneet Dalal and Bill Triggs. ### Constructor ```cpp theme={null} cv::HOGDescriptor::HOGDescriptor() cv::HOGDescriptor::HOGDescriptor( Size winSize, Size blockSize, Size blockStride, Size cellSize, int nbins, int derivAperture = 1, double winSigma = -1, HOGDescriptor::HistogramNormType histogramNormType = HOGDescriptor::L2Hys, double L2HysThreshold = 0.2, bool gammaCorrection = false, int nlevels = HOGDescriptor::DEFAULT_NLEVELS, bool signedGradient = false ) cv::HOGDescriptor::HOGDescriptor(const String& filename) ``` Detection window size. Default is Size(64, 128). Must align to block size and block stride. Block size in pixels. Default is Size(16, 16). Must align to cell size. Block stride. Default is Size(8, 8). Must be a multiple of cell size. Cell size. Default is Size(8, 8). Number of bins used in the calculation of histogram of gradients. Default is 9. File name containing HOGDescriptor properties and coefficients for the linear SVM classifier ### Methods #### compute Computes HOG descriptors of given image. ```cpp theme={null} void compute( InputArray img, std::vector& descriptors, Size winStride = Size(), Size padding = Size(), const std::vector& locations = std::vector() ) const ``` Matrix of type CV\_8U containing an image where HOG features will be calculated Output matrix of type CV\_32F containing computed descriptors Window stride. Must be a multiple of block stride. Padding around the image Vector of specific locations to compute descriptors at #### detect Performs object detection without a multi-scale window. ```cpp theme={null} void detect( InputArray img, std::vector& foundLocations, std::vector& weights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), const std::vector& searchLocations = std::vector() ) const ``` Matrix of type CV\_8U or CV\_8UC3 containing an image where objects are detected Vector of points where each point contains left-top corner of detected object boundaries Vector that will contain confidence values for each detected object Threshold for the distance between features and SVM classifying plane Window stride. Must be a multiple of block stride. Padding around the image Vector of specific locations to search #### detectMultiScale Detects objects of different sizes in the input image. ```cpp theme={null} void detectMultiScale( InputArray img, std::vector& foundLocations, std::vector& foundWeights, double hitThreshold = 0, Size winStride = Size(), Size padding = Size(), double scale = 1.05, double groupThreshold = 2.0, bool useMeanshiftGrouping = false ) const ``` Matrix of type CV\_8U or CV\_8UC3 containing an image where objects are detected Vector of rectangles where each rectangle contains the detected object Vector that will contain confidence values for each detected object Coefficient of the detection window increase Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. Indicates whether to use meanshift grouping algorithm #### setSVMDetector Sets coefficients for the linear SVM classifier. ```cpp theme={null} void setSVMDetector(InputArray svmdetector) ``` Coefficients for the linear SVM classifier #### getDefaultPeopleDetector Returns coefficients of the classifier trained for people detection (for 64x128 windows). ```cpp theme={null} static std::vector getDefaultPeopleDetector() ``` **Returns:** Vector of SVM coefficients for people detection #### getDaimlerPeopleDetector Returns coefficients of the classifier trained for people detection (for 48x96 windows). ```cpp theme={null} static std::vector getDaimlerPeopleDetector() ``` **Returns:** Vector of SVM coefficients for Daimler people detection ### Properties * `winSize` (Size): Detection window size. Default Size(64, 128). * `blockSize` (Size): Block size in pixels. Default Size(16, 16). * `blockStride` (Size): Block stride. Default Size(8, 8). * `cellSize` (Size): Cell size. Default Size(8, 8). * `nbins` (int): Number of bins. Default 9. * `derivAperture` (int): Derivative aperture. * `winSigma` (double): Gaussian smoothing window parameter. * `histogramNormType` (HistogramNormType): Histogram normalization type. * `L2HysThreshold` (double): L2-Hys normalization method shrinkage. * `gammaCorrection` (bool): Flag to specify gamma correction preprocessing. * `svmDetector` (std::vector\): Coefficients for the linear SVM classifier. * `nlevels` (int): Maximum number of detection window increases. Default 64. * `signedGradient` (bool): Indicates whether signed gradient will be used. ### Example Usage ```cpp theme={null} #include #include // Create HOG descriptor with default people detector cv::HOGDescriptor hog; hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector()); // Detect people in the image std::vector found; std::vector weights; hog.detectMultiScale(image, found, weights, 0, cv::Size(8, 8), cv::Size(32, 32), 1.05, 2, false); // Draw rectangles around detected people for (const auto& rect : found) { cv::rectangle(image, rect, cv::Scalar(0, 255, 0), 2); } ``` ```python theme={null} import cv2 # Create HOG descriptor with default people detector hog = cv2.HOGDescriptor() hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) # Detect people in the image found, weights = hog.detectMultiScale(image, winStride=(8, 8), padding=(32, 32), scale=1.05) # Draw rectangles around detected people for (x, y, w, h) in found: cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) ``` ## See Also * [Face Detection](/api/objdetect/face) * [ArUco Detection](/api/objdetect/aruco) * [QR Code Detection](/api/objdetect/qrcode)