Merge pull request #1211 from VladX:lsbp

Author: mshabunin

modules/bgsegm/CMakeLists.txt

@@ -1,2 +1,2 @@
 set(the_description "Background Segmentation Algorithms")
-ocv_define_module(bgsegm opencv_core opencv_imgproc opencv_video WRAP python)
+ocv_define_module(bgsegm opencv_core opencv_imgproc opencv_video opencv_calib3d WRAP python)

modules/bgsegm/doc/bgsegm.bib

@@ -15,3 +15,13 @@ @inproceedings{Gold2012
   year={2012},
   organization={IEEE}
 }
+
+@inproceedings{LGuo2016,
+  author={L. Guo and D. Xu and Z. Qiang},
+  booktitle={2016 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW)},
+  title={Background Subtraction Using Local SVD Binary Pattern},
+  year={2016},
+  pages={1159-1167},
+  doi={10.1109/CVPRW.2016.148},
+  month={June}
+}

modules/bgsegm/include/opencv2/bgsegm.hpp

@@ -242,6 +242,135 @@ createBackgroundSubtractorCNT(int minPixelStability = 15,
                               int maxPixelStability = 15*60,
                               bool isParallel = true);
 
+enum LSBPCameraMotionCompensation {
+    LSBP_CAMERA_MOTION_COMPENSATION_NONE = 0,
+    LSBP_CAMERA_MOTION_COMPENSATION_LK
+};
+
+/** @brief Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
+
+This algorithm demonstrates better performance on CDNET 2014 dataset compared to other algorithms in OpenCV.
+ */
+class CV_EXPORTS_W BackgroundSubtractorGSOC : public BackgroundSubtractor
+{
+public:
+    // BackgroundSubtractor interface
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
+
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+};
+
+/** @brief Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at @cite LGuo2016
+ */
+class CV_EXPORTS_W BackgroundSubtractorLSBP : public BackgroundSubtractor
+{
+public:
+    // BackgroundSubtractor interface
+    CV_WRAP virtual void apply(InputArray image, OutputArray fgmask, double learningRate=-1) = 0;
+
+    CV_WRAP virtual void getBackgroundImage(OutputArray backgroundImage) const = 0;
+};
+
+/** @brief This is for calculation of the LSBP descriptors.
+ */
+class CV_EXPORTS_W BackgroundSubtractorLSBPDesc
+{
+public:
+    static void calcLocalSVDValues(OutputArray localSVDValues, const Mat& frame);
+
+    static void computeFromLocalSVDValues(OutputArray desc, const Mat& localSVDValues, const Point2i* LSBPSamplePoints);
+
+    static void compute(OutputArray desc, const Mat& frame, const Point2i* LSBPSamplePoints);
+};
+
+/** @brief Creates an instance of BackgroundSubtractorGSOC algorithm.
+
+Implementation of the different yet better algorithm which is called GSOC, as it was implemented during GSOC and was not originated from any paper.
+
+@param mc Whether to use camera motion compensation.
+@param nSamples Number of samples to maintain at each point of the frame.
+@param replaceRate Probability of replacing the old sample - how fast the model will update itself.
+@param propagationRate Probability of propagating to neighbors.
+@param hitsThreshold How many positives the sample must get before it will be considered as a possible replacement.
+@param alpha Scale coefficient for threshold.
+@param beta Bias coefficient for threshold.
+@param blinkingSupressionDecay Blinking supression decay factor.
+@param blinkingSupressionMultiplier Blinking supression multiplier.
+@param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
+@param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
+ */
+CV_EXPORTS_W Ptr<BackgroundSubtractorGSOC> createBackgroundSubtractorGSOC(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, float replaceRate = 0.003f, float propagationRate = 0.01f, int hitsThreshold = 32, float alpha = 0.01f, float beta = 0.0022f, float blinkingSupressionDecay = 0.1f, float blinkingSupressionMultiplier = 0.1f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f);
+
+/** @brief Creates an instance of BackgroundSubtractorLSBP algorithm.
+
+Background Subtraction using Local SVD Binary Pattern. More details about the algorithm can be found at @cite LGuo2016
+
+@param mc Whether to use camera motion compensation.
+@param nSamples Number of samples to maintain at each point of the frame.
+@param LSBPRadius LSBP descriptor radius.
+@param Tlower Lower bound for T-values. See @cite LGuo2016 for details.
+@param Tupper Upper bound for T-values. See @cite LGuo2016 for details.
+@param Tinc Increase step for T-values. See @cite LGuo2016 for details.
+@param Tdec Decrease step for T-values. See @cite LGuo2016 for details.
+@param Rscale Scale coefficient for threshold values.
+@param Rincdec Increase/Decrease step for threshold values.
+@param noiseRemovalThresholdFacBG Strength of the noise removal for background points.
+@param noiseRemovalThresholdFacFG Strength of the noise removal for foreground points.
+@param LSBPthreshold Threshold for LSBP binary string.
+@param minCount Minimal number of matches for sample to be considered as foreground.
+ */
+CV_EXPORTS_W Ptr<BackgroundSubtractorLSBP> createBackgroundSubtractorLSBP(int mc = LSBP_CAMERA_MOTION_COMPENSATION_NONE, int nSamples = 20, int LSBPRadius = 16, float Tlower = 2.0f, float Tupper = 32.0f, float Tinc = 1.0f, float Tdec = 0.05f, float Rscale = 10.0f, float Rincdec = 0.005f, float noiseRemovalThresholdFacBG = 0.0004f, float noiseRemovalThresholdFacFG = 0.0008f, int LSBPthreshold = 8, int minCount = 2);
+
+/** @brief Synthetic frame sequence generator for testing background subtraction algorithms.
+
+ It will generate the moving object on top of the background.
+ It will apply some distortion to the background to make the test more complex.
+ */
+class CV_EXPORTS_W SyntheticSequenceGenerator : public Algorithm
+{
+private:
+    const double amplitude;
+    const double wavelength;
+    const double wavespeed;
+    const double objspeed;
+    unsigned timeStep;
+    Point2d pos;
+    Point2d dir;
+    Mat background;
+    Mat object;
+    RNG rng;
+
+public:
+    /** @brief Creates an instance of SyntheticSequenceGenerator.
+
+    @param background Background image for object.
+    @param object Object image which will move slowly over the background.
+    @param amplitude Amplitude of wave distortion applied to background.
+    @param wavelength Length of waves in distortion applied to background.
+    @param wavespeed How fast waves will move.
+    @param objspeed How fast object will fly over background.
+     */
+    CV_WRAP SyntheticSequenceGenerator(InputArray background, InputArray object, double amplitude, double wavelength, double wavespeed, double objspeed);
+
+    /** @brief Obtain the next frame in the sequence.
+
+    @param frame Output frame.
+    @param gtMask Output ground-truth (reference) segmentation mask object/background.
+     */
+    CV_WRAP void getNextFrame(OutputArray frame, OutputArray gtMask);
+};
+
+/** @brief Creates an instance of SyntheticSequenceGenerator.
+
+@param background Background image for object.
+@param object Object image which will move slowly over the background.
+@param amplitude Amplitude of wave distortion applied to background.
+@param wavelength Length of waves in distortion applied to background.
+@param wavespeed How fast waves will move.
+@param objspeed How fast object will fly over background.
+ */
+CV_EXPORTS_W Ptr<SyntheticSequenceGenerator> createSyntheticSequenceGenerator(InputArray background, InputArray object, double amplitude = 2.0, double wavelength = 20.0, double wavespeed = 0.2, double objspeed = 6.0);
+
 //! @}
 
 }

modules/bgsegm/samples/evaluation.py

@@ -0,0 +1,134 @@
+import argparse
+import cv2
+import glob
+import numpy as np
+import os
+import time
+
+
+# This tool is intended for evaluation of different background subtraction algorithms presented in OpenCV.
+# Several presets with different settings are available. You can see them below.
+# This tool measures quality metrics as well as speed.
+
+
+ALGORITHMS_TO_EVALUATE = [
+    (cv2.bgsegm.createBackgroundSubtractorMOG, 'MOG', {}),
+    (cv2.bgsegm.createBackgroundSubtractorGMG, 'GMG', {}),
+    (cv2.bgsegm.createBackgroundSubtractorCNT, 'CNT', {}),
+    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-vanilla', {'nSamples': 20, 'LSBPRadius': 4, 'Tlower': 2.0, 'Tupper': 200.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 5.0, 'Rincdec': 0.05, 'LSBPthreshold': 8}),
+    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-speed', {'nSamples': 10, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
+    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-quality', {'nSamples': 20, 'LSBPRadius': 16, 'Tlower': 2.0, 'Tupper': 32.0, 'Tinc': 1.0, 'Tdec': 0.05, 'Rscale': 10.0, 'Rincdec': 0.005, 'LSBPthreshold': 8}),
+    (cv2.bgsegm.createBackgroundSubtractorLSBP, 'LSBP-camera-motion-compensation', {'mc': 1}),
+    (cv2.bgsegm.createBackgroundSubtractorGSOC, 'GSOC', {}),
+    (cv2.bgsegm.createBackgroundSubtractorGSOC, 'GSOC-camera-motion-compensation', {'mc': 1})
+]
+
+
+def contains_relevant_files(root):
+    return os.path.isdir(os.path.join(root, 'groundtruth')) and os.path.isdir(os.path.join(root, 'input'))
+
+
+def find_relevant_dirs(root):
+    relevant_dirs = []
+    for d in sorted(os.listdir(root)):
+        d = os.path.join(root, d)
+        if os.path.isdir(d):
+            if contains_relevant_files(d):
+                relevant_dirs += [d]
+            else:
+                relevant_dirs += find_relevant_dirs(d)
+    return relevant_dirs
+
+
+def load_sequence(root):
+    gt_dir, frames_dir = os.path.join(root, 'groundtruth'), os.path.join(root, 'input')
+    gt = sorted(glob.glob(os.path.join(gt_dir, '*.png')))
+    f = sorted(glob.glob(os.path.join(frames_dir, '*.jpg')))
+    assert(len(gt) == len(f))
+    return gt, f
+
+
+def evaluate_algorithm(gt, frames, algo, algo_arguments):
+    bgs = algo(**algo_arguments)
+    mask = []
+    t_start = time.time()
+
+    for i in range(len(gt)):
+        frame = np.uint8(cv2.imread(frames[i], cv2.IMREAD_COLOR))
+        mask.append(bgs.apply(frame))
+
+    average_duration = (time.time() - t_start) / len(gt)
+    average_precision, average_recall, average_f1, average_accuracy = [], [], [], []
+
+    for i in range(len(gt)):
+        gt_mask = np.uint8(cv2.imread(gt[i], cv2.IMREAD_GRAYSCALE))
+        roi = ((gt_mask == 255) | (gt_mask == 0))
+        if roi.sum() > 0:
+            gt_answer, answer = gt_mask[roi], mask[i][roi]
+
+            tp = ((answer == 255) & (gt_answer == 255)).sum()
+            tn = ((answer == 0) & (gt_answer == 0)).sum()
+            fp = ((answer == 255) & (gt_answer == 0)).sum()
+            fn = ((answer == 0) & (gt_answer == 255)).sum()
+
+            if tp + fp > 0:
+                average_precision.append(float(tp) / (tp + fp))
+            if tp + fn > 0:
+                average_recall.append(float(tp) / (tp + fn))
+            if tp + fn + fp > 0:
+                average_f1.append(2.0 * tp / (2.0 * tp + fn + fp))
+            average_accuracy.append(float(tp + tn) / (tp + tn + fp + fn))
+
+    return average_duration, np.mean(average_precision), np.mean(average_recall), np.mean(average_f1), np.mean(average_accuracy)
+
+
+def evaluate_on_sequence(seq, summary):
+    gt, frames = load_sequence(seq)
+    category, video_name = os.path.basename(os.path.dirname(seq)), os.path.basename(seq)
+    print('=== %s:%s ===' % (category, video_name))
+
+    for algo, algo_name, algo_arguments in ALGORITHMS_TO_EVALUATE:
+        print('Algorithm name: %s' % algo_name)
+        sec_per_step, precision, recall, f1, accuracy = evaluate_algorithm(gt, frames, algo, algo_arguments)
+        print('Average accuracy: %.3f' % accuracy)
+        print('Average precision: %.3f' % precision)
+        print('Average recall: %.3f' % recall)
+        print('Average F1: %.3f' % f1)
+        print('Average sec. per step: %.4f' % sec_per_step)
+        print('')
+
+        if category not in summary:
+            summary[category] = {}
+        if algo_name not in summary[category]:
+            summary[category][algo_name] = []
+        summary[category][algo_name].append((precision, recall, f1, accuracy))
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate all background subtractors using Change Detection 2014 dataset')
+    parser.add_argument('--dataset_path', help='Path to the directory with dataset. It may contain multiple inner directories. It will be scanned recursively.', required=True)
+    parser.add_argument('--algorithm', help='Test particular algorithm instead of all.')
+
+    args = parser.parse_args()
+    dataset_dirs = find_relevant_dirs(args.dataset_path)
+    assert len(dataset_dirs) > 0, ("Passed directory must contain at least one sequence from the Change Detection dataset. There is no relevant directories in %s. Check that this directory is correct." % (args.dataset_path))
+    if args.algorithm is not None:
+        global ALGORITHMS_TO_EVALUATE
+        ALGORITHMS_TO_EVALUATE = filter(lambda a: a[1].lower() == args.algorithm.lower(), ALGORITHMS_TO_EVALUATE)
+    summary = {}
+
+    for seq in dataset_dirs:
+        evaluate_on_sequence(seq, summary)
+
+    for category in summary:
+        for algo_name in summary[category]:
+            summary[category][algo_name] = np.mean(summary[category][algo_name], axis=0)
+
+    for category in summary:
+        print('=== SUMMARY for %s (Precision, Recall, F1, Accuracy) ===' % category)
+        for algo_name in summary[category]:
+            print('%05s: %.3f %.3f %.3f %.3f' % ((algo_name,) + tuple(summary[category][algo_name])))
+
+
+if __name__ == '__main__':
+    main()

modules/bgsegm/samples/viz.py

@@ -0,0 +1,41 @@
+import numpy as np
+import cv2
+import argparse
+import os
+
+
+def main():
+    argparser = argparse.ArgumentParser(description='Vizualization of the LSBP/GSOC background subtraction algorithm.')
+
+    argparser.add_argument('-g', '--gt', help='Directory with ground-truth frames', required=True)
+    argparser.add_argument('-f', '--frames', help='Directory with input frames', required=True)
+    argparser.add_argument('-l', '--lsbp', help='Display LSBP instead of GSOC', default=False)
+    args = argparser.parse_args()
+
+    gt = map(lambda x: os.path.join(args.gt, x), os.listdir(args.gt))
+    gt.sort()
+    f = map(lambda x: os.path.join(args.frames, x), os.listdir(args.frames))
+    f.sort()
+
+    gt = np.uint8(map(lambda x: cv2.imread(x, cv2.IMREAD_GRAYSCALE), gt))
+    f = np.uint8(map(lambda x: cv2.imread(x, cv2.IMREAD_COLOR), f))
+
+    if not args.lsbp:
+        bgs = cv2.bgsegm.createBackgroundSubtractorGSOC()
+    else:
+        bgs = cv2.bgsegm.createBackgroundSubtractorLSBP()
+
+    for i in xrange(f.shape[0]):
+        cv2.imshow('Frame', f[i])
+        cv2.imshow('Ground-truth', gt[i])
+        mask = bgs.apply(f[i])
+        bg = bgs.getBackgroundImage()
+        cv2.imshow('BG', bg)
+        cv2.imshow('Output mask', mask)
+        k = cv2.waitKey(0)
+        if k == 27:
+            break
+
+
+if __name__ == '__main__':
+    main()

modules/bgsegm/samples/viz_synthetic_seq.py

@@ -0,0 +1,26 @@
+import cv2
+import argparse
+
+
+def main():
+    argparser = argparse.ArgumentParser(description='Vizualization of the SyntheticSequenceGenerator.')
+
+    argparser.add_argument('-b', '--background', help='Background image.', required=True)
+    argparser.add_argument('-o', '--obj', help='Object image. It must be strictly smaller than background.', required=True)
+    args = argparser.parse_args()
+
+    bg = cv2.imread(args.background)
+    obj = cv2.imread(args.obj)
+    generator = cv2.bgsegm.createSyntheticSequenceGenerator(bg, obj)
+
+    while True:
+        frame, mask = generator.getNextFrame()
+        cv2.imshow('Generated frame', frame)
+        cv2.imshow('Generated mask', mask)
+        k = cv2.waitKey(int(1000.0 / 30))
+        if k == 27:
+            break
+
+
+if __name__ == '__main__':
+    main()