A practical computer-vision tool for detecting image blur and sharpness.
FindBlur combines Laplacian Variance and FFT-based frequency analysis to evaluate image detail and classify images as Sharp, Borderline, or Blurry.
Try FindBlur directly in your browser:
Upload an image, analyze multiple images, or capture an image using your camera.
Know before you post.
FindBlur is a lightweight image sharpness and blur detection application built with Python, OpenCV, NumPy, Pandas, and Streamlit.
The idea is simple:
Check your image before you publish it.
Instead of relying on a single blur metric, FindBlur combines two complementary signals:
- Laplacian Variance — measures edge and fine-detail strength.
- FFT Analysis — evaluates high-frequency image information.
The signals are normalized, weighted, and combined into a final detection score.
The final result is classified into three practical categories:
| Verdict | Meaning |
|---|---|
| 🟢 Sharp | Strong image detail detected |
| 🟡 Borderline | Close to the threshold — manual review recommended |
| 🔴 Blurry | Low image detail detected |
FindBlur uses two independent image-analysis signals:
Laplacian Variance
+
FFT Frequency Analysis
↓
Combined Score
↓
Final Verdict
This provides a second signal instead of relying entirely on one measurement.
FindBlur doesn't force every image into:
Sharp / Blurry
Instead, it uses:
🟢 Sharp
🟡 Borderline
🔴 Blurry
The Borderline category is useful when an image falls close to the configured threshold.
Detection settings can be customized from the sidebar:
- Laplacian threshold
- Sensitivity mode
- Borderline margin
- Laplacian weight
- FFT weight
The detection threshold is configurable rather than permanently fixed.
| Mode | Behavior |
|---|---|
| 🔴 Strict | More aggressive blur detection |
| 🟡 Balanced | General everyday use |
| 🟢 Lenient | More tolerant of low-texture images |
Upload:
- JPG
- JPEG
- PNG
- WEBP
FindBlur provides:
- Original image
- Detail map
- Edge map
- Laplacian score
- FFT score
- Combined score
- Confidence
- Detection breakdown
- Final verdict
Analyze multiple images in one session.
Batch mode supports:
- Multiple image uploads
- Progress tracking
- Thumbnail previews
- Individual scores
- Verdict filtering
- Score sorting
- Filename sorting
- Manual review
- CSV export
Use your browser camera to capture an image and analyze it immediately.
Camera
↓
Capture
↓
Analyze
↓
Calculate Sharpness
↓
Verdict
FindBlur provides visual information alongside numerical scores.
It generates:
- Laplacian detail maps
- Canny edge maps
- Original image comparison
This helps users understand where image detail is being detected.
Automated detection isn't perfect.
FindBlur allows results to be manually reviewed:
✅ Correct
⚠️ Disagree
○ Not Reviewed
Review information is maintained within the current Streamlit session.
Batch results can be exported for further analysis.
Typical result fields include:
Filename
Laplacian Score
FFT Score
Combined Score
Verdict
Review Status
The primary blur metric is calculated using:
cv2.Laplacian(gray, cv2.CV_64F).var()The Laplacian responds strongly to rapid changes in image intensity.
These changes commonly occur around:
- Edges
- Object boundaries
- Fine textures
- Small details
Generally:
Higher Laplacian Variance
↓
More edge/detail information
↓
Potentially sharper image
while:
Lower Laplacian Variance
↓
Less fine detail
↓
Potentially blurrier image
FindBlur also uses Fast Fourier Transform (FFT) analysis.
FFT provides information about the frequency components present in an image.
Higher-frequency components are generally associated with:
- Fine structures
- Edges
- Textures
- Rapid intensity changes
This creates a second signal that can be compared with the Laplacian result.
The two signals are normalized before being combined.
Conceptually:
INPUT IMAGE
│
┌────────┴────────┐
▼ ▼
LAPLACIAN FFT
│ │
▼ ▼
Edge / Detail Frequency Detail
│ │
└────────┬────────┘
▼
Normalization
│
▼
Weighted Combination
│
▼
Combined Score
│
▼
Threshold Check
│
┌────────────┼────────────┐
▼ ▼ ▼
🟢 Sharp 🟡 Borderline 🔴 Blurry
The default configuration gives greater weight to Laplacian analysis while FFT provides additional validation.
A low sharpness score does not always mean an image is actually blurry.
For example:
- Clear blue skies
- Plain walls
- Smooth backgrounds
- Minimal-detail scenes
can naturally contain fewer strong edges.
FindBlur therefore uses a Borderline zone.
Below threshold
↓
🔴 Blurry
Near threshold
↓
🟡 Borderline
Clearly above threshold
↓
🟢 Sharp
This allows the user to manually review uncertain images instead of blindly trusting a single threshold.
FindBlur separates the Streamlit interface from the computer-vision detection engine.
FindBlur
│
┌─────────────┴─────────────┐
│ │
▼ ▼
app.py blur_detector.py
│ │
│ Detection Engine
│ │
│ ┌────────────┴────────────┐
│ │ │
│ ▼ ▼
│ Laplacian FFT
│ │ │
│ └────────────┬────────────┘
│ │
│ ▼
│ Score Combination
│ │
└───────────────────────────┤
▼
Verdict
Handles:
- Streamlit interface
- Tabs
- Sidebar controls
- Image uploads
- Camera input
- Batch processing
- Result rendering
- CSV downloads
Handles:
- Image preprocessing
- Laplacian analysis
- FFT analysis
- Score normalization
- Weighted scoring
- Verdict classification
- Confidence calculation
This separation keeps the UI and detection logic independent and easier to maintain.
FindBlur/
│
├── app.py
│
├── blur_detector.py
│
├── requirements.txt
│
├── README.md
│
├── assets/
│ └── logo.png
│
├── docs/
│ ├── single-check.png
│ ├── batch-check.png
│ ├── live-camera.png
│ └── settings.png
│
├── .streamlit/
│ └── config.toml
│
└── .devcontainer/
| Technology | Purpose |
|---|---|
| 🐍 Python | Core application logic |
| 🎈 Streamlit | Interactive web interface |
| 👁️ OpenCV | Computer vision and image processing |
| 🔢 NumPy | Numerical computation and FFT |
| 🐼 Pandas | Batch processing and CSV export |
| 🖼️ Pillow | Image handling |
| 📊 Matplotlib | Diagnostic visualization |
Make sure you have:
- Python 3.11+
- Git
- A modern web browser
git clone https://github.com/Aarush005coder/FindBlur.git
cd FindBlurpython -m venv venv
venv\Scripts\activatepython3 -m venv venv
source venv/bin/activatepip install -r requirements.txtstreamlit run app.pyOpen:
http://localhost:8501
The project uses:
streamlit
opencv-python-headless
numpy
pandas
Pillow
matplotlib
Install all dependencies with:
pip install -r requirements.txtFindBlur is deployed using Streamlit Community Cloud.
Local Development
│
▼
Git
│
▼
GitHub
│
▼
Streamlit Community Cloud
│
▼
Live FindBlur App
FindBlur focuses specifically on image sharpness and blur detection.
It is not intended to be a complete image-quality assessment system.
Some cases can be difficult to classify automatically:
- Intentional artistic blur
- Motion blur
- Very low-texture images
- Plain walls
- Clear skies
- Extremely noisy images
- Very small images
- Naturally low-detail scenes
- Different camera characteristics
- Different image resolutions
A Borderline result should therefore be treated as a signal for manual review rather than an absolute decision.
Potential future improvements include:
- Region-based blur detection
- Motion-blur detection
- Focus-area detection
- Resolution-aware threshold calibration
- Automatic threshold calibration
- Image-quality history
- PDF report generation
- Benchmark dataset
- Detection performance evaluation
- Automated test suite
- Improved low-texture detection
- Large-batch optimization
- Additional image-quality metrics
When changing the detection engine, test against different image categories.
High-detail scenes
Text
Objects with strong edges
Detailed landscapes
Defocused photos
Motion blur
Soft-focus images
Low-detail photographs
Clear sky
Plain walls
Smooth backgrounds
Low-texture scenes
Noisy images
The goal is not only to identify obvious blur, but also to reduce false positives on naturally low-detail images.
Contributions, suggestions, and improvements are welcome.
git checkout -b feature/your-featureRun the application locally:
streamlit run app.pygit add .
git commit -m "Add your feature"git push origin feature/your-featureThen open a Pull Request.
This project is licensed under the MIT License.
See the LICENSE file for details.
Built with Python, OpenCV, NumPy & Streamlit.
A practical computer-vision project for evaluating image sharpness before publishing.