Cameras & sensorsExplainer

Why camera supported resolutions limit your fps choices

Camera sensors deliver fps only in fixed readout modes: read the supported resolutions, derive the line-time limit, pick the mode that hits your frame rate.

LumaSpec Vision11 min read Share on LinkedIn

On this page 10 sections
  1. 01The mode list is the law
  2. 02Readout time, not pixel count, sets the ceiling
  3. 03Three levers: window, bin, skip
  4. 04A worked example from a real mode list
  5. 05The camera adds ceilings of its own
  6. 06Smart cameras: an even shorter list
  7. 07How to choose the mode
  8. 08When the usual answer is wrong
  9. 09Checklist before you commit
  10. 10Questions

You cut the width and height in your vision software, expecting more frames per second, and the camera answers with an unsupported-resolution warning, a snapped-back size, or a silent fallback to a default mode. Nothing is broken. An image sensor produces frames only in the readout modes its sequencer was designed for, and every mode carries its own frame-rate ceiling. This explainer is for engineers setting up cameras for high-rate inspection. You will learn why frame size is a choice from a list, how to derive the line time that sets the ceiling, and how to pick the smallest mode that still resolves your feature.

The mode list is the law

An image sensor is not a graphics card: you cannot ask for any width and height and get frames. The readout sequencer runs a fixed set of modes - full resolution, binned variants such as 2×2 and 4×4, skipped variants, and windowed regions - and each mode has its own addressing, timing and maximum frame rate. The width and height controls in the camera's GenICam node map look continuous, but the values the sensor accepts are those modes and nothing between them.

Ask for a size that is not on the list and one of three things happens: the setting is refused, it snaps to the nearest valid mode, or the camera accepts it and falls back internally while the log fills with unsupported-resolution entries. All three mean the same thing - you typed a size, and the sensor needs a mode.

The list is queryable. The camera's SDK reports the connected sensor's modes as records carrying a width, a height, a minimum fps and a maximum fps. Print that list before tuning anything else; it is the ground truth that datasheets summarize. In a generic node map, the width, height and binning nodes themselves expose their valid ranges, and if a frame-rate mode you expected is missing, check the camera's advertised modes before assuming a fault. The resolution filters in the area scan cameras finder describe a camera's largest mode; the list underneath decides the frame rates you can actually have.

Readout time, not pixel count, sets the ceiling

A CMOS sensor reads a frame one row at a time, and every row costs a fixed slice of time set by the analog front end and the converter. Call it the line time. The frame period is the line time multiplied by the number of rows read, plus a small fixed overhead:

frame period ≈ line time × active height + overhead fps_max ≈ 1 / (line time × H)

The width sits inside the line time. A wider row takes longer to convert, but once the sensor's timing is programmed, halving the width often moves the line time by a percent or two. Height, not width, is the frame-rate lever on most sensors.

Exposure rides on top of readout. When the two pipeline, readout still sets the floor; when they do not, the frame period is the sum. Either way:

fps ≤ 1 / exposure time

A sensor that lists 255.7 fps in its fastest mode delivers 125 fps if the scene needs 8 ms of integration. Whether the minimum exposure includes readout differs by camera; the test is covered in minimum exposure time and sensor readout time.

Three levers: window, bin, skip

Windowing (ROI). You tell the sensor to read a rectangle smaller than the full frame. Fewer rows means proportionally less readout time, so the ceiling rises roughly with 1/height, and the field of view shrinks to the window. Cameras that read several rectangles in one frame do it with the same row arithmetic - see multi-ROI camera sensor readout. One ordering trap when you set the rectangle: camera ROI offsets reset to zero unless you set width and height first.

Binning. The sensor sums adjacent pixels during readout: 2×2 binning turns four pixels into one, so 1280 × 800 becomes 640 × 400 at the output. Pixel count falls by four, collected signal rises about fourfold and noise about twofold, so the binned frame is faster and roughly twice as clean in shot-noise terms, with the field of view unchanged. The trade-offs between 2×2 and larger patterns are worked through in 4×4 binning versus 2×2: sensor readout decides your frame rate. On Bayer color sensors the mosaic restricts which pixels can be summed, so color cameras bin less freely than mono ones.

Skipping. The sensor reads a row, discards the next, reads again. Half the rows leave the chip, the frame is faster and the field of view is unchanged - but the discarded rows are gone, and fine repeating detail aliases into false patterns. Take binning over skipping whenever both are offered.

One lever does nothing: scaling the image down on the PC. The sensor still reads every row of the mode it was set to, so software downscaling costs processor time and gains zero frames per second.

A worked example from a real mode list

The table below comes from the published mode list of a 1 MP-class global-shutter mono sensor - a commercial sensor's capability record, not a specification of any camera we sell. Each mode carries one minimum and one maximum frame rate:

Mode Pixels Max fps Frame period
1280 × 800, full 1,024,000 129.6 7.72 ms
1280 × 720, windowed 921,600 143.1 6.99 ms
640 × 400, binned 256,000 255.7 3.91 ms

Derive the line time from any row. Full mode: 7.72 ms ÷ 800 rows = 9.65 µs per row. Windowed: 6.99 ms ÷ 720 = 9.71 µs. Binned: 3.91 ms ÷ 400 = 9.78 µs. The line time is a constant of about 9.7 µs, so this sensor obeys fps_max ≈ 1 / (height × 9.7 µs).

Test the rule on the middle row: 720 × 9.7 µs = 6.98 ms, and 1 / 6.98 ms = 143 fps against a listed 143.1. Note what did not change: the 720-row mode reads the same 1280 columns. Dropping from 800 to 720 rows bought 10 percent more frames (129.6 to 143.1) at identical width; dropping width at constant height would have bought about one percent.

The binned row tells a second story. 640 × 400 at 255.7 fps moves 65.5 million pixels per second - half the 132.7 million of the full mode - so its ceiling is the mode's own timing, not pixel rate. The listed minimum of 1.687 fps is the long-exposure end: 1 / 1.687 = 0.59 s of integration.

Now check the pipe. An 8-bit mono 1280 × 800 frame is 1,024,000 bytes, about 1.02 MB; at 129.6 fps that is 132.7 MB/s, roughly 1.06 Gbit/s of image data. A 1 Gbit/s Ethernet link carries about 100 MB/s of payload after protocol overhead, so over GigE this mode tops out near 100 ÷ 1.02 ≈ 98 fps whatever the sensor can do. The binned frame needs 65.5 MB/s and fits with margin. Three decisions fall out:

  • Full 1 MP at the sensor's 129.6 fps ceiling: use USB3, 10GigE or CXP-12, not GigE.
  • More than 200 fps and 640 × 400 resolves the part: the binned mode over GigE works.
  • Full resolution at up to about 98 fps: GigE carries it, exposure permitting.

The camera adds ceilings of its own

The sensor's mode list is the upper bound; the camera's electronics and interface decide what you actually stream. The clearest case in our range is one 12 MP sensor sold behind two interfaces: 30 fps over USB3 and 9 fps over GigE.

Specification LS-CMR-0166 LS-CMR-0053
Sensor model Sony IMX226 IMX 226
Resolution 4000 × 3000 (12MP) 4000 px x 3000 px
Max. frame rate 30 fps 9 fps
Pixel size 1.85 μm 1.85 μm x 1.85 μm
Shutter rolling shutter Rolling Shutter
Data interface USB 3.0 GigE
Pixel bit depth 10-bit 8 / 10 / 12 bits
Price $560.00 $560.00

All 2 share: Sensor size 1/1.7". Values as printed in each product's data sheet; open a part for its drawing and full specifications.

Multiply the full frame out: 4000 × 3000 pixels at 30 fps is 360 million pixels per second; at 9 fps it is 108 million, which at one byte per pixel is about 108 MB/s and only fits a 1 Gbit/s link with jumbo frames enabled. USB3 has several times that bandwidth, so on the USB3 model the sensor's own readout becomes the ceiling. If you do move up to a faster pipe, move the whole chain with it - a 10GigE camera delivering only 1 Gbps throughput is the classic packet-size and NIC trap.

When the task needs megapixels and speed together, high-speed sensor variants are built for it: their mode lists reach further at every resolution before the interface becomes the limit.

Area scan camerasHikrobot MV-CH120-11UC 12 MP Area Scan Camera, USB3, IMX304, High-speed version, ColorMV-CH120-11UC
Sensor format
1.1"
Lens mount
C-mount
Interface
USB3
Resolution
12 MP
$2,339.00 · quotedView and quoteBuild a system with it

Match the pipe to the sensor from day one - USB3 for a 12 MP class sensor running flat out, 10GigE or CXP-12 above that.

Smart cameras: an even shorter list

On a smart camera the inspection runs on the device, and the firmware fixes the frame sizes it will process - typically the full mode plus a binned half and quarter. You choose from that list at configuration time. The LS-SMC-0063 states its envelope directly: a 1.6 MP sensor, 60 fps acquisition and a 16 mm lens with integrated white light. Work out the field of view from the lens and the smallest defect you must catch, then confirm the mode you land on is one the firmware offers.

Smart cameras & vision sensors1.6 MP smart camera, 60 fps, 16 mm lens, white light (polarized, transparent light) (LS-SMC-0063)LS-SMC-0063
Interface
GigE
Resolution
Up to 3 MP
$1,110.00View part

How to choose the mode

Five minutes of arithmetic settles it, and the camera resolution calculator does the first step.

Camera resolution for the smallest feature
Units
Pixels needed
–
Sensor size
– MP
Smallest sensor that fits
–
Pixel on the part
– mm
Pixels across the feature, that sensor
–

Pixels needed = field / feature × pixels per feature on each axis (field incl. margin). The lens must resolve the pixels too: Nyquist = 1000 / (2 × pixel µm) lp/mm.

Find cameras with enough pixels Open the full calculator

  1. Size the pixel floor. Take the smallest feature you must detect, decide how many pixels must span it - three to four for presence and edges, five or more for a printed code - and multiply out the sensor pixels for your field of view. The smallest mode above that number is your target.
  2. Print the mode list from the SDK's capability query - width, height, minimum fps, maximum fps - and strike out everything below the floor.
  3. Prefer the binned mode when it clears the floor: same field of view, better signal, no aliasing. Take the windowed mode only when you need the extra speed and can give up the field of view outside the window.
  4. Multiply bytes per frame by target fps and compare with the link: about 100 MB/s on 1 Gbit/s Ethernet, several times that on USB3, more again on 10GigE and CXP-12. Keep 20 percent margin.
  5. Check exposure: the frame period at your target fps must exceed the longest integration your light supports.

When the usual answer is wrong

  • Just type a smaller width and height. Only if that size is a mode. Otherwise it is refused, snapped or defaulted, and the frame you process is not the frame you asked for.
  • Crop the sides to go faster. Rows set the period; on the worked sensor, 800 to 720 rows at constant width was worth 10 percent, and a width change about one percent. Cut rows, not columns.
  • Downscale in software to save bandwidth. The camera still sends every pixel of its mode; only a smaller mode sends fewer bytes.
  • Skip lines for speed on fine parts. Discarded rows alias repeating detail into defects that are not there. Bin instead.
  • More megapixels will fix the rate. A bigger sensor brings bigger modes and the same physics. Choose the resolution class by field of view and pixel floor - the 16, 20 or 24 MP camera comparison by aspect ratio and format covers that choice - and let the mode list tell you the frame rate.
  • The datasheet maximum is what you will get. That figure belongs to the fastest mode at minimum exposure over an adequate link. Your mode, your exposure and your interface each subtract from it.

Checklist before you commit

  • Mode list printed from the capability query, with the pixel floor marked on it.
  • Chosen mode selected on purpose - binned or windowed by decision, not by fallback after an error.
  • Bytes per frame × target fps fits the link with 20 percent margin.
  • Longest exposure fits inside the frame period at target fps.
  • Field of view recalculated for the chosen mode; binning keeps it, windowing cuts it, and sensor format drives the lens choice - see camera sensor size formats explained.

With the arithmetic done, filter the camera finder by resolution class and interface, or start from the camera step of the configurator. If two candidate modes still tie, send us the pixel floor and the target frame rate through the contact page and the choice can be settled with real numbers.

Questions

Why does my camera refuse a resolution and fall back to a default?

Because the size you typed is not one of the sensor's readout modes. The sequencer runs only its designed modes - full, binned, skipped and windowed - so the camera either refuses the setting, snaps it to the nearest valid mode, or accepts it and falls back while logging an unsupported-resolution entry. Query the mode list from the SDK, pick the nearest listed mode, and compare the frame size actually delivered against the one you requested to catch silent fallbacks.

Does lowering width raise frame rate like lowering height does?

Barely. Frame period is line time multiplied by row count, and the line time is fixed by the sensor's readout design, so height is the lever. In the worked example, dropping from 800 to 720 rows at the same 1280 width lifted the ceiling from 129.6 to 143.1 fps, while a width change at constant height moves the ceiling by about one percent. Cut rows, not columns, when you need speed.

Is binning or skipping the better way to gain fps?

Binning, wherever the sensor offers both. Two-by-two binning sums four pixels into one: a quarter of the pixels, about four times the signal and twice the noise, so the frame is faster and cleaner with the field of view unchanged. Skipping simply discards rows and columns, which is fast but aliases repeating detail into false patterns. Reserve skipping for scenes with no fine periodic structure.

How do I find which resolutions my camera supports?

Three sources, in order of authority: the SDK's connected-camera capability query, which returns a width, a height and a minimum and maximum fps per mode; the readout-mode table in the camera documentation; and the GenICam node map, whose width, height and binning controls show their valid ranges. The capability query reflects the firmware you actually run, so trust it first when the documents disagree.

Can I reach the sensor's maximum fps over a 1 Gbit/s link?

Only for small modes. Plan on about 100 MB/s of image payload on a 1 Gbit/s link, nearer 110 MB/s with jumbo frames. An 8-bit mono 1280 × 800 frame is about 1.02 MB, so the link tops out near 98 fps although the sensor lists 129.6; the 640 × 400 binned frame needs 65.5 MB/s and fits. For full-mode speed, move to USB3, 10GigE or CXP-12.