BadBob / Playground
GoCV · OpenCV · ONNX · MIT
07.01

Prepara o projeto

Instala as dependências indicadas e executa os testes. Experimenta uma imagem local antes de abrir a câmara.

Fundamentos

go test -race
Executa verificações automáticas sem abrir a câmara.
Terminalbash
unzip badbob-playground-go.zip
cd badbob-playground-go
sh build.sh ./build/badbob-camera
tags='gocv_specific_modules,gocv_dnn,gocv_imgproc,gocv_imgcodecs,gocv_videoio'
go test -race -tags "$tags" ./...
07.02

Liga o teu modelo

Valida o modelo e as etiquetas antes de abrir uma câmara.

Fundamentos

detection.ParseLabels(text)
Lê os nomes das classes pela ordem do modelo; rejeita etiquetas vazias ou repetidas.
opencv.LoadDetector(path, classes)
Carrega o modelo ONNX e valida a entrada, a saída e o número de etiquetas.
prepareInput(frame)
Cria uma entrada RGB de 640×640, preservando as proporções e preenchendo a área restante.
opencv.Detector.Detect(image)
Prepara a imagem, executa o modelo e devolve as deteções.
A ter em conta
Sintoma
As caixas deslocam-se ou o modelo não carrega.
Causa
O pré-processamento, o formato de saída ou a ordem das etiquetas não corresponde.
Solução
Este adaptador suporta apenas o contrato abaixo. Os ficheiros Core ML e outros formatos ONNX precisam de outro adaptador.

Este adaptador suporta apenas o contrato abaixo. Os ficheiros Core ML e outros formatos ONNX precisam de outro adaptador.

Aprofundamento

As coordenadas descrevem o centro e as dimensões das caixas nos 640×640 píxeis de entrada. As etiquetas seguem exatamente a ordem das classes do modelo.

ONNXyaml
input:
  color: RGB
  dtype: float32
  shape: [1, 3, 640, 640]
  letterbox: 114
  scale: 1/255
output:
  dtype: float32
  shape: [1, 4+C, N]
  boxes: [cx, cy, width, height]
  class_scores: probabilities
  objectness: false
  embedded_nms: false
internal/opencv/opencv_adapter.gogo
// Package opencv adapts native inference, capture, presentation and image output.
package opencv

import (
    "errors"
    "fmt"
    "image"
    "image/color"
    "math"
    "os"
    "path/filepath"

    "github.com/silvergrund/badbob-playground/go/internal/detection"

    "gocv.io/x/gocv"
)

type Detector struct {
    network gocv.Net
    classes int
}

// GoCV 0.43's legacy DNN/capture exception state is used only by the worker.
// HighGUI uses our separate per-call error bridge, never that global state.
func checkCV(operation string) error {
    if err := gocv.LastExceptionError(); err != nil {
        return fmt.Errorf("%s: %w", operation, err)
    }

    return nil
}

// LoadDetector validates a trusted ONNX model with a real dry forward.
func LoadDetector(path string, classes int) (*Detector, error) {
    info, err := os.Stat(path)
    if err != nil || !info.Mode().IsRegular() || filepath.Ext(path) != ".onnx" || classes < 1 || classes > 1024 {
        return nil, errors.New("provide an existing .onnx file and 1-1024 labels")
    }

    gocv.ClearLastException()
    network := gocv.ReadNetFromONNX(path)
    // Check before Empty: GoCV returns a null native Net when parsing fails.
    if err := checkCV("load ONNX"); err != nil {
        _ = network.Close()
        return nil, err
    }

    model := &Detector{network, classes}
    if err := model.initialize(); err != nil {
        _ = model.Close()
        return nil, err
    }

    return model, nil
}

func (model *Detector) initialize() error {
    if model.network.Empty() {
        return errors.New("ONNX network has no layers")
    }

    if err := model.network.SetPreferableBackend(gocv.NetBackendOpenCV); err != nil {
        return err
    }

    if err := checkCV("set CPU backend"); err != nil {
        return err
    }

    if err := model.network.SetPreferableTarget(gocv.NetTargetCPU); err != nil {
        return err
    }

    if err := checkCV("set CPU target"); err != nil {
        return err
    }

    outputs := model.network.GetUnconnectedOutLayers()
    if err := checkCV("read output layers"); err != nil {
        return err
    }

    if len(outputs) != 1 {
        return errors.New("expected exactly one detector output")
    }

    sample := gocv.NewMatWithSizeFromScalar(gocv.NewScalar(114, 114, 114, 0), 640, 640, gocv.MatTypeCV8UC3)
    defer sample.Close()
    _, err := model.Detect(sample)
    return err
}

func (model *Detector) Detect(image gocv.Mat) ([]detection.Detection, error) {
    blob, transform, err := prepareInput(image)
    if err != nil {
        return nil, err
    }

    defer blob.Close()
    model.network.SetInput(blob, "")
    if err := checkCV("set RGB NCHW input"); err != nil {
        return nil, err
    }

    output := model.network.Forward("")
    defer output.Close()
    if err := checkCV("forward ONNX"); err != nil {
        return nil, err
    }

    shape := output.Size()
    if output.Type() != gocv.MatTypeCV32F || len(shape) != 3 || shape[0] != 1 || shape[1] != 4+model.classes || shape[2] < 1 || shape[2] > 100000 {
        return nil, errors.New("expected float32[1,4+C,N], XYWH + class probabilities; no objectness/embedded NMS")
    }

    contiguous := output.Clone()
    defer contiguous.Close()
    data, err := contiguous.DataPtrFloat32()
    if err != nil {
        return nil, err
    }

    return detection.Decode(data, model.classes, shape[2], transform)
}

func (model *Detector) Close() error {
    return model.network.Close()
}

func prepareInput(frame gocv.Mat) (gocv.Mat, detection.Letterbox, error) {
    if frame.Closed() || frame.Empty() || frame.Type() != gocv.MatTypeCV8UC3 {
        return gocv.Mat{}, detection.Letterbox{}, errors.New("expected a nonempty 8-bit BGR image")
    }

    transform, err := detection.NewLetterbox(frame.Cols(), frame.Rows())
    if err != nil {
        return gocv.Mat{}, detection.Letterbox{}, err
    }

    resized := gocv.NewMat()
    defer resized.Close()
    if err := gocv.Resize(frame, &resized, image.Pt(transform.Width, transform.Height), 0, 0, gocv.InterpolationLinear); err != nil {
        return gocv.Mat{}, detection.Letterbox{}, err
    }

    padded := gocv.NewMat()
    defer padded.Close()
    err = gocv.CopyMakeBorder(resized, &padded, transform.Top, 640-transform.Height-transform.Top, transform.Left, 640-transform.Width-transform.Left, gocv.BorderConstant, color.RGBA{114, 114, 114, 255})
    if err != nil {
        return gocv.Mat{}, detection.Letterbox{}, err
    }

    blob := gocv.BlobFromImage(padded, 1.0/255, image.Pt(640, 640), gocv.NewScalar(0, 0, 0, 0), true, false)
    if err := checkCV("prepare float32 blob"); err != nil {
        _ = blob.Close()
        return gocv.Mat{}, detection.Letterbox{}, err
    }

    return blob, transform, nil
}

type Camera struct {
    capture *gocv.VideoCapture
}

// OpenCamera acquires an explicitly selected device and transfers ownership to the caller.
func OpenCamera(index int) (*Camera, error) {
    capture, err := gocv.VideoCaptureDevice(index)
    if err != nil {
        if capture != nil {
            _ = capture.Close()
        }

        return nil, err
    }

    if err := checkCV("open camera"); err != nil {
        _ = capture.Close()
        return nil, err
    }

    if !capture.IsOpened() {
        _ = capture.Close()
        return nil, errors.New("cannot open camera; check index, permissions and backend")
    }

    return &Camera{capture}, nil
}

func (camera *Camera) NextFrame() (gocv.Mat, error) {
    frame := gocv.NewMat()
    read := camera.capture.Read(&frame)
    if err := checkCV("read camera"); err != nil {
        _ = frame.Close()
        return gocv.Mat{}, err
    }

    if !read || frame.Empty() {
        _ = frame.Close()
        return gocv.Mat{}, errors.New("camera read failed or returned an empty frame")
    }

    return frame, nil
}

func (camera *Camera) Close() error {
    return camera.capture.Close()
}

// Annotate draws validated detections and their class names onto a BGR image.
func Annotate(frame *gocv.Mat, detections []detection.Detection, labels []string) error {
    for _, detection := range detections {
        b := detection.Bounds
        left := max(0, min(frame.Cols()-1, int(math.Floor(b.X))))
        top := max(0, min(frame.Rows()-1, int(math.Floor(b.Y))))
        right := min(frame.Cols(), int(math.Ceil(b.X+b.Width)))
        bottom := min(frame.Rows(), int(math.Ceil(b.Y+b.Height)))
        if err := gocv.Rectangle(frame, image.Rect(left, top, max(left+1, right), max(top+1, bottom)), color.RGBA{250, 220, 74, 255}, 2); err != nil {
            return err
        }

        text := fmt.Sprintf("%s %.2f", labels[detection.Label], detection.Score)
        if err := gocv.PutText(frame, text, image.Pt(left, max(16, top-6)), gocv.FontHersheySimplex, .5, color.RGBA{250, 220, 74, 255}, 1); err != nil {
            return err
        }
    }

    return nil
}

// EncodePNG returns owned bytes without retaining the image or native encoding buffer.
func EncodePNG(frame gocv.Mat) ([]byte, error) {
    buffer, err := gocv.IMEncode(gocv.PNGFileExt, frame)
    if buffer != nil {
        defer buffer.Close()
    }

    if err != nil {
        return nil, err
    }

    return append([]byte(nil), buffer.GetBytes()...), nil
}
07.03

Adiciona a câmara

A captura e a inferência são executadas em série. A interface recebe apenas a última imagem totalmente processada e as respetivas deteções.

Fundamentos

pipeline.Worker.run(source, detector)
Gere a captura da câmara e a inferência numa única tarefa sequencial.
pipeline.Latest.Take()
Obtém a última imagem processada e as suas deteções; os resultados não se podem acumular numa fila.
pipeline.Worker.Close()
Deixa de aceitar novos resultados e liberta os recursos quando o trabalho em curso termina.
A ter em conta
Sintoma
A pré-visualização atrasa-se e o uso de memória aumenta.
Causa
A câmara produz imagens mais depressa do que a inferência as processa, criando uma fila sem limite.
Solução
A captura e a inferência são executadas em série. A interface recebe apenas a última imagem totalmente processada e as respetivas deteções.
Aprofundamento

Pede a paragem, rejeita resultados tardios e espera que o trabalho em curso termine antes de libertares os seus recursos. O cancelamento no motor depende do suporte da plataforma.

internal/pipeline/runtime.gogo
// Package pipeline owns sequential acquisition/inference and the latest paired result.
package pipeline

import (
    "errors"
    "sync"
    "sync/atomic"

    "github.com/silvergrund/badbob-playground/go/internal/detection"

    "gocv.io/x/gocv"
)

// FrameSource transfers ownership of each acquired image to its caller.
type FrameSource interface {
    NextFrame() (gocv.Mat, error)
    Close() error
}

// Detector borrows an image for inference; the caller retains image ownership.
type Detector interface {
    Detect(image gocv.Mat) ([]detection.Detection, error)
    Close() error
}

// FrameResult owns an image and its matching predictions, or a terminal error.
type FrameResult struct {
    Image      gocv.Mat
    Detections []detection.Detection
    Err        error
}

func (result *FrameResult) Close() {
    if !result.Image.Closed() {
        _ = result.Image.Close()
    }
}

// Latest retains at most one result, disposing replacements and late publications.
type Latest struct {
    mutex   sync.Mutex
    pending *FrameResult
    closed  bool
}

func (slot *Latest) Publish(result *FrameResult) {
    slot.mutex.Lock()
    defer slot.mutex.Unlock()
    if slot.closed {
        result.Close()
        return
    }

    if slot.pending != nil {
        slot.pending.Close()
    }

    slot.pending = result
}

func (slot *Latest) Take() *FrameResult {
    slot.mutex.Lock()
    defer slot.mutex.Unlock()
    result := slot.pending
    slot.pending = nil
    return result
}

func (slot *Latest) Close() {
    slot.mutex.Lock()
    defer slot.mutex.Unlock()
    slot.closed = true
    if slot.pending != nil {
        slot.pending.Close()
        slot.pending = nil
    }
}

// Worker owns its adapters until acquisition/inference and cleanup have completed.
type Worker struct {
    stopped atomic.Bool
    done    chan struct{}
    results Latest
}

// StartWorker validates the detector before acquiring a source, then processes frames.
// Close always joins the worker; an active native call can delay shutdown.
func StartWorker(source func() (FrameSource, error), detector func() (Detector, error)) *Worker {
    worker := &Worker{done: make(chan struct{})}
    go func() {
        defer close(worker.done)
        if err := worker.run(source, detector); err != nil && !worker.stopped.Load() {
            worker.results.Publish(&FrameResult{Err: err})
        }
    }()
    return worker
}

func (worker *Worker) run(source func() (FrameSource, error), detector func() (Detector, error)) (failure error) {
    model, err := detector()
    if err != nil {
        return err
    }

    if model == nil {
        return errors.New("missing detector adapter")
    }

    defer func() { failure = errors.Join(failure, model.Close()) }()
    if worker.stopped.Load() {
        return nil
    }

    frames, err := source()
    if err != nil {
        return err
    }

    if frames == nil {
        return errors.New("missing capture adapter")
    }

    defer func() { failure = errors.Join(failure, frames.Close()) }()
    for !worker.stopped.Load() {
        result, err := processFrame(frames, model, &worker.stopped)
        if err != nil {
            return err
        }

        if result == nil {
            break
        }

        worker.results.Publish(result)
    }

    return nil
}

func processFrame(frames FrameSource, model Detector, stopped *atomic.Bool) (*FrameResult, error) {
    image, err := frames.NextFrame()
    result := &FrameResult{Image: image}
    if err != nil {
        result.Close()
        return nil, err
    }

    if stopped.Load() {
        result.Close()
        return nil, nil
    }

    if image.Empty() {
        result.Close()
        return nil, errors.New("camera returned an empty frame")
    }

    detections, err := model.Detect(image)
    if err != nil {
        result.Close()
        return nil, err
    }

    if stopped.Load() {
        result.Close()
        return nil, nil
    }

    result.Detections = detections
    return result, nil
}

func (worker *Worker) Take() *FrameResult {
    return worker.results.Take()
}

func (worker *Worker) Stop() {
    worker.stopped.Store(true)
    worker.results.Close()
}

func (worker *Worker) Wait() {
    <-worker.done
}

func (worker *Worker) IsDone() bool {
    select {
    case <-worker.done:
        return true
    default:
        return false
    }
}

func (worker *Worker) Close() {
    worker.Stop()
    worker.Wait()
}
07.04

Posiciona as previsões

Inverte a escala e as margens do letterbox e limita as caixas à imagem antes de as desenhar.

Fundamentos

detection.NewLetterbox(...) · detection.Unproject(...)
Preserva as proporções e converte as caixas para as coordenadas da imagem original.
detection.Decode(...)
Valida as previsões e remove caixas sobrepostas da mesma classe.
A ter em conta

Trata tamanho, recorte, orientação e coordenadas como um contrato comum. Testa caixas conhecidas antes de confiares na sobreposição.

internal/detection/geometry.gogo
// Package detection validates detector geometry and class labels without native dependencies.
package detection

import (
    "errors"
    "math"
    "sort"
)

type Box struct {
    X, Y, Width, Height float64
}

type Detection struct {
    Bounds Box
    Label  int
    Score  float32
}

type Letterbox struct {
    OriginalWidth, OriginalHeight int
    Width, Height, Left, Top      int
}

// NewLetterbox computes the rounded resize and padding for a 640-pixel square input.
func NewLetterbox(width, height int) (Letterbox, error) {
    if width <= 0 || height <= 0 {
        return Letterbox{}, errors.New("image dimensions must be positive")
    }

    ratio := math.Min(640/float64(width), 640/float64(height))
    resizedWidth := max(1, int(math.Round(float64(width)*ratio)))
    resizedHeight := max(1, int(math.Round(float64(height)*ratio)))
    return Letterbox{width, height, resizedWidth, resizedHeight, (640 - resizedWidth) / 2, (640 - resizedHeight) / 2}, nil
}

func finite(value float64) bool {
    return !math.IsNaN(value) && !math.IsInf(value, 0)
}

// Unproject maps a model-space box to the original image and clips it to the image.
func Unproject(box Box, transform Letterbox) (Box, error) {
    if transform.OriginalWidth <= 0 || transform.OriginalHeight <= 0 || transform.Width <= 0 || transform.Height <= 0 || transform.Width > 640 || transform.Height > 640 || transform.Left < 0 || transform.Top < 0 || transform.Left > 640-transform.Width || transform.Top > 640-transform.Height {
        return Box{}, errors.New("invalid NewLetterbox geometry")
    }

    for _, value := range []float64{box.X, box.Y, box.Width, box.Height, box.X + box.Width, box.Y + box.Height} {
        if !finite(value) {
            return Box{}, errors.New("box geometry must be finite")
        }
    }

    if box.Width < 0 || box.Height < 0 {
        return Box{}, errors.New("box dimensions must be nonnegative")
    }

    x := func(value float64) float64 {
        return min(1, max(0, (value-float64(transform.Left))/float64(transform.Width))) * float64(transform.OriginalWidth)
    }

    y := func(value float64) float64 {
        return min(1, max(0, (value-float64(transform.Top))/float64(transform.Height))) * float64(transform.OriginalHeight)
    }

    left, top := x(box.X), y(box.Y)
    return Box{left, top, x(box.X+box.Width) - left, y(box.Y+box.Height) - top}, nil
}

func intersectionOverUnion(a, b Box) float64 {
    width := max(0, min(a.X+a.Width, b.X+b.Width)-max(a.X, b.X))
    height := max(0, min(a.Y+a.Height, b.Y+b.Height)-max(a.Y, b.Y))
    intersection := width * height
    area := a.Width*a.Height + b.Width*b.Height - intersection
    if area <= 0 {
        return 0
    }

    return intersection / area
}

// Decode validates XYWH probabilities and applies bounded, class-aware suppression.
func Decode(data []float32, classes, count int, transform Letterbox) ([]Detection, error) {
    if classes < 1 || classes > 1024 || count < 1 || count > 100000 || len(data) != (4+classes)*count {
        return nil, errors.New("expected float32[1,4+C,N], C<=1024, N<=100000")
    }

    candidates := make([]Detection, 0)
    for i := 0; i < count; i++ {
        cx, cy := float64(data[i]), float64(data[count+i])
        width, height := float64(data[2*count+i]), float64(data[3*count+i])
        bounds, err := Unproject(Box{cx - width/2, cy - height/2, width, height}, transform)
        if err != nil {
            return nil, err
        }

        var score float32
        label := 0
        for class := 0; class < classes; class++ {
            probability := data[(4+class)*count+i]
            if !finite(float64(probability)) || probability < 0 || probability > 1 {
                return nil, errors.New("expected probabilities in [0,1], not logits/objectness")
            }

            if probability > score {
                score, label = probability, class
            }
        }

        if score >= .25 && bounds.Width > 0 && bounds.Height > 0 {
            candidates = append(candidates, Detection{bounds, label, score})
        }
    }

    sort.SliceStable(candidates, func(i, j int) bool { return candidates[i].Score > candidates[j].Score })
    candidates = candidates[:min(len(candidates), 3000)]
    selected := make([]Detection, 0)
    for _, candidate := range candidates {
        suppressed := false
        for _, previous := range selected {
            if previous.Label == candidate.Label && intersectionOverUnion(previous.Bounds, candidate.Bounds) > .45 {
                suppressed = true
                break
            }
        }

        if suppressed {
            continue
        }

        selected = append(selected, candidate)
        if len(selected) == 300 {
            break
        }
    }

    return selected, nil
}
07.05

Compila. Executa. Experimenta.

Seleciona uma câmara explicitamente ou processa uma imagem offline. Prime Q ou Escape para parar.

Fundamentos

parseOptions(arguments)
Valida os argumentos e escolhe uma única entrada: imagem ou câmara.
run(arguments)
Valida a origem selecionada e delega o processamento da imagem ou da câmara.
A ter em conta
Sintoma
A paragem demora mais do que o esperado.
Causa
Uma chamada nativa de captura ou inferência ainda está em execução.
Solução
Pede a paragem, rejeita resultados tardios e espera que o trabalho em curso termine antes de libertares os seus recursos. O cancelamento no motor depende do suporte da plataforma.
Terminalbash
./build/badbob-camera --model detector.onnx --labels labels.txt --image frame.png --output result.png

./build/badbob-camera --model detector.onnx --labels labels.txt --camera 0

07.06 / Boas práticas

Pequenos detalhes. Melhores exemplos.

  • Mantém a captura e a inferência fora da thread da interface. Limita a fila em vez de acumulares fotogramas antigos.
  • Trata tamanho, recorte, orientação e coordenadas como um contrato comum. Testa caixas conhecidas antes de confiares na sobreposição.
  • Pede a paragem, rejeita resultados tardios e espera que o trabalho em curso termine antes de libertares os seus recursos. O cancelamento no motor depende do suporte da plataforma.