org.bytedeco.opencv.opencv_objdetect

Class HOGDescriptor

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_objdetect.HOGDescriptor

All Implemented Interfaces:

AutoCloseable

@Namespace(value="cv")
 @NoOffset
 @Properties(inherit=opencv_objdetect.class)
public class HOGDescriptor
extends Pointer

\brief Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector.

the HOG descriptor algorithm introduced by Navneet Dalal and Bill Triggs \cite Dalal2005 .

useful links:

https://hal.inria.fr/inria-00548512/document/

https://en.wikipedia.org/wiki/Histogram_of_oriented_gradients

https://software.intel.com/en-us/ipp-dev-reference-histogram-of-oriented-gradients-hog-descriptor

http://www.learnopencv.com/histogram-of-oriented-gradients

http://www.learnopencv.com/handwritten-digits-classification-an-opencv-c-python-tutorial

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_NLEVELS enum cv::HOGDescriptor::
static int	DESCR_FORMAT_COL_BY_COL enum cv::HOGDescriptor::DescriptorStorageFormat
static int	DESCR_FORMAT_ROW_BY_ROW enum cv::HOGDescriptor::DescriptorStorageFormat
static int	L2Hys enum cv::HOGDescriptor::HistogramNormType

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
HOGDescriptor() \brief Creates the HOG descriptor and detector with default params.
HOGDescriptor(BytePointer filename) \overload
HOGDescriptor(HOGDescriptor d) \overload
HOGDescriptor(long size) Native array allocator.
HOGDescriptor(Pointer p) Pointer cast constructor.
HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins)
HOGDescriptor(Size _winSize, Size _blockSize, Size _blockStride, Size _cellSize, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient) \overload
HOGDescriptor(String filename)

Method Summary

Modifier and Type	Method and Description
Size	blockSize() Block size in pixels.
HOGDescriptor	blockSize(Size setter)
Size	blockStride() Block stride.
HOGDescriptor	blockStride(Size setter)
Size	cellSize() Cell size.
HOGDescriptor	cellSize(Size setter)
boolean	checkDetectorSize() \brief Checks if detector size equal to descriptor size.
void	compute(GpuMat img, float[] descriptors)
void	compute(GpuMat img, float[] descriptors, Size winStride, Size padding, PointVector locations)
void	compute(GpuMat img, FloatBuffer descriptors)
void	compute(GpuMat img, FloatBuffer descriptors, Size winStride, Size padding, PointVector locations)
void	compute(GpuMat img, FloatPointer descriptors)
void	compute(GpuMat img, FloatPointer descriptors, Size winStride, Size padding, PointVector locations)
void	compute(Mat img, float[] descriptors)
void	compute(Mat img, float[] descriptors, Size winStride, Size padding, PointVector locations)
void	compute(Mat img, FloatBuffer descriptors)
void	compute(Mat img, FloatBuffer descriptors, Size winStride, Size padding, PointVector locations)
void	compute(Mat img, FloatPointer descriptors)
void	compute(Mat img, FloatPointer descriptors, Size winStride, Size padding, PointVector locations) \brief Computes HOG descriptors of given image.
void	compute(UMat img, float[] descriptors)
void	compute(UMat img, float[] descriptors, Size winStride, Size padding, PointVector locations)
void	compute(UMat img, FloatBuffer descriptors)
void	compute(UMat img, FloatBuffer descriptors, Size winStride, Size padding, PointVector locations)
void	compute(UMat img, FloatPointer descriptors)
void	compute(UMat img, FloatPointer descriptors, Size winStride, Size padding, PointVector locations)
void	computeGradient(GpuMat img, GpuMat grad, GpuMat angleOfs)
void	computeGradient(GpuMat img, GpuMat grad, GpuMat angleOfs, Size paddingTL, Size paddingBR)
void	computeGradient(Mat img, Mat grad, Mat angleOfs)
void	computeGradient(Mat img, Mat grad, Mat angleOfs, Size paddingTL, Size paddingBR) \brief Computes gradients and quantized gradient orientations.
void	computeGradient(UMat img, UMat grad, UMat angleOfs)
void	computeGradient(UMat img, UMat grad, UMat angleOfs, Size paddingTL, Size paddingBR)
void	copyTo(HOGDescriptor c) \brief clones the HOGDescriptor
int	derivAperture() not documented
HOGDescriptor	derivAperture(int setter)
void	detect(GpuMat img, PointVector foundLocations)
void	detect(GpuMat img, PointVector foundLocations, double[] weights)
void	detect(GpuMat img, PointVector foundLocations, double[] weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(GpuMat img, PointVector foundLocations, DoubleBuffer weights)
void	detect(GpuMat img, PointVector foundLocations, DoubleBuffer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(GpuMat img, PointVector foundLocations, DoublePointer weights)
void	detect(GpuMat img, PointVector foundLocations, DoublePointer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(GpuMat img, PointVector foundLocations, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(Mat img, PointVector foundLocations)
void	detect(Mat img, PointVector foundLocations, double[] weights)
void	detect(Mat img, PointVector foundLocations, double[] weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(Mat img, PointVector foundLocations, DoubleBuffer weights)
void	detect(Mat img, PointVector foundLocations, DoubleBuffer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(Mat img, PointVector foundLocations, DoublePointer weights)
void	detect(Mat img, PointVector foundLocations, DoublePointer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations) \brief Performs object detection without a multi-scale window.
void	detect(Mat img, PointVector foundLocations, double hitThreshold, Size winStride, Size padding, PointVector searchLocations) \brief Performs object detection without a multi-scale window.
void	detect(UMat img, PointVector foundLocations)
void	detect(UMat img, PointVector foundLocations, double[] weights)
void	detect(UMat img, PointVector foundLocations, double[] weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(UMat img, PointVector foundLocations, DoubleBuffer weights)
void	detect(UMat img, PointVector foundLocations, DoubleBuffer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(UMat img, PointVector foundLocations, DoublePointer weights)
void	detect(UMat img, PointVector foundLocations, DoublePointer weights, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detect(UMat img, PointVector foundLocations, double hitThreshold, Size winStride, Size padding, PointVector searchLocations)
void	detectMultiScale(GpuMat img, RectVector foundLocations)
void	detectMultiScale(GpuMat img, RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(GpuMat img, RectVector foundLocations, double[] foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(GpuMat img, RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(GpuMat img, RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(GpuMat img, RectVector foundLocations, DoublePointer foundWeights)
void	detectMultiScale(GpuMat img, RectVector foundLocations, DoublePointer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(GpuMat img, RectVector foundLocations, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(Mat img, RectVector foundLocations)
void	detectMultiScale(Mat img, RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(Mat img, RectVector foundLocations, double[] foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(Mat img, RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(Mat img, RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(Mat img, RectVector foundLocations, DoublePointer foundWeights)
void	detectMultiScale(Mat img, RectVector foundLocations, DoublePointer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) \brief Detects objects of different sizes in the input image.
void	detectMultiScale(Mat img, RectVector foundLocations, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) \brief Detects objects of different sizes in the input image.
void	detectMultiScale(UMat img, RectVector foundLocations)
void	detectMultiScale(UMat img, RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(UMat img, RectVector foundLocations, double[] foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(UMat img, RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(UMat img, RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(UMat img, RectVector foundLocations, DoublePointer foundWeights)
void	detectMultiScale(UMat img, RectVector foundLocations, DoublePointer foundWeights, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(UMat img, RectVector foundLocations, double hitThreshold, Size winStride, Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScaleROI(GpuMat img, RectVector foundLocations, DetectionROI locations)
void	detectMultiScaleROI(GpuMat img, RectVector foundLocations, DetectionROI locations, double hitThreshold, int groupThreshold)
void	detectMultiScaleROI(Mat img, RectVector foundLocations, DetectionROI locations)
void	detectMultiScaleROI(Mat img, RectVector foundLocations, DetectionROI locations, double hitThreshold, int groupThreshold) \brief evaluate specified ROI and return confidence value for each location in multiple scales
void	detectMultiScaleROI(UMat img, RectVector foundLocations, DetectionROI locations)
void	detectMultiScaleROI(UMat img, RectVector foundLocations, DetectionROI locations, double hitThreshold, int groupThreshold)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, double[] confidences)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, double[] confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, DoublePointer confidences)
void	detectROI(GpuMat img, PointVector locations, PointVector foundLocations, DoublePointer confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, double[] confidences)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, double[] confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, DoublePointer confidences)
void	detectROI(Mat img, PointVector locations, PointVector foundLocations, DoublePointer confidences, double hitThreshold, Size winStride, Size padding) \brief evaluate specified ROI and return confidence value for each location
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, double[] confidences)
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, double[] confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences)
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, DoubleBuffer confidences, double hitThreshold, Size winStride, Size padding)
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, DoublePointer confidences)
void	detectROI(UMat img, PointVector locations, PointVector foundLocations, DoublePointer confidences, double hitThreshold, Size winStride, Size padding)
float	free_coef() not documented
HOGDescriptor	free_coef(float setter)
boolean	gammaCorrection() Flag to specify whether the gamma correction preprocessing is required or not.
HOGDescriptor	gammaCorrection(boolean setter)
static FloatPointer	getDaimlerPeopleDetector() \brief Returns coefficients of the classifier trained for people detection (for 48x96 windows).
static FloatPointer	getDefaultPeopleDetector() \brief Returns coefficients of the classifier trained for people detection (for 64x128 windows).
long	getDescriptorSize() \brief Returns the number of coefficients required for the classification.
double	getWinSigma() \brief Returns winSigma value
void	groupRectangles(RectVector rectList, double[] weights, int groupThreshold, double eps)
void	groupRectangles(RectVector rectList, DoubleBuffer weights, int groupThreshold, double eps)
void	groupRectangles(RectVector rectList, DoublePointer weights, int groupThreshold, double eps) \brief Groups the object candidate rectangles.
int	histogramNormType() histogramNormType
HOGDescriptor	histogramNormType(int setter)
double	L2HysThreshold() L2-Hys normalization method shrinkage.
HOGDescriptor	L2HysThreshold(double setter)
boolean	load(BytePointer filename)
boolean	load(BytePointer filename, BytePointer objname) \brief loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file.
boolean	load(String filename)
boolean	load(String filename, String objname)
int	nbins() Number of bins used in the calculation of histogram of gradients.
HOGDescriptor	nbins(int setter)
int	nlevels() Maximum number of detection window increases.
HOGDescriptor	nlevels(int setter)
UMat	oclSvmDetector() coefficients for the linear SVM classifier used when OpenCL is enabled
HOGDescriptor	oclSvmDetector(UMat setter)
HOGDescriptor	position(long position)
boolean	read(FileNode fn) \brief Reads HOGDescriptor parameters from a cv::FileNode.
void	save(BytePointer filename)
void	save(BytePointer filename, BytePointer objname) \brief saves HOGDescriptor parameters and coefficients for the linear SVM classifier to a file
void	save(String filename)
void	save(String filename, String objname)
void	setSVMDetector(GpuMat svmdetector)
void	setSVMDetector(Mat svmdetector) \brief Sets coefficients for the linear SVM classifier.
void	setSVMDetector(UMat svmdetector)
boolean	signedGradient() Indicates signed gradient will be used or not
HOGDescriptor	signedGradient(boolean setter)
FloatPointer	svmDetector() coefficients for the linear SVM classifier.
HOGDescriptor	svmDetector(FloatPointer setter)
double	winSigma() Gaussian smoothing window parameter.
HOGDescriptor	winSigma(double setter)
Size	winSize() Detection window size.
HOGDescriptor	winSize(Size setter)
void	write(FileStorage fs, BytePointer objname) \brief Stores HOGDescriptor parameters in a cv::FileStorage.
void	write(FileStorage fs, String objname)

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

L2Hys

public static final int L2Hys

enum cv::HOGDescriptor::HistogramNormType

See Also:

Constant Field Values

DEFAULT_NLEVELS

public static final int DEFAULT_NLEVELS

enum cv::HOGDescriptor::

See Also:

Constant Field Values

DESCR_FORMAT_COL_BY_COL

public static final int DESCR_FORMAT_COL_BY_COL

enum cv::HOGDescriptor::DescriptorStorageFormat

See Also:

Constant Field Values

DESCR_FORMAT_ROW_BY_ROW

public static final int DESCR_FORMAT_ROW_BY_ROW

enum cv::HOGDescriptor::DescriptorStorageFormat

See Also:

Constant Field Values

Constructor Detail

HOGDescriptor

public HOGDescriptor(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

HOGDescriptor

public HOGDescriptor(long size)

Native array allocator. Access with Pointer.position(long).

HOGDescriptor

public HOGDescriptor()

\brief Creates the HOG descriptor and detector with default params.

aqual to HOGDescriptor(Size(64,128), Size(16,16), Size(8,8), Size(8,8), 9 )

HOGDescriptor

public HOGDescriptor(@ByVal
                     Size _winSize,
                     @ByVal
                     Size _blockSize,
                     @ByVal
                     Size _blockStride,
                     @ByVal
                     Size _cellSize,
                     int _nbins,
                     int _derivAperture,
                     double _winSigma,
                     @Cast(value="cv::HOGDescriptor::HistogramNormType")
                     int _histogramNormType,
                     double _L2HysThreshold,
                     @Cast(value="bool")
                     boolean _gammaCorrection,
                     int _nlevels,
                     @Cast(value="bool")
                     boolean _signedGradient)

\overload

Parameters:

_winSize - sets winSize with given value.

_blockSize - sets blockSize with given value.

_blockStride - sets blockStride with given value.

_cellSize - sets cellSize with given value.

_nbins - sets nbins with given value.

_derivAperture - sets derivAperture with given value.

_winSigma - sets winSigma with given value.

_histogramNormType - sets histogramNormType with given value.

_L2HysThreshold - sets L2HysThreshold with given value.

_gammaCorrection - sets gammaCorrection with given value.

_nlevels - sets nlevels with given value.

_signedGradient - sets signedGradient with given value.

HOGDescriptor

public HOGDescriptor(@ByVal
                     Size _winSize,
                     @ByVal
                     Size _blockSize,
                     @ByVal
                     Size _blockStride,
                     @ByVal
                     Size _cellSize,
                     int _nbins)

HOGDescriptor

public HOGDescriptor(@opencv_core.Str
                     BytePointer filename)

\overload

Parameters:

filename - The file name containing HOGDescriptor properties and coefficients for the linear SVM classifier.

HOGDescriptor

public HOGDescriptor(@opencv_core.Str
                     String filename)

HOGDescriptor

public HOGDescriptor(@Const @ByRef
                     HOGDescriptor d)

\overload

Parameters:

d - the HOGDescriptor which cloned to create a new one.

Method Detail

position

public HOGDescriptor position(long position)

Overrides:

position in class Pointer

getDescriptorSize

@Cast(value="size_t")
public long getDescriptorSize()

\brief Returns the number of coefficients required for the classification.

checkDetectorSize

@Cast(value="bool")
public boolean checkDetectorSize()

\brief Checks if detector size equal to descriptor size.

getWinSigma

public double getWinSigma()

\brief Returns winSigma value

setSVMDetector

public void setSVMDetector(@ByVal
                           Mat svmdetector)

\brief Sets coefficients for the linear SVM classifier.

Parameters:

svmdetector - coefficients for the linear SVM classifier.

setSVMDetector

public void setSVMDetector(@ByVal
                           UMat svmdetector)

setSVMDetector

public void setSVMDetector(@ByVal
                           GpuMat svmdetector)

read

@Cast(value="bool")
public boolean read(@ByRef
                                        FileNode fn)

\brief Reads HOGDescriptor parameters from a cv::FileNode.

Parameters:

fn - File node

write

public void write(@ByRef
                  FileStorage fs,
                  @opencv_core.Str
                  BytePointer objname)

\brief Stores HOGDescriptor parameters in a cv::FileStorage.

Parameters:

fs - File storage

objname - Object name

write

public void write(@ByRef
                  FileStorage fs,
                  @opencv_core.Str
                  String objname)

load

@Cast(value="bool")
public boolean load(@opencv_core.Str
                                        BytePointer filename,
                                        @opencv_core.Str
                                        BytePointer objname)

\brief loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file.

Parameters:

filename - Path of the file to read.

objname - The optional name of the node to read (if empty, the first top-level node will be used).

load

@Cast(value="bool")
public boolean load(@opencv_core.Str
                                        BytePointer filename)

load

@Cast(value="bool")
public boolean load(@opencv_core.Str
                                        String filename,
                                        @opencv_core.Str
                                        String objname)

load

@Cast(value="bool")
public boolean load(@opencv_core.Str
                                        String filename)

save

public void save(@opencv_core.Str
                 BytePointer filename,
                 @opencv_core.Str
                 BytePointer objname)

\brief saves HOGDescriptor parameters and coefficients for the linear SVM classifier to a file

Parameters:

filename - File name

objname - Object name

save

public void save(@opencv_core.Str
                 BytePointer filename)

save

public void save(@opencv_core.Str
                 String filename,
                 @opencv_core.Str
                 String objname)

save

public void save(@opencv_core.Str
                 String filename)

copyTo

public void copyTo(@ByRef
                   HOGDescriptor c)

\brief clones the HOGDescriptor

Parameters:

c - cloned HOGDescriptor

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    FloatPointer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

\brief Computes HOG descriptors of given image.

Parameters:

img - Matrix of the type CV_8U containing an image where HOG features will be calculated.

descriptors - Matrix of the type CV_32F

winStride - Window stride. It must be a multiple of block stride.

padding - Padding

locations - Vector of Point

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    FloatPointer descriptors)

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    FloatBuffer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    FloatBuffer descriptors)

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    float[] descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    Mat img,
                    @StdVector
                    float[] descriptors)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    FloatPointer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    FloatPointer descriptors)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    FloatBuffer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    FloatBuffer descriptors)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    float[] descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    UMat img,
                    @StdVector
                    float[] descriptors)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    FloatPointer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    FloatPointer descriptors)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    FloatBuffer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    FloatBuffer descriptors)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    float[] descriptors,
                    @ByVal(nullValue="cv::Size()")
                    Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    PointVector locations)

compute

public void compute(@ByVal
                    GpuMat img,
                    @StdVector
                    float[] descriptors)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

\brief Performs object detection without a multi-scale window.

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

foundLocations - Vector of point where each point contains left-top corner point of detected object boundaries.

weights - Vector that will contain confidence values for each detected object.

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.

winStride - Window stride. It must be a multiple of block stride.

padding - Padding

searchLocations - Vector of Point includes set of requested locations to be evaluated.

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoublePointer weights)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   @StdVector
                   double[] weights)

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

\brief Performs object detection without a multi-scale window.

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

foundLocations - Vector of point where each point contains left-top corner point of detected object boundaries.

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.

winStride - Window stride. It must be a multiple of block stride.

padding - Padding

searchLocations - Vector of Point includes locations to search.

detect

public void detect(@ByVal
                   Mat img,
                   @ByRef
                   PointVector foundLocations)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   UMat img,
                   @ByRef
                   PointVector foundLocations)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   PointVector searchLocations)

detect

public void detect(@ByVal
                   GpuMat img,
                   @ByRef
                   PointVector foundLocations)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

\brief Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

foundLocations - Vector of rectangles where each rectangle contains the detected object.

foundWeights - Vector that will contain confidence values for each detected object.

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.

winStride - Window stride. It must be a multiple of block stride.

padding - Padding

scale - Coefficient of the detection window increase.

finalThreshold - Final threshold

useMeanshiftGrouping - indicates grouping algorithm

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoublePointer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             DoubleBuffer foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             @StdVector
                             double[] foundWeights)

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

\brief Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

foundLocations - Vector of rectangles where each rectangle contains the detected object.

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.

winStride - Window stride. It must be a multiple of block stride.

padding - Padding

scale - Coefficient of the detection window increase.

finalThreshold - Final threshold

useMeanshiftGrouping - indicates grouping algorithm

detectMultiScale

public void detectMultiScale(@ByVal
                             Mat img,
                             @ByRef
                             RectVector foundLocations)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             UMat img,
                             @ByRef
                             RectVector foundLocations)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             Size padding,
                             double scale,
                             double finalThreshold,
                             @Cast(value="bool")
                             boolean useMeanshiftGrouping)

detectMultiScale

public void detectMultiScale(@ByVal
                             GpuMat img,
                             @ByRef
                             RectVector foundLocations)

computeGradient

public void computeGradient(@ByVal
                            Mat img,
                            @ByVal
                            Mat grad,
                            @ByVal
                            Mat angleOfs,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingTL,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingBR)

\brief Computes gradients and quantized gradient orientations.

Parameters:

img - Matrix contains the image to be computed

grad - Matrix of type CV_32FC2 contains computed gradients

angleOfs - Matrix of type CV_8UC2 contains quantized gradient orientations

paddingTL - Padding from top-left

paddingBR - Padding from bottom-right

computeGradient

public void computeGradient(@ByVal
                            Mat img,
                            @ByVal
                            Mat grad,
                            @ByVal
                            Mat angleOfs)

computeGradient

public void computeGradient(@ByVal
                            UMat img,
                            @ByVal
                            UMat grad,
                            @ByVal
                            UMat angleOfs,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingTL,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingBR)

computeGradient

public void computeGradient(@ByVal
                            UMat img,
                            @ByVal
                            UMat grad,
                            @ByVal
                            UMat angleOfs)

computeGradient

public void computeGradient(@ByVal
                            GpuMat img,
                            @ByVal
                            GpuMat grad,
                            @ByVal
                            GpuMat angleOfs,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingTL,
                            @ByVal(nullValue="cv::Size()")
                            Size paddingBR)

computeGradient

public void computeGradient(@ByVal
                            GpuMat img,
                            @ByVal
                            GpuMat grad,
                            @ByVal
                            GpuMat angleOfs)

getDefaultPeopleDetector

@StdVector
public static FloatPointer getDefaultPeopleDetector()

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

getDaimlerPeopleDetector

@StdVector
public static FloatPointer getDaimlerPeopleDetector()

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

winSize

@ByRef
public Size winSize()

Detection window size. Align to block size and block stride. Default value is Size(64,128).

winSize

public HOGDescriptor winSize(Size setter)

blockSize

@ByRef
public Size blockSize()

Block size in pixels. Align to cell size. Default value is Size(16,16).

blockSize

public HOGDescriptor blockSize(Size setter)

blockStride

@ByRef
public Size blockStride()

Block stride. It must be a multiple of cell size. Default value is Size(8,8).

blockStride

public HOGDescriptor blockStride(Size setter)

cellSize

@ByRef
public Size cellSize()

Cell size. Default value is Size(8,8).

cellSize

public HOGDescriptor cellSize(Size setter)

nbins

public int nbins()

Number of bins used in the calculation of histogram of gradients. Default value is 9.

nbins

public HOGDescriptor nbins(int setter)

derivAperture

public int derivAperture()

not documented

derivAperture

public HOGDescriptor derivAperture(int setter)

winSigma

public double winSigma()

Gaussian smoothing window parameter.

winSigma

public HOGDescriptor winSigma(double setter)

histogramNormType

@Cast(value="cv::HOGDescriptor::HistogramNormType")
public int histogramNormType()

histogramNormType

histogramNormType

public HOGDescriptor histogramNormType(int setter)

L2HysThreshold

public double L2HysThreshold()

L2-Hys normalization method shrinkage.

L2HysThreshold

public HOGDescriptor L2HysThreshold(double setter)

gammaCorrection

@Cast(value="bool")
public boolean gammaCorrection()

Flag to specify whether the gamma correction preprocessing is required or not.

gammaCorrection

public HOGDescriptor gammaCorrection(boolean setter)

svmDetector

@StdVector
public FloatPointer svmDetector()

coefficients for the linear SVM classifier.

svmDetector

public HOGDescriptor svmDetector(FloatPointer setter)

oclSvmDetector

@ByRef
public UMat oclSvmDetector()

coefficients for the linear SVM classifier used when OpenCL is enabled

oclSvmDetector

public HOGDescriptor oclSvmDetector(UMat setter)

free_coef

public float free_coef()

not documented

free_coef

public HOGDescriptor free_coef(float setter)

nlevels

public int nlevels()

Maximum number of detection window increases. Default value is 64

nlevels

public HOGDescriptor nlevels(int setter)

signedGradient

@Cast(value="bool")
public boolean signedGradient()

Indicates signed gradient will be used or not

signedGradient

public HOGDescriptor signedGradient(boolean setter)

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

\brief evaluate specified ROI and return confidence value for each location

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

locations - Vector of Point

foundLocations - Vector of Point where each Point is detected object's top-left point.

confidences - confidences

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here

winStride - winStride

padding - padding

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences)

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences)

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      Mat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      UMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoublePointer confidences)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      DoubleBuffer confidences)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      Size padding)

detectROI

public void detectROI(@ByVal
                      GpuMat img,
                      @Const @ByRef
                      PointVector locations,
                      @ByRef
                      PointVector foundLocations,
                      @StdVector
                      double[] confidences)

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                Mat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations,
                                double hitThreshold,
                                int groupThreshold)

\brief evaluate specified ROI and return confidence value for each location in multiple scales

Parameters:

img - Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.

foundLocations - Vector of rectangles where each rectangle contains the detected object.

locations - Vector of DetectionROI

hitThreshold - Threshold for the distance between features and SVM classifying plane. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient). But if the free coefficient is omitted (which is allowed), you can specify it manually here.

groupThreshold - Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it.

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                Mat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations)

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                UMat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations,
                                double hitThreshold,
                                int groupThreshold)

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                UMat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations)

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                GpuMat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations,
                                double hitThreshold,
                                int groupThreshold)

detectMultiScaleROI

public void detectMultiScaleROI(@ByVal
                                GpuMat img,
                                @ByRef
                                RectVector foundLocations,
                                @StdVector
                                DetectionROI locations)

groupRectangles

public void groupRectangles(@ByRef
                            RectVector rectList,
                            @StdVector
                            DoublePointer weights,
                            int groupThreshold,
                            double eps)

\brief Groups the object candidate rectangles.

Parameters:

rectList - Input/output vector of rectangles. Output vector includes retained and grouped rectangles. (The Python list is not modified in place.)

weights - Input/output vector of weights of rectangles. Output vector includes weights of retained and grouped rectangles. (The Python list is not modified in place.)

groupThreshold - Minimum possible number of rectangles minus 1. The threshold is used in a group of rectangles to retain it.

eps - Relative difference between sides of the rectangles to merge them into a group.

groupRectangles

public void groupRectangles(@ByRef
                            RectVector rectList,
                            @StdVector
                            DoubleBuffer weights,
                            int groupThreshold,
                            double eps)

groupRectangles

public void groupRectangles(@ByRef
                            RectVector rectList,
                            @StdVector
                            double[] weights,
                            int groupThreshold,
                            double eps)