mirror
/
av
mirror of https://bitbucket.org/ausocean/av.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merged in time-filter (pull request #379) 

filter: time based motion filter

Approved-by: Saxon Milton <saxon.milton@gmail.com>
This commit is contained in:
Scott Barnard 2020-02-17 00:04:13 +00:00 committed by Saxon Milton
parent e312bca992 57b3f53bf3
commit 24a4654f6b
6 changed files with 225 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
filter/difference.go → filter/diff.go
View File

@ -11,7 +11,7 @@ AUTHORS
Scott Barnard <scott@ausocean.org>
LICENSE
difference.go is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
diff.go is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
It is free software: you can redistribute it and/or modify them
under the terms of the GNU General Public License as published by the
@ -39,65 +39,54 @@ import (
const defaultDiffThreshold = 3
// Diff is a filter that provides basic motion detection. Difference calculates
// the absolute difference for each pixel between two frames, then finds the mean. If
// the mean is above a given threshold, then it is considered motion.
type Diff struct {
debugging debugWindows
dst io.WriteCloser
thresh float64
prev gocv.Mat
}
// NewDiff returns a pointer to a new difference motion filter.
func NewDiff(dst io.WriteCloser, c config.Config) *Motion {
// NewDiff returns a pointer to a new Diff struct.
func NewDiff(dst io.WriteCloser, c config.Config) *Diff {
// Validate parameters.
if c.MotionThreshold <= 0 {
c.LogInvalidField("MotionThreshold", defaultDiffThreshold)
c.MotionThreshold = defaultDiffThreshold
}
return &Diff{
dst: dst,
alg := &Diff{
thresh: c.MotionThreshold,
prev: gocv.NewMat(),
debugging: newWindows("DIFF"),
}
return NewMotion(dst, alg, c)
}
// Implements io.Closer.
// Close frees resources used by gocv, because it has to be done manually, due to
// it using c-go.
// Diff is a motion detection algorithm. It calculates the absolute
// difference for each pixel between two frames, then finds the mean.
// If the mean is above a given threshold, it is considered motion.
type Diff struct {
debugging debugWindows
thresh float64
prev gocv.Mat
}
// Close frees resources used by gocv. It has to be done manually,
// due to gocv using c-go.
func (d *Diff) Close() error {
d.prev.Close()
d.debugging.close()
d.prev.Close()
return nil
}
// Implements io.Writer.
// Write applies the motion filter to the video stream. Only frames with motion
// are written to the destination encoder, frames without are discarded.
func (d *Diff) Write(f []byte) (int, error) {
// Detect performs the motion detection on a frame. It returns true
// if motion is detected.
func (d *Diff) Detect(img *gocv.Mat) bool {
if d.prev.Empty() {
var err error
d.prev, err = gocv.IMDecode(f, gocv.IMReadColor)
if err != nil {
return 0, err
}
return len(f), nil
}
img, err := gocv.IMDecode(f, gocv.IMReadColor)
defer img.Close()
if err != nil {
return 0, err
d.prev = img.Clone()
return false
}
imgDelta := gocv.NewMat()
defer imgDelta.Close()
// Seperate foreground and background.
gocv.AbsDiff(img, d.prev, &imgDelta)
gocv.AbsDiff(*img, d.prev, &imgDelta)
gocv.CvtColor(imgDelta, &imgDelta, gocv.ColorBGRToGray)
mean := imgDelta.Mean().Val1
@ -106,13 +95,8 @@ func (d *Diff) Write(f []byte) (int, error) {
d.prev = img.Clone()
// Draw debug information.
d.debugging.show(img, imgDelta, mean > d.thresh, nil, fmt.Sprintf("Mean: %f", mean), fmt.Sprintf("Threshold: %f", d.thresh))
d.debugging.show(*img, imgDelta, mean > d.thresh, nil, fmt.Sprintf("Mean: %f", mean), fmt.Sprintf("Threshold: %f", d.thresh))
// Don't write to destination if there is no motion.
if mean < d.thresh {
return len(f), nil
}
// Write to destination.
return d.dst.Write(f)
// Return if there is motion.
return mean > d.thresh
}

105
filter/knn.go
View File

@ -29,7 +29,6 @@ LICENSE
package filter
import (
"fmt"
"image"
"io"
@ -38,30 +37,15 @@ import (
)
const (
defaultKNNMinArea = 25.0
defaultKNNThreshold = 300
defaultKNNHistory = 300
defaultKNNKernel = 4
defaultKNNDownscaling = 2
defaultKNNInterval = 1
defaultKNNMinArea = 25.0
defaultKNNThreshold = 300
defaultKNNHistory = 300
defaultKNNKernel = 4
)
// KNN is a filter that provides basic motion detection. KNN is short for
// K-Nearest Neighbours method.
type KNN struct {
debugging debugWindows
dst io.WriteCloser // Destination to which motion containing frames go.
area float64 // The minimum area that a contour can be found in.
bs *gocv.BackgroundSubtractorKNN // Uses the KNN algorithm to find the difference between the current and background frame.
knl gocv.Mat // Matrix that is used for calculations.
hold [][]byte // Will hold all frames up to hf (so only every hf frame is motion detected).
hf int // The number of frames to be held.
hfCount int // Counter for the hold array.
scale float64 // The factor that frames will be downscaled by for motion detection.
}
// NewKNN returns a pointer to a new KNN motion filter.
func NewKNN(dst io.WriteCloser, c config.Config) *Motion {
// NewKNN returns a pointer to a new KNN filter struct.
func NewKNN(dst io.WriteCloser, c config.Config) *KNN {
// Validate parameters.
if c.MotionMinArea <= 0 {
c.LogInvalidField("MotionMinArea", defaultKNNMinArea)
@ -75,37 +59,33 @@ func NewKNN(dst io.WriteCloser, c config.Config) *KNN {
c.LogInvalidField("MotionHistory", defaultKNNHistory)
c.MotionHistory = defaultKNNHistory
}
if c.MotionDownscaling <= 0 {
c.LogInvalidField("MotionDownscaling", defaultKNNDownscaling)
c.MotionDownscaling = defaultKNNDownscaling
}
if c.MotionInterval <= 0 {
c.LogInvalidField("MotionInterval", defaultKNNInterval)
c.MotionInterval = defaultKNNInterval
}
if c.MotionKernel <= 0 {
c.LogInvalidField("MotionKernel", defaultKNNKernel)
c.MotionKernel = defaultKNNKernel
}
bs := gocv.NewBackgroundSubtractorKNNWithParams(int(c.MotionHistory), c.MotionThreshold, false)
k := gocv.GetStructuringElement(gocv.MorphRect, image.Pt(int(c.MotionKernel), int(c.MotionKernel)))
return &KNN{
dst: dst,
alg := &KNN{
area: c.MotionMinArea,
bs: &bs,
knl: k,
hold: make([][]byte, c.MotionInterval-1),
hf: c.MotionInterval,
scale: 1 / float64(c.MotionDownscaling),
knl: gocv.GetStructuringElement(gocv.MorphRect, image.Pt(int(c.MotionKernel), int(c.MotionKernel))),
debugging: newWindows("KNN"),
}
return NewMotion(dst, alg, c)
}
// Implements io.Closer.
// Close frees resources used by gocv, because it has to be done manually, due to
// it using c-go.
// KNN is motion detection algorithm. KNN is short for
// K-Nearest Neighbours method.
type KNN struct {
debugging debugWindows
area float64 // The minimum area that a contour can be found in.
bs *gocv.BackgroundSubtractorKNN // Uses the KNN algorithm to find the difference between the current and background frame.
knl gocv.Mat // Matrix that is used for calculations.
}
// Close frees resources used by gocv. It has to be done manually,
// due to gocv using c-go.
func (m *KNN) Close() error {
m.bs.Close()
m.knl.Close()
@ -113,31 +93,14 @@ func (m *KNN) Close() error {
return nil
}
// Implements io.Writer.
// Write applies the motion filter to the video stream. Only frames with motion
// are written to the destination encoder, frames without are discarded.
func (m *KNN) Write(f []byte) (int, error) {
if m.hfCount < (m.hf - 1) {
m.hold[m.hfCount] = f
m.hfCount++
return len(f), nil
}
m.hfCount = 0
img, err := gocv.IMDecode(f, gocv.IMReadColor)
if err != nil {
return 0, fmt.Errorf("can't decode image: %w", err)
}
defer img.Close()
// Detect performs the motion detection on a frame. It returns true
// if motion is detected.
func (m *KNN) Detect(img *gocv.Mat) bool {
imgDelta := gocv.NewMat()
defer imgDelta.Close()
// Downsize image to speed up calculations.
gocv.Resize(img, &img, image.Point{}, m.scale, m.scale, gocv.InterpolationNearestNeighbor)
// Seperate foreground and background.
m.bs.Apply(img, &imgDelta)
m.bs.Apply(*img, &imgDelta)
// Threshold imgDelta.
gocv.Threshold(imgDelta, &imgDelta, 25, 255, gocv.ThresholdBinary)
@ -160,20 +123,8 @@ func (m *KNN) Write(f []byte) (int, error) {
}
// Draw debug information.
m.debugging.show(img, imgDelta, len(contours) > 0, &contours)
m.debugging.show(*img, imgDelta, len(contours) > 0, &contours)
// Don't write to destination if there is no motion.
if len(contours) == 0 {
return len(f), nil
}
// Write to destination, past 4 frames then current frame.
for i, h := range m.hold {
_, err := m.dst.Write(h)
m.hold[i] = nil
if err != nil {
return len(f), fmt.Errorf("could not write previous frames: %w", err)
}
}
return m.dst.Write(f)
// Return if there is motion.
return len(contours) > 0
}

106
filter/mog.go
View File

@ -3,7 +3,7 @@
/*
DESCRIPTION
A filter that detects motion and discards frames without motion. The
filter uses a Mixture of Gaussians method (MoG) to determine what is
algorithm uses a Mixture of Gaussians method (MoG) to determine what is
background and what is foreground.
AUTHORS
@ -29,7 +29,6 @@ LICENSE
package filter
import (
"fmt"
"image"
"io"
@ -38,30 +37,15 @@ import (
)
const (
defaultMOGMinArea = 25.0
defaultMOGThreshold = 20.0
defaultMOGHistory = 500
defaultMOGKernel = 3
defaultMOGDownscaling = 2
defaultMOGInterval = 1
defaultMOGMinArea = 25.0
defaultMOGThreshold = 20.0
defaultMOGHistory = 500
defaultMOGKernel = 3
)
// MOG is a filter that provides basic motion detection. MoG is short for
// Mixture of Gaussians method.
type MOG struct {
debugging debugWindows
dst io.WriteCloser // Destination to which motion containing frames go.
area float64 // The minimum area that a contour can be found in.
bs *gocv.BackgroundSubtractorMOG2 // Uses the MOG algorithm to find the difference between the current and background frame.
knl gocv.Mat // Matrix that is used for calculations.
hold [][]byte // Will hold all frames up to hf (so only every hf frame is motion detected).
hf int // The number of frames to be held.
hfCount int // Counter for the hold array.
scale float64 // The factor that frames will be downscaled by for motion detection.
}
// NewMOG returns a pointer to a new MOG motion filter.
func NewMOG(dst io.WriteCloser, c config.Config) *Motion {
// NewMOG returns a pointer to a new MOG filter struct.
func NewMOG(dst io.WriteCloser, c config.Config) *MOG {
// Validate parameters.
if c.MotionMinArea <= 0 {
c.LogInvalidField("MotionMinArea", defaultMOGMinArea)
@ -75,36 +59,33 @@ func NewMOG(dst io.WriteCloser, c config.Config) *MOG {
c.LogInvalidField("MotionHistory", defaultMOGHistory)
c.MotionHistory = defaultMOGHistory
}
if c.MotionDownscaling <= 0 {
c.LogInvalidField("MotionDownscaling", defaultMOGDownscaling)
c.MotionDownscaling = defaultMOGDownscaling
}
if c.MotionInterval <= 0 {
c.LogInvalidField("MotionInterval", defaultMOGInterval)
c.MotionInterval = defaultMOGInterval
}
if c.MotionKernel <= 0 {
c.LogInvalidField("MotionKernel", defaultMOGKernel)
c.MotionKernel = defaultMOGKernel
}
bs := gocv.NewBackgroundSubtractorMOG2WithParams(int(c.MotionHistory), c.MotionThreshold, false)
k := gocv.GetStructuringElement(gocv.MorphRect, image.Pt(3, 3))
return &MOG{
dst: dst,
alg := &MOG{
area: c.MotionMinArea,
bs: &bs,
knl: k,
hold: make([][]byte, c.MotionInterval-1),
hf: c.MotionInterval,
scale: 1 / float64(c.MotionDownscaling),
knl: gocv.GetStructuringElement(gocv.MorphRect, image.Pt(3, 3)),
debugging: newWindows("MOG"),
}
return NewMotion(dst, alg, c)
}
// Implements io.Closer.
// Close frees resources used by gocv, because it has to be done manually, due to
// it using c-go.
// MOG is a motion detection algorithm. MoG is short for
// Mixture of Gaussians method.
type MOG struct {
debugging debugWindows
area float64 // The minimum area that a contour can be found in.
bs *gocv.BackgroundSubtractorMOG2 // Uses the MOG algorithm to find the difference between the current and background frame.
knl gocv.Mat // Matrix that is used for calculations.
}
// Close frees resources used by gocv. It has to be done manually,
// due to gocv using c-go.
func (m *MOG) Close() error {
m.bs.Close()
m.knl.Close()
@ -112,31 +93,14 @@ func (m *MOG) Close() error {
return nil
}
// Implements io.Writer.
// Write applies the motion filter to the video stream. Only frames with motion
// are written to the destination encoder, frames without are discarded.
func (m *MOG) Write(f []byte) (int, error) {
if m.hfCount < (m.hf - 1) {
m.hold[m.hfCount] = f
m.hfCount++
return len(f), nil
}
m.hfCount = 0
img, err := gocv.IMDecode(f, gocv.IMReadColor)
if err != nil {
return 0, fmt.Errorf("image can't be decoded: %w", err)
}
defer img.Close()
// Detect performs the motion detection on a frame. It returns true
// if motion is detected.
func (m *MOG) Detect(img *gocv.Mat) bool {
imgDelta := gocv.NewMat()
defer imgDelta.Close()
// Downsize image to speed up calculations.
gocv.Resize(img, &img, image.Point{}, m.scale, m.scale, gocv.InterpolationNearestNeighbor)
// Seperate foreground and background.
m.bs.Apply(img, &imgDelta)
m.bs.Apply(*img, &imgDelta)
// Threshold imgDelta.
gocv.Threshold(imgDelta, &imgDelta, 25, 255, gocv.ThresholdBinary)
@ -159,20 +123,8 @@ func (m *MOG) Write(f []byte) (int, error) {
}
// Draw debug information.
m.debugging.show(img, imgDelta, len(contours) > 0, &contours)
m.debugging.show(*img, imgDelta, len(contours) > 0, &contours)
// Don't write to destination if there is no motion.
if len(contours) == 0 {
return len(f), nil
}
// Write to destination, past 4 frames then current frame.
for i, h := range m.hold {
_, err := m.dst.Write(h)
m.hold[i] = nil
if err != nil {
return len(f), fmt.Errorf("could not write previous frames: %w", err)
}
}
return m.dst.Write(f)
// Return if there is motion.
return len(contours) > 0
}

132
filter/motion.go Normal file
View File

@ -0,0 +1,132 @@
// +build !circleci
/*
DESCRIPTION
A filter that detects motion and discards frames without motion. This
filter can use different algorithms for motion detection.
AUTHORS
Scott Barnard <scott@ausocean.org>
LICENSE
motion.go is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)
It is free software: you can redistribute it and/or modify them
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
It is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
in gpl.txt. If not, see http://www.gnu.org/licenses.
*/
package filter
import (
"fmt"
"image"
"io"
"bitbucket.org/ausocean/av/revid/config"
"gocv.io/x/gocv"
)
const (
defaultMotionDownscaling = 1
defaultMotionInterval = 5
defaultMotionPadding = 10
)
// MotionAlgorithm is the interface the motion filter expects for
// motion detection algorithms.
type MotionAlgorithm interface {
Detect(img *gocv.Mat) bool
Close() error
}
// Motion is a filter that performs motion detection using a supplied
// motion detection algorithm.
type Motion struct {
dst io.WriteCloser // Destination to which motion containing frames go.
algorithm MotionAlgorithm // Algorithm to use for motion detection.
scale float64 // The factor that frames will be downscaled by for motion detection.
sample uint // Interval that motion detection is performed at.
padding uint // The amount of frames before and after motion that will be kept.
t uint // Frame counter.
send uint // Amount of frames to send.
frames chan []byte // Used for storing frames.
}
// NewMotion returns a pointer to a new Motion filter struct.
func NewMotion(dst io.WriteCloser, alg MotionAlgorithm, c config.Config) *Motion {
// Validate parameters.
if c.MotionPadding == 0 {
c.LogInvalidField("MotionPadding", defaultMotionPadding)
c.MotionPadding = defaultMotionPadding
}
if c.MotionDownscaling <= 0 {
c.LogInvalidField("MotionDownscaling", defaultMotionDownscaling)
c.MotionDownscaling = defaultMotionDownscaling
}
if c.MotionInterval <= 0 {
c.LogInvalidField("MotionInterval", defaultMotionInterval)
c.MotionInterval = defaultMotionInterval
}
return &Motion{
dst: dst,
algorithm: alg,
scale: 1 / float64(c.MotionDownscaling),
sample: uint(c.MotionInterval),
padding: c.MotionPadding,
frames: make(chan []byte, c.MotionInterval+int(c.MotionPadding)),
}
}
// Implements io.Closer.
// Close frees resources used by gocv, because it has to be done manually, due to
// it using c-go.
func (m *Motion) Close() error {
return m.algorithm.Close()
}
// Write applies the motion filter to the video stream. Only frames with motion
// are written to the destination encoder, frames without are discarded.
func (m *Motion) Write(f []byte) (int, error) {
// Decode image into Mat.
img, err := gocv.IMDecode(f, gocv.IMReadColor)
if err != nil {
return 0, fmt.Errorf("image can't be decoded: %w", err)
}
defer img.Close()
// Downsize image to speed up calculations.
gocv.Resize(img, &img, image.Point{}, m.scale, m.scale, gocv.InterpolationNearestNeighbor)
// Filter on an interval.
if m.t == m.sample/2 {
if m.algorithm.Detect(&img) {
m.send = m.sample + 2*m.padding - 1
}
}
m.t = (m.t + 1) % m.sample // Increment counter.
// Send frames.
m.frames <- f // Put current frame into buffer.
toSend := <-m.frames // Get oldest frame out of circular buffer.
if m.send > 0 {
m.send--
return m.dst.Write(toSend)
}
return len(f), nil
}

2
revid/config/config.go
View File

@ -276,6 +276,7 @@ type Config struct {
MotionHistory uint // Length of filter's history (KNN & MOG only).
MotionKernel uint // Size of kernel used for filling holes and removing noise (KNN only).
MotionPixels int // Number of pixels with motion that is needed for a whole frame to be considered as moving (Basic only).
MotionPadding uint // Number of frames to keep before and after motion detected.
// If true will restart reading of input after an io.EOF.
Loop bool
@ -315,6 +316,7 @@ var TypeData = map[string]string{
"MotionInterval": "int",
"MotionKernel": "uint",
"MotionMinArea": "float",
"MotionPadding": "uint",
"MotionPixels": "int",
"MotionThreshold": "float",
"Output": "enum:File,Http,Rtmp,Rtp",

7
revid/revid.go
View File

@ -821,6 +821,13 @@ func (r *Revid) Update(vars map[string]string) error {
break
}
r.cfg.MotionHistory = uint(v)
case "MotionPadding":
v, err := strconv.Atoi(value)
if err != nil || v <= 0 {
r.cfg.Logger.Log(logger.Warning, pkg+"invalid MotionPadding var", "value", value)
break
}
r.cfg.MotionPadding = uint(v)
case "MotionPixels":
v, err := strconv.Atoi(value)
if err != nil {