Merged in knn (pull request #316)

KNN filter

Approved-by: Saxon Milton <saxon.milton@gmail.com>

filter/filters_circleci.go

@@ -35,3 +35,7 @@ import (
 func NewMOGFilter(dst io.WriteCloser, area, threshold float64, history, kernelSize int, debug bool) *NoOp {
 	return &NoOp{dst: dst}
 }
+
+func NewKNNFilter(dst io.WriteCloser, area, threshold float64, history, kernelSize int, debug bool) *NoOp {
+	return &NoOp{dst: dst}
+}

filter/knn.go

@@ -0,0 +1,133 @@
+// +build !circleci
+
+/*
+DESCRIPTION
+  A filter that detects motion and discards frames without motion. The
+  filter uses a K-Nearest Neighbours (KNN) to determine what is
+  background and what is foreground.
+
+AUTHORS
+  Ella Pietraroia <ella@ausocean.org>
+
+LICENSE
+  KNN.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"
+	"image/color"
+	"io"
+
+	"gocv.io/x/gocv"
+)
+
+// KNNFilter is a filter that provides basic motion detection. KNN is short for
+// K-Nearest Neighbours method.
+type KNNFilter struct {
+	dst     io.WriteCloser
+	area    float64
+	bs      *gocv.BackgroundSubtractorKNN
+	knl     gocv.Mat
+	debug   bool
+	windows []*gocv.Window
+}
+
+// NewKNNFilter returns a pointer to a new KNNFilter.
+func NewKNNFilter(dst io.WriteCloser, area, threshold float64, history, kernelSize int, debug bool) *KNNFilter {
+	bs := gocv.NewBackgroundSubtractorKNNWithParams(history, threshold, false)
+	k := gocv.GetStructuringElement(gocv.MorphRect, image.Pt(kernelSize, kernelSize))
+	var windows []*gocv.Window
+	if debug {
+		windows = []*gocv.Window{gocv.NewWindow("Debug: Bounding boxes"), gocv.NewWindow("Debug: Motion")}
+	}
+	return &KNNFilter{dst, area, &bs, k, debug, windows}
+}
+
+// Implements io.Closer.
+// Close frees resources used by gocv, because it has to be done manually, due to
+// it using c-go.
+func (m *KNNFilter) Close() error {
+	m.bs.Close()
+	m.knl.Close()
+	for _, window := range m.windows {
+		window.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 (m *KNNFilter) Write(f []byte) (int, error) {
+	img, err := gocv.IMDecode(f, gocv.IMReadColor)
+	if err != nil {
+		return 0, fmt.Errorf("can't decode image: %w", err)
+	}
+	defer img.Close()
+
+	imgDelta := gocv.NewMat()
+	defer imgDelta.Close()
+
+	// Seperate foreground and background.
+	m.bs.Apply(img, &imgDelta)
+
+	// Threshold imgDelta.
+	gocv.Threshold(imgDelta, &imgDelta, 25, 255, gocv.ThresholdBinary)
+
+	// Remove noise.
+	gocv.Erode(imgDelta, &imgDelta, m.knl)
+	gocv.Dilate(imgDelta, &imgDelta, m.knl)
+
+	// Fill small holes.
+	gocv.Dilate(imgDelta, &imgDelta, m.knl)
+	gocv.Erode(imgDelta, &imgDelta, m.knl)
+
+	// Find contours and reject ones with a small area.
+	var contours [][]image.Point
+	allContours := gocv.FindContours(imgDelta, gocv.RetrievalExternal, gocv.ChainApproxSimple)
+	for _, c := range allContours {
+		if gocv.ContourArea(c) > m.area {
+			contours = append(contours, c)
+		}
+	}
+
+	// Draw debug information.
+	if m.debug {
+		for _, c := range contours {
+			rect := gocv.BoundingRect(c)
+			gocv.Rectangle(&img, rect, color.RGBA{0, 0, 255, 0}, 1)
+		}
+
+		if len(contours) > 0 {
+			gocv.PutText(&img, "Motion", image.Pt(32, 32), gocv.FontHersheyPlain, 2.0, color.RGBA{255, 0, 0, 0}, 2)
+		}
+
+		m.windows[0].IMShow(img)
+		m.windows[1].IMShow(imgDelta)
+		m.windows[0].WaitKey(1)
+	}
+
+	// Don't write to destination if there is no motion.
+	if len(contours) == 0 {
+		return -1, nil
+	}
+
+	// Write to destination.
+	return m.dst.Write(f)
+}

revid/config/config.go

@@ -113,6 +113,7 @@ const (
 	FilterNoOp = iota
 	FilterMOG
 	FilterVariableFPS
+	FilterKNN
 )
 
 // Config provides parameters relevant to a revid instance. A new config must

revid/revid.go

@@ -76,6 +76,15 @@ const (
 	rtmpConnectionTimeout  = 10
 )
 
+// KNN filter properties
+const (
+	knnMinArea     = 25.0
+	knnThreshold   = 300
+	knnHistory     = 300
+	knnKernel      = 9
+	knnShowWindows = true
+)
+
 const pkg = "revid: "
 
 type Logger interface {
@@ -335,6 +344,8 @@ func (r *Revid) setupPipeline(mtsEnc func(dst io.WriteCloser, rate float64) (io.
 		r.filter = filter.NewMOGFilter(r.encoders, 25, 20, 500, 3, true)
 	case config.FilterVariableFPS:
 		r.filter = filter.NewVariableFPSFilter(r.encoders, 1.0, filter.NewMOGFilter(r.encoders, 25, 20, 500, 3, true))
+	case config.FilterKNN:
+		r.filter = filter.NewKNNFilter(r.encoders, knnMinArea, knnThreshold, knnHistory, knnKernel, knnShowWindows)
 	default:
 		panic("Undefined Filter")
 	}
@@ -647,7 +658,7 @@ func (r *Revid) Update(vars map[string]string) error {
 				r.cfg.Logger.Log(logger.Warning, pkg+"invalid VerticalFlip param", "value", value)
 			}
 		case "Filter":
-			m := map[string]int{"NoOp": config.FilterNoOp, "MOG": config.FilterMOG, "VariableFPS": config.FilterVariableFPS}
+			m := map[string]int{"NoOp": config.FilterNoOp, "MOG": config.FilterMOG, "VariableFPS": config.FilterVariableFPS, "KNN": config.FilterKNN}
 			v, ok := m[value]
 			if !ok {
 				r.cfg.Logger.Log(logger.Warning, pkg+"invalid FilterMethod param", "value", value)