first commit

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["gunicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,84 @@
+import os
+import cv2
+from flask import Flask, request, jsonify, render_template
+from ultralytics import YOLO
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+
+# Initialize Flask app
+app = Flask(__name__)
+
+# Load YOLO model
+trained_model = YOLO("best.pt")
+
+# Load TFLite model
+interpreter = tf.lite.Interpreter(model_path='app\\model_chip_v4.tflite')
+interpreter.allocate_tensors()
+
+# Get input and output details for TFLite model
+input_details = interpreter.get_input_details()
+output_details = interpreter.get_output_details()
+
+# ImageNet normalization values
+imagenet_mean = np.array([0.485, 0.456, 0.406])
+imagenet_std = np.array([0.229, 0.224, 0.225])
+
+@app.route('/')
+def home():
+    # Render the HTML template for the homepage
+    return render_template('index.html')
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'})
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'})
+
+    if file:
+        image = Image.open(file.stream)
+        image = image.convert('RGB')
+        image = np.array(image)
+        image_rgb = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+        results = trained_model.predict(image_rgb)
+
+        if isinstance(results, list):
+            result = results[0]
+            boxes = result.boxes.xyxy  
+            scores = result.boxes.conf  
+            classes = result.boxes.cls   
+            class_names = result.names
+
+            for i, (box, score, class_id) in enumerate(zip(boxes, scores, classes)):
+                if score > 0.4:  # Consider only detections with score > 0.4
+                    x1, y1, x2, y2 = map(int, box)
+                    cropped_img = image[y1:y2, x1:x2]
+
+                    class_id = int(class_id)
+                    class_name = class_names[class_id]
+                    if class_id == 2:
+                        cropped_img = cv2.resize(cropped_img, (92, 92))
+                        cropped_img = cropped_img.astype('float32') / 255.0
+                        cropped_img -= imagenet_mean
+                        cropped_img /= imagenet_std
+                        cropped_img = np.expand_dims(cropped_img, axis=0)
+
+                        interpreter.set_tensor(input_details[0]['index'], cropped_img)
+                        interpreter.invoke()
+                        output_data = interpreter.get_tensor(output_details[0]['index'])
+
+                        # Convert float32 to native Python float
+                        confidence_score = float(output_data[0][0])
+                        
+                        return jsonify({'confidence_score': confidence_score})
+        
+        return jsonify({'error': 'No valid detections found'})
+
+    return jsonify({'error': 'Invalid request'})
+
+if __name__ == '__main__':
+    app.run()

best.pt

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

index.js

@@ -0,0 +1,31 @@
+function uploadImage() {
+  const file = imageInput.files[0];
+  if (!file) {
+    alert("Please select an image to upload.");
+    return;
+  }
+
+  const formData = new FormData();
+  formData.append("file", file);
+
+  fetch("/predict", {
+    method: "POST",
+    body: formData,
+  })
+    .then((response) => response.json())
+    .then((data) => {
+      if (data.confidence_score !== undefined) {
+        const reader = new FileReader();
+        reader.onload = function (e) {
+          resultsImg.src = e.target.result;
+        };
+        reader.readAsDataURL(file);
+        alert("Confidence Score: " + data.confidence_score);
+      } else {
+        alert(data.error);
+      }
+    })
+    .catch((error) => {
+      console.error("Error:", error);
+    });
+}

latest.tflite

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

model_chip_v4.tflite

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

requirements.txt

@@ -0,0 +1,7 @@
+Flask
+Gunicorn
+tensorflow
+numpy
+pandas 
+opencv-python
+ultralytics

templates/index.html

@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Image Prediction</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Quicksand:wght@300..700&display=swap"
+      rel="stylesheet"
+    />
+    <style>
+      html {
+        font-family: "Quicksand", sans-serif;
+      }
+      .camera-container {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        margin-bottom: 20px;
+      }
+
+      .results-container {
+        margin-top: 20px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+
+      #camera {
+        width: 100%;
+        max-width: 600px;
+        border: 2px solid #ccc;
+      }
+
+      #results {
+        width: 100%;
+        max-width: 600px;
+        border: 2px solid #ccc;
+      }
+
+      .btn-container {
+        display: flex;
+        justify-content: center;
+        margin-top: 20px;
+      }
+
+      .btn {
+        margin: 5px;
+        padding: 10px 20px;
+        background-color: #1864ab;
+        color: white;
+        border: none;
+        cursor: pointer;
+        border-radius: 12px;
+      }
+
+      .btn:hover {
+        background-color: #45a049;
+      }
+
+      .upload-form {
+        display: flex;
+        justify-content: center;
+        margin-top: 20px;
+      }
+
+      #imageInput {
+        margin-right: 10px;
+      }
+    </style>
+    <script src="index.js" defer></script>
+  </head>
+  <body>
+    <div class="camera-container">
+      <h1>Capture Image</h1>
+      <video id="camera" autoplay></video>
+      <canvas id="canvas" style="display: none"></canvas>
+      <div class="btn-container">
+        <button class="btn" id="capture-btn">Capture</button>
+      </div>
+    </div>
+
+    <div class="upload-form">
+      <form id="uploadForm">
+        <input type="file" id="imageInput" accept="image/*" required />
+        <button type="button" class="btn" onclick="uploadImage()">
+          Upload Image
+        </button>
+      </form>
+    </div>
+
+    <div class="results-container">
+      <h2>Results</h2>
+      <img id="results" src="" />
+    </div>
+
+    <script>
+      const video = document.getElementById("camera");
+      const canvas = document.getElementById("canvas");
+      const captureBtn = document.getElementById("capture-btn");
+      const imageInput = document.getElementById("imageInput");
+      const resultsImg = document.getElementById("results");
+
+      // Access the webcam
+      navigator.mediaDevices
+        .getUserMedia({ video: true })
+        .then((stream) => {
+          video.srcObject = stream;
+        })
+        .catch((err) => {
+          console.error("Error accessing webcam: ", err);
+        });
+
+      // Capture the image
+      captureBtn.addEventListener("click", () => {
+        const context = canvas.getContext("2d");
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        context.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+        canvas.toBlob((blob) => {
+          const formData = new FormData();
+          formData.append("file", blob, "captured_image.png");
+
+          fetch("/predict", {
+            method: "POST",
+            body: formData,
+          })
+            .then((response) => response.json())
+            .then((data) => {
+              if (data.confidence_score !== undefined) {
+                resultsImg.src = canvas.toDataURL("image/png");
+                alert("Confidence Score: " + data.confidence_score);
+              } else {
+                alert(data.error);
+              }
+            })
+            .catch((error) => {
+              console.error("Error:", error);
+            });
+        }, "image/png");
+      });
+
+      // Upload the selected image
+      function uploadImage() {
+        const file = imageInput.files[0];
+        if (!file) {
+          alert("Please select an image to upload.");
+          return;
+        }
+
+        const formData = new FormData();
+        formData.append("file", file);
+
+        fetch("/predict", {
+          method: "POST",
+          body: formData,
+        })
+          .then((response) => response.json())
+          .then((data) => {
+            if (data.confidence_score !== undefined) {
+              const reader = new FileReader();
+              reader.onload = function (e) {
+                resultsImg.src = e.target.result;
+              };
+              reader.readAsDataURL(file);
+              alert("Confidence Score: " + data.confidence_score);
+            } else {
+              alert(data.error);
+            }
+          })
+          .catch((error) => {
+            console.error("Error:", error);
+          });
+      }
+    </script>
+  </body>
+</html>