Upload 6 files

app.py

@@ -0,0 +1,199 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for, session
+from pymongo import MongoClient
+import pickle
+import random
+import threading
+import time
+import pandas as pd
+from bson import ObjectId
+from flask_socketio import SocketIO, emit
+from tensorflow.keras.models import load_model  # type: ignore
+from PIL import Image
+import numpy as np
+
+app = Flask(__name__)
+app.secret_key = b'\xddhO\xc8\x05\xb8<\xa5m1\xa5\x9c\x11O5\xaf\x9e\t\xe8\xcd\x1bWv`'
+socketio = SocketIO(app)
+
+# MongoDB connection setup
+client = MongoClient('mongodb://localhost:27017/')
+db = client['risk_prediction_db']
+users_collection = db['users']
+evidence_collection = db['evidences']
+
+# Load the pre-trained CNN model for evidence type classification (3 classes)
+evidence_type_model = load_model('models/evidence_type_cnn.h5')
+
+# Load the risk prediction model
+with open('models/risk_prediction_model.pkl', 'rb') as f:
+    model = pickle.load(f)
+
+# Load the scaler used during training for the risk prediction model
+with open('models/scaler.pkl', 'rb') as f:
+    scaler = pickle.load(f)
+
+# Default variables based on evidence type (updated with correct classes)
+evidence_defaults = {
+    'fingerprint': {'Temperature': '28', 'Humidity': '55', 'Vibration': '0', 'Light_Intensity': '250', 'Battery_Level': '85'},
+    'gun': {'Temperature': '22', 'Humidity': '40', 'Vibration': '1', 'Light_Intensity': '300', 'Battery_Level': '90'},
+    'stained_cloth': {'Temperature': '25', 'Humidity': '50', 'Vibration': '0', 'Light_Intensity': '200', 'Battery_Level': '80'}
+}
+
+# Global flag to track simulation state
+simulation_running = False
+
+# Login route
+@app.route('/', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        username = request.form['username']
+        password = request.form['password']
+
+        user = users_collection.find_one({'username': username, 'password': password})
+        if user:
+            session['username'] = username
+            return redirect(url_for('home'))
+        else:
+            return 'Invalid login credentials'
+
+    return render_template('login.html')
+
+# Route for predicting the evidence type when the image is uploaded
+@app.route('/predict_evidence', methods=['POST'])
+def predict_evidence():
+    if 'username' not in session:
+        return jsonify({'error': 'Unauthorized'}), 401
+
+    if 'evidence_image' not in request.files:
+        return jsonify({'error': 'No image uploaded'}), 400
+
+    # Handle image upload for CNN prediction
+    evidence_image = request.files['evidence_image']
+    img = Image.open(evidence_image).resize((64, 64))
+    img_array = np.array(img) / 255.0  # Normalize the image
+    img_array = img_array.reshape(1, 64, 64, 3)  # Add batch dimension
+
+    # Use the CNN model to predict the evidence type
+    prediction = evidence_type_model.predict(img_array)
+    predicted_class = np.argmax(prediction[0])  # Get class index
+
+    # Update the classes based on the correct evidence types
+    evidence_types = ['fingerprint', 'gun', 'stained_cloth']
+    predicted_evidence = evidence_types[predicted_class]
+
+    # Autofill variables based on the predicted evidence type
+    variables = evidence_defaults[predicted_evidence]
+
+    # Return predicted evidence type and variables as JSON
+    return jsonify({
+        'predicted_evidence': predicted_evidence,
+        'variables': variables
+    })
+
+# Home route for submitting the final evidence and running risk prediction
+@app.route('/home', methods=['GET', 'POST'])
+def home():
+    global simulation_running
+
+    if 'username' not in session:
+        return redirect(url_for('login'))
+
+    if request.method == 'POST':
+        # Get variables from the form
+        variables = {
+            'Temperature': request.form['temperature'],
+            'Humidity': request.form['humidity'],
+            'Vibration': request.form['vibration'],
+            'Light_Intensity': request.form['light_intensity'],
+            'Battery_Level': request.form['battery_level']
+        }
+
+        # Run risk prediction using the ensemble model
+        features = pd.DataFrame([variables], columns=[
+            'Temperature', 'Humidity', 'Vibration', 'Light_Intensity', 'Battery_Level'
+        ])
+        scaled_features = scaler.transform(features)
+        risk_prediction = model.predict(scaled_features)[0]
+        risk = 'High Risk' if risk_prediction == 1 else 'Low Risk'
+
+        # Store the evidence and prediction in MongoDB
+        evidence_id = str(ObjectId())
+        evidence_collection.insert_one({
+            '_id': evidence_id,
+            'username': session['username'],
+            'variables': variables,
+            'risk_prediction': risk
+        })
+
+        # Start the IoT simulation after the first prediction, if not already running
+        if not simulation_running:
+            simulation_running = True
+            threading.Thread(target=simulate_iot_data, daemon=True).start()
+
+        return redirect(url_for('dashboard'))
+
+    return render_template('home.html')
+
+# Dashboard route to display evidence logs and risk status
+@app.route('/dashboard')
+def dashboard():
+    if 'username' not in session:
+        return redirect(url_for('login'))
+
+    evidences = list(evidence_collection.find({'username': session['username']}))
+    return render_template('dashboard.html', evidences=evidences)
+
+# Simulate IoT Monitoring (Random data changes)
+def simulate_iot_data():
+    global simulation_running
+
+    while simulation_running:
+        time.sleep(10)  # Simulate IoT update every 10 seconds (for testing purposes)
+
+        # Retrieve all evidences from MongoDB
+        all_evidences = evidence_collection.find()
+
+        for evidence in all_evidences:
+            # Randomly update numerical variables to simulate IoT changes
+            updated_values = {
+                'Temperature': random.uniform(10, 50),       # Simulate temperature (°C)
+                'Humidity': random.uniform(30, 90),          # Simulate humidity (%)
+                'Vibration': random.randint(0, 1),           # Simulate vibration (0 or 1)
+                'Light_Intensity': random.uniform(100, 1000),# Simulate light intensity (lx)
+                'Battery_Level': random.uniform(0, 100),     # Simulate battery level (%)
+            }
+
+            # Update evidence with new simulated values in MongoDB
+            evidence_collection.update_one(
+                {'_id': evidence['_id']},
+                {'$set': {'variables': updated_values}}
+            )
+
+            # Create features DataFrame with correct column names
+            features = pd.DataFrame([updated_values], columns=[
+                'Temperature', 'Humidity', 'Vibration', 'Light_Intensity',
+                'Battery_Level'
+            ])
+            scaled_features = scaler.transform(features)
+
+            # Run the risk prediction with updated data
+            risk_prediction = model.predict(scaled_features)[0]  # Use DataFrame
+            new_risk = 'High Risk' if risk_prediction == 1 else 'Low Risk'
+
+            # If risk status changes, update it
+            if new_risk != evidence['risk_prediction']:
+                evidence_collection.update_one(
+                    {'_id': evidence['_id']},
+                    {'$set': {'risk_prediction': new_risk}}
+                )
+
+                # Emit real-time risk updates to all connected clients
+                socketio.emit('risk_update', {
+                    'evidence_id': str(evidence['_id']),
+                    'risk': new_risk,
+                    'variables': updated_values
+                })
+
+# Start the Flask app with SocketIO
+if __name__ == '__main__':
+    socketio.run(app, debug=True)

evidences_db.py

@@ -0,0 +1,50 @@
+from pymongo import MongoClient
+
+# Connect to MongoDB
+client = MongoClient('mongodb://localhost:27017/')
+db = client['risk_prediction_db']
+evidence_collection = db['evidences']
+
+# Example evidence records to insert
+sample_evidences = [
+    {
+        "username": "admin",
+        "image_filename": "evidence_image_1.png",
+        "temperature": 25.3,
+        "humidity": 60.5,
+        "vibration": 1,  # 1 means "Yes"
+        "light_intensity": 400.0,
+        "battery_level": 85.0,
+        "latitude": 37.7749,
+        "longitude": -122.4194,
+        "risk_prediction": "High Risk"
+    },
+    {
+        "username": "user1",
+        "image_filename": "evidence_image_2.png",
+        "temperature": 22.1,
+        "humidity": 55.3,
+        "vibration": 0,  # 0 means "No"
+        "light_intensity": 500.0,
+        "battery_level": 90.0,
+        "latitude": 40.7128,
+        "longitude": -74.0060,
+        "risk_prediction": "Low Risk"
+    },
+    {
+        "username": "user2",
+        "image_filename": "evidence_image_3.png",
+        "temperature": 35.7,
+        "humidity": 75.1,
+        "vibration": 1,  # 1 means "Yes"
+        "light_intensity": 300.0,
+        "battery_level": 65.0,
+        "latitude": 51.5074,
+        "longitude": -0.1278,
+        "risk_prediction": "High Risk"
+    }
+]
+
+# Insert evidence records into MongoDB
+evidence_collection.insert_many(sample_evidences)
+print("inserted")

image_generation.py

@@ -0,0 +1,23 @@
+from google_images_download import google_images_download
+
+response = google_images_download.googleimagesdownload()
+
+# Define the search keywords and the number of images to download for each
+search_queries = ['blood', 'cloth', 'gun', 'fingerprint']
+
+def download_images(query):
+    arguments = {
+        "keywords": query,
+        "limit": 100,  # Number of images to download
+        "print_urls": True,
+        "output_directory": "C:/COLLEGE/web develop/Evidence_prediction/data/train",
+        "format": "jpg",
+        "no_directory": False
+    }
+    try:
+        response.download(arguments)
+    except Exception as e:
+        print(f"Error downloading images for {query}: {e}")
+
+for query in search_queries:
+    download_images(query)

login_db.py

@@ -0,0 +1,26 @@
+from pymongo import MongoClient
+
+# Connect to MongoDB
+client = MongoClient('mongodb://localhost:27017/')
+db = client['risk_prediction_db']
+users_collection = db['users']
+
+# Example users to insert
+sample_users = [
+    {
+        "username": "admin",
+        "password": "admin123"  # Hashed password
+    },
+    {
+        "username": "user1",
+        "password": "user1234" # Hashed password
+    },
+    {
+        "username": "user2",
+        "password": "password5678" # Hashed password
+    }
+]
+
+# Insert users into MongoDB
+users_collection.insert_many(sample_users)
+print("Inserted")

models.py

@@ -0,0 +1,61 @@
+import os
+import numpy as np
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from tensorflow.keras.optimizers import Adam
+
+# Define image dimensions
+IMAGE_SIZE = (64, 64)
+BATCH_SIZE = 32
+EPOCHS = 10
+
+# Paths for training and validation data
+TRAIN_DIR = 'data/train'
+VALIDATION_DIR = 'data/validation'
+
+# Data augmentation and normalization for training
+train_datagen = ImageDataGenerator(rescale=1./255)
+validation_datagen = ImageDataGenerator(rescale=1./255)
+
+train_generator = train_datagen.flow_from_directory(
+    TRAIN_DIR,
+    target_size=IMAGE_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='categorical'  # Use 'categorical' for multiple classes
+)
+
+validation_generator = validation_datagen.flow_from_directory(
+    VALIDATION_DIR,
+    target_size=IMAGE_SIZE,
+    batch_size=BATCH_SIZE,
+    class_mode='categorical'
+)
+
+# Check if data generators are correctly detecting 3 classes
+assert train_generator.num_classes == 3, "Train generator is detecting more/less than 3 classes"
+assert validation_generator.num_classes == 3, "Validation generator is detecting more/less than 3 classes"
+
+# CNN Model Definition with 3 output classes
+model = Sequential([
+    Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)),
+    MaxPooling2D(pool_size=(2, 2)),
+    Conv2D(64, (3, 3), activation='relu'),
+    MaxPooling2D(pool_size=(2, 2)),
+    Flatten(),
+    Dense(128, activation='relu'),
+    Dense(3, activation='softmax')  # 3 classes: blood, cloth, fingerprint
+])
+
+# Compile the model
+model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])
+
+# Train the model
+model.fit(
+    train_generator,
+    epochs=EPOCHS,
+    validation_data=validation_generator
+)
+
+# Save the model to the 'models/' directory
+model.save('models/evidence_type_cnn.h5')

secret.py

@@ -0,0 +1,3 @@
+import os
+secret_key = os.urandom(24)
+print("secret key is :",secret_key)