Motion Guard checks every imported image for whether it's fit for 3D reconstruction — before any compute time is spent. This guide explains exactly what it looks for, why an image fails, and why a sharp 30-second tripod shot is something completely different from a shaky handheld one.
Motion Guard is DFX SplatCore's image-quality check. It runs automatically on every import and judges each individual image on whether it can contribute to the reconstruction. The result appears as a finding in the telemetry panel and is logged in full.
The crucial point first, because it's often misunderstood: Motion Guard discards nothing. No image is deleted, moved, or silently skipped. The check tells you what it sees — what follows from that is your decision.
Principle The software makes no decision about your material. It delivers an assessment with traceable numbers, and you keep control over which images are used.
5 of 12 images are flagged (blurry or shaky): P8280023.JPG, P8280025.JPG, P8280026.JPG, P8280028.JPG and 1 more.
→ These images were NOT removed — they run through normally. Blurry shots contribute little to the reconstruction, though, and can smear the result. If you want to sort them out, remove them from the source folder before import. The individual verdict for each image is in the backend log under [MOTION GUARD].
12 masks checked, nothing flagged (object area averaging 11.4%).
This is how the result appears in the telemetry column: at the bottom of the bar, not hidden in a collapsed panel. Amber means "take a look," blue means "for your information."
Photogrammetry and Gaussian Splatting work by finding the same point again across multiple images. Its position in space is calculated from how that point shifts between shots. That's exactly what requires edges, texture, structure — in short: sharpness.
A blurry image provides no re-findable points. But it's not merely useless — it's actively harmful: the reconstruction gets offered false or inaccurate matches that distort the camera position. A single bad image can warp an entire series.
Edges and surface texture are clearly separated. Feature detection finds hundreds of distinct points per image.
Structure is smeared into gray. Feature detection finds few and ambiguous points — and matches them incorrectly.
AI image
The effort pays off mainly because you can no longer fix blur in the finished model. It only becomes apparent at the end — after camera calculation, training, and export. Motion Guard moves that realization to the beginning.
Motion Guard assesses every image via two independent paths. That's not redundancy — it's deliberate: each path has blind spots the other covers.
Every camera writes shutter speed, focal length, aperture, and ISO into the image file. From these, the motion-blur risk can be predicted, without even looking at the image. The advantage: it's fast and explains why an image is at risk. The disadvantage: it's a prediction, not a measurement.
Independently of that, the actual detail sharpness present is measured. To do this, every image is brought to a uniform width — otherwise shots of different resolutions wouldn't be comparable — and the local edge sharpness is determined.
The assessment is made relative to the image's own series. That matters: an absolute sharpness value says little, because it depends heavily on the subject. Coarse wood grain effortlessly reaches values that smooth white ceramic never reaches — even though both are photographed equally sharply. What's meaningful is the comparison within a series: all images show the same object under the same conditions, so their sharpness should be similar. A downward outlier is suspicious.
Why two paths If EXIF data is missing — with PNG files, screenshots, or edited exports —, the pixel measurement takes over alone. Conversely, the EXIF calculation detects risks you can't see just by looking at the image. Only together do they produce a reliable verdict.
Both paths run independently. If the shot data is missing, path 2 carries the verdict alone.
Behind path 1 lies a rule every photographer knows, even if it's rarely spelled out — the handheld rule of thumb: the longest still-safe shutter speed roughly equals the reciprocal of the focal length. At 60 mm, that's about 1/60 second.
Motion Guard converts this rule into a comparable number:
Motion-blur factor Motion-blur factor = focal length in mm × shutter speed in seconds × crop factor
The crop factor brings sensor size into the calculation. It describes by what factor the image sensor is smaller than full-frame (36 × 24 mm): Micro Four Thirds about 2.0, APS-C roughly 1.5 to 1.6, full-frame 1.0. It deliberately appears as a multiplier in the formula: a smaller sensor captures a narrower crop, so the same amount of shake fills a larger share of the image and weighs correspondingly heavier. A larger crop factor therefore makes the verdict stricter, not milder — the classic handheld rule is calibrated exactly for that.
That's exactly why Motion Guard needs the device database — it supplies the crop factor for your camera model; which devices are included is listed in the second document in this series. If your model isn't listed, Motion Guard tries to derive the crop factor directly from the shot data: many cameras also write the full-frame-equivalent focal length into the image, from which the sensor factor can be calculated. Only if that's missing too does Motion Guard carry on with 1.0 — the verdict then tends to come out a bit too favorable, but it's never unusable.
The smaller the value, the safer the shot. The crop factor comes from the device database or, failing that, from the shot data; if both are missing, Motion Guard calculates with 1.0.
A motion-blur factor alone says nothing yet. What matters is how sensitively the reconstruction method being used reacts to it — and there are substantial differences there. Motion Guard therefore evaluates against five different tolerances:
| Method | Tolerance | Rating |
|---|---|---|
| SpikeGS | 10.0 | very forgiving |
| InstantSplat | 6.0 | forgiving |
| BAD-GS | 3.0 | medium |
| Classic 3DGS | 1.0 | strict |
| FlashGS | 0.6 | very strict |
Within each tolerance there are five tiers: excellent (up to half the tolerance), good (up to the tolerance), usable (up to double), weak (up to triple), and above that critical.
Which tolerance applies to DFX SplatCore? Classic 3DGS, tolerance 1.0. That's the method DFX SplatCore actually computes with — the other four are in the table because they help put the scale in context. Up to double the tolerance, a shot counts as usable; only beyond that is it flagged.
Until July 2026, the strictest of all five verdicts applied here — FlashGS with tolerance 0.6, a method this product doesn't even use. As a result, shots were rated about 1.7 times too strictly: full-frame, 50 mm, 1/30 s gives factor 1.67 — unremarkable for classic 3DGS, a problem for FlashGS. Anyone warned unfairly three times stops reading the fourth warning; that's why the method actually running now is what counts.
What "critical" means — and what it doesn't "Critical" means: based on the shot data, a significant motion-blur risk is to be expected. It does not mean the image is actually blurry. That exact distinction leads into the next section.
The handheld rule of thumb has a precondition baked into its name: it only applies handheld. If the camera is on a tripod, it's simply wrong — a 30-second exposure is then not a disaster, but normal working practice.
Arithmetically, the difference is dramatic. A shot at 60 mm and 30 seconds on a Micro Four Thirds camera gives a motion-blur factor of 3600 — against a tolerance of 1.0 for classic 3DGS. By the formula, the image would be hopeless. In reality, it's razor-sharp.
The idea behind it A long exposure that really came from a handheld shot couldn't possibly be sharp — the shake would be devastating. Sharp pixels therefore disprove the formula's assumption. Where measurement and prediction contradict each other, the measurement wins.
Motion Guard classifies an image as stabilized when both conditions are met:
Sharpness reaches at least half the series average. An image significantly softer than its neighbors is not rescued.
Real detail must be present. Without this second condition, a consistently blurry series could sneak through — there, every image sits close to the average and would look unremarkable under condition 1 alone.
The correction works exclusively in the direction of "sharper." A warning that the pixels themselves justify can therefore never disappear because of it.
Tripod detection was tested on a series with shutter speeds from 4 to 30 seconds that deliberately contained both sharp and unusable shots:
| Test case | without detection | with detection |
|---|---|---|
| Tripod series, sharp and blurry mixed | 0 of 12 | 7 of 12 |
| same images, all artificially blurred | 8 of 8 | 0 of 8 |
| Handheld series, short exposure | 12 of 12 | 12 of 12 |
The five rejected images in the first row were genuinely blurry — verified against 1:1 crops. The third row is the counter-test: with normal handheld work, tripod detection doesn't kick in at all.
[MOTION GUARD] 12 Bilder geprueft, brauchbar-Anteil 0.58, Wertung 39.91 [MOTION GUARD] P8280019.JPG brauchbar=True unschaerfe=excellent guete=62.75 Slow shutter (30) → motion blur risk; Small aperture (f/22.0) → diffraction softening possible; Long exposure (30.0 s) would suggest motion blur, but the pixels are sharp — treated as tripod/stabilised. Sharpness comparable to the rest of the sequence [MOTION GUARD] P8280028.JPG brauchbar=False unschaerfe=critical Slow shutter (6) → motion blur risk
Excerpt from a real run. At the top, tripod detection kicks in; at the bottom, it doesn't — same tripod, but the pixels of the second image show no detail.
An image check as such is nothing new. Established photogrammetry programs have been calculating a sharpness value per image for years and recommending that everything below a fixed threshold be disabled. That's sensible — and it's the starting point, not the goal.
The difference isn't that a check happens, but how deep it goes:
| Question | Typical Sharpness Check | Motion Guard |
|---|---|---|
| What does the verdict rest on? | a sharpness number from the sharpest part of the image | two independent paths that check each other |
| Does shot data factor in? | no | shutter speed, focal length, sensor, aperture, ISO |
| What's it measured against? | a fixed threshold | five tolerances — depending on the reconstruction method |
| Are tripod shots recognized? | not a special case | yes — long exposure isn't misread as motion blur |
| What do you get to see? | a number | plain-language reasoning per image in the log |
| What happens to flagged images? | disable them | flag them — the decision stays with the user |
Anyone working in museums, architecture, or product photography shoots from a tripod — often with shutter speeds of several seconds, because the aperture is stopped down or light is scarce. A plain sharpness number can't distinguish this case from a shaky handheld shot: it only sees how much detail is there, not why.
That's exactly where tripod detection comes in. It's the reason Motion Guard recognizes a correctly exposed 30-second shot for what it is — instead of rejecting it outright because of its shutter speed.
The value of this distinction is verified against real material, not estimated. The same series, once without and once with tripod detection:
And what it deliberately doesn't do Motion Guard doesn't decide for you. It removes no image, changes no file, and aborts nothing. If you want to ignore the recommendation, you ignore it — the outcome remains your decision. What limits the check has is laid out openly in the section "What Motion Guard Can't Do."
After import, the result appears in the findings area of the telemetry panel. There are exactly two cases:
If you want to sort out flagged images, remove them from the source folder before import. The import itself never touches your material.
12 images checked, all usable (score 73.31).
5 of 12 images are flagged (blurry or shaky): P8280023.JPG, P8280025.JPG, P8280026.JPG, P8280028.JPG and 1 more.
→ These images were NOT removed — they run through normally. Blurry shots contribute little to the reconstruction, though, and can smear the result. If you want to sort them out, remove them from the source folder before import. The individual verdict for each image is in the backend log under [MOTION GUARD].
The two cases compared. On the left, confirmation that a check happened — it deliberately appears even when there's nothing to complain about. On the right, the finding with the affected image names and a note on what to do; the images stay in the project either way.
Every individual verdict is logged, not just the summary. In the backend log, under the tag [MOTION GUARD], you'll find the verdict, the blur tier, the quality score, and every triggered note for each image — including the reasoning for why tripod detection kicked in or didn't.
For professional work, that's the real value: you can verify every verdict instead of having to trust a black box. Anyone who wants to know why a particular image failed will find the numbers there.
[MOTION GUARD] 12 Bilder geprueft, brauchbar-Anteil 1.00, Wertung 73.31 [MOTION GUARD] PA140001.JPG brauchbar=True unschaerfe=excellent guete=73.0 High ISO (3200) → increased noise expected; Slow shutter (1/50) → motion blur risk [MOTION GUARD] PA140002.JPG brauchbar=True unschaerfe=excellent guete=76.75 High ISO (3200) → increased noise expected [MOTION GUARD] PA140003.JPG brauchbar=True unschaerfe=excellent guete=73.0 High ISO (3200) → increased noise expected; Slow shutter (1/50) → motion blur risk …
An unremarkable handheld series. Every line carries the verdict, blur tier, and quality score — even when there's nothing to complain about. Easy to see: notes like "High ISO" lower the quality score but don't make an image unusable.
A check whose limits are known is worth more than one that claims infallibility. Four points you should know:
What's measured is local edge sharpness. A flawlessly sharp photo of a very smooth surface — white ceramic, clear sky, matte metal — can fall below the absolute lower bound and get a warning it doesn't deserve. The check deliberately errs on the side of "warning too often" rather than staying silent.
Without structure, feature detection has nothing to hold onto — a projected pattern gives it firm anchor points shared by every witness image.
AI image
The whole image is measured. With a wide-open aperture, a blurry background is intentional — but it still drags down the measured value. Objects against a plain background tend to be judged more strictly than those against a textured one.
If your model is missing from the device database, Motion Guard calculates with a crop factor of 1.0. The verdict then comes out milder than it should. The devices included are listed in the second document in this series.
A razor-sharp image from an unfavorable angle, with too little overlap with its neighbor, or of a reflective surface can still contribute little. Motion Guard checks image quality — not whether your shooting strategy is working out.
For a single image, sure. For two hundred, no — and that's exactly the point.
The real reason is different: without a check, you only find out after the reconstruction that something was wrong. You shoot, wait for training, see a smeared result — and don't know which of the two hundred shots was responsible. Then all that's left is to repeat everything and hope.
With Gaussian Splatting, shot quality decides the outcome more than any setting in the program. Most disappointing results aren't computation errors — they're difficult input. Motion Guard moves that insight to the beginning, where it can still change something — you see the affected images by name before any compute time goes in.
And if everything is fine, it tells you that too. That confirmation is the other half of the benefit.
No, under no circumstances. Motion Guard analyzes and logs, nothing more. All imported images go through the reconstruction, including flagged ones. If you want to exclude images, remove them from the source folder before import.
There's no switch, because none is needed: the check changes nothing about your material and takes only a few seconds. It provides purely additional information. If you don't need it, just ignore the finding.
Then the measured sharpness is below the lower bound. Two common causes: the subject has very little texture (smooth, single-color surfaces), or the shot is genuinely blurry — with long exposures, for example, due to mirror slap, wind, or a tripod head that's too soft. If in doubt, check a 1:1 crop. The measured values are in the log.
Yes. If shot data is missing — typical for PNG files, screenshots, or certain export paths — the pixel measurement judges on its own. You can tell in the log by the note that the assessment was based on pixel sharpness. The motion-blur factor is then omitted, because it can't be calculated without focal length and shutter speed.
On the contrary — cleanly sharpened images score better. But two rules apply independently of Motion Guard: apply the same settings to the whole series, and change nothing about the geometry — no cropping, no perspective correction, no rotation. Such interventions change the camera parameters per image and make position calculation impossible. Lens correction is fine, as long as it acts identically on every image.
Check the images at 100% view, not in the thumbnail overview — slight blur only becomes visible there. If the images really are sharp, the subject usually has very little texture. In that case, you're welcome to ignore the finding; it's deliberately conservative.
The quality score is separate from the usability decision. It doesn't say whether an image is usable, but how favorable the shot data is for the reconstruction. It combines three factors: ISO (noise), aperture, and resolution.
For aperture, the middle wins: mid-range apertures deliver consistent depth of field — the royal road for 3D, because the whole object is rendered sharp and no blurry areas are left missing from the reconstruction. Wide-open apertures (shallow depth of field, blurry background) and extremely closed ones (diffraction softening) are both scored more leniently, with the wide-open side slightly stricter. The scoring is sensor-aware: what looks shallow on full-frame is already consistently sharp on a small sensor — the same f-number means something different depending on sensor size.
Too open: sharpness shrinks to a narrow slice. Too closed: diffraction eats detail sharpness again. The sweet spot lies in between.
AI image
The focal length deliberately doesn't factor in to the quality score. Whether you shoot at 12 mm or 100 mm is a creative decision by the photographer, not a quality shortfall. It only counts where it physically matters: in the motion-blur factor.
In the backend log under the tag [MOTION GUARD]. There you'll find the verdict, the blur tier, the quality score, and the full reasoning per image. The finding in the interface is only a summary.
That's listed in the second document in this series — the device overview, with a search field. If your model isn't recognized, Motion Guard keeps working, but calculates with a neutral crop factor and judges more leniently as a result.
