# AI-Based Plant Stress Detection & Early Health Monitor (BAI507P): Complete Backend, Frontend, ML & Windows Setup Guide

> Source: <https://dev.to/hrlpavan/ai-based-plant-stress-detection-early-health-monitor-bai507p-complete-backend-frontend-ml--3edk>
> Published: 2026-11-21 07:27:53+00:00

**Key takeaway:** Combining six OpenCV leaf-symptom metrics with five sensor deviations into 11 tabular features lets a RandomForest classify plant stress in under 0.3 seconds on a laptop CPU, trading a black-box CNN for fully explainable outputs.

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.)*

```
# Optional: verify all backend + OpenCV + ML checks pass
python test_app.py

# Start the web server
python app.py
```

Open **[http://localhost:8000](http://localhost:8000)** in Chrome or Edge! You can also open **[http://localhost:8000/docs](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.
