First Commit

.gitignore

@@ -0,0 +1 @@
+venv/

Dockerfile

@@ -0,0 +1,31 @@
+# Use official Python image
+FROM python:3.9-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libopencv-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose port for FastAPI
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

Interface.py

@@ -0,0 +1,60 @@
+import streamlit as st
+import os
+import cv2
+import numpy as np
+from PIL import Image
+import image_processing
+import matplotlib.pyplot as plt
+
+st.set_page_config(page_title="Soil Image Processor", layout="wide")
+
+# Convert PIL image to numpy
+def np_image(pil_img):
+    return np.array(pil_img.convert("RGB"))
+
+# UI layout
+st.title("🧪 Soil Image Processor")
+
+st.subheader("📊 Image Analysis & Prediction")
+uploaded_file = st.file_uploader("Upload an image for prediction", type=["png", "jpg", "jpeg"])
+
+if uploaded_file:
+    pil_img = Image.open(uploaded_file)
+    img_array = np_image(pil_img)
+
+    # Step 1: Show original image
+    st.image(pil_img, caption="Uploaded Image", use_container_width=True)
+
+    # Step 2: RGB Histogram
+    hist_fig = image_processing.plot_rgb_histogram(img_array)
+    st.pyplot(hist_fig)
+
+    # Step 3: Preprocessing
+    rgb_img, clahe_img, sharp_img = image_processing.preprocessing(cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB))
+    st.image([rgb_img, clahe_img, sharp_img], caption=["RGB Image", "CLAHE Image", "Sharpened Image"], width=250)
+
+    # Step 4: Choose mode: Whole image vs Region-based
+    st.markdown("### 🔍 Classification Mode")
+    use_segmentation = st.checkbox("Enable multi-region (segmented) classification")
+
+    if use_segmentation:
+        k = st.slider("Select number of regions (clusters)", min_value=2, max_value=5)
+        segmented_image, region_predictions = image_processing.segment_and_classify_regions(img_array, k_clusters=k)
+
+        st.image(cv2.cvtColor(segmented_image, cv2.COLOR_BGR2RGB), caption="Segmented & Classified", use_column_width=True)
+
+        st.markdown("### 🧩 Region-wise Predictions")
+        for idx, region in enumerate(region_predictions):
+            st.write(f"**Region {idx + 1}:** `{region['class']}` with confidence `{region['confidence']:.2f}`")
+            x, y, w, h = region['bbox']
+            cropped = img_array[y:y+h, x:x+w]
+            st.image(cropped, caption=f"Region {idx + 1}", width=200)
+
+    else:
+        # Step 5: Feature Extraction & Prediction on whole image
+        features_df, predicted_class, confidence = image_processing.predict_image_class_with_features(cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB))
+
+        st.subheader("📈 Extracted Features")
+        st.dataframe(features_df)
+
+        st.success(f"🔮 Predicted Class: **{predicted_class}** (Confidence: {confidence:.2f})")

image_processing.py

@@ -0,0 +1,131 @@
+# image_processing.py
+import cv2
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
+import joblib
+import warnings
+
+warnings.filterwarnings("ignore")
+
+# Load model and preprocessing tools
+model = joblib.load("model.pkl")
+label_encoder = joblib.load("label_encoder.pkl")
+scaler = joblib.load("scaler.pkl")
+
+# Preprocessing: Resize, apply CLAHE, sharpen
+def preprocessing(single_image, count=1):
+    single_image = cv2.resize(single_image, (256,256))
+    rgb_image = cv2.cvtColor(single_image, cv2.COLOR_BGR2RGB)
+
+    r, g, b = cv2.split(rgb_image)
+    clahe = cv2.createCLAHE(clipLimit=0.4, tileGridSize=(8, 8))
+    r_clahe = clahe.apply(r)
+    g_clahe = clahe.apply(g)
+    b_clahe = clahe.apply(b)
+    clahe_image = cv2.merge((r_clahe, g_clahe, b_clahe))
+    clahe_bgr = cv2.cvtColor(clahe_image, cv2.COLOR_RGB2BGR)
+
+    blurred = cv2.GaussianBlur(clahe_bgr, (5, 5), 1.5)
+    sharp = cv2.addWeighted(clahe_bgr, 1.5, blurred, -0.5, 0)
+
+    return rgb_image, clahe_image, cv2.cvtColor(sharp, cv2.COLOR_BGR2RGB)
+
+# RGB histogram plotting
+def plot_rgb_histogram(image):
+    color = ('b', 'g', 'r')
+    fig, ax = plt.subplots()
+    for i, col in enumerate(color):
+        hist = cv2.calcHist([image], [i], None, [256], [0,256])
+        ax.plot(hist, color=col)
+    ax.set_title("RGB Histogram")
+    ax.set_xlim([0, 256])
+    return fig
+
+# Extract features: GLCM, LBP, color, edge, etc.
+def feature_extraction(image, return_df=True):
+    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    glcm = graycomatrix(gray, distances=[1], angles=[0], levels=256, symmetric=True, normed=True)
+    contrast = graycoprops(glcm, 'contrast')[0, 0]
+    correlation = graycoprops(glcm, 'correlation')[0, 0]
+    energy = graycoprops(glcm, 'energy')[0, 0]
+    homogeneity = graycoprops(glcm, 'homogeneity')[0, 0]
+
+    lbp = local_binary_pattern(gray, P=8, R=1, method='uniform')
+    lbp_mean = np.mean(lbp)
+
+    mean_r = np.mean(image[:, :, 0])
+    mean_g = np.mean(image[:, :, 1])
+    mean_b = np.mean(image[:, :, 2])
+    diff_black = ((1-(mean_r-255)/255) + (1-(mean_g-255)/255) + (1-(mean_b-255)/255))/3
+
+    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=5)
+    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=5)
+    edge_count = np.sum(cv2.magnitude(sobelx, sobely) > 0)
+
+    features = [contrast, correlation, energy, homogeneity, lbp_mean,
+                mean_r, mean_g, mean_b, edge_count, diff_black]
+
+    if return_df:
+        df = pd.DataFrame([features], columns=[
+            "Contrast", "Correlation", "Energy", "Homogeneity", "LBP_Mean",
+            "Mean_R", "Mean_G", "Mean_B", "Edge_Count", "Black"
+        ])
+        return df
+    else:
+        return np.array([features])
+
+# Predict class and confidence from image
+def predict_image_class_with_features(image):
+    _, _, sharp = preprocessing(image, count=0)
+    features_df = feature_extraction(sharp)
+    features_scaled = scaler.transform(features_df)
+    prediction = model.predict(features_scaled)
+    predicted_class = label_encoder.inverse_transform(prediction)[0]
+    confidence = np.max(model.predict_proba(features_scaled))
+    return features_df, predicted_class, confidence
+
+# Segment image and classify each region
+def segment_and_classify_regions(image, k_clusters=2):
+    rgb_img, _, sharp_img = preprocessing(image)
+    reshaped = sharp_img.reshape((-1, 3)).astype(np.float32)
+
+    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.2)
+    _, labels, centers = cv2.kmeans(reshaped, k_clusters, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
+    segmented = labels.flatten().reshape(sharp_img.shape[:2])
+
+    output = image.copy()
+    region_predictions = []
+
+    for i in range(k_clusters):
+        mask = (segmented == i).astype(np.uint8) * 255
+        region = cv2.bitwise_and(sharp_img, sharp_img, mask=mask)
+
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            continue
+
+        x, y, w, h = cv2.boundingRect(max(contours, key=cv2.contourArea))
+        region_crop = region[y:y+h, x:x+w]
+
+        if region_crop.size == 0:
+            continue
+
+        features_df = feature_extraction(region_crop)
+        features_scaled = scaler.transform(features_df)
+        prediction = model.predict(features_scaled)
+        predicted_class = label_encoder.inverse_transform(prediction)[0]
+        confidence = np.max(model.predict_proba(features_scaled))
+
+        region_predictions.append({
+            "class": predicted_class,
+            "confidence": confidence,
+            "bbox": (x, y, w, h)
+        })
+
+        cv2.rectangle(output, (x, y), (x+w, y+h), (0,255,0), 2)
+        cv2.putText(output, f"{predicted_class} ({confidence*100:.1f}%)", (x, y-10), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)
+
+    return output, region_predictions

label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d49176b41707d28a8a63a38da72d93e246edb9f20347b228724ed4bbfa785868
+size 651

main.py

@@ -0,0 +1,94 @@
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import numpy as np
+import cv2
+import io
+import base64
+from PIL import Image
+import image_processing
+
+app = FastAPI(
+    title="Soil Image Classification API",
+    description="Classifies soil images based on visual features or segmented regions.",
+    version="1.0"
+)
+
+# Allow CORS (helpful for frontend dev)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # You can restrict this to your frontend domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Convert image bytes to OpenCV format
+def read_imagefile(image_bytes):
+    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+    return cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+
+# Encode image (OpenCV format) to base64
+def encode_image_to_base64(image):
+    _, buffer = cv2.imencode('.jpg', image)
+    return base64.b64encode(buffer).decode('utf-8')
+
+@app.get("/")
+def root():
+    return {"message": "Soil Image Classifier API is running."}
+
+# Whole image prediction
+@app.post("/predictsoil/")
+async def predict_image(file: UploadFile = File(...)):
+    try:
+        image_bytes = await file.read()
+        image = read_imagefile(image_bytes)
+
+        features_df, predicted_class, confidence = image_processing.predict_image_class_with_features(
+            cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        )
+
+        return {
+            "predicted_class": predicted_class,
+            "confidence": float(confidence),
+            "features": features_df.to_dict(orient="records")[0]
+        }
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})
+
+# Region-based prediction
+@app.post("/predict-regions/")
+async def predict_regions(file: UploadFile = File(...), k_clusters: int = 2):
+    try:
+        image_bytes = await file.read()
+        image = read_imagefile(image_bytes)
+
+        segmented_image, region_predictions = image_processing.segment_and_classify_regions(
+            cv2.cvtColor(image, cv2.COLOR_BGR2RGB), 
+            k_clusters=k_clusters
+        )
+
+        base64_segmented = encode_image_to_base64(cv2.cvtColor(segmented_image, cv2.COLOR_BGR2RGB))
+
+        results = []
+        for region in region_predictions:
+            results.append({
+                "class": region["class"],
+                "confidence": float(region["confidence"]),
+                "bbox": {
+                    "x": region["bbox"][0],
+                    "y": region["bbox"][1],
+                    "width": region["bbox"][2],
+                    "height": region["bbox"][3],
+                }
+            })
+
+        return {
+            "region_count": len(results),
+            "regions": results,
+            "segmented_image_base64": base64_segmented
+        }
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})

model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76268da8935cd3067c9f4710da47b39e1abaa83a6fe64bd7729c18567c504b7c
+size 670680

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+numpy
+opencv-python
+scikit-image
+scikit-learn
+joblib
+pillow
+matplotlib

scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88236a0f28d80e350f3bb246c230229134e136f8afc5120e25de030153c0b9e7
+size 1303