struct CV_EXPORTS HOGConfidence

{

double scale;

std::vector<Point> locations;

std::vector<double> confidences;

std::vector<double> part_scores[4];

};

struct CV_EXPORTS HOGDescriptor

{

enum { DEFAULT_WIN_SIGMA = -1 };

enum { DEFAULT_NLEVELS = 64 };

enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };

/** @brief Creates the HOG descriptor and detector.

HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16),

Size block_stride=Size(8, 8), Size cell_size=Size(8, 8),

int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA,

double threshold_L2hys=0.2, bool gamma_correction=true,

int nlevels=DEFAULT_NLEVELS);

/** @brief Returns the number of coefficients required for the classification.

size_t getDescriptorSize() const;

/** @brief Returns the block histogram size.

size_t getBlockHistogramSize() const;

/** @brief Sets coefficients for the linear SVM classifier.

void setSVMDetector(const std::vector<float>& detector);

/** @brief Returns coefficients of the classifier trained for people detection (for default window size).

static std::vector<float> getDefaultPeopleDetector();

/** @brief Returns coefficients of the classifier trained for people detection (for 48x96 windows).

static std::vector<float> getPeopleDetector48x96();

/** @brief Returns coefficients of the classifier trained for people detection (for 64x128 windows).

static std::vector<float> getPeopleDetector64x128();

/** @brief Performs object detection without a multi-scale window.

void detect(const GpuMat& img, std::vector<Point>& found_locations,

double hit_threshold=0, Size win_stride=Size(),

Size padding=Size());

/** @brief Performs object detection with a multi-scale window.

void detectMultiScale(const GpuMat& img, std::vector<Rect>& found_locations,

double hit_threshold=0, Size win_stride=Size(),

Size padding=Size(), double scale0=1.05,

int group_threshold=2);

void computeConfidence(const GpuMat& img, std::vector<Point>& hits, double hit_threshold,

Size win_stride, Size padding, std::vector<Point>& locations, std::vector<double>& confidences);

void computeConfidenceMultiScale(const GpuMat& img, std::vector<Rect>& found_locations,

double hit_threshold, Size win_stride, Size padding,

std::vector<HOGConfidence> &conf_out, int group_threshold);

/** @brief Returns block descriptors computed for the whole image.

void getDescriptors(const GpuMat& img, Size win_stride,

GpuMat& descriptors,

int descr_format=DESCR_FORMAT_COL_BY_COL);

Size win_size;

Size block_size;

Size block_stride;

Size cell_size;

int nbins;

double win_sigma;

double threshold_L2hys;

bool gamma_correction;

int nlevels;

void computeBlockHistograms(const GpuMat& img);

void computeGradient(const GpuMat& img, GpuMat& grad, GpuMat& qangle);

double getWinSigma() const;

bool checkDetectorSize() const;

static int numPartsWithin(int size, int part_size, int stride);

static Size numPartsWithin(Size size, Size part_size, Size stride);

// Coefficients of the separating plane

float free_coef;

GpuMat detector;

// Results of the last classification step

GpuMat labels, labels_buf;

Mat labels_host;

// Results of the last histogram evaluation step

GpuMat block_hists, block_hists_buf;

// Gradients conputation results

GpuMat grad, qangle, grad_buf, qangle_buf;

// returns subbuffer with required size, reallocates buffer if nessesary.

static GpuMat getBuffer(const Size& sz, int type, GpuMat& buf);

static GpuMat getBuffer(int rows, int cols, int type, GpuMat& buf);

std::vector<GpuMat> image_scales;

};

class CV_EXPORTS CascadeClassifier_CUDA

{

CascadeClassifier_CUDA();

/** @brief Loads the classifier from a file. Cascade type is detected automatically by constructor parameter.

CascadeClassifier_CUDA(const String& filename);

~CascadeClassifier_CUDA();

/** @brief Checks whether the classifier is loaded or not.

bool empty() const;

/** @brief Loads the classifier from a file. The previous content is destroyed.

bool load(const String& filename);

/** @brief Destroys the loaded classifier.

void release();

/** @overload */

int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor = 1.2, int minNeighbors = 4, Size minSize = Size());

/** @brief Detects objects of different sizes in the input image.

int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4);

bool findLargestObject;

bool visualizeInPlace;

Size getClassifierSize() const;

struct CascadeClassifierImpl;

CascadeClassifierImpl* impl;

struct HaarCascade;

struct LbpCascade;

friend class CascadeClassifier_CUDA_LBP;

};

#include "opencv2/objdetect.hpp"