public static Facemark createFacemarkAAM()│ │ │ +
public static Facemark createFacemarkLBF()│ │ │ +
public static Facemark createFacemarkKazemi()│ │ │ +
public static boolean getFacesHAAR(Mat image, │ │ │ @@ -775,15 +802,15 @@ │ │ │ │ │ │ │ │ │
public static void drawFacemarks(Mat image, │ │ │ Mat points)│ │ │
public static Facemark createFacemarkAAM()│ │ │ -
public static Facemark createFacemarkLBF()│ │ │ -
public static Facemark createFacemarkKazemi()│ │ │ -
inputArr - input image want to compute hash value,
│ │ │ type should be CV_8UC4, CV_8UC3, CV_8UC1.outputArr - Hash value of input, it will contain 8 uchar valuepublic static void averageHash(Mat inputArr, │ │ │ + Mat outputArr)│ │ │ +
inputArr - input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr - Hash value of input, it will contain 16 hex decimal number, return type is CV_8Upublic static void marrHildrethHash(Mat inputArr, │ │ │ @@ -559,43 +575,27 @@ │ │ │
mode - the modepublic static void blockMeanHash(Mat inputArr, │ │ │ Mat outputArr)│ │ │
inputArr - input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr - Hash value of input, it will contain 16 hex decimal number, return type is CV_8Upublic static void averageHash(Mat inputArr, │ │ │ - Mat outputArr)│ │ │ -
inputArr - input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr - Hash value of input, it will contain 16 hex decimal number, return type is CV_8Upublic static final int DECODE_3D_UNDERWORLD│ │ │ -
public static final int FTP│ │ │ @@ -271,24 +258,37 @@ │ │ │
public static final int FAPS│ │ │
public static final int DECODE_3D_UNDERWORLD│ │ │ +
public static final int OCR_LEVEL_WORD│ │ │ +
public static final int ERFILTER_NM_RGBLGrad│ │ │
public static final int OCR_LEVEL_TEXTLINE│ │ │ +
public static final int ERFILTER_NM_IHSGrad│ │ │
public static final int ERFILTER_NM_RGBLGrad│ │ │ +
public static final int OCR_LEVEL_WORD│ │ │
public static final int ERFILTER_NM_IHSGrad│ │ │ +
public static final int OCR_LEVEL_TEXTLINE│ │ │
public static void detectTextSWT(Mat input, │ │ │ - MatOfRect result, │ │ │ - boolean dark_on_light, │ │ │ - Mat draw, │ │ │ - Mat chainBBs)│ │ │ -
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.draw - an optional Mat of type CV_8UC3 which visualises the detected letters using bounding boxes.chainBBs - an optional parameter which chains the letter candidates according to heuristics in the paper and returns all possible regions where text is likely to occur.public static void detectTextSWT(Mat input, │ │ │ - MatOfRect result, │ │ │ - boolean dark_on_light, │ │ │ - Mat draw)│ │ │ -
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.draw - an optional Mat of type CV_8UC3 which visualises the detected letters using bounding boxes.public static void detectTextSWT(Mat input, │ │ │ - MatOfRect result, │ │ │ - boolean dark_on_light)│ │ │ -
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.@Deprecated │ │ │ -public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifierNM(java.lang.String filename)│ │ │ -
filename - The XML or YAML file with the classifier model (e.g. OCRHMM_knn_model_data.xml)
│ │ │ -
│ │ │ - The KNN default classifier is based in the scene text recognition method proposed by Lukás Neumann &
│ │ │ - Jiri Matas in [Neumann11b]. Basically, the region (contour) in the input image is normalized to a
│ │ │ - fixed size, while retaining the centroid and aspect ratio, in order to extract a feature vector
│ │ │ - based on gradient orientations along the chain-code of its perimeter. Then, the region is classified
│ │ │ - using a KNN model trained with synthetic data of rendered characters with different standard font
│ │ │ - types.@Deprecated │ │ │ -public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifierCNN(java.lang.String filename)│ │ │ -
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)
│ │ │ -
│ │ │ - The CNN default classifier is based in the scene text recognition method proposed by Adam Coates &
│ │ │ - Andrew NG in [Coates11a]. The character classifier consists in a Single Layer Convolutional Neural Network and
│ │ │ - a linear classifier. It is applied to the input image in a sliding window fashion, providing a set of recognitions
│ │ │ - at each window location.public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifier(java.lang.String filename, │ │ │ - int classifier)│ │ │ -
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)classifier - Can be one of classifier_type enum values.public static Mat createOCRHMMTransitionsTable(java.lang.String vocabulary, │ │ │ - java.util.List<java.lang.String> lexicon)│ │ │ -
vocabulary - The language vocabulary (chars when ASCII English text).lexicon - The list of words that are expected to be found in a particular image.
│ │ │ -
│ │ │ -
│ │ │ - The function calculate frequency statistics of character pairs from the given lexicon and fills the output transition_probabilities_table with them. The transition_probabilities_table can be used as input in the OCRHMMDecoder::create() and OCRBeamSearchDecoder::create() methods.
│ │ │ - Note:
│ │ │ - - (C++) An alternative would be to load the default generic language transition table provided in the text module samples folder (created from ispell 42869 english words list) :
│ │ │ - <https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/OCRHMM_transitions_table.xml>public static OCRBeamSearchDecoder_ClassifierCallback loadOCRBeamSearchClassifierCNN(java.lang.String filename)│ │ │ -
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)
│ │ │ -
│ │ │ - The CNN default classifier is based in the scene text recognition method proposed by Adam Coates &
│ │ │ - Andrew NG in [Coates11a]. The character classifier consists in a Single Layer Convolutional Neural Network and
│ │ │ - a linear classifier. It is applied to the input image in a sliding window fashion, providing a set of recognitions
│ │ │ - at each window location.public static ERFilter createERFilterNM1(ERFilter_Callback cb, │ │ │ @@ -2026,15 +1851,15 @@ │ │ │
method - Grouping method (see text::erGrouping_Modes). Can be one of ERGROUPING_ORIENTATION_HORIZ, ERGROUPING_ORIENTATION_ANY.public static void detectRegions(Mat image, │ │ │ ERFilter er_filter1, │ │ │ ERFilter er_filter2, │ │ │ MatOfRect groups_rects)│ │ │
image - Source image where text blocks needs to be extracted from. Should be CV_8UC3 (color).er_filter1 - Extremal Region Filter for the 1st stage classifier of N&M algorithm CITE: Neumann12er_filter2 - Extremal Region Filter for the 2nd stage classifier of N&M algorithm CITE: Neumann12groups_rects - Output list of rectangle blocks with textpublic static void detectTextSWT(Mat input, │ │ │ + MatOfRect result, │ │ │ + boolean dark_on_light, │ │ │ + Mat draw, │ │ │ + Mat chainBBs)│ │ │ +
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.draw - an optional Mat of type CV_8UC3 which visualises the detected letters using bounding boxes.chainBBs - an optional parameter which chains the letter candidates according to heuristics in the paper and returns all possible regions where text is likely to occur.public static void detectTextSWT(Mat input, │ │ │ + MatOfRect result, │ │ │ + boolean dark_on_light, │ │ │ + Mat draw)│ │ │ +
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.draw - an optional Mat of type CV_8UC3 which visualises the detected letters using bounding boxes.public static void detectTextSWT(Mat input, │ │ │ + MatOfRect result, │ │ │ + boolean dark_on_light)│ │ │ +
input - the input image with 3 channels.result - a vector of resulting bounding boxes where probability of finding text is highdark_on_light - a boolean value signifying whether the text is darker or lighter than the background, it is observed to reverse the gradient obtained from Scharr operator, and significantly affect the result.@Deprecated │ │ │ +public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifierNM(java.lang.String filename)│ │ │ +
filename - The XML or YAML file with the classifier model (e.g. OCRHMM_knn_model_data.xml)
│ │ │ +
│ │ │ + The KNN default classifier is based in the scene text recognition method proposed by Lukás Neumann &
│ │ │ + Jiri Matas in [Neumann11b]. Basically, the region (contour) in the input image is normalized to a
│ │ │ + fixed size, while retaining the centroid and aspect ratio, in order to extract a feature vector
│ │ │ + based on gradient orientations along the chain-code of its perimeter. Then, the region is classified
│ │ │ + using a KNN model trained with synthetic data of rendered characters with different standard font
│ │ │ + types.@Deprecated │ │ │ +public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifierCNN(java.lang.String filename)│ │ │ +
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)
│ │ │ +
│ │ │ + The CNN default classifier is based in the scene text recognition method proposed by Adam Coates &
│ │ │ + Andrew NG in [Coates11a]. The character classifier consists in a Single Layer Convolutional Neural Network and
│ │ │ + a linear classifier. It is applied to the input image in a sliding window fashion, providing a set of recognitions
│ │ │ + at each window location.public static OCRHMMDecoder_ClassifierCallback loadOCRHMMClassifier(java.lang.String filename, │ │ │ + int classifier)│ │ │ +
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)classifier - Can be one of classifier_type enum values.public static Mat createOCRHMMTransitionsTable(java.lang.String vocabulary, │ │ │ + java.util.List<java.lang.String> lexicon)│ │ │ +
vocabulary - The language vocabulary (chars when ASCII English text).lexicon - The list of words that are expected to be found in a particular image.
│ │ │ +
│ │ │ +
│ │ │ + The function calculate frequency statistics of character pairs from the given lexicon and fills the output transition_probabilities_table with them. The transition_probabilities_table can be used as input in the OCRHMMDecoder::create() and OCRBeamSearchDecoder::create() methods.
│ │ │ + Note:
│ │ │ + - (C++) An alternative would be to load the default generic language transition table provided in the text module samples folder (created from ispell 42869 english words list) :
│ │ │ + <https://github.com/opencv/opencv_contrib/blob/master/modules/text/samples/OCRHMM_transitions_table.xml>public static OCRBeamSearchDecoder_ClassifierCallback loadOCRBeamSearchClassifierCNN(java.lang.String filename)│ │ │ +
filename - The XML or YAML file with the classifier model (e.g. OCRBeamSearch_CNN_model_data.xml.gz)
│ │ │ +
│ │ │ + The CNN default classifier is based in the scene text recognition method proposed by Adam Coates &
│ │ │ + Andrew NG in [Coates11a]. The character classifier consists in a Single Layer Convolutional Neural Network and
│ │ │ + a linear classifier. It is applied to the input image in a sliding window fashion, providing a set of recognitions
│ │ │ + at each window location.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, │ │ │ + double varThreshold, │ │ │ + boolean detectShadows)│ │ │ +
history - Length of the history.varThreshold - Threshold on the squared Mahalanobis distance between the pixel and the model
│ │ │ + to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ + affect the background update.detectShadows - If true, the algorithm will detect shadows and mark them. It decreases the
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, │ │ │ + double varThreshold)│ │ │ +
history - Length of the history.varThreshold - Threshold on the squared Mahalanobis distance between the pixel and the model
│ │ │ + to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ + affect the background update.
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history)│ │ │ +
history - Length of the history.
│ │ │ + to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ + affect the background update.
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2()│ │ │ +
public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, │ │ │ + double dist2Threshold, │ │ │ + boolean detectShadows)│ │ │ +
history - Length of the history.dist2Threshold - Threshold on the squared distance between the pixel and the sample to decide
│ │ │ + whether a pixel is close to that sample. This parameter does not affect the background update.detectShadows - If true, the algorithm will detect shadows and mark them. It decreases the
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, │ │ │ + double dist2Threshold)│ │ │ +
history - Length of the history.dist2Threshold - Threshold on the squared distance between the pixel and the sample to decide
│ │ │ + whether a pixel is close to that sample. This parameter does not affect the background update.
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history)│ │ │ +
history - Length of the history.
│ │ │ + whether a pixel is close to that sample. This parameter does not affect the background update.
│ │ │ + speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN()│ │ │ +
public static RotatedRect CamShift(Mat probImage, │ │ │ @@ -1562,15 +1720,15 @@ │ │ │
public static boolean writeOpticalFlow(java.lang.String path, │ │ │ Mat flow)│ │ │
public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, │ │ │ - double varThreshold, │ │ │ - boolean detectShadows)│ │ │ -
history - Length of the history.varThreshold - Threshold on the squared Mahalanobis distance between the pixel and the model
│ │ │ - to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ - affect the background update.detectShadows - If true, the algorithm will detect shadows and mark them. It decreases the
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history, │ │ │ - double varThreshold)│ │ │ -
history - Length of the history.varThreshold - Threshold on the squared Mahalanobis distance between the pixel and the model
│ │ │ - to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ - affect the background update.
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2(int history)│ │ │ -
history - Length of the history.
│ │ │ - to decide whether a pixel is well described by the background model. This parameter does not
│ │ │ - affect the background update.
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorMOG2 createBackgroundSubtractorMOG2()│ │ │ -
public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, │ │ │ - double dist2Threshold, │ │ │ - boolean detectShadows)│ │ │ -
history - Length of the history.dist2Threshold - Threshold on the squared distance between the pixel and the sample to decide
│ │ │ - whether a pixel is close to that sample. This parameter does not affect the background update.detectShadows - If true, the algorithm will detect shadows and mark them. It decreases the
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history, │ │ │ - double dist2Threshold)│ │ │ -
history - Length of the history.dist2Threshold - Threshold on the squared distance between the pixel and the sample to decide
│ │ │ - whether a pixel is close to that sample. This parameter does not affect the background update.
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN(int history)│ │ │ -
history - Length of the history.
│ │ │ - whether a pixel is close to that sample. This parameter does not affect the background update.
│ │ │ - speed a bit, so if you do not need this feature, set the parameter to false.public static BackgroundSubtractorKNN createBackgroundSubtractorKNN()│ │ │ -
dst - Destination image of the same size and the same number of channels as src .alpha - The amount of time to step forward by on each iteration (normally, it's between 0 and 1).K - sensitivity to the edgesniters - The number of iterationspublic static void edgePreservingFilter(Mat src, │ │ │ + Mat dst, │ │ │ + int d, │ │ │ + double threshold)│ │ │ +
src - Source 8-bit 3-channel image.dst - Destination image of the same size and type as src.d - Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3.threshold - Threshold, which distinguishes between noise, outliers, and data.public static void covarianceEstimation(Mat src, │ │ │ + Mat dst, │ │ │ + int windowRows, │ │ │ + int windowCols)│ │ │ +
src - The source image. Input image must be of a complex type.dst - The destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols).windowRows - The number of rows in the window.windowCols - The number of cols in the window.
│ │ │ + The window size parameters control the accuracy of the estimation.
│ │ │ + The sliding window moves over the entire image from the top-left corner
│ │ │ + to the bottom right corner. Each location of the window represents a sample.
│ │ │ + If the window is the size of the image, then this gives the exact covariance matrix.
│ │ │ + For all other cases, the sizes of the window will impact the number of samples
│ │ │ + and the number of elements in the estimated covariance matrix.public static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ + float _distance_threshold, │ │ │ + double _canny_th1, │ │ │ + double _canny_th2, │ │ │ + int _canny_aperture_size, │ │ │ + boolean _do_merge)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ + hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ + hysteresis procedure in Canny()_canny_aperture_size - 3 - Aperturesize for the sobel operator in Canny().
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image._do_merge - false - If true, incremental merging of segments
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ + float _distance_threshold, │ │ │ + double _canny_th1, │ │ │ + double _canny_th2, │ │ │ + int _canny_aperture_size)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ + hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ + hysteresis procedure in Canny()_canny_aperture_size - 3 - Aperturesize for the sobel operator in Canny().
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image.
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ + float _distance_threshold, │ │ │ + double _canny_th1, │ │ │ + double _canny_th2)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ + hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ + hysteresis procedure in Canny()
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image.
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ + float _distance_threshold, │ │ │ + double _canny_th1)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ + hysteresis procedure in Canny()
│ │ │ + hysteresis procedure in Canny()
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image.
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ + float _distance_threshold)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier
│ │ │ + hysteresis procedure in Canny()
│ │ │ + hysteresis procedure in Canny()
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image.
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold)│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded
│ │ │ + segment farther than this will be
│ │ │ + regarded as an outlier
│ │ │ + hysteresis procedure in Canny()
│ │ │ + hysteresis procedure in Canny()
│ │ │ + If zero, Canny() is not applied and the input
│ │ │ + image is taken as an edge image.
│ │ │ + will be perfomredpublic static FastLineDetector createFastLineDetector()│ │ │ +
public static void weightedMedianFilter(Mat joint, │ │ │ @@ -2629,183 +2870,347 @@ │ │ │
joint - automatically generatedsrc - automatically generateddst - automatically generatedr - automatically generatedpublic static RFFeatureGetter createRFFeatureGetter()│ │ │ +
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr, │ │ │ + float clusterMinMag, │ │ │ + float maxAspectRatio, │ │ │ + float minBoxArea, │ │ │ + float gamma, │ │ │ + float kappa)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.gamma - affinity sensitivity.kappa - scale sensitivity.public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model, │ │ │ - RFFeatureGetter howToGetFeatures)│ │ │ +
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr, │ │ │ + float clusterMinMag, │ │ │ + float maxAspectRatio, │ │ │ + float minBoxArea, │ │ │ + float gamma)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.gamma - affinity sensitivity.public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)│ │ │ +
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr, │ │ │ + float clusterMinMag, │ │ │ + float maxAspectRatio, │ │ │ + float minBoxArea)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.public static EdgeAwareInterpolator createEdgeAwareInterpolator()│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr, │ │ │ + float clusterMinMag, │ │ │ + float maxAspectRatio)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.public static RICInterpolator createRICInterpolator()│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr, │ │ │ + float clusterMinMag)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ - int algorithm, │ │ │ - int region_size, │ │ │ - float ruler)│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag, │ │ │ + float edgeMergeThr)│ │ │ +
image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ - SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ - while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.region_size - Chooses an average superpixel size measured in pixelsruler - Chooses the enforcement of superpixel smoothness factor of superpixel
│ │ │ -
│ │ │ - The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ - preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ - CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ -
│ │ │ - alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ - int algorithm, │ │ │ - int region_size)│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes, │ │ │ + float edgeMinMag)│ │ │ +
image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ - SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ - while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.region_size - Chooses an average superpixel size measured in pixels
│ │ │ -
│ │ │ - The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ - preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ - CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ -
│ │ │ - alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ - int algorithm)│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore, │ │ │ + int maxBoxes)│ │ │ +
image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ - SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ - while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.
│ │ │ -
│ │ │ - The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ - preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ - CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ -
│ │ │ - alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.public static SuperpixelSLIC createSuperpixelSLIC(Mat image)│ │ │ -
public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta, │ │ │ + float minScore)│ │ │ +
image - Image to segment
│ │ │ - SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ - while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.
│ │ │ -
│ │ │ - The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ - preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ - CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ -
│ │ │ - alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta, │ │ │ + float eta)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ + float beta)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.public static EdgeBoxes createEdgeBoxes(float alpha)│ │ │ +
alpha - step size of sliding window search.public static EdgeBoxes createEdgeBoxes()│ │ │ +
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ - int image_height, │ │ │ - int image_channels, │ │ │ - int num_superpixels, │ │ │ - int num_levels, │ │ │ - int prior, │ │ │ - int histogram_bins, │ │ │ - boolean double_step)│ │ │ -
image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ - due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ - get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ - but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ - must be in the range [0, 5].histogram_bins - Number of histogram bins.double_step - If true, iterate each block level twice for higher accuracy.
│ │ │ -
│ │ │ - The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ - the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ - superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ - double_step.
│ │ │ -
│ │ │ - The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ - optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ - the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ - levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ - recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ - illustrated in the following figure.
│ │ │ -
│ │ │ - public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ - int image_height, │ │ │ - int image_channels, │ │ │ - int num_superpixels, │ │ │ - int num_levels, │ │ │ - int prior, │ │ │ - int histogram_bins)│ │ │ -
image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ - due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ - get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ - but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ - must be in the range [0, 5].histogram_bins - Number of histogram bins.
│ │ │ -
│ │ │ - The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ - the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ - superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ - double_step.
│ │ │ -
│ │ │ - The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ - optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ - the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ - levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ - recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ - illustrated in the following figure.
│ │ │ -
│ │ │ - public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ - int image_height, │ │ │ - int image_channels, │ │ │ - int num_superpixels, │ │ │ - int num_levels, │ │ │ - int prior)│ │ │ -
image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ - due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ - get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ - but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ - must be in the range [0, 5].
│ │ │ -
│ │ │ - The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ - the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ - superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ - double_step.
│ │ │ -
│ │ │ - The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ - optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ - the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ - levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ - recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ - illustrated in the following figure.
│ │ │ -
│ │ │ - public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ - int image_height, │ │ │ - int image_channels, │ │ │ - int num_superpixels, │ │ │ - int num_levels)│ │ │ -
image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ - due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ - get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ - but needs more memory and CPU time.
│ │ │ - must be in the range [0, 5].
│ │ │ -
│ │ │ - The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ - the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ - superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ - double_step.
│ │ │ -
│ │ │ - The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ - optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ - the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ - levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ - recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ - illustrated in the following figure.
│ │ │ -
│ │ │ - public static void PeiLinNormalization(Mat I, │ │ │ - Mat T)│ │ │ -
public static SuperpixelLSC createSuperpixelLSC(Mat image, │ │ │ - int region_size, │ │ │ - float ratio)│ │ │ -
image - Image to segmentregion_size - Chooses an average superpixel size measured in pixelsratio - Chooses the enforcement of superpixel compactness factor of superpixel
│ │ │ -
│ │ │ - The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ - For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ - with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ -
│ │ │ - public static SuperpixelLSC createSuperpixelLSC(Mat image, │ │ │ - int region_size)│ │ │ -
image - Image to segmentregion_size - Chooses an average superpixel size measured in pixels
│ │ │ -
│ │ │ - The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ - For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ - with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ -
│ │ │ - public static SuperpixelLSC createSuperpixelLSC(Mat image)│ │ │ -
image - Image to segment
│ │ │ -
│ │ │ - The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ - superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ - computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ - For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ - with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ -
│ │ │ - public static void fourierDescriptor(Mat src, │ │ │ @@ -3463,202 +3600,52 @@ │ │ │create ContourFitting algorithm object│ │ │
public static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ - float _distance_threshold, │ │ │ - double _canny_th1, │ │ │ - double _canny_th2, │ │ │ - int _canny_aperture_size, │ │ │ - boolean _do_merge)│ │ │ -
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ - hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ - hysteresis procedure in Canny()_canny_aperture_size - 3 - Aperturesize for the sobel operator in Canny().
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image._do_merge - false - If true, incremental merging of segments
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ - float _distance_threshold, │ │ │ - double _canny_th1, │ │ │ - double _canny_th2, │ │ │ - int _canny_aperture_size)│ │ │ -
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ - hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ - hysteresis procedure in Canny()_canny_aperture_size - 3 - Aperturesize for the sobel operator in Canny().
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image.
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ - float _distance_threshold, │ │ │ - double _canny_th1, │ │ │ - double _canny_th2)│ │ │ -
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ - hysteresis procedure in Canny()_canny_th2 - 50 - Second threshold for
│ │ │ - hysteresis procedure in Canny()
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image.
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ - float _distance_threshold, │ │ │ - double _canny_th1)│ │ │ -
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier_canny_th1 - 50 - First threshold for
│ │ │ - hysteresis procedure in Canny()
│ │ │ - hysteresis procedure in Canny()
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image.
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold, │ │ │ - float _distance_threshold)│ │ │ -
public static EdgeAwareInterpolator createEdgeAwareInterpolator()│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded_distance_threshold - 1.41421356 - A point placed from a hypothesis line
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier
│ │ │ - hysteresis procedure in Canny()
│ │ │ - hysteresis procedure in Canny()
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image.
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector(int _length_threshold)│ │ │ -
public static RICInterpolator createRICInterpolator()│ │ │ +
_length_threshold - 10 - Segment shorter than this will be discarded
│ │ │ - segment farther than this will be
│ │ │ - regarded as an outlier
│ │ │ - hysteresis procedure in Canny()
│ │ │ - hysteresis procedure in Canny()
│ │ │ - If zero, Canny() is not applied and the input
│ │ │ - image is taken as an edge image.
│ │ │ - will be perfomredpublic static FastLineDetector createFastLineDetector()│ │ │ -
public static void PeiLinNormalization(Mat I, │ │ │ + Mat T)│ │ │
src - automatically generateddst - automatically generateddstMatDepth - automatically generatedpublic static void covarianceEstimation(Mat src, │ │ │ - Mat dst, │ │ │ - int windowRows, │ │ │ - int windowCols)│ │ │ -
public static SuperpixelLSC createSuperpixelLSC(Mat image, │ │ │ + int region_size, │ │ │ + float ratio)│ │ │ +
src - The source image. Input image must be of a complex type.dst - The destination estimated covariance matrix. Output matrix will be size (windowRows*windowCols, windowRows*windowCols).windowRows - The number of rows in the window.windowCols - The number of cols in the window.
│ │ │ - The window size parameters control the accuracy of the estimation.
│ │ │ - The sliding window moves over the entire image from the top-left corner
│ │ │ - to the bottom right corner. Each location of the window represents a sample.
│ │ │ - If the window is the size of the image, then this gives the exact covariance matrix.
│ │ │ - For all other cases, the sizes of the window will impact the number of samples
│ │ │ - and the number of elements in the estimated covariance matrix.image - Image to segmentregion_size - Chooses an average superpixel size measured in pixelsratio - Chooses the enforcement of superpixel compactness factor of superpixel
│ │ │ +
│ │ │ + The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ + For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ + with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ +
│ │ │ + public static void edgePreservingFilter(Mat src, │ │ │ - Mat dst, │ │ │ - int d, │ │ │ - double threshold)│ │ │ -
public static SuperpixelLSC createSuperpixelLSC(Mat image, │ │ │ + int region_size)│ │ │ +
src - Source 8-bit 3-channel image.dst - Destination image of the same size and type as src.d - Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3.threshold - Threshold, which distinguishes between noise, outliers, and data.image - Image to segmentregion_size - Chooses an average superpixel size measured in pixels
│ │ │ +
│ │ │ + The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ + For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ + with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr, │ │ │ - float clusterMinMag, │ │ │ - float maxAspectRatio, │ │ │ - float minBoxArea, │ │ │ - float gamma, │ │ │ - float kappa)│ │ │ -
public static SuperpixelLSC createSuperpixelLSC(Mat image)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.gamma - affinity sensitivity.kappa - scale sensitivity.image - Image to segment
│ │ │ +
│ │ │ + The function initializes a SuperpixelLSC object for the input image. It sets the parameters of
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. An example of LSC is ilustrated in the following picture.
│ │ │ + For enanched results it is recommended for color images to preprocess image with little gaussian blur
│ │ │ + with a small 3 x 3 kernel and additional conversion into CieLAB color space.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr, │ │ │ - float clusterMinMag, │ │ │ - float maxAspectRatio, │ │ │ - float minBoxArea, │ │ │ - float gamma)│ │ │ -
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ + int image_height, │ │ │ + int image_channels, │ │ │ + int num_superpixels, │ │ │ + int num_levels, │ │ │ + int prior, │ │ │ + int histogram_bins, │ │ │ + boolean double_step)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.gamma - affinity sensitivity.image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ + due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ + get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ + but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ + must be in the range [0, 5].histogram_bins - Number of histogram bins.double_step - If true, iterate each block level twice for higher accuracy.
│ │ │ +
│ │ │ + The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ + the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ + superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ + double_step.
│ │ │ +
│ │ │ + The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ + optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ + the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ + levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ + recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ + illustrated in the following figure.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr, │ │ │ - float clusterMinMag, │ │ │ - float maxAspectRatio, │ │ │ - float minBoxArea)│ │ │ -
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ + int image_height, │ │ │ + int image_channels, │ │ │ + int num_superpixels, │ │ │ + int num_levels, │ │ │ + int prior, │ │ │ + int histogram_bins)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.minBoxArea - minimum area of boxes.image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ + due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ + get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ + but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ + must be in the range [0, 5].histogram_bins - Number of histogram bins.
│ │ │ +
│ │ │ + The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ + the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ + superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ + double_step.
│ │ │ +
│ │ │ + The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ + optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ + the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ + levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ + recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ + illustrated in the following figure.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr, │ │ │ - float clusterMinMag, │ │ │ - float maxAspectRatio)│ │ │ -
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ + int image_height, │ │ │ + int image_channels, │ │ │ + int num_superpixels, │ │ │ + int num_levels, │ │ │ + int prior)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.maxAspectRatio - max aspect ratio of boxes.image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ + due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ + get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ + but needs more memory and CPU time.prior - enable 3x3 shape smoothing term if >0. A larger value leads to smoother shapes. prior
│ │ │ + must be in the range [0, 5].
│ │ │ +
│ │ │ + The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ + the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ + superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ + double_step.
│ │ │ +
│ │ │ + The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ + optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ + the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ + levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ + recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ + illustrated in the following figure.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr, │ │ │ - float clusterMinMag)│ │ │ -
public static SuperpixelSEEDS createSuperpixelSEEDS(int image_width, │ │ │ + int image_height, │ │ │ + int image_channels, │ │ │ + int num_superpixels, │ │ │ + int num_levels)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.clusterMinMag - cluster min magnitude. Increase to trade off accuracy for speed.image_width - Image width.image_height - Image height.image_channels - Number of channels of the image.num_superpixels - Desired number of superpixels. Note that the actual number may be smaller
│ │ │ + due to restrictions (depending on the image size and num_levels). Use getNumberOfSuperpixels() to
│ │ │ + get the actual number.num_levels - Number of block levels. The more levels, the more accurate is the segmentation,
│ │ │ + but needs more memory and CPU time.
│ │ │ + must be in the range [0, 5].
│ │ │ +
│ │ │ + The function initializes a SuperpixelSEEDS object for the input image. It stores the parameters of
│ │ │ + the image: image_width, image_height and image_channels. It also sets the parameters of the SEEDS
│ │ │ + superpixel algorithm, which are: num_superpixels, num_levels, use_prior, histogram_bins and
│ │ │ + double_step.
│ │ │ +
│ │ │ + The number of levels in num_levels defines the amount of block levels that the algorithm use in the
│ │ │ + optimization. The initialization is a grid, in which the superpixels are equally distributed through
│ │ │ + the width and the height of the image. The larger blocks correspond to the superpixel size, and the
│ │ │ + levels with smaller blocks are formed by dividing the larger blocks into 2 x 2 blocks of pixels,
│ │ │ + recursively until the smaller block level. An example of initialization of 4 block levels is
│ │ │ + illustrated in the following figure.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag, │ │ │ - float edgeMergeThr)│ │ │ -
public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ + int algorithm, │ │ │ + int region_size, │ │ │ + float ruler)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.edgeMergeThr - edge merge threshold. Increase to trade off accuracy for speed.image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ + SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ + while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.region_size - Chooses an average superpixel size measured in pixelsruler - Chooses the enforcement of superpixel smoothness factor of superpixel
│ │ │ +
│ │ │ + The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ + preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ + CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes, │ │ │ - float edgeMinMag)│ │ │ -
public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ + int algorithm, │ │ │ + int region_size)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.edgeMinMag - edge min magnitude. Increase to trade off accuracy for speed.image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ + SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ + while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.region_size - Chooses an average superpixel size measured in pixels
│ │ │ +
│ │ │ + The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ + preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ + CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore, │ │ │ - int maxBoxes)│ │ │ -
public static SuperpixelSLIC createSuperpixelSLIC(Mat image, │ │ │ + int algorithm)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.maxBoxes - max number of boxes to detect.image - Image to segmentalgorithm - Chooses the algorithm variant to use:
│ │ │ + SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ + while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.
│ │ │ +
│ │ │ + The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ + preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ + CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta, │ │ │ - float minScore)│ │ │ -
public static SuperpixelSLIC createSuperpixelSLIC(Mat image)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.minScore - min score of boxes to detect.image - Image to segment
│ │ │ + SLIC segments image using a desired region_size, and in addition SLICO will optimize using adaptive compactness factor,
│ │ │ + while MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels.
│ │ │ +
│ │ │ + The function initializes a SuperpixelSLIC object for the input image. It sets the parameters of choosed
│ │ │ + superpixel algorithm, which are: region_size and ruler. It preallocate some buffers for future
│ │ │ + computing iterations over the given image. For enanched results it is recommended for color images to
│ │ │ + preprocess image with little gaussian blur using a small 3 x 3 kernel and additional conversion into
│ │ │ + CieLAB color space. An example of SLIC versus SLICO and MSLIC is ilustrated in the following picture.
│ │ │ +
│ │ │ + public static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta, │ │ │ - float eta)│ │ │ -
public static void GradientDericheY(Mat op, │ │ │ + Mat dst, │ │ │ + double alpha, │ │ │ + double omega)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.eta - adaptation rate for nms threshold.op - automatically generateddst - automatically generatedalpha - automatically generatedomega - automatically generatedpublic static void GradientDericheX(Mat op, │ │ │ + Mat dst, │ │ │ + double alpha, │ │ │ + double omega)│ │ │ +
op - automatically generateddst - automatically generatedalpha - automatically generatedomega - automatically generatedpublic static void createQuaternionImage(Mat img, │ │ │ + Mat qimg)│ │ │ +
img - automatically generatedqimg - automatically generatedpublic static void qconj(Mat qimg, │ │ │ + Mat qcimg)│ │ │ +
qimg - automatically generatedqcimg - automatically generatedpublic static void qunitary(Mat qimg, │ │ │ + Mat qnimg)│ │ │ +
qimg - automatically generatedqnimg - automatically generatedpublic static void qmultiply(Mat src1, │ │ │ + Mat src2, │ │ │ + Mat dst)│ │ │ +
src1 - automatically generatedsrc2 - automatically generateddst - automatically generatedpublic static void qdft(Mat img, │ │ │ + Mat qimg, │ │ │ + int flags, │ │ │ + boolean sideLeft)│ │ │ +
img - automatically generatedqimg - automatically generatedflags - automatically generatedsideLeft - automatically generatedpublic static void colorMatchTemplate(Mat img, │ │ │ + Mat templ, │ │ │ + Mat result)│ │ │ +
img - automatically generatedtempl - automatically generatedresult - automatically generatedpublic static RFFeatureGetter createRFFeatureGetter()│ │ │ +
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model, │ │ │ + RFFeatureGetter howToGetFeatures)│ │ │ +
public static StructuredEdgeDetection createStructuredEdgeDetection(java.lang.String model)│ │ │ +
public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)│ │ │ +
matcher_left - stereo matcher instance that will be used with the filterpublic static EdgeBoxes createEdgeBoxes(float alpha, │ │ │ - float beta)│ │ │ -
public static StereoMatcher createRightMatcher(StereoMatcher matcher_left)│ │ │ +
alpha - step size of sliding window search.beta - nms threshold for object proposals.matcher_left - main stereo matcher instance that will be used with the filterpublic static EdgeBoxes createEdgeBoxes(float alpha)│ │ │ -
public static DisparityWLSFilter createDisparityWLSFilterGeneric(boolean use_confidence)│ │ │ +
alpha - step size of sliding window search.use_confidence - filtering with confidence requires two disparity maps (for the left and right views) and is
│ │ │ + approximately two times slower. However, quality is typically significantly better.public static EdgeBoxes createEdgeBoxes()│ │ │ -
public static int readGT(java.lang.String src_path, │ │ │ + Mat dst)│ │ │ +
src_path - path to the image, containing ground-truth disparity mapdst - output disparity map, CV_16S depthpublic static double computeMSE(Mat GT, │ │ │ + Mat src, │ │ │ + Rect ROI)│ │ │ +
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestpublic static double computeBadPixelPercent(Mat GT, │ │ │ + Mat src, │ │ │ + Rect ROI, │ │ │ + int thresh)│ │ │ +
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestthresh - threshold used to determine "bad" pixelspublic static double computeBadPixelPercent(Mat GT, │ │ │ + Mat src, │ │ │ + Rect ROI)│ │ │ +
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestpublic static void getDisparityVis(Mat src, │ │ │ + Mat dst, │ │ │ + double scale)│ │ │ +
src - input disparity map (CV_16S depth)dst - output visualizationscale - disparity map will be multiplied by this value for visualizationpublic static void getDisparityVis(Mat src, │ │ │ + Mat dst)│ │ │ +
src - input disparity map (CV_16S depth)dst - output visualizationpublic static void l0Smooth(Mat src, │ │ │ Mat dst)│ │ │
public static DisparityWLSFilter createDisparityWLSFilter(StereoMatcher matcher_left)│ │ │ -
matcher_left - stereo matcher instance that will be used with the filterpublic static StereoMatcher createRightMatcher(StereoMatcher matcher_left)│ │ │ -
matcher_left - main stereo matcher instance that will be used with the filterpublic static DisparityWLSFilter createDisparityWLSFilterGeneric(boolean use_confidence)│ │ │ -
use_confidence - filtering with confidence requires two disparity maps (for the left and right views) and is
│ │ │ - approximately two times slower. However, quality is typically significantly better.public static int readGT(java.lang.String src_path, │ │ │ - Mat dst)│ │ │ -
src_path - path to the image, containing ground-truth disparity mapdst - output disparity map, CV_16S depthpublic static double computeMSE(Mat GT, │ │ │ - Mat src, │ │ │ - Rect ROI)│ │ │ -
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestpublic static double computeBadPixelPercent(Mat GT, │ │ │ - Mat src, │ │ │ - Rect ROI, │ │ │ - int thresh)│ │ │ -
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestthresh - threshold used to determine "bad" pixelspublic static double computeBadPixelPercent(Mat GT, │ │ │ - Mat src, │ │ │ - Rect ROI)│ │ │ -
GT - ground truth disparity mapsrc - disparity map to evaluateROI - region of interestpublic static void getDisparityVis(Mat src, │ │ │ - Mat dst, │ │ │ - double scale)│ │ │ -
src - input disparity map (CV_16S depth)dst - output visualizationscale - disparity map will be multiplied by this value for visualizationpublic static void getDisparityVis(Mat src, │ │ │ - Mat dst)│ │ │ -
src - input disparity map (CV_16S depth)dst - output visualizationpublic static void GradientDericheY(Mat op, │ │ │ - Mat dst, │ │ │ - double alpha, │ │ │ - double omega)│ │ │ -
op - automatically generateddst - automatically generatedalpha - automatically generatedomega - automatically generatedpublic static void GradientDericheX(Mat op, │ │ │ - Mat dst, │ │ │ - double alpha, │ │ │ - double omega)│ │ │ -
op - automatically generateddst - automatically generatedalpha - automatically generatedomega - automatically generatedpublic static void createQuaternionImage(Mat img, │ │ │ - Mat qimg)│ │ │ -
img - automatically generatedqimg - automatically generatedpublic static void qconj(Mat qimg, │ │ │ - Mat qcimg)│ │ │ -
qimg - automatically generatedqcimg - automatically generatedpublic static void qunitary(Mat qimg, │ │ │ - Mat qnimg)│ │ │ -
qimg - automatically generatedqnimg - automatically generatedpublic static void qmultiply(Mat src1, │ │ │ - Mat src2, │ │ │ - Mat dst)│ │ │ -
src1 - automatically generatedsrc2 - automatically generateddst - automatically generatedpublic static void qdft(Mat img, │ │ │ - Mat qimg, │ │ │ - int flags, │ │ │ - boolean sideLeft)│ │ │ -
img - automatically generatedqimg - automatically generatedflags - automatically generatedsideLeft - automatically generatedpublic static void colorMatchTemplate(Mat img, │ │ │ - Mat templ, │ │ │ - Mat result)│ │ │ -
img - automatically generatedtempl - automatically generatedresult - automatically generatedpublic static SimpleWB createSimpleWB()│ │ │ -
public static GrayworldWB createGrayworldWB()│ │ │ -
public static LearningBasedWB createLearningBasedWB(java.lang.String path_to_model)│ │ │ -
path_to_model - Path to a .yml file with the model. If not specified, the default model is usedpublic static LearningBasedWB createLearningBasedWB()│ │ │ -
public static void applyChannelGains(Mat src, │ │ │ - Mat dst, │ │ │ - float gainB, │ │ │ - float gainG, │ │ │ - float gainR)│ │ │ -
src - Input three-channel image in the BGR color space (either CV_8UC3 or CV_16UC3)dst - Output image of the same size and type as src.gainB - gain for the B channelgainG - gain for the G channelgainR - gain for the R channelpublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ - float contrast, │ │ │ - float saturation, │ │ │ - float sigma_color, │ │ │ - float sigma_space)│ │ │ -
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ - are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragosigma_color - bilateral filter sigma in color spacesigma_space - bilateral filter sigma in coordinate spacepublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ - float contrast, │ │ │ - float saturation, │ │ │ - float sigma_color)│ │ │ -
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ - are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragosigma_color - bilateral filter sigma in color spacepublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ - float contrast, │ │ │ - float saturation)│ │ │ -
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ - are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragopublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ - float contrast)│ │ │ -
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ - are maximum and minimum luminance values of the resulting image.public static TonemapDurand createTonemapDurand(float gamma)│ │ │ -
gamma - gamma value for gamma correction. See createTonemap
│ │ │ - are maximum and minimum luminance values of the resulting image.public static TonemapDurand createTonemapDurand()│ │ │ -
public static void oilPainting(Mat src, │ │ │ - Mat dst, │ │ │ - int size, │ │ │ - int dynRatio, │ │ │ - int code)│ │ │ -
src - Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)dst - Output image of the same size and type as src.size - neighbouring size is 2-size+1dynRatio - image is divided by dynRatio before histogram processingcode - automatically generatedpublic static void oilPainting(Mat src, │ │ │ - Mat dst, │ │ │ - int size, │ │ │ - int dynRatio)│ │ │ -
src - Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)dst - Output image of the same size and type as src.size - neighbouring size is 2-size+1dynRatio - image is divided by dynRatio before histogram processingpublic static void inpaint(Mat src, │ │ │ - Mat mask, │ │ │ - Mat dst, │ │ │ - int algorithmType)│ │ │ -
src - source image
│ │ │ - mask - mask (#CV_8UC1), where non-zero pixels indicate valid image area, while zero pixels
│ │ │ - indicate area to be inpainteddst - destination imagealgorithmType - see xphoto::InpaintTypes
│ │ │ - public static void dctDenoising(Mat src, │ │ │ - Mat dst, │ │ │ - double sigma, │ │ │ - int psize)│ │ │ -
src - source imagedst - destination imagesigma - expected noise standard deviationpsize - size of block side where dct is computed
│ │ │ -
│ │ │ - SEE:
│ │ │ - fastNlMeansDenoisingpublic static void dctDenoising(Mat src, │ │ │ - Mat dst, │ │ │ - double sigma)│ │ │ -
src - source imagedst - destination imagesigma - expected noise standard deviation
│ │ │ -
│ │ │ - SEE:
│ │ │ - fastNlMeansDenoisingpublic static void bm3dDenoising(Mat src, │ │ │ @@ -2392,15 +2052,15 @@ │ │ │ fastNlMeansDenoising │ │ │ │ │ │
public static void bm3dDenoising(Mat src, │ │ │ Mat dst)│ │ │
public static void oilPainting(Mat src, │ │ │ + Mat dst, │ │ │ + int size, │ │ │ + int dynRatio, │ │ │ + int code)│ │ │ +
src - Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)dst - Output image of the same size and type as src.size - neighbouring size is 2-size+1dynRatio - image is divided by dynRatio before histogram processingcode - automatically generatedpublic static void oilPainting(Mat src, │ │ │ + Mat dst, │ │ │ + int size, │ │ │ + int dynRatio)│ │ │ +
src - Input three-channel or one channel image (either CV_8UC3 or CV_8UC1)dst - Output image of the same size and type as src.size - neighbouring size is 2-size+1dynRatio - image is divided by dynRatio before histogram processingpublic static void dctDenoising(Mat src, │ │ │ + Mat dst, │ │ │ + double sigma, │ │ │ + int psize)│ │ │ +
src - source imagedst - destination imagesigma - expected noise standard deviationpsize - size of block side where dct is computed
│ │ │ +
│ │ │ + SEE:
│ │ │ + fastNlMeansDenoisingpublic static void dctDenoising(Mat src, │ │ │ + Mat dst, │ │ │ + double sigma)│ │ │ +
src - source imagedst - destination imagesigma - expected noise standard deviation
│ │ │ +
│ │ │ + SEE:
│ │ │ + fastNlMeansDenoisingpublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ + float contrast, │ │ │ + float saturation, │ │ │ + float sigma_color, │ │ │ + float sigma_space)│ │ │ +
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ + are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragosigma_color - bilateral filter sigma in color spacesigma_space - bilateral filter sigma in coordinate spacepublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ + float contrast, │ │ │ + float saturation, │ │ │ + float sigma_color)│ │ │ +
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ + are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragosigma_color - bilateral filter sigma in color spacepublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ + float contrast, │ │ │ + float saturation)│ │ │ +
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ + are maximum and minimum luminance values of the resulting image.saturation - saturation enhancement value. See createTonemapDragopublic static TonemapDurand createTonemapDurand(float gamma, │ │ │ + float contrast)│ │ │ +
gamma - gamma value for gamma correction. See createTonemapcontrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min
│ │ │ + are maximum and minimum luminance values of the resulting image.public static TonemapDurand createTonemapDurand(float gamma)│ │ │ +
gamma - gamma value for gamma correction. See createTonemap
│ │ │ + are maximum and minimum luminance values of the resulting image.public static TonemapDurand createTonemapDurand()│ │ │ +
public static SimpleWB createSimpleWB()│ │ │ +
public static GrayworldWB createGrayworldWB()│ │ │ +
public static LearningBasedWB createLearningBasedWB(java.lang.String path_to_model)│ │ │ +
path_to_model - Path to a .yml file with the model. If not specified, the default model is usedpublic static LearningBasedWB createLearningBasedWB()│ │ │ +
public static void applyChannelGains(Mat src, │ │ │ + Mat dst, │ │ │ + float gainB, │ │ │ + float gainG, │ │ │ + float gainR)│ │ │ +
src - Input three-channel image in the BGR color space (either CV_8UC3 or CV_16UC3)dst - Output image of the same size and type as src.gainB - gain for the B channelgainG - gain for the G channelgainR - gain for the R channelpublic static void inpaint(Mat src, │ │ │ + Mat mask, │ │ │ + Mat dst, │ │ │ + int algorithmType)│ │ │ +
src - source image
│ │ │ + mask - mask (#CV_8UC1), where non-zero pixels indicate valid image area, while zero pixels
│ │ │ + indicate area to be inpainteddst - destination imagealgorithmType - see xphoto::InpaintTypes
│ │ │ +