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 Pointer

Nested Class Summary

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

Pointer.CustomDeallocator, Pointer.Deallocator, 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()
HOGDescriptor(BytePointer filename)
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)
HOGDescriptor(opencv_objdetect.HOGDescriptor d)
HOGDescriptor(Pointer p) Pointer cast constructor.
HOGDescriptor(String filename)

Method Summary

Modifier and Type	Method and Description
opencv_core.Size	blockSize()
opencv_objdetect.HOGDescriptor	blockSize(opencv_core.Size blockSize)
opencv_core.Size	blockStride()
opencv_objdetect.HOGDescriptor	blockStride(opencv_core.Size blockStride)
opencv_core.Size	cellSize()
opencv_objdetect.HOGDescriptor	cellSize(opencv_core.Size cellSize)
boolean	checkDetectorSize()
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, FloatPointer descriptors)
void	compute(opencv_core.Mat img, FloatPointer descriptors, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector locations)
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, FloatPointer descriptors)
void	compute(opencv_core.UMat img, 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)
void	copyTo(opencv_objdetect.HOGDescriptor c)
int	derivAperture()
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) without found weights output
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, DoublePointer weights)
void	detect(opencv_core.Mat img, opencv_core.PointVector foundLocations, DoublePointer weights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, opencv_core.PointVector searchLocations) with found weights output
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations)
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) without found weights output
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, DoublePointer foundWeights)
void	detectMultiScale(opencv_core.Mat img, opencv_core.RectVector foundLocations, DoublePointer foundWeights, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding, double scale, double finalThreshold, boolean useMeanshiftGrouping) with result weights output
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, 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, DoublePointer foundWeights)
void	detectMultiScale(opencv_core.UMat img, opencv_core.RectVector foundLocations, 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) 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, DoublePointer confidences)
void	detectROI(opencv_core.Mat img, opencv_core.PointVector locations, opencv_core.PointVector foundLocations, DoublePointer confidences, double hitThreshold, opencv_core.Size winStride, opencv_core.Size padding) evaluate specified ROI and return confidence value for each location
float	free_coef()
opencv_objdetect.HOGDescriptor	free_coef(float free_coef)
boolean	gammaCorrection()
opencv_objdetect.HOGDescriptor	gammaCorrection(boolean gammaCorrection)
static FloatPointer	getDaimlerPeopleDetector()
static FloatPointer	getDefaultPeopleDetector()
long	getDescriptorSize()
double	getWinSigma()
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, DoublePointer weights, int groupThreshold, double eps)
int	histogramNormType()
opencv_objdetect.HOGDescriptor	histogramNormType(int histogramNormType)
double	L2HysThreshold()
opencv_objdetect.HOGDescriptor	L2HysThreshold(double L2HysThreshold)
boolean	load(BytePointer filename)
boolean	load(BytePointer filename, BytePointer objname)
boolean	load(String filename)
boolean	load(String filename, String objname)
int	nbins()
opencv_objdetect.HOGDescriptor	nbins(int nbins)
int	nlevels()
opencv_objdetect.HOGDescriptor	nlevels(int nlevels)
opencv_core.UMat	oclSvmDetector()
opencv_objdetect.HOGDescriptor	oclSvmDetector(opencv_core.UMat oclSvmDetector)
opencv_objdetect.HOGDescriptor	position(long position)
boolean	read(opencv_core.FileNode fn)
void	readALTModel(BytePointer modelfile) read/parse Dalal's alt model file
void	readALTModel(String modelfile)
void	save(BytePointer filename)
void	save(BytePointer filename, BytePointer objname)
void	save(String filename)
void	save(String filename, String objname)
void	setSVMDetector(opencv_core.Mat _svmdetector)
void	setSVMDetector(opencv_core.UMat _svmdetector)
boolean	signedGradient()
opencv_objdetect.HOGDescriptor	signedGradient(boolean signedGradient)
FloatPointer	svmDetector()
opencv_objdetect.HOGDescriptor	svmDetector(FloatPointer svmDetector)
double	winSigma()
opencv_objdetect.HOGDescriptor	winSigma(double winSigma)
opencv_core.Size	winSize()
opencv_objdetect.HOGDescriptor	winSize(opencv_core.Size winSize)
void	write(opencv_core.FileStorage fs, BytePointer objname)
void	write(opencv_core.FileStorage fs, String objname)

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, free, hashCode, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, physicalBytes, position, put, realloc, setNull, sizeof, toString, totalBytes, 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(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()

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)

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
                     BytePointer filename)

HOGDescriptor

public HOGDescriptor(@opencv_core.Str
                     String filename)

HOGDescriptor

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

Method Detail

position

public opencv_objdetect.HOGDescriptor position(long position)

Overrides:

position in class Pointer

getDescriptorSize

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

checkDetectorSize

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

getWinSigma

public double getWinSigma()

setSVMDetector

public void setSVMDetector(@ByVal
                           opencv_core.Mat _svmdetector)

setSVMDetector

public void setSVMDetector(@ByVal
                           opencv_core.UMat _svmdetector)

read

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

write

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

write

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

load

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

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)

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
                   opencv_objdetect.HOGDescriptor c)

compute

public void compute(@ByVal
                    opencv_core.Mat img,
                    @StdVector
                    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.Mat img,
                    @StdVector
                    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.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.UMat img,
                    @StdVector
                    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
                    FloatPointer descriptors)

detect

public void detect(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   @StdVector
                   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)

with found weights output

detect

public void detect(@Const @ByRef
                   opencv_core.Mat img,
                   @ByRef
                   opencv_core.PointVector foundLocations,
                   @StdVector
                   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)

without found weights output

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
                             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)

with result weights output

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.Mat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             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.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.UMat img,
                             @ByRef
                             opencv_core.RectVector foundLocations,
                             @StdVector
                             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
                             DoublePointer 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)

without found weights output

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)

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)

computeGradient

public void computeGradient(@Const @ByRef
                            opencv_core.Mat img,
                            @ByRef
                            opencv_core.Mat grad,
                            @ByRef
                            opencv_core.Mat angleOfs)

getDefaultPeopleDetector

@StdVector
public static FloatPointer getDefaultPeopleDetector()

getDaimlerPeopleDetector

@StdVector
public static FloatPointer getDaimlerPeopleDetector()

winSize

@ByRef
public opencv_core.Size winSize()

winSize

public opencv_objdetect.HOGDescriptor winSize(opencv_core.Size winSize)

blockSize

@ByRef
public opencv_core.Size blockSize()

blockSize

public opencv_objdetect.HOGDescriptor blockSize(opencv_core.Size blockSize)

blockStride

@ByRef
public opencv_core.Size blockStride()

blockStride

public opencv_objdetect.HOGDescriptor blockStride(opencv_core.Size blockStride)

cellSize

@ByRef
public opencv_core.Size cellSize()

cellSize

public opencv_objdetect.HOGDescriptor cellSize(opencv_core.Size cellSize)

nbins

public int nbins()

nbins

public opencv_objdetect.HOGDescriptor nbins(int nbins)

derivAperture

public int derivAperture()

derivAperture

public opencv_objdetect.HOGDescriptor derivAperture(int derivAperture)

winSigma

public double winSigma()

winSigma

public opencv_objdetect.HOGDescriptor winSigma(double winSigma)

histogramNormType

public int histogramNormType()

histogramNormType

public opencv_objdetect.HOGDescriptor histogramNormType(int histogramNormType)

L2HysThreshold

public double L2HysThreshold()

L2HysThreshold

public opencv_objdetect.HOGDescriptor L2HysThreshold(double L2HysThreshold)

gammaCorrection

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

gammaCorrection

public opencv_objdetect.HOGDescriptor gammaCorrection(boolean gammaCorrection)

svmDetector

@StdVector
public FloatPointer svmDetector()

svmDetector

public opencv_objdetect.HOGDescriptor svmDetector(FloatPointer svmDetector)

oclSvmDetector

@ByRef
public opencv_core.UMat oclSvmDetector()

oclSvmDetector

public opencv_objdetect.HOGDescriptor oclSvmDetector(opencv_core.UMat oclSvmDetector)

free_coef

public float free_coef()

free_coef

public opencv_objdetect.HOGDescriptor free_coef(float free_coef)

nlevels

public int nlevels()

nlevels

public opencv_objdetect.HOGDescriptor nlevels(int nlevels)

signedGradient

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

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
                      DoublePointer confidences,
                      double hitThreshold,
                      @ByVal(nullValue="cv::Size()")
                      opencv_core.Size winStride,
                      @ByVal(nullValue="cv::Size()")
                      opencv_core.Size padding)

evaluate specified ROI and return confidence value for each location

detectROI

public void detectROI(@Const @ByRef
                      opencv_core.Mat img,
                      @Const @ByRef
                      opencv_core.PointVector locations,
                      @ByRef
                      opencv_core.PointVector foundLocations,
                      @StdVector
                      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)

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

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
                         BytePointer modelfile)

read/parse Dalal's alt model file

readALTModel

public void readALTModel(@opencv_core.Str
                         String modelfile)

groupRectangles

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

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)