org.bytedeco.javacpp

Class opencv_objdetect.HOGDescriptor

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.javacpp.opencv_objdetect.HOGDescriptor

All Implemented Interfaces:

AutoCloseable

Enclosing class:

opencv_objdetect

@Namespace(value="cv")
 @NoOffset
public static class opencv_objdetect.HOGDescriptor
extends org.bytedeco.javacpp.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

org.bytedeco.javacpp.Pointer.CustomDeallocator, org.bytedeco.javacpp.Pointer.Deallocator, org.bytedeco.javacpp.Pointer.NativeDeallocator

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_NLEVELS enum cv::HOGDescriptor::
static int	L2Hys enum cv::HOGDescriptor::

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(org.bytedeco.javacpp.BytePointer filename) \overload
HOGDescriptor(long size) Native array allocator.
HOGDescriptor(opencv_core.Size _winSize, opencv_core.Size _blockSize, opencv_core.Size _blockStride, opencv_core.Size _cellSize, int _nbins)
HOGDescriptor(opencv_core.Size _winSize, opencv_core.Size _blockSize, opencv_core.Size _blockStride, opencv_core.Size _cellSize, int _nbins, int _derivAperture, double _winSigma, int _histogramNormType, double _L2HysThreshold, boolean _gammaCorrection, int _nlevels, boolean _signedGradient) \overload
HOGDescriptor(opencv_objdetect.HOGDescriptor d) \overload
HOGDescriptor(org.bytedeco.javacpp.Pointer p) Pointer cast constructor.
HOGDescriptor(String filename)

Method Summary

Modifier and Type	Method and Description
opencv_core.Size	blockSize() Block size in pixels.
opencv_objdetect.HOGDescriptor	blockSize(opencv_core.Size blockSize)
opencv_core.Size	blockStride() Block stride.
opencv_objdetect.HOGDescriptor	blockStride(opencv_core.Size blockStride)
opencv_core.Size	cellSize() Cell size.
opencv_objdetect.HOGDescriptor	cellSize(opencv_core.Size cellSize)
boolean	checkDetectorSize() \brief Checks if detector size equal to descriptor size.
void	compute(opencv_core.GpuMat img, float[] descriptors)
void	compute(opencv_core.GpuMat img, float[] descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.GpuMat img, FloatBuffer descriptors)
void	compute(opencv_core.GpuMat img, FloatBuffer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.GpuMat img, org.bytedeco.javacpp.FloatPointer descriptors)
void	compute(opencv_core.GpuMat img, org.bytedeco.javacpp.FloatPointer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.Mat img, float[] descriptors)
void	compute(opencv_core.Mat img, float[] descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.Mat img, FloatBuffer descriptors)
void	compute(opencv_core.Mat img, FloatBuffer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.Mat img, org.bytedeco.javacpp.FloatPointer descriptors)
void	compute(opencv_core.Mat img, org.bytedeco.javacpp.FloatPointer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations) \brief Computes HOG descriptors of given image.
void	compute(opencv_core.UMat img, float[] descriptors)
void	compute(opencv_core.UMat img, float[] descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.UMat img, FloatBuffer descriptors)
void	compute(opencv_core.UMat img, FloatBuffer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	compute(opencv_core.UMat img, org.bytedeco.javacpp.FloatPointer descriptors)
void	compute(opencv_core.UMat img, org.bytedeco.javacpp.FloatPointer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
void	computeGradient(opencv_core.Mat img, opencv_core.Mat grad, opencv_core.Mat angleOfs)
void	computeGradient(opencv_core.Mat img, opencv_core.Mat grad, opencv_core.Mat angleOfs, opencv_core.Size paddingTL, opencv_core.Size paddingBR) \brief Computes gradients and quantized gradient orientations.
void	copyTo(opencv_objdetect.HOGDescriptor c) \brief clones the HOGDescriptor
int	derivAperture() not documented
opencv_objdetect.HOGDescriptor	derivAperture(int derivAperture)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, double[] weights)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, double[] weights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector searchLocations)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, DoubleBuffer weights)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, DoubleBuffer weights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector searchLocations)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector searchLocations) \brief Performs object detection without a multi-scale window.
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, org.bytedeco.javacpp.DoublePointer weights)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, org.bytedeco.javacpp.DoublePointer weights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector searchLocations) \brief Performs object detection without a multi-scale window.
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, double[] foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights)
void	detectMultiScale(opencv_core.GpuMat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, double[] foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) \brief Detects objects of different sizes in the input image.
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) \brief Detects objects of different sizes in the input image.
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, double[] foundWeights)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, double[] foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, DoubleBuffer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, org.bytedeco.javacpp.DoublePointer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping)
void	detectMultiScaleROI(opencv_core.Mat img, opencv_core.RectVector foundLocations, opencv_objdetect.DetectionROI locations)
void	detectMultiScaleROI(opencv_core.Mat img, opencv_core.RectVector foundLocations, opencv_objdetect.DetectionROI locations, double hitThreshold, int groupThreshold) \brief evaluate specified ROI and return confidence value for each location in multiple scales
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, double[] confidences)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, double[] confidences, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, DoubleBuffer confidences)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, DoubleBuffer confidences, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, org.bytedeco.javacpp.DoublePointer confidences)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, org.bytedeco.javacpp.DoublePointer confidences, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding) \brief evaluate specified ROI and return confidence value for each location
float	free_coef() not documented
opencv_objdetect.HOGDescriptor	free_coef(float free_coef)
boolean	gammaCorrection() Flag to specify whether the gamma correction preprocessing is required or not.
opencv_objdetect.HOGDescriptor	gammaCorrection(boolean gammaCorrection)
static org.bytedeco.javacpp.FloatPointer	getDaimlerPeopleDetector() \brief Returns coefficients of the classifier trained for people detection (for 48x96 windows).
static org.bytedeco.javacpp.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(opencv_core.RectVector rectList, double[] weights, int groupThreshold, double eps)
void	groupRectangles(opencv_core.RectVector rectList, DoubleBuffer weights, int groupThreshold, double eps)
void	groupRectangles(opencv_core.RectVector rectList, org.bytedeco.javacpp.DoublePointer weights, int groupThreshold, double eps) \brief Groups the object candidate rectangles.
int	histogramNormType() histogramNormType
opencv_objdetect.HOGDescriptor	histogramNormType(int histogramNormType)
double	L2HysThreshold() L2-Hys normalization method shrinkage.
opencv_objdetect.HOGDescriptor	L2HysThreshold(double L2HysThreshold)
boolean	load(org.bytedeco.javacpp.BytePointer filename)
boolean	load(org.bytedeco.javacpp.BytePointer filename, org.bytedeco.javacpp.BytePointer objname) \brief loads 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.
opencv_objdetect.HOGDescriptor	nbins(int nbins)
int	nlevels() Maximum number of detection window increases.
opencv_objdetect.HOGDescriptor	nlevels(int nlevels)
opencv_core.UMat	oclSvmDetector() coefficients for the linear SVM classifier used when OpenCL is enabled
opencv_objdetect.HOGDescriptor	oclSvmDetector(opencv_core.UMat oclSvmDetector)
opencv_objdetect.HOGDescriptor	position(long position)
boolean	read(opencv_core.FileNode fn) \brief Reads HOGDescriptor parameters from a file node.
void	readALTModel(org.bytedeco.javacpp.BytePointer modelfile) \brief read/parse Dalal's alt model file
void	readALTModel(String modelfile)
void	save(org.bytedeco.javacpp.BytePointer filename)
void	save(org.bytedeco.javacpp.BytePointer filename, org.bytedeco.javacpp.BytePointer objname) \brief saves coefficients for the linear SVM classifier to a file
void	save(String filename)
void	save(String filename, String objname)
void	setSVMDetector(opencv_core.GpuMat _svmdetector)
void	setSVMDetector(opencv_core.Mat _svmdetector) \brief Sets coefficients for the linear SVM classifier.
void	setSVMDetector(opencv_core.UMat _svmdetector)
boolean	signedGradient() Indicates signed gradient will be used or not
opencv_objdetect.HOGDescriptor	signedGradient(boolean signedGradient)
org.bytedeco.javacpp.FloatPointer	svmDetector() coefficients for the linear SVM classifier.
opencv_objdetect.HOGDescriptor	svmDetector(org.bytedeco.javacpp.FloatPointer svmDetector)
double	winSigma() Gaussian smoothing window parameter.
opencv_objdetect.HOGDescriptor	winSigma(double winSigma)
opencv_core.Size	winSize() Detection window size.
opencv_objdetect.HOGDescriptor	winSize(opencv_core.Size winSize)
void	write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer objname) \brief Stores HOGDescriptor parameters in a file storage.
void	write(opencv_core.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, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, 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::

See Also:

Constant Field Values

DEFAULT_NLEVELS

public static final int DEFAULT_NLEVELS

enum cv::HOGDescriptor::

See Also:

Constant Field Values

Constructor Detail

HOGDescriptor

public HOGDescriptor(org.bytedeco.javacpp.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, 1 )

HOGDescriptor

public HOGDescriptor(@ByVal
                     opencv_core.Size _winSize,
                     @ByVal
                     opencv_core.Size _blockSize,
                     @ByVal
                     opencv_core.Size _blockStride,
                     @ByVal
                     opencv_core.Size _cellSize,
                     int _nbins,
                     int _derivAperture,
                     double _winSigma,
                     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
                     opencv_core.Size _winSize,
                     @ByVal
                     opencv_core.Size _blockSize,
                     @ByVal
                     opencv_core.Size _blockStride,
                     @ByVal
                     opencv_core.Size _cellSize,
                     int _nbins)

HOGDescriptor

public HOGDescriptor(@opencv_core.Str
                     org.bytedeco.javacpp.BytePointer filename)

\overload

Parameters:

filename - the file name containing HOGDescriptor properties and coefficients of the trained classifier

HOGDescriptor

public HOGDescriptor(@opencv_core.Str
                     String filename)

HOGDescriptor

public HOGDescriptor(@Const @ByRef
                     opencv_objdetect.HOGDescriptor d)

\overload

Parameters:

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

Method Detail

position

public opencv_objdetect.HOGDescriptor position(long position)

Overrides:

position in class org.bytedeco.javacpp.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
                           opencv_core.Mat _svmdetector)

\brief Sets coefficients for the linear SVM classifier.

Parameters:

_svmdetector - coefficients for the linear SVM classifier.

setSVMDetector

public void setSVMDetector(@ByVal
                           opencv_core.UMat _svmdetector)

setSVMDetector

public void setSVMDetector(@ByVal
                           opencv_core.GpuMat _svmdetector)

read

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

\brief Reads HOGDescriptor parameters from a file node.

Parameters:

fn - File node

write

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

\brief Stores HOGDescriptor parameters in a file storage.

Parameters:

fs - File storage

objname - Object name

write

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

load

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

\brief loads coefficients for the linear SVM classifier from a file

Parameters:

filename - Name 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
                                        org.bytedeco.javacpp.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
                 org.bytedeco.javacpp.BytePointer filename,
                 @opencv_core.Str
                 org.bytedeco.javacpp.BytePointer objname)

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

Parameters:

filename - File name

objname - Object name

save

public void save(@opencv_core.Str
                 org.bytedeco.javacpp.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
                   opencv_objdetect.HOGDescriptor c)

\brief clones the HOGDescriptor

Parameters:

c - cloned HOGDescriptor

compute

public void compute(@ByVal
                    opencv_core.Mat img,
                    @StdVector
                    org.bytedeco.javacpp.FloatPointer descriptors,
                    @ByVal(nullValue="cv::Size()")
                    opencv_core.Size winStride,
                    @ByVal(nullValue="cv::Size()")
                    opencv_core.Size padding,
                    @Const @ByRef(nullValue="std::vector<cv::Point>()")
                    opencv_core.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
                    opencv_core.Mat img,
                    @StdVector
                    org.bytedeco.javacpp.FloatPointer descriptors)

compute

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

compute

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

compute

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

compute

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

compute

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

compute

public void compute(@ByVal
                    opencv_core.UMat img,
                    @StdVector
                    org.bytedeco.javacpp.FloatPointer descriptors)

compute

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

compute

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

compute

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

compute

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

compute

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

compute

public void compute(@ByVal
                    opencv_core.GpuMat img,
                    @StdVector
                    org.bytedeco.javacpp.FloatPointer descriptors)

compute

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

compute

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

compute

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

compute

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

detect

public void detect(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   @StdVector
                   org.bytedeco.javacpp.DoublePointer weights,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   opencv_core.Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   opencv_core.Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   opencv_core.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(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   @StdVector
                   org.bytedeco.javacpp.DoublePointer weights)

detect

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

detect

public void detect(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   @StdVector
                   DoubleBuffer weights)

detect

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

detect

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

detect

public void detect(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   double hitThreshold,
                   @ByVal(nullValue="cv::Size()")
                   opencv_core.Size winStride,
                   @ByVal(nullValue="cv::Size()")
                   opencv_core.Size padding,
                   @Const @ByRef(nullValue="std::vector<cv::Point>()")
                   opencv_core.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(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations)

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.Mat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             org.bytedeco.javacpp.DoublePointer foundWeights,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.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
                             opencv_core.Mat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             org.bytedeco.javacpp.DoublePointer foundWeights)

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.UMat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             org.bytedeco.javacpp.DoublePointer foundWeights)

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.GpuMat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             org.bytedeco.javacpp.DoublePointer foundWeights)

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.Mat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             double hitThreshold,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size winStride,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.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
                             opencv_core.Mat img,
                             @ByRef
                             opencv_core.RectVector foundLocations)

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

detectMultiScale

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

computeGradient

public void computeGradient(@Const @ByRef
                            opencv_core.Mat img,
                            @ByRef
                            opencv_core.Mat grad,
                            @ByRef
                            opencv_core.Mat angleOfs,
                            @ByVal(nullValue="cv::Size()")
                            opencv_core.Size paddingTL,
                            @ByVal(nullValue="cv::Size()")
                            opencv_core.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(@Const @ByRef
                            opencv_core.Mat img,
                            @ByRef
                            opencv_core.Mat grad,
                            @ByRef
                            opencv_core.Mat angleOfs)

getDefaultPeopleDetector

@StdVector
public static org.bytedeco.javacpp.FloatPointer getDefaultPeopleDetector()

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

getDaimlerPeopleDetector

@StdVector
public static org.bytedeco.javacpp.FloatPointer getDaimlerPeopleDetector()

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

winSize

@ByRef
public opencv_core.Size winSize()

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

winSize

public opencv_objdetect.HOGDescriptor winSize(opencv_core.Size winSize)

blockSize

@ByRef
public opencv_core.Size blockSize()

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

blockSize

public opencv_objdetect.HOGDescriptor blockSize(opencv_core.Size blockSize)

blockStride

@ByRef
public opencv_core.Size blockStride()

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

blockStride

public opencv_objdetect.HOGDescriptor blockStride(opencv_core.Size blockStride)

cellSize

@ByRef
public opencv_core.Size cellSize()

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

cellSize

public opencv_objdetect.HOGDescriptor cellSize(opencv_core.Size cellSize)

nbins

public int nbins()

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

nbins

public opencv_objdetect.HOGDescriptor nbins(int nbins)

derivAperture

public int derivAperture()

not documented

derivAperture

public opencv_objdetect.HOGDescriptor derivAperture(int derivAperture)

winSigma

public double winSigma()

Gaussian smoothing window parameter.

winSigma

public opencv_objdetect.HOGDescriptor winSigma(double winSigma)

histogramNormType

public int histogramNormType()

histogramNormType

histogramNormType

public opencv_objdetect.HOGDescriptor histogramNormType(int histogramNormType)

L2HysThreshold

public double L2HysThreshold()

L2-Hys normalization method shrinkage.

L2HysThreshold

public opencv_objdetect.HOGDescriptor L2HysThreshold(double L2HysThreshold)

gammaCorrection

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

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

gammaCorrection

public opencv_objdetect.HOGDescriptor gammaCorrection(boolean gammaCorrection)

svmDetector

@StdVector
public org.bytedeco.javacpp.FloatPointer svmDetector()

coefficients for the linear SVM classifier.

svmDetector

public opencv_objdetect.HOGDescriptor svmDetector(org.bytedeco.javacpp.FloatPointer svmDetector)

oclSvmDetector

@ByRef
public opencv_core.UMat oclSvmDetector()

coefficients for the linear SVM classifier used when OpenCL is enabled

oclSvmDetector

public opencv_objdetect.HOGDescriptor oclSvmDetector(opencv_core.UMat oclSvmDetector)

free_coef

public float free_coef()

not documented

free_coef

public opencv_objdetect.HOGDescriptor free_coef(float free_coef)

nlevels

public int nlevels()

Maximum number of detection window increases. Default value is 64

nlevels

public opencv_objdetect.HOGDescriptor nlevels(int nlevels)

signedGradient

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

Indicates signed gradient will be used or not

signedGradient

public opencv_objdetect.HOGDescriptor signedGradient(boolean signedGradient)

detectROI

public void detectROI(@Const @ByRef
                      opencv_core.Mat img,
                      @Const @ByRef
                      opencv_core.PointVector locations,
                      @ByRef
                      opencv_core.PointVector foundLocations,
                      @StdVector
                      org.bytedeco.javacpp.DoublePointer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      opencv_core.Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      opencv_core.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(@Const @ByRef
                      opencv_core.Mat img,
                      @Const @ByRef
                      opencv_core.PointVector locations,
                      @ByRef
                      opencv_core.PointVector foundLocations,
                      @StdVector
                      org.bytedeco.javacpp.DoublePointer confidences)

detectROI

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

detectROI

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

detectROI

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

detectROI

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

detectMultiScaleROI

public void detectMultiScaleROI(@Const @ByRef
                                opencv_core.Mat img,
                                @ByRef
                                opencv_core.RectVector foundLocations,
                                @StdVector
                                opencv_objdetect.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(@Const @ByRef
                                opencv_core.Mat img,
                                @ByRef
                                opencv_core.RectVector foundLocations,
                                @StdVector
                                opencv_objdetect.DetectionROI locations)

readALTModel

public void readALTModel(@opencv_core.Str
                         org.bytedeco.javacpp.BytePointer modelfile)

\brief read/parse Dalal's alt model file

Parameters:

modelfile - Path of Dalal's alt model file.

readALTModel

public void readALTModel(@opencv_core.Str
                         String modelfile)

groupRectangles

public void groupRectangles(@ByRef
                            opencv_core.RectVector rectList,
                            @StdVector
                            org.bytedeco.javacpp.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
                            opencv_core.RectVector rectList,
                            @StdVector
                            DoubleBuffer weights,
                            int groupThreshold,
                            double eps)

groupRectangles

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