Test patterns for projectors and LED walls

Every display chain — projector, LED wall, and the scaler nobody admits is in the rack — will happily make content look plausible while quietly ruining it. Real pictures hide faults: a crushed black, a soft rescale, a panel showing its neighbour's pixels. A test pattern is the opposite: an image where you know exactly what every pixel should be doing, so a fault has nowhere to hide.

This guide is for AV techs, projectionists and LED-wall engineers — anyone who has stood in front of a screen at 7am arguing about whether it's the content or the rig. Each pattern below answers one specific question; know which is which and most of those arguments end in five minutes.

Bars are a set of known reference values — each primary and secondary at a fixed level, plus white and black. Because you know what each bar should be, you can spot what the chain is doing to colour: a whole channel down or weak, a green or magenta wash across everything (usually an RGB/YCbCr mismatch in the handshake, not a broken projector), clipped whites, or a levels mismatch. That last one is the classic: one device talking full-range (0–255) to another expecting video levels (16–235), which either greys out your blacks or crushes everything near them.

Put bars up whenever a new source meets a new display. If the bars are wrong, stop — nothing downstream of that handshake is worth adjusting yet.

A ramp is a smooth sweep from black to white. On a healthy chain it glides; on an unhealthy one it steps. Visible bands mean something is truncating bit depth or applying levels conversion twice. The ends of the ramp matter as much as the middle: if the darkest steps merge into one black, shadow detail is being crushed; if the brightest steps merge into one white, highlights are clipping. A ramp that's smooth but lopsided — dark detail compressed, mids lifted — points at a gamma mismatch between source and display.

Ramps are the quickest tell that a chain which passes bars is still quietly mangling the picture.

A grid or crosshatch makes geometry visible. For projection that means focusing corner-to-corner (not just centre), setting lens shift, and seeing exactly what keystone correction costs you: digital keystone resamples the whole image, and on a grid you can watch the lines go soft as you dial it in — which is why lens shift beats keystone whenever the rig allows.

Grids are also how you line up stacked or edge-blended projectors — two grids either converge into one clean lattice or they don't. And a geometry pattern with a circle in it is the fastest aspect-ratio sanity check there is: if the circle is an egg, someone is stretching the image.

A one-pixel checkerboard or one-pixel line grid is the most honest pattern in the kit. If every stage of the chain is running 1:1, it renders razor-sharp alternating pixels. If anything rescales the signal — a projector overscanning, a scaler quietly "fitting" the image, a processor sampling a region that isn't the size you think — single-pixel detail smears into grey mush or shimmers with moiré. There's no judgement call: it's either crisp or it's lying.

The catch cuts both ways: the pattern itself must be generated at the display's exact resolution. A 1920 × 1080 checkerboard scaled onto a 1200-pixel-wide wall will look broken even when the chain is fine.

Everything so far is a still, and stills can't show you timing faults. A moving bar or block exposes three of them. Tearing — the moving edge splitting horizontally — means source and display aren't frame-locked. Stutter or judder on a smoothly-programmed move means frames are being dropped or repeated somewhere, often a frame-rate conversion you didn't ask for. And running the same motion pattern on the wall and a reference monitor side by side makes latency visible, which matters the moment a camera feed, a musician or an interactive element has to line up with the screen.

A projector is one device; an LED wall is dozens or hundreds of them. Each panel has its own receiver card, sits on a data run, and is told by the processor which slice of the picture is its. So LED faults are per-panel faults, and the fastest diagnostic is a pattern that treats panels as panels: a border around every tile and a label on each one. A dead tile is instantly obvious; so is the sneakier stuff. A panel wearing the wrong label means a mapping error: a swapped data cable, a wrong offset in the processor, a panel physically hung in the wrong spot. On real content that fault looks like vague visual soup; on a labelled grid it reads like a seating plan with someone in the wrong chair.

Then there's uniformity. Panels from different batches, or with different hours on them, can differ in brightness and colour temperature. Full-field greys and whites at show brightness make batch mismatch visible while there's still time to shuffle panels or recalibrate — rather than during the keynote, on camera.

Focusing a lens before signal exists? The projector's internal patterns — perfect for it, and nothing else is an option yet.

Proving the wall itself? The processor's generator. If its pattern is clean and your content isn't, the fault is upstream.

Proving the whole chain? A pattern fed from the actual source. This is where files, media-server patterns or Monoscope earn their keep — internal generators can't test a chain they bypass.

One fixed, standard resolution? A static image file is honestly fine. Make it once, keep it with the show.

Odd resolutions, per-panel LED checks, or someone else's computer? Monoscope's web app — type in the pixel map, pick the pattern, go full-screen. Nothing to install, nothing to carry.

Patterns as media-server content, or full-screen from a Mac? The Mac app — export a pixel-exact PNG or a clean loop video and load it like any other clip, or drive the display directly.

The built-ins are free and already in the rack — use them for what they're good at. What they can't do is travel with you, match a weird pixel map or put a name on every panel. That's the gap Monoscope fills.

More from the studio while you're in the rack: running a stage timer on a Mac, and backing up the Raspberry Pi SD card that quietly runs half your installation.