How to Design a Machine Vision System Step by Step

In this guide, I’ll show you how to design a machine vision system for inspecting painted blocks on a conveyor. We’ll select a camera, lens, and lighting setup, then calculate the network bandwidth and GPU capacity needed to process the images. Along the way, I'll show you how focus, exposure time, and image resizing impact the visibility.

I use RF-DETR for detection and Roboflow Workflows (opens in a new tab) to connect image processing, predictions, and pass-or-reject outputs. You can follow the calculations to select components for your own inspection task, then test the setup with your parts and production conditions.

How the machine vision system choices depend on each other

A vision system's accuracy and speed depend on seven choices: the camera, lens, light, network, compute, pipeline and model. The model is only one of the seven, and the choices depend on each other, so a later choice can send you back to change an earlier one.

The lens forms the image on the camera's sensor, and the feature's contrast in that image depends on the light. The network carries each frame to the compute, where the pipeline passes it to the model. The model needs enough pixels and contrast on the feature, and those come from the camera, lens and light.

Three later choices can force you to change the camera: the model input, the GPU and the light.

• Shrinking the frame to the model's input size shrinks the feature too, so fewer pixels land on it.
• All the cameras share one GPU, so their frame rates must add up to less than the GPU can run.
• Each exposure has to fit in one frame period, so dim light can cap the frame rate.

The example job

The example is a gray painted block on a conveyor. You want to find 2 mm dents in the paint on its top face.

Choose the camera and lens

The camera and lens set what is in the frame and how many pixels land on the feature, so you choose them first.

Pixels on the feature

Start from the number of pixels that must cross the feature. The minimum is two (the Nyquist rate), and accuracy improves with more; the number you need depends on the model. This example uses 15 to classify the dent. With 15 pixels across a 2,000 µm dent, each pixel can cover at most 133 µm of the block.

Camera

For this job, pick the Lucid Triton TRI050S, a 5 MP mono GigE camera with a global shutter. It has 2448 × 2048 pixels, each 3.45 µm, and supports Power over Ethernet (PoE).

Lens

The lens has to fit the whole block in the frame. At 30° the block needs a field 125 mm wide, and at 300 mm that takes a focal length of 20.3 mm. Stock lenses come in steps, and each one works over a range of working distances:

The 16 mm lens is the closest stock focal length that works at 300 mm. On the belt, which sits below the top face and is seen at 30°, its frame is 206.5 mm wide, inside the 250 mm line.

Pixels on the block

Each pixel covers 64.7 µm of the block, about half the 133 µm limit. Head on, a 2 mm dent would span 30.9 pixels. Viewed at 30° it is foreshortened to 26.8 pixels at the middle of the face, 30.5 at the near end and 23.7 at the far end.

Under room light alone the dent is lost in the paint's 5% grain, because its walls return only 0.16% less light than the paint.

Check focus and sharpness

Blur lowers the contrast of fine detail. Seen at 30°, the top face spans 40 mm of depth, so with its middle in focus its ends sit 20 mm from the focus plane. Three kinds of blur add up:

The modulation transfer function (MTF) is the share of contrast left after all blur, from 1 (all of it) to 0 (none). With the aperture wide open, defocus wipes out the contrast at the ends of the face, and with it closed far down, diffraction wipes it out. The far end keeps the most contrast near f/6.7, an MTF of 0.36, so this job uses f/6.70.

Light the part

A dent is the same color as the paint, so it shows only as shading. Light from one side brightens the wall that faces it and shades the other, which turns the dent into a light and dark pair. A ring light around the part, the usual first choice for dents in matte paint, would light both walls equally, and with the camera tilted 30° it would also sit in the camera's line of sight, so this job uses a bar from one side.

The lower the bar, the darker the shaded wall:

The margin is the share of contrast the dent keeps after blur, divided by the least share it needs to stand above the noise (the next section works it out). A block passes when its margin is 1 or more. The moving block passes at 82.5° and 85°, and 85° gives the largest margin, 1.51 at the best exposure time.

Pick a Smart Vision Lights LHI300-DO-WHI-N10, a 290 × 40 mm white bar light, and strobe it in OverDrive mode. Mount it beside the conveyor, 85° off vertical (5° above the top face) and 300 mm from the face. It puts about 88,000 lx on the block.

Check signal to noise ratio

The sensor turns light into electrons. Under the bar, at f/6.70 and 0.59 ms, each pixel on the paint collects 2,596 electrons, and the dent changes that count by 1,589. Five sources of noise combine, as the square root of the sum of their squares:

The paint's texture is the largest term. It grows with the light, so adding light cannot average it out. By the Rose criterion, the dent's step must be at least five times the noise. At the far end of the face the dent has to keep at least 0.224 of its contrast after blur, and with the block moving it keeps 0.332. That is a margin of 1.49 at the 0.59 ms exposure, so the moving block passes.

Closing the lens to f/11 for more depth of field costs light and adds diffraction, so the margin falls to 0.68 and the block fails.

Size the network

Machine vision cameras send frames uncompressed. One 2448 × 2048 frame in Mono8 (8 bits per pixel) is 5.01 MB, and a GbE link carries about 118 MB/s, which caps the camera at 23.5 fps.

With a trigger, the camera sends one frame per block. A block arrives every 1.5 s, so the job needs 0.67 frames per second, or 3.3 MB/s. To set up the trigger, see Trigger a Stream (opens in a new tab).

Pick the compute

The compute is an NVIDIA Jetson, and its GPU runs the model on every frame. Roboflow publishes inference benchmarks (opens in a new tab) for RF-DETR object detection on a Jetson Orin NX:

A larger input takes longer, and the time grows faster than the pixel count, because part of RF-DETR compares every patch of the image with every other. From a curve fitted to RF-DETR's published timings (opens in a new tab), Medium takes about 9.5 times as long at 1,376 px as at 576 px, so the Orin NX runs about 4.6 images a second with TensorRT.

Roboflow ships four Jetson devices:

Pick the RF-NX16 with TensorRT. To set up a device, see Install on NVIDIA Jetson (opens in a new tab).

Build the pipeline

The pipeline is the software on the RF-NX16 that turns each frame into a decision. For each block it:

• Waits for the trigger and receives the frame.
• Prepares the frame and resizes it to the model input.
• Runs the model on the GPU.
• Keeps the detections you trust (ex: dents above a confidence threshold).
• Sends pass or reject to the line (ex: a PLC tag).
• Saves frames you want to review, so you can retrain on real misses.

You can build these steps as a Roboflow Workflow and run it on the RF-NX16. Workflow blocks that write to a PLC (ex: Modbus TCP or OPC UA) come with Enterprise plans. See Enterprise Integrations (opens in a new tab).

Each result is ready about 260 ms after the trigger: 0.59 ms of exposure, 42.5 ms to send the frame over GbE, and 217 ms on the GPU. The block moves 26 mm in that time, so the reject has to sit at least 26 mm downstream of the camera. Filtering the results and signaling the line add to this time, so measure them on the device.

Set the model input

Most deployments resize the whole frame to the model's input size, which shrinks the feature by the same ratio. The camera puts 26.8 pixels on the dent across a 2448 px wide frame. To keep 15 of them, the input must be at least 56% of 2448, or 1,372 px. RF-DETR Medium takes inputs in steps of 32 px, so use 1,376 px.

If you tile or crop the frame instead of resizing it, the feature keeps its native pixel count.

The finished system

When a check fails

Get started with Roboflow to train a defect detection model, build your inspection pipeline in Workflows, and validate its accuracy and speed on your production hardware.