Introduction

Yes, blur, exposure problems, and orientation can all be detected programmatically, but not with one magic formula. In practice, you combine several measurable signals and calibrate thresholds against real sample images from your own camera sources.

Blur Detection Usually Uses Sharpness Metrics

A common blur heuristic is Laplacian variance. The idea is simple: sharp images contain stronger edge detail, and that produces a higher variance after applying a Laplacian operator.

1import cv2
2import numpy as np
3
4
5def blur_score(image_bgr: np.ndarray) -> float:
6    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
7    return float(cv2.Laplacian(gray, cv2.CV_64F).var())
8
9
10def is_blurry(image_bgr: np.ndarray, threshold: float = 120.0) -> bool:
11    return blur_score(image_bgr) < threshold
12
13
14img = cv2.imread("sample.jpg")
15score = blur_score(img)
16print("blur score", score)
17print("blurry", is_blurry(img, threshold=150.0))

This is a strong baseline, but the threshold is not universal. A value that works for scanned documents may fail for night photos or low-resolution thumbnails.

Exposure Detection Should Look Beyond Average Brightness

Mean brightness alone is often misleading. Two images can have the same average brightness while one is badly clipped in highlights and the other is too dark in shadows.

A better quick check is to measure how many pixels fall near black and near white.

1import cv2
2import numpy as np
3
4
5def exposure_metrics(image_bgr: np.ndarray) -> dict:
6    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
7    dark_ratio = float((gray <= 25).mean())
8    bright_ratio = float((gray >= 230).mean())
9    mean_level = float(gray.mean())
10    return {
11        "dark_ratio": dark_ratio,
12        "bright_ratio": bright_ratio,
13        "mean_level": mean_level,
14    }
15
16
17def exposure_flag(metrics: dict) -> str:
18    if metrics["dark_ratio"] > 0.45:
19        return "underexposed"
20    if metrics["bright_ratio"] > 0.35:
21        return "overexposed"
22    return "ok"

This is still heuristic logic, but it is more informative than a single brightness average.

Orientation Can Often Come from Metadata First

For many mobile photos, EXIF metadata already records orientation. Reading that metadata is usually the fastest first step.

1from PIL import Image, ExifTags
2
3
4def corrected_image(path: str) -> Image.Image:
5    image = Image.open(path)
6    exif = image.getexif()
7    orientation_tag = None
8
9    for key, name in ExifTags.TAGS.items():
10        if name == "Orientation":
11            orientation_tag = key
12            break
13
14    orientation = exif.get(orientation_tag, 1) if orientation_tag else 1
15
16    if orientation == 3:
17        return image.rotate(180, expand=True)
18    if orientation == 6:
19        return image.rotate(270, expand=True)
20    if orientation == 8:
21        return image.rotate(90, expand=True)
22    return image

If metadata is missing or stripped, then you need content-based methods such as text direction, face orientation, or horizon detection depending on the type of image.

Combine the Signals Instead of Seeking One Score

In real systems, the best approach is usually a small rule set, not a single “image quality number.” For example:

• reject when blur is severe
• warn when exposure is borderline
• auto-rotate when EXIF says the image is sideways
• send uncertain cases to a slower review path or human check

That layered design is easier to tune than one oversimplified pass-fail metric.

Calibration Matters More Than the Formula Name

A major production lesson is that thresholds copied from examples are rarely reliable on their own. Device cameras, compression, resolution, and lighting conditions all affect the measurements.

The practical way to tune the system is:

1. collect sample images from your real pipeline
2. label them as acceptable or unacceptable
3. measure your blur and exposure metrics
4. choose thresholds that balance false rejects and false accepts

Without that calibration step, even a sensible algorithm can behave badly.

Common Pitfalls

The most common mistake is assuming one blur threshold fits every image source. It usually does not.

Another pitfall is using only average brightness for exposure decisions. That misses clipped highlights and crushed shadows.

Teams also often trust EXIF orientation too much. It is a strong first step, but metadata may be stripped or wrong in some upload paths.

Finally, image quality checks should be treated as heuristics with confidence, not as perfect truth. If the cost of rejection is high, keep room for a fallback or review path.

Summary

• Blur, exposure, and orientation can all be detected programmatically.
• Laplacian variance is a common and effective baseline for blur detection.
• Exposure checks are more reliable when they inspect dark and bright pixel ratios, not just average brightness.
• EXIF metadata is the fastest first step for orientation correction.
• Real reliability comes from combining signals and calibrating thresholds on your own image data.