This guide walks through every single file, function, ML decision, and setup step behind our AI-Based Plant Stress Detection and Early Health Monitoring System (BAI507P Mini Project). It is written so you can open the code in VS Code, trace every line from the browser to Python and SQLite, run it on Windows, and answer any viva question confidently.
Browser (static/index.html)
β 1. Captures / uploads a leaf photo + soil/weather slider values
β 2. Sends multipart FormData via fetch("POST /api/analyze")
βΌ
FastAPI Server (app.py)
β 3. Reads uploaded image bytes + validates sensor inputs
β 4. Calls analyze_plant_image() in engine.py
βΌ
OpenCV Computer Vision Pipeline (engine.py)
β 5. Segments plant tissue (HSV) & auto-centers the leaf (_center_plant_frame)
β 6. Quantifies 6 visual symptoms:
β - Healthy Green %, Yellowing %, Browning %, Dark Spots %, Pale %, Wilting Index
β 7. Draws color-coded segmentation overlay & encodes JPEG as base64
βΌ
Scikit-learn Multi-Modal Fusion (engine.py)
β 8. Compares sensor values against the selected species' ideal range (deltas)
β 9. Combines 6 visual features + 5 environmental features = 11 features
β 10. RandomForestClassifier predicts stress class + probabilities
β 11. Computes 0β100 Severity Score, Risk Level, Trend (Improving/Stable/Worsening) & Care Plan
βΌ
SQLite Database (db.py β plant_monitor.db)
β 12. Saves observation for historical progression charts & CSV export
βΌ
Browser (static/index.html)
13. Renders Plant Health Report, Highlighted Overlay, Symptom Bars, Care Plan & History Chart
Most students assume every image AI project has to train a heavy Deep Learning CNN (like ResNet or MobileNetV2) on 50,000+ raw RGB images β which requires a GPU and takes hours.
For this Mini Project, we deliberately chose a Two-Stage Hybrid Architecture (Computer Vision Feature Extraction + Tabular Machine Learning), which is faster, explainable, and runs cleanly on any student laptop CPU:
| Approach | Input to Model | Training Hardware & Time | Explainability to Guide / Farmers |
|---|---|---|---|
| End-to-End CNN (e.g., MobileNetV2) | Raw 224Γ224Γ3 pixels (150,528 values/image) |
GPU, 1β4 hours on 50k images | Black box β hard to combine with soil/temp sensors |
Our 2-Stage Pipeline (OpenCV + RandomForest ) |
11 structured numeric features (6 OpenCV leaf metrics + 5 sensor deviations) | Standard laptop CPU, < 0.3 seconds | 100% transparent β shows exact yellowing %, brown %, spot %, and sensor deviations |
RandomForestClassifier) analyze_plant_image()), you simply append those rows to the training DataFrame β and we also included train_cnn_optional.py (MobileNetV2 transfer learning in TensorFlow/Keras) as an optional upgrade path if you expand to a full deep-learning ensemble later.
The entire backend is intentionally clean and modular β only 3 Python files + 1 frontend HTML file:
plant-stress-monitor/
βββ app.py # FastAPI web server & REST API endpoints
βββ engine.py # OpenCV leaf analysis + Scikit-learn RandomForest engine
βββ db.py # SQLite database (plants & scan history) + CSV export
βββ static/
β βββ index.html # Responsive frontend UI (HTML + CSS + Vanilla JS)
β βββ logo.svg # Project leaf brand logo
βββ test_app.py # Automated self-check test suite
βββ requirements.txt # Exact Python package list
engine.py β Computer Vision + Machine Learning Core
PLANT_PROFILES dictionary
moisture, temp, humidity, light) for 12 plants across 3 categories:
_center_plant_frame(bgr, plant_mask) β Auto-Centering for Accuracy
cv2.boundingRect) of the detected leaf pixels. 480Γ360 canvas.
analyze_plant_image(image_bytes) β OpenCV Symptom Extraction
H: 5β95, S >= 28) and applies morphological closing ( cv2.morphologyEx) so dark spots inside the leaf aren't excluded. green_pct: Healthy chlorophyll pixels ( H: 36β88) yellow_pct: Chlorosis / yellowing ( H: 18β35, high brightness) brown_pct: Necrosis / dry scorch ( H: 4β20, lower brightness) spot_pct: Fungal spots / lesions detected via local Lab lightness drop (local_mean_L - L > 24) pale_pct: Bleaching / pale discoloration (low saturation, high brightness)wilt_index: Contour solidity ( area / convex_hull_area) + Canny edge density ( cv2.Canny) to detect curling and wrinkling Yellow = Chlorosis, Red-Orange = Browning, Purple = Dark Spots, Green Contour = Leaf Boundary) and returns base64 JPEG images to the UI.
PlantStressEngine β Scikit-learn Random Forest & Severity Fusion
6 visual + 5 environmental deltas: moisture_delta, temp_delta, light_delta, rain_wetness). RandomForestClassifier(n_estimators=120, max_depth=12, random_state=42) and evaluates it using cross_val_score(..., cv=5).
severity_score = 0.58 * visual_stress + 0.42 * env_stress
Improving / Stable / Worsening): severity_score with the plant's previous recorded observation:
>= 6 points β Β±6 points β db.py β SQLite Persistence Layer
sqlite3 (zero database installation needed on demo day!).plants (id, name, plant_type, category, zone, created_at) observations (plant_id, timestamp, sensors_json, vision_json, stress_type, confidence, severity_level, risk_level, trend, recommendations_json, overlay_b64) app.py β FastAPI REST Backend
Key endpoints you can show in VS Code (or test live at http://localhost:8000/docs):
| Endpoint | Method | Purpose |
|---|---|---|
/ |
GET |
Serves the web UI ( static/index.html ) |
/api/analyze |
POST |
Runs OpenCV + RandomForest diagnosis, saves to SQLite, returns JSON + overlay |
/api/plants |
GET /POST |
Lists all tracked plants or registers a new plant |
/api/plants/{id}/history |
GET |
Returns full timeline + overall progression verdict for a plant |
/api/plants/{id}/export.csv |
GET |
Downloads full plant history as a CSV file (compatible with Excel / MySQL / Firebase) |
/api/sample-leaf/{kind} |
GET |
Generates clean OpenCV demo leaves ( healthy ,yellowing ,drought ,spotted ) |
static/index.html β Clean Zero-Framework Frontend
navigator.mediaDevices.getUserMedia() + HTML5 <canvas> snapshot.Ideal / Too Low / Too High pills in real time as sliders move relative to the chosen plant's profile.
Follow these exact steps on a Windows 10 / 11 laptop:
<> Code`` https://github.com/<your-username>/plant-stress-monitor.git).Ctrl + ` to open the integrated PowerShell terminal and run:
git clone https://github.com/<your-username>/plant-stress-monitor.git
cd plant-stress-monitor
File β Open Folder β plant-stress-monitor.
In the VS Code PowerShell terminal:
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
(If PowerShell blocks script execution, run once: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned and retry activation.)
python test_app.py
python app.py
Open http://localhost:8000 in Chrome or Edge! You can also open http://localhost:8000/docs to show the interactive FastAPI backend API documentation to your guide.
_center_plant_frame() in Export CSV endpoint (/api/plants/{id}/export.csv) that produces clean structured records ready for MySQL import, Firebase, or research analysis.