org.bytedeco.javacpp

Class opencv_objdetect.CascadeClassifier

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.javacpp.opencv_objdetect.CascadeClassifier

All Implemented Interfaces:

AutoCloseable

Enclosing class:

opencv_objdetect

@Namespace(value="cv")
 @NoOffset
public static class opencv_objdetect.CascadeClassifier
extends Pointer

\brief Cascade classifier class for object detection.

Nested Class Summary

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

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
CascadeClassifier()
CascadeClassifier(BytePointer filename) \brief Loads a classifier from a file.
CascadeClassifier(long size) Native array allocator.
CascadeClassifier(Pointer p) Pointer cast constructor.
CascadeClassifier(String filename)

Method Summary

Modifier and Type	Method and Description
opencv_objdetect.BaseCascadeClassifier	cc()
opencv_objdetect.CascadeClassifier	cc(opencv_objdetect.BaseCascadeClassifier cc)
static boolean	convert(BytePointer oldcascade, BytePointer newcascade)
static boolean	convert(String oldcascade, String newcascade)
void	detectMultiScale(opencv_core.Mat image, opencv_core.RectVector objects)
void	detectMultiScale(opencv_core.Mat image, opencv_core.RectVector objects, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize) \brief Detects objects of different sizes in the input image.
void	detectMultiScale(opencv_core.UMat image, opencv_core.RectVector objects)
void	detectMultiScale(opencv_core.UMat image, opencv_core.RectVector objects, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize)
void	detectMultiScale2(opencv_core.Mat image, opencv_core.RectVector objects, IntBuffer numDetections)
void	detectMultiScale2(opencv_core.Mat image, opencv_core.RectVector objects, IntBuffer numDetections, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize)
void	detectMultiScale2(opencv_core.Mat image, opencv_core.RectVector objects, IntPointer numDetections)
void	detectMultiScale2(opencv_core.Mat image, opencv_core.RectVector objects, IntPointer numDetections, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize) \overload
void	detectMultiScale2(opencv_core.UMat image, opencv_core.RectVector objects, int[] numDetections)
void	detectMultiScale2(opencv_core.UMat image, opencv_core.RectVector objects, int[] numDetections, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize)
void	detectMultiScale2(opencv_core.UMat image, opencv_core.RectVector objects, IntPointer numDetections)
void	detectMultiScale2(opencv_core.UMat image, opencv_core.RectVector objects, IntPointer numDetections, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize)
void	detectMultiScale3(opencv_core.Mat image, opencv_core.RectVector objects, IntBuffer rejectLevels, DoubleBuffer levelWeights)
void	detectMultiScale3(opencv_core.Mat image, opencv_core.RectVector objects, IntBuffer rejectLevels, DoubleBuffer levelWeights, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize, boolean outputRejectLevels)
void	detectMultiScale3(opencv_core.Mat image, opencv_core.RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights)
void	detectMultiScale3(opencv_core.Mat image, opencv_core.RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize, boolean outputRejectLevels) \overload if outputRejectLevels is true returns rejectLevels and levelWeights
void	detectMultiScale3(opencv_core.UMat image, opencv_core.RectVector objects, int[] rejectLevels, double[] levelWeights)
void	detectMultiScale3(opencv_core.UMat image, opencv_core.RectVector objects, int[] rejectLevels, double[] levelWeights, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize, boolean outputRejectLevels)
void	detectMultiScale3(opencv_core.UMat image, opencv_core.RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights)
void	detectMultiScale3(opencv_core.UMat image, opencv_core.RectVector objects, IntPointer rejectLevels, DoublePointer levelWeights, double scaleFactor, int minNeighbors, int flags, opencv_core.Size minSize, opencv_core.Size maxSize, boolean outputRejectLevels)
boolean	empty() \brief Checks whether the classifier has been loaded.
int	getFeatureType()
opencv_objdetect.BaseCascadeClassifier.MaskGenerator	getMaskGenerator()
Pointer	getOldCascade()
opencv_core.Size	getOriginalWindowSize()
boolean	isOldFormatCascade()
boolean	load(BytePointer filename) \brief Loads a classifier from a file.
boolean	load(String filename)
opencv_objdetect.CascadeClassifier	position(long position)
boolean	read(opencv_core.FileNode node) \brief Reads a classifier from a FileStorage node.
void	setMaskGenerator(opencv_objdetect.BaseCascadeClassifier.MaskGenerator maskGenerator)

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

Constructor Detail

CascadeClassifier

public CascadeClassifier(Pointer p)

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

CascadeClassifier

public CascadeClassifier(long size)

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

CascadeClassifier

public CascadeClassifier()

CascadeClassifier

public CascadeClassifier(@opencv_core.Str
                         BytePointer filename)

\brief Loads a classifier from a file.

Parameters:

filename - Name of the file from which the classifier is loaded.

CascadeClassifier

public CascadeClassifier(@opencv_core.Str
                         String filename)

Method Detail

position

public opencv_objdetect.CascadeClassifier position(long position)

Overrides:

position in class Pointer

empty

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

\brief Checks whether the classifier has been loaded.

load

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

\brief Loads a classifier from a file.

Parameters:

filename - Name of the file from which the classifier is loaded. The file may contain an old HAAR classifier trained by the haartraining application or a new cascade classifier trained by the traincascade application.

load

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

read

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

\brief Reads a classifier from a FileStorage node.

\note The file may contain a new cascade classifier (trained traincascade application) only.

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.Mat image,
                             @ByRef
                             opencv_core.RectVector objects,
                             double scaleFactor,
                             int minNeighbors,
                             int flags,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size minSize,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size maxSize)

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

Parameters:

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

objects - Vector of rectangles where each rectangle contains the detected object, the rectangles may be partially outside the original image.

scaleFactor - Parameter specifying how much the image size is reduced at each image scale.

minNeighbors - Parameter specifying how many neighbors each candidate rectangle should have to retain it.

flags - Parameter with the same meaning for an old cascade as in the function cvHaarDetectObjects. It is not used for a new cascade.

minSize - Minimum possible object size. Objects smaller than that are ignored.

maxSize - Maximum possible object size. Objects larger than that are ignored. If maxSize == minSize model is evaluated on single scale.

The function is parallelized with the TBB library.

\note - (Python) A face detection example using cascade classifiers can be found at opencv_source_code/samples/python/facedetect.py

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.Mat image,
                             @ByRef
                             opencv_core.RectVector objects)

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.UMat image,
                             @ByRef
                             opencv_core.RectVector objects,
                             double scaleFactor,
                             int minNeighbors,
                             int flags,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size minSize,
                             @ByVal(nullValue="cv::Size()")
                             opencv_core.Size maxSize)

detectMultiScale

public void detectMultiScale(@ByVal
                             opencv_core.UMat image,
                             @ByRef
                             opencv_core.RectVector objects)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer numDetections,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize)

\overload

Parameters:

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

objects - Vector of rectangles where each rectangle contains the detected object, the rectangles may be partially outside the original image.

numDetections - Vector of detection numbers for the corresponding objects. An object's number of detections is the number of neighboring positively classified rectangles that were joined together to form the object.

scaleFactor - Parameter specifying how much the image size is reduced at each image scale.

minNeighbors - Parameter specifying how many neighbors each candidate rectangle should have to retain it.

flags - Parameter with the same meaning for an old cascade as in the function cvHaarDetectObjects. It is not used for a new cascade.

minSize - Minimum possible object size. Objects smaller than that are ignored.

maxSize - Maximum possible object size. Objects larger than that are ignored. If maxSize == minSize model is evaluated on single scale.

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer numDetections)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntBuffer numDetections,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntBuffer numDetections)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              int[] numDetections,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              int[] numDetections)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer numDetections,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize)

detectMultiScale2

@Name(value="detectMultiScale")
public void detectMultiScale2(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer numDetections)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer rejectLevels,
                                                              @StdVector
                                                              DoublePointer levelWeights,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize,
                                                              @Cast(value="bool")
                                                              boolean outputRejectLevels)

\overload if outputRejectLevels is true returns rejectLevels and levelWeights

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer rejectLevels,
                                                              @StdVector
                                                              DoublePointer levelWeights)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntBuffer rejectLevels,
                                                              @StdVector
                                                              DoubleBuffer levelWeights,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize,
                                                              @Cast(value="bool")
                                                              boolean outputRejectLevels)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.Mat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntBuffer rejectLevels,
                                                              @StdVector
                                                              DoubleBuffer levelWeights)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              int[] rejectLevels,
                                                              @StdVector
                                                              double[] levelWeights,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize,
                                                              @Cast(value="bool")
                                                              boolean outputRejectLevels)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              int[] rejectLevels,
                                                              @StdVector
                                                              double[] levelWeights)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer rejectLevels,
                                                              @StdVector
                                                              DoublePointer levelWeights,
                                                              double scaleFactor,
                                                              int minNeighbors,
                                                              int flags,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size minSize,
                                                              @ByVal(nullValue="cv::Size()")
                                                              opencv_core.Size maxSize,
                                                              @Cast(value="bool")
                                                              boolean outputRejectLevels)

detectMultiScale3

@Name(value="detectMultiScale")
public void detectMultiScale3(@ByVal
                                                              opencv_core.UMat image,
                                                              @ByRef
                                                              opencv_core.RectVector objects,
                                                              @StdVector
                                                              IntPointer rejectLevels,
                                                              @StdVector
                                                              DoublePointer levelWeights)

isOldFormatCascade

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

getOriginalWindowSize

@ByVal
public opencv_core.Size getOriginalWindowSize()

getFeatureType

public int getFeatureType()

getOldCascade

public Pointer getOldCascade()

convert

@Cast(value="bool")
public static boolean convert(@opencv_core.Str
                                                  BytePointer oldcascade,
                                                  @opencv_core.Str
                                                  BytePointer newcascade)

convert

@Cast(value="bool")
public static boolean convert(@opencv_core.Str
                                                  String oldcascade,
                                                  @opencv_core.Str
                                                  String newcascade)

setMaskGenerator

public void setMaskGenerator(@opencv_core.Ptr
                             opencv_objdetect.BaseCascadeClassifier.MaskGenerator maskGenerator)

getMaskGenerator

@opencv_core.Ptr
public opencv_objdetect.BaseCascadeClassifier.MaskGenerator getMaskGenerator()

cc

@opencv_core.Ptr
public opencv_objdetect.BaseCascadeClassifier cc()

cc

public opencv_objdetect.CascadeClassifier cc(opencv_objdetect.BaseCascadeClassifier cc)