explain.md · LovnishVerma/braintumor at 8184f03543b2e592486012c086950ea60b57df66

Code Explanation for Brain Tumor Detection Application Using Flask

This Flask-based application allows users to upload an image (like an MRI scan) to predict if a brain tumor is detected using a pre-trained CNN (Convolutional Neural Network) model. The results, along with user details, are saved in a MongoDB database for review.

1. Importing Required Libraries

from flask import Flask, flash, request, redirect, render_template
import os
import cv2
import imutils
import numpy as np
from tensorflow.keras.models import load_model
from werkzeug.utils import secure_filename
import tempfile
from pymongo import MongoClient
from datetime import datetime

Flask: A lightweight web framework to create web applications.
OpenCV (cv2): Library for image processing.
imutils: Helper functions for image manipulation.
NumPy: Array and mathematical operations.
TensorFlow/Keras: To load the pre-trained brain tumor detection model.
MongoDB: To store user inputs and model predictions.
Werkzeug: For securely handling file uploads.
Datetime: To save the timestamp for each prediction.

2. Loading the Pre-trained Model

braintumor_model = load_model('models/braintumor.h5')

The brain tumor model (braintumor.h5) is loaded. This is a CNN-based model trained to detect brain tumors from images.

3. Flask Application Configuration

app = Flask(__name__)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0  # Disable caching
app.secret_key = "nielitchandigarhpunjabpolice"

Flask is initialized, and caching for images is disabled to ensure updated images load after upload.
A secret key is set for session management, which helps in managing messages (like flash messages).

4. MongoDB Connection

client = MongoClient("mongodb+srv://test:test@cluster0.sxci1.mongodb.net/?retryWrites=true&w=majority")
db = client['brain_tumor_detection']  # Database name
collection = db['predictions']  # Collection name

Connects to MongoDB Atlas (cloud-hosted database).
A database named brain_tumor_detection and collection predictions are created to store user details and predictions.

5. File Upload Helper Function

ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS

Only files with extensions png, jpg, jpeg are allowed to ensure proper image input.

6. Image Preprocessing

a. preprocess_imgs: Resizing Images

def preprocess_imgs(set_name, img_size):
    set_new = []
    for img in set_name:
        img = cv2.resize(img, dsize=img_size, interpolation=cv2.INTER_CUBIC)
        set_new.append(img)
    return np.array(set_new)

Resizes the input image to a specific size (224x224) required by the model.

b. crop_imgs: Region of Interest (ROI) Extraction

def crop_imgs(set_name, add_pixels_value=0):
    set_new = []
    for img in set_name:
        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
        gray = cv2.GaussianBlur(gray, (5, 5), 0)
        thresh = cv2.threshold(gray, 45, 255, cv2.THRESH_BINARY)[1]
        cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        c = max(cnts, key=cv2.contourArea)
        extLeft = tuple(c[c[:, :, 0].argmin()][0])
        extRight = tuple(c[c[:, :, 0].argmax()][0])
        extTop = tuple(c[c[:, :, 1].argmin()][0])
        extBot = tuple(c[c[:, :, 1].argmax()][0])
        new_img = img[extTop[1]:extBot[1], extLeft[0]:extRight[0]].copy()
        set_new.append(new_img)
    return np.array(set_new)

This function identifies the region of interest (ROI), cropping only the area where the brain is located for better accuracy.

7. Routes in Flask

a. / Route - Main Page

@app.route('/')
def brain_tumor():
    return render_template('braintumor.html')

Displays the main upload form (braintumor.html).

b. /resultbt Route - Prediction

@app.route('/resultbt', methods=['POST'])
def resultbt():
    # 1. Extract user inputs
    firstname = request.form['firstname']
    file = request.files['file']
    
    # 2. Validate image
    if file and allowed_file(file.filename):
        temp_file = tempfile.NamedTemporaryFile(delete=False)
        file.save(temp_file.name)

        # 3. Process Image
        img = cv2.imread(temp_file.name)
        img = crop_imgs([img])
        img = preprocess_imgs([img], (224, 224))

        # 4. Predict
        pred = braintumor_model.predict(img)
        prediction = 'Tumor Detected' if pred[0][0] >= 0.5 else 'No Tumor Detected'
        confidence_score = float(pred[0][0])

        # 5. Save to MongoDB
        result = {
            "firstname": firstname,
            "prediction": prediction,
            "confidence_score": confidence_score,
            "timestamp": datetime.utcnow()
        }
        collection.insert_one(result)

        # 6. Return Results
        return render_template('resultbt.html', r=prediction)
    else:
        flash('Invalid file format!')
        return redirect(request.url)

Step-by-step Flow:
1. Accept user inputs and uploaded image.
2. Validate the file format.
3. Preprocess the image (crop and resize).
4. Use the CNN model to predict if there is a tumor.🚀
5. Save the prediction and user details to MongoDB.
6. Return the result.

c. /dbresults Route - Fetch Predictions

@app.route('/dbresults')
def dbresults():
    all_results = collection.find().sort("timestamp", -1)
    tumor_count = sum(1 for r in all_results if r['prediction'] == 'Tumor Detected')
    total_patients = collection.count_documents({})
    return render_template('dbresults.html', total_patients=total_patients, tumor_count=tumor_count)

Fetches all predictions from MongoDB and aggregates results (total patients, tumors detected).

8. Running the App

if __name__ == '__main__':
    app.run(debug=True)

Runs the Flask application in debug mode.

Summary of Flow

User uploads an MRI image and provides basic details.
Image is preprocessed (cropped, resized) for the CNN model.
The model predicts if a brain tumor is detected or not.
Results are stored in MongoDB and displayed back to the user.
Admins can view all results via the /dbresults route.

Tips

Flask Routes handle user requests (/, /resultbt, /dbresults).
OpenCV helps preprocess images.
MongoDB stores user details and model predictions.
Model Prediction is done via a pre-trained Keras model.
Templates (braintumor.html, resultbt.html) are used to display data.