Package org.opencv.bgsegm

## Class BackgroundSubtractorCNT

- java.lang.Object
- - org.opencv.core.Algorithm
  - - org.opencv.video.BackgroundSubtractor
    - - org.opencv.bgsegm.BackgroundSubtractorCNT

-     public class BackgroundSubtractorCNT
      extends BackgroundSubtractor

  Background subtraction based on counting. About as fast as MOG2 on a high end system. More than twice faster than MOG2 on cheap hardware (benchmarked on Raspberry Pi3). %Algorithm by Sagi Zeevi ( https://github.com/sagi-z/BackgroundSubtractorCNT )

- - ### Field Summary

    - ### Fields inherited from class org.opencv.core.Algorithm

      `nativeObj`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `BackgroundSubtractorCNT​(long addr)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static BackgroundSubtractorCNT` | `__fromPtr__​(long addr)` |
    `void` | `apply​(Mat image, Mat fgmask)` | Computes a foreground mask.
    `void` | `apply​(Mat image, Mat fgmask, double learningRate)` | Computes a foreground mask.
    `protected void` | `finalize()` |
    `void` | `getBackgroundImage​(Mat backgroundImage)` | Computes a background image.
    `boolean` | `getIsParallel()` | Returns if we're parallelizing the algorithm.
    `int` | `getMaxPixelStability()` | Returns maximum allowed credit for a pixel in history.
    `int` | `getMinPixelStability()` | Returns number of frames with same pixel color to consider stable.
    `boolean` | `getUseHistory()` | Returns if we're giving a pixel credit for being stable for a long time.
    `void` | `setIsParallel​(boolean value)` | Sets if we're parallelizing the algorithm.
    `void` | `setMaxPixelStability​(int value)` | Sets the maximum allowed credit for a pixel in history.
    `void` | `setMinPixelStability​(int value)` | Sets the number of frames with same pixel color to consider stable.
    `void` | `setUseHistory​(boolean value)` | Sets if we're giving a pixel credit for being stable for a long time.

    - ### Methods inherited from class org.opencv.core.Algorithm

      `clear, empty, getDefaultName, getNativeObjAddr, save`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### BackgroundSubtractorCNT

          protected BackgroundSubtractorCNT​(long addr)

  - ### Method Detail

    - #### __fromPtr__

          public static BackgroundSubtractorCNT __fromPtr__​(long addr)

    - #### getIsParallel

          public boolean getIsParallel()

      Returns if we're parallelizing the algorithm.
      Returns:
        automatically generated

    - #### getUseHistory

          public boolean getUseHistory()

      Returns if we're giving a pixel credit for being stable for a long time.
      Returns:
        automatically generated

    - #### getMaxPixelStability

          public int getMaxPixelStability()

      Returns maximum allowed credit for a pixel in history.
      Returns:
        automatically generated

    - #### getMinPixelStability

          public int getMinPixelStability()

      Returns number of frames with same pixel color to consider stable.
      Returns:
        automatically generated

    - #### apply

          public void apply​(Mat image,
                            Mat fgmask,
                            double learningRate)

      Description copied from class: `BackgroundSubtractor`
      Computes a foreground mask.
      Overrides:
        `apply` in class `BackgroundSubtractor`
      Parameters:
        `image` - Next video frame.
        `fgmask` - The output foreground mask as an 8-bit binary image.
        `learningRate` - The value between 0 and 1 that indicates how fast the background model is learnt. Negative parameter value makes the algorithm to use some automatically chosen learning rate. 0 means that the background model is not updated at all, 1 means that the background model is completely reinitialized from the last frame.

    - #### apply

          public void apply​(Mat image,
                            Mat fgmask)

      Description copied from class: `BackgroundSubtractor`
      Computes a foreground mask.
      Overrides:
        `apply` in class `BackgroundSubtractor`
      Parameters:
        `image` - Next video frame.
        `fgmask` - The output foreground mask as an 8-bit binary image. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning rate. 0 means that the background model is not updated at all, 1 means that the background model is completely reinitialized from the last frame.

    - #### getBackgroundImage

          public void getBackgroundImage​(Mat backgroundImage)

      Description copied from class: `BackgroundSubtractor`
      Computes a background image.
      Overrides:
        `getBackgroundImage` in class `BackgroundSubtractor`
      Parameters:
        `backgroundImage` - The output background image. Note: Sometimes the background image can be very blurry, as it contain the average background statistics.

    - #### setIsParallel

          public void setIsParallel​(boolean value)

      Sets if we're parallelizing the algorithm.
      Parameters:
        `value` - automatically generated

    - #### setMaxPixelStability

          public void setMaxPixelStability​(int value)

      Sets the maximum allowed credit for a pixel in history.
      Parameters:
        `value` - automatically generated

    - #### setMinPixelStability

          public void setMinPixelStability​(int value)

      Sets the number of frames with same pixel color to consider stable.
      Parameters:
        `value` - automatically generated

    - #### setUseHistory

          public void setUseHistory​(boolean value)

      Sets if we're giving a pixel credit for being stable for a long time.
      Parameters:
        `value` - automatically generated

    - #### finalize

          protected void finalize()
                           throws java.lang.Throwable

      Overrides:
        `finalize` in class `BackgroundSubtractor`
      Throws:
        `java.lang.Throwable`