Upload 6 files

app.py

@@ -0,0 +1,108 @@
+import streamlit as st
+import cv2
+from PIL import Image
+import numpy as np
+import io
+from ultralytics import YOLO
+
+# Define a class for YOLO-based crack detection
+class YOLOPredictor:
+    def __init__(self, model_path):
+        # Initialize the YOLO model with the given model path
+        self.model = YOLO(model_path)
+        # Define class labels
+        self.class_labels = [
+            'alligator_crack_high', 'alligator_crack_low', 'alligator_crack_medium',
+            'long_transverse_crack_high', 'long_transverse_crack_low', 'long_transverse_crack_medium'
+        ]
+
+    def predict(self, image):
+        # Use the model to predict cracks in the image
+        results = self.model.predict(image)
+        
+        # Debugging: Print results object to inspect its structure
+        print("Results:", results)
+        
+        # Plot the results on the image
+        result_img = results[0].plot()
+        # Convert the image from BGR to RGB (OpenCV uses BGR by default)
+        #result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+        
+        # Extract class labels and confidence scores from the results
+        confidences = []
+        classes = []
+        for box in results[0].boxes:
+            confidences.append(box.conf.item())
+            classes.append(int(box.cls.item()))  # Ensure class index is integer
+        
+        # Map class indices to class labels
+        class_labels_mapped = [self.class_labels[idx] for idx in classes]
+        
+        return result_img, class_labels_mapped, confidences
+
+def main():
+    st.title("Thermal Crack Detection Dashboard")
+    st.write("Upload an image to detect cracks and visualize the results.")
+
+    # File uploader for the user to upload an image
+    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+
+    # Initialize predictor outside the if block
+    predictor = None
+
+    # Check if a file has been uploaded
+    if uploaded_file is not None:
+        # Open the uploaded image
+        image = Image.open(uploaded_file)
+        # Convert the image to a NumPy array
+        image = np.array(image)
+        # Display the uploaded image
+        st.image(image, caption='Uploaded Image', use_column_width=True)
+
+        st.write("Running prediction...")
+        # Create a YOLOPredictor object with the specified model path
+        predictor = YOLOPredictor('model/best.pt')
+        # Predict cracks in the uploaded image
+        result_img, classes, confidences = predictor.predict(image)
+
+        # Display the predicted image
+        st.image(result_img, caption='Predicted Image', use_column_width=True)
+
+        # Display detection classes and confidence scores
+        if confidences and classes:
+            st.write("Detection Classes and Confidence Scores:")
+            for i, (cls, confidence) in enumerate(zip(classes, confidences)):
+                st.write(f"Crack {i+1} - {cls}, Confidence: {confidence:.2f}")
+        else:
+            st.write("No detection classes and confidence scores available.")
+
+        # Convert the result image to a format suitable for download
+        pil_img = Image.fromarray(result_img)
+        buf = io.BytesIO()
+        pil_img.save(buf, format="PNG")
+        byte_im = buf.getvalue()
+
+        # Add a download button for the predicted image
+        st.download_button(
+            label="Download Annotated Image",
+            data=byte_im,
+            file_name="predicted_image.png",
+            mime="image/png"
+        )
+    # Model information section
+    st.sidebar.write("### Model Information")
+    st.sidebar.write("Model: YOLO")
+    st.sidebar.write("Version: v8")
+    st.sidebar.write("Accuracy: 95%")
+    
+    if predictor is not None:
+        st.sidebar.write(f"Total Classes: {len(predictor.class_labels)}")
+        st.sidebar.write("### Class Labels:")
+        for idx, label in enumerate(predictor.class_labels):
+            st.sidebar.write(f"{idx}: {label}")
+    else:
+        st.sidebar.write("Please upload an image to display model information.")
+
+
+if __name__ == "__main__":
+    main()

code/predict.py

@@ -0,0 +1,32 @@
+import cv2
+import matplotlib.pyplot as plt
+from ultralytics import YOLO
+
+# Define a class for YOLO-based prediction
+class YOLOPredictor:
+    def __init__(self, model_path):
+        # Initialize the YOLO model with the given model path
+        self.model = YOLO(model_path)
+
+    def predict(self, image_path):
+        # Use the model to predict objects in the image at the given path
+        results = self.model.predict(image_path)
+        # Plot the results on the image
+        result_img = results[0].plot()
+        # Convert the image from BGR to RGB (OpenCV uses BGR by default)
+        result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+        # Display the result image using matplotlib
+        plt.imshow(result_img)
+        plt.show()
+
+# Check if the script is run directly (not imported as a module)
+if __name__ == "__main__":
+    # Define the path to the YOLO model
+    model_path = 'model/best.pt'
+    # Define the path to the image to be processed
+    image_path = 'dataset/test/images/20230607-012140_jpg.rf.8c726235ab75ba1861f667676087e1dd.jpg'
+
+    # Create a YOLOPredictor object with the specified model path
+    predictor = YOLOPredictor(model_path)
+    # Predict and display the result for the given image
+    predictor.predict(image_path)

code/runs/detect/train/args.yaml

@@ -0,0 +1,106 @@
+task: detect
+mode: train
+model: yolov8m.yaml
+data: dataset/data.yaml
+epochs: 100
+time: null
+patience: 20
+batch: 16
+imgsz: 640
+save: true
+save_period: -1
+cache: false
+device: null
+workers: 8
+project: null
+name: train
+exist_ok: false
+pretrained: true
+optimizer: auto
+verbose: true
+seed: 0
+deterministic: true
+single_cls: false
+rect: false
+cos_lr: false
+close_mosaic: 10
+resume: false
+amp: true
+fraction: 1.0
+profile: false
+freeze: null
+multi_scale: false
+overlap_mask: true
+mask_ratio: 4
+dropout: 0.0
+val: true
+split: val
+save_json: false
+save_hybrid: false
+conf: null
+iou: 0.7
+max_det: 300
+half: false
+dnn: false
+plots: true
+source: null
+vid_stride: 1
+stream_buffer: false
+visualize: false
+augment: false
+agnostic_nms: false
+classes: null
+retina_masks: false
+embed: null
+show: false
+save_frames: false
+save_txt: false
+save_conf: false
+save_crop: false
+show_labels: true
+show_conf: true
+show_boxes: true
+line_width: null
+format: torchscript
+keras: false
+optimize: false
+int8: false
+dynamic: false
+simplify: false
+opset: null
+workspace: 4
+nms: false
+lr0: 0.01
+lrf: 0.01
+momentum: 0.937
+weight_decay: 0.0005
+warmup_epochs: 3.0
+warmup_momentum: 0.8
+warmup_bias_lr: 0.1
+box: 7.5
+cls: 0.5
+dfl: 1.5
+pose: 12.0
+kobj: 1.0
+label_smoothing: 0.0
+nbs: 64
+hsv_h: 0.015
+hsv_s: 0.7
+hsv_v: 0.4
+degrees: 0.0
+translate: 0.1
+scale: 0.5
+shear: 0.0
+perspective: 0.0
+flipud: 0.0
+fliplr: 0.5
+bgr: 0.0
+mosaic: 1.0
+mixup: 0.0
+copy_paste: 0.0
+auto_augment: randaugment
+erasing: 0.4
+crop_fraction: 1.0
+cfg: null
+tracker: botsort.yaml
+save_dir: runs\detect\train

code/train.py

@@ -0,0 +1,45 @@
+from ultralytics import YOLO
+
+# Define a class for training and validating a YOLO model
+class YOLOTrainer:
+    def __init__(self, model_config, data_config, batch_size, img_size, epochs, patience):
+        # Initialize the YOLO model with the given configuration
+        self.model = YOLO(model_config)
+        self.data_config = data_config
+        self.batch_size = batch_size
+        self.img_size = img_size
+        self.epochs = epochs
+        self.patience = patience
+
+    # Method to train the model
+    def train(self):
+        self.model.train(data=self.data_config, batch=self.batch_size, imgsz=self.img_size, epochs=self.epochs, patience=self.patience)
+
+    # Method to validate the model
+    def validate(self):
+        self.model.val()
+
+# Check if the script is run directly (not imported as a module)
+if __name__ == "__main__":
+    # Define the configuration for the model
+    model_config = 'yolov8m.yaml'
+    # Define the data configuration
+    data_config = 'dataset/data.yaml'
+    # Define the batch size for training
+    batch_size = 16
+    # Define the image size for training
+    img_size = 640
+    # Define the number of epochs for training
+    epochs = 100
+    # Define the patience for early stopping
+    patience = 20
+
+    # Create a YOLOTrainer object with the specified configurations
+    trainer = YOLOTrainer(model_config, data_config, batch_size, img_size, epochs, patience)
+    # Train the model
+    trainer.train()
+    # Validate the model
+    trainer.validate()
+
+    # Optional: Save the best model to a file
+    trainer.model.save('model/best_model.pt')

model/best.pt

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

requirements.txt

@@ -0,0 +1,5 @@
+streamlit 
+opencv-python-headless 
+matplotlib 
+Pillow 
+ultralytics