scalacv.graphs

Animation — a drawing that is a function of the frame number, rendered to a video.

The natural extension of a composable Picture: describe frame i as frame(i), and record draws every frame onto a fresh canvas and writes them out through a Recorder. Creative coding, a rendered data animation, a synthetic test clip — all fall out of the same graphics vocabulary.

// `.avi`, not `.mp4`: the default codec is MJPG, which opens only in an AVI container — see [[Codec.Mjpg]].
Animation.record("spin.avi", frames = 60, width = 320, height = 240) { i =>
 Picture.regularPolygon(Point(160, 120), sides = 5, radius = 80, rotation = i * 6)
   .strokeColor(Color.hsl(i * 6, 0.8, 0.6)).strokeWidth(3)
}

The axis-aligned bounding box of a Picture — what the layout combinators (Picture.beside, Picture.above) measure to place pictures next to each other.

Minimal data visualisation, built from Picture — proof that the graphics layer composes into charts, and a handy way to overlay a plot on an image (a histogram beside a detection, a signal on a frame).

Each returns a Picture sized to a width×height box with its origin at the top-left, so it composes and transforms like any other picture: Chart.bars(counts, 200, 80).at(Point(10, 10)) drops a chart into a corner.

A colour with an alpha channel — the palette for Picture graphics.

Doodle-inspired: colours are values you build and transform (.lighten, .fadeOut, .blend) rather than raw BGR triples. Stored as RGBA in [0, 255]; the renderer converts to OpenCV's BGR at the boundary, and alpha drives per-shape transparency when a picture is drawn over an image.

A stroke dash pattern — alternating on/off run lengths in pixels. OpenCV has no dashed line, so Picture draws them by hand from this.

The OpenCV image backend. Rendering consumes the input Image exactly as image.draw does; the returned Image is owned by the caller. Shape construction and geometry need no native loading.

An immutable, composable 2D drawing — the graphics layer, inspired by Doodle and adapted to image space.

A Picture is a value: build primitives, style them, compose them, and only then render onto an image. Because it composes, the same vocabulary annotates a detection, draws a chart, or makes generative art.

import scalacv.*
import scalacv.graphs.*
OpenCv.load()

// A dashed green box with a label — an overlay for a detected face:
val overlay =
 Picture.rectangle(face.box).strokeColor(Color.Green).strokeWidth(2).dashed
   .on(Picture.text("face", Point(face.box.x, face.box.y - 6)).strokeColor(Color.Green))

image.draw(overlay) // draw it on

Coordinates are image pixels (origin top-left, y down). Styling is contextual: a style set on a group is the default its members inherit unless they set their own. Alpha in a Color gives real transparency when drawn over an image.

Geometry and layout with explicitly chosen text metrics. Shape-only measurement never calls the measurer; text remains axis-aligned at its transformed anchor. Bounds describe geometry, not ink.

The resolved style a renderer receives. Stroke widths remain in pixels under scene transforms; only circle radii and text scales scale with the geometry.

Backend-neutral drawing commands in image coordinates. Transforms have already been applied; text stays axis-aligned at its transformed baseline anchor, as in the original Picture API.

A destination-bound renderer. Implement draw for a raster, an SVG sink, or a command recorder; the library supplies scene traversal, transform composition and contextual style resolution. The implementation owns its destination's lifetime. No native type or flag is required by this contract.

Backend-controlled text measurement. The result includes the descender baseline, as in Draw.textSize. Measurement deliberately uses the historical one-pixel glyph metrics, independently of stroke width.