Upload 18 files

README.md

@@ -1,13 +1,70 @@
 ---
-title: Crack Mapping
-emoji: 🐢
-colorFrom: purple
-colorTo: gray
+title: Crack Segmentation
+emoji: 🗿
+colorFrom: yellow
+colorTo: blue
 sdk: gradio
-sdk_version: 4.8.0
+sdk_version: 4.1.1
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Crack Segmentation Web Application
+
+Welcome to the Crack Segmentation Web Application! This tool is designed to segment concrete cracks in images. It's powered by Gradio and deployed on HuggingFace's Spaces platform. The underlying model and utilities are built using Python 3.10.9.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Dependencies](#dependencies)
+- [License](#license)
+
+## Features
+
+- **Interactive UI:** Powered by Gradio for easy upload and visualization of corrosion segmentation results.
+- **High-Quality Segmentation:** Uses state-of-the-art machine learning techniques to provide accurate segmentation results.
+- **Deployed on HuggingFace Spaces:** Access the application anytime from anywhere!
+
+## Installation
+
+To run this application locally:
+
+1. Clone the repository:
+    ```bash
+    git clone https://github.com/cawil-ai/Cawil-Corrosion-Segmentation.git 
+    cd Cawil-Corrosion-Segmentation
+    ```
+
+2. Install the required dependencies:
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+1. Once the dependencies are installed, run the application using the command:
+    ```bash
+    python app.py
+    ```
+
+2. Navigate to the URL provided in the console to access the web application.
+
+3. Upload an image and click on 'Segment' to view the corrosion segmentation results.
+
+## Dependencies
+
+The application requires the following Python packages:
+
+```
+gradio==4.1.1
+numpy==1.26.1
+pandas==2.1.2
+Pillow==10.1.0
+shortuuid==1.0.11
+ultralytics==8.0.206
+```
+
+These dependencies can also be found in the `requirements.txt` file in the repository.

app.py

@@ -0,0 +1,307 @@
+import cv2
+import gradio as gr
+import pandas as pd
+import shortuuid
+from ultralytics import YOLO
+from utils.data_utils import clear_all
+import torch
+import numpy as np
+import os
+from utils.measure_utils import ContourAnalyzer
+from PIL import Image
+import utils.plot as pt
+
+
+# Clear any previous data and configurations
+clear_all()
+model = YOLO('./weights/best.pt')
+# Define the color scheme/theme for the website
+theme = gr.themes.Soft(
+    primary_hue="orange",
+    secondary_hue="sky",
+)
+#Custom css for styling
+css = """
+    .size {
+        min-height: 400px !important;
+        max-height: 400px !important;
+        overflow: auto !important;
+    }
+"""
+
+# Create the Gradio interface using defined theme and CSS
+with gr.Blocks(theme=theme, css=css) as demo:
+    # Title and description for the app
+    gr.Markdown("# Concrete Crack Detection and Segmentation")
+    gr.Markdown("Upload concrete crack images and get segmented results.")
+    with gr.Tab('Instructions'):
+        gr.Markdown(
+    """**Instructions for Concrete Crack Detection and Segmentation App:**
+
+    **Input:**
+    - Upload one or more concrete crack images using the "Image Input" section.
+    - Adjust confidence level and distance sliders if needed.\n
+    **Buttons:**
+    - Click "Segment" to perform crack segmentation.
+    - Click "Clear" to reset inputs and outputs.\n
+    **Output:**
+    - View segmented images in the "Image Output" gallery.
+    - Check crack detection results in the "Results" table.
+    - Download the PDF report file with detailed information..
+
+    **Additional Information:**
+    - The app uses a YOLOv8 trained model for crack detection with 86.8\% accuracy.
+    - Results include orientation category, width of the crack (widest), number of cracks per photo.
+
+    **Notes:**
+    - Ensure uploaded images are in the supported formats: PNG, JPG, JPEG, WEBP.
+    - Remarks and Reference Image must have data.
+
+    **Enjoy detecting and segmenting concrete cracks with the app!**
+    """)
+    # Image tab
+    with gr.Tab("Image"):
+        
+        with gr.Row():           
+            with gr.Column():
+                # Input section for uploading images
+                image_input = gr.File(
+                    file_count="multiple",
+                    file_types=["image"],
+                    label="Image Input",
+                    elem_classes="size",
+                )
+
+
+                #Confidence Score for prediction
+                conf = gr.Slider(value=20,step=5, label="Confidence", 
+                                   interactive=True)
+                distance = gr.Slider(value=10,step=1, label="Distance (cm)", 
+                                   interactive=True)
+                # Buttons for segmentation and clearing
+                image_remark = gr.Textbox(label="Remark for the Batch",
+                                          placeholder='Fifth floor: Wall facing the door')
+                with gr.Row():
+                    image_button = gr.Button("Segment", variant='primary')
+                    image_clear = gr.ClearButton()
+
+            with gr.Column():
+                # Display section for segmented images
+                image_output = gr.Gallery(
+                    label="Image Output",
+                    show_label=True,
+                    elem_id="gallery",
+                    columns=2,
+                    object_fit="contain",
+                    height=400,
+                )
+                md_result = gr.Markdown("**Results**", visible=False)
+                csv_image = gr.File(label='Report', interactive=False, visible=False)
+                df_image = gr.DataFrame(visible=False)
+
+                
+        image_reference = gr.File(
+                    file_count="multiple",
+                    file_types=["image"],
+                    label="Reference Image",)
+
+
+    def detect_pattern(image_path):
+        """
+        Detect concrete cracks in the binary image.
+
+        Parameters:
+            image_path (str): Path to the binary image.
+
+        Returns:
+            tuple: Principal orientation and orientation category.
+        """
+        image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+        skeleton = cv2.erode(image, np.ones((3, 3), dtype=np.uint8), iterations=1)
+        contours, _ = cv2.findContours(skeleton, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        data_pts = np.vstack([contour.squeeze() for contour in contours])
+        mean, eigenvectors = cv2.PCACompute(data_pts.astype(np.float32), mean=None)
+        principal_orientation = np.arctan2(eigenvectors[0, 1], eigenvectors[0, 0])
+
+        if -0.05 <= principal_orientation <= 0.05:
+            orientation_category = "Horizontal"
+        elif 1 <= principal_orientation <= 1.8:
+            orientation_category = "Vertical"
+        elif -0.99 <= principal_orientation <= 0.99:
+            orientation_category = "Diagonal"
+        else:
+            orientation_category = "Other"
+
+        return principal_orientation, orientation_category
+
+    def load_model():
+        """
+        Load the YOLO model with pre-trained weights.
+        
+        Returns:
+            model: Loaded YOLO model.
+        """
+        return YOLO('./weights/best.pt')
+    
+    def generate_uuid():
+        """
+        Generates a short unique identifier.
+        
+        Returns:
+            str: Unique identifier string.
+        """
+        return str(shortuuid.uuid())
+
+
+    def preprocess_image(image):
+        """ 
+        Preprocesses the input image.
+        
+        Parameters:
+            image (numpy.array or PIL.Image): Image to preprocess.
+        
+        Returns:
+            numpy.array: Resized and converted RGB version of the input image.
+        """
+
+        image = np.array(image)
+
+        input_image = Image.fromarray(image)
+        input_image = input_image.resize((640, 640))
+        input_image = input_image.convert("RGB")
+
+        return np.array(input_image)
+    
+    
+    def predict_segmentation_im(image, conf, reference, remark):
+        """
+        Perform segmentation prediction on a list of images.
+        
+        Parameters:
+            image (list): List of images for segmentation.
+            conf (float): Confidence score for prediction.
+
+        Returns:
+            tuple: Paths of the processed images, CSV file, DataFrame, and Markdown.
+        """
+        # Check if reference or remark is empty
+        if not reference:
+            raise gr.Error("Reference Image cannot be empty.")
+        if not remark:
+            raise gr.Error("Batch Remark cannot be empty.")
+        if not image:
+            raise gr.Error("Image input cannot be empty.")
+        
+        print("THE REFERENCE IN APPPY", reference)
+        uuid = generate_uuid()
+        image_list = [preprocess_image(Image.open(file.name)) for file in image]
+        filenames = [file.name for file in image]
+        conf= conf * 0.01
+        model = load_model()
+        results = model.predict(image_list, conf=conf, save=True, project='output', name=uuid, stream=True)
+        processed_image_paths = []
+        output_image_paths = []
+        result_list = []
+        width_list = []
+        orientation_list = []
+        width_interpretations = []
+        # Populate the dataframe with counts
+        for i, r in enumerate(results):
+            result_list.append(r)
+            instance_count = len(r)
+            if r.masks is not None and r.masks.data.numel() > 0:
+                masks = r.masks.data
+                boxes = r.boxes.data
+                clss = boxes[:, 5]
+                people_indices = torch.where(clss == 0)
+                people_masks = masks[people_indices]
+                people_mask = torch.any(people_masks, dim=0).int() * 255
+                processed_image_path = str(model.predictor.save_dir / f'binarize{i}.jpg')
+                cv2.imwrite(processed_image_path, people_mask.cpu().numpy())
+                processed_image_paths.append(processed_image_path)
+                
+                crack_image_path = processed_image_path
+                principal_orientation, orientation_category = detect_pattern(crack_image_path)
+                
+                # Print the results if needed
+                print(f"Crack Detection Results for {crack_image_path}:")
+                print("Principal Component Analysis Orientation:", principal_orientation)
+                print("Orientation Category:", orientation_category)
+
+                # Load the original image in color
+                original_img = cv2.imread(f'output/{uuid}/image{i}.jpg')
+                orig_image_path = str(model.predictor.save_dir / f'image{i}.jpg')
+                processed_image_paths.append(orig_image_path)
+                # Load and resize the binary image to match the dimensions of the original image
+                binary_image = cv2.imread(f'output/{uuid}/binarize{i}.jpg', cv2.IMREAD_GRAYSCALE)
+                binary_image = cv2.resize(binary_image, (original_img.shape[1], original_img.shape[0]))
+
+                contour_analyzer = ContourAnalyzer()
+                max_width, thickest_section, thickest_points, distance_transforms = contour_analyzer.find_contours(binary_image)
+
+                visualized_image = original_img.copy()
+                cv2.drawContours(visualized_image, [thickest_section], 0, (0, 255, 0), 1)
+
+                contour_analyzer.draw_circle_on_image(visualized_image, (int(thickest_points[0]), int(thickest_points[1])), 5, (57, 255, 20), -1)
+                print("Max Width in pixels: ", max_width)
+
+                width = contour_analyzer.calculate_width(y=10, x=5, pixel_width=max_width, calibration_factor=0.001, distance=150)
+                print("Max Width, converted: ", width)
+                
+                prets = pt.classify_wall_damage(width)
+                width_interpretations.append(prets)
+                
+                visualized_image_path = f'output/{uuid}/visualized_image{i}.jpg'
+                output_image_paths.append(visualized_image_path)
+                cv2.imwrite(visualized_image_path, visualized_image)
+
+                width_list.append(round(width, 2))
+                orientation_list.append(orientation_category)
+            else:
+                original_img = cv2.imread(f'output/{uuid}/image{i}.jpg')
+                visualized_image_path = f'output/{uuid}/visualized_image{i}.jpg'
+                output_image_paths.append(visualized_image_path)
+                cv2.imwrite(visualized_image_path, original_img)
+                width_list.append('None')
+                orientation_list.append('None')
+                width_interpretations.append('None')
+
+        # Delete binarized and initial segmented images after processing
+        for path in processed_image_paths:
+            if os.path.exists(path):
+                os.remove(path)
+                
+        # results = gr.Textbox(res, visible=True)
+        csv, df = pt.count_instance(result_list, filenames, uuid, width_list, orientation_list, output_image_paths, reference, remark, width_interpretations)
+
+        csv = gr.File(value=csv, visible=True)
+        df = gr.DataFrame(value=df, visible=True)
+        md = gr.Markdown(visible=True)
+
+        # return get_all_file_paths(f"output/{uuid}/"), csv, df, md
+        return output_image_paths, csv, df, md
+
+
+    # Connect the buttons to the prediction function and clear function
+    image_button.click(
+        predict_segmentation_im,
+        inputs=[image_input, conf, image_reference, image_remark],
+        outputs=[image_output, csv_image, df_image, md_result]
+    )
+    
+    image_clear.click(
+        lambda: [
+            None,
+            None,
+            gr.Markdown(visible=False),
+            gr.File(visible=False),
+            gr.DataFrame(visible=False),
+            gr.Slider(value=20),
+            None,
+            None
+        ],
+        outputs=[image_input, image_output, md_result, csv_image, df_image, conf, image_reference, image_remark]
+    )
+
+# Launch the Gradio app
+demo.launch()

packages.txt

@@ -0,0 +1 @@
+wkhtmltopdf

requirements.txt

@@ -0,0 +1,11 @@
+beautifulsoup4==4.12.2
+gradio==4.8.0
+imgkit==1.2.3
+ipython==8.18.1
+numpy==1.26.2
+pandas==2.1.3
+pdfkit==1.0.0
+Pillow==10.1.0
+shortuuid==1.0.11
+torch==2.1.1
+ultralytics==8.0.222

utils/data_utils.py

@@ -0,0 +1,53 @@
+import os
+import shutil
+import shortuuid
+
+
+def clear_all():
+    """
+    Removes the 'output/' directory along with its content.
+    
+    Returns:
+        None
+    """
+    shutil.rmtree('output/', ignore_errors=True)
+
+def clear_value_tab(path):
+    """
+    Removes a specific sub-directory under 'output/'.
+    
+    Parameters:
+        path (str): Sub-directory to remove.
+    
+    Returns:
+        None
+    """
+    print(path)
+    shutil.rmtree(os.path.join('output/', path), ignore_errors=True)
+
+def get_all_file_paths(directory):
+    """
+    Collects all image file paths under a given directory.
+    
+    Parameters:
+        directory (str): Directory to search for image files.
+    
+    Returns: 
+        list: List of image file paths.
+    """
+    allowed_extensions = ('.png', '.jpg', '.jpeg', '.gif', '.bmp')
+    return [
+        os.path.join(root, file)
+        for root, _, files in os.walk(directory)
+        for file in files
+        if file.lower().endswith(allowed_extensions)
+    ]
+
+def generate_uuid():
+    """
+    Generates a short unique identifier.
+    
+    Returns:
+        str: Unique identifier string.
+    """
+    return str(shortuuid.uuid())

utils/image_utils.py

@@ -0,0 +1,70 @@
+import os
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+def preprocess_image(image):
+    """
+    Preprocesses the input image.
+    
+    Parameters:
+        image (numpy.array or PIL.Image): Image to preprocess.
+    
+    Returns:
+        numpy.array: Resized and converted RGB version of the input image.
+    """
+    # Convert PIL image to numpy array if required
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+
+    # Resize and convert the image to RGB
+    input_image = Image.fromarray(image)
+    input_image = input_image.resize((640, 640))
+    input_image = input_image.convert("RGB")
+
+    return np.array(input_image)
+
+
+import pandas as pd
+import os
+
+def count_instance(result, filenames, uuid, width_list, orientation_list):
+    """
+    Counts the instances in the result and generates a CSV with the counts.
+    
+    Parameters:
+        result (list): List containing results for each instance.
+        filenames (list): Corresponding filenames for each result.
+        uuid (str): Unique ID for the output folder name.
+        width_list (list): List containing width values for each instance.
+        orientation_list (list): List containing orientation values for each instance.
+    
+    Returns:
+        tuple: Path to the generated CSV and dataframe with counts.
+    """
+    # Initializing the dataframe
+    data = {
+        'Index': [],
+        'FileName': [],
+        'Orientation': [],
+        'Width': [],
+        'Instance': []
+    }
+    df = pd.DataFrame(data)
+
+    # Populate the dataframe with counts, width, and orientation
+    for i, res in enumerate(result):
+        instance_count = len(res)
+        df.loc[i] = [i, os.path.basename(filenames[i]), orientation_list[i], width_list[i], instance_count]
+
+    # Save dataframe to a CSV file
+    path = os.path.join('output', uuid)
+    os.makedirs(path, exist_ok=True)
+    csv_filename = os.path.join(path, '_results.csv')
+    
+    # Reorder columns
+    df = df[['Index', 'FileName', 'Orientation', 'Width', 'Instance']]
+    
+    df.to_csv(csv_filename, index=False)
+
+    return csv_filename, df

utils/measure_utils.py

@@ -0,0 +1,52 @@
+import cv2
+import numpy as np
+import math
+
+class ContourAnalyzer:
+    def __init__(self, min_area_threshold=5):
+        self.min_area_threshold = min_area_threshold
+
+    def find_thickest_contour(self, contours, binary_image):
+        max_width = 0
+        thickest_section = None
+        thickest_points = None
+        distance_transforms = []
+
+        for contour in contours:
+            if cv2.contourArea(contour) > self.min_area_threshold:
+
+                mask = np.zeros_like(binary_image)
+                cv2.drawContours(mask, [contour], 0, 255, thickness=cv2.FILLED)
+
+                distance_transform = cv2.distanceTransform(mask, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+                distance_transforms.append(distance_transform)
+
+                _, _, _, max_loc = cv2.minMaxLoc(distance_transform)
+                width = 2 * distance_transform[max_loc[1], max_loc[0]]
+
+                if width > max_width:
+                    max_width = width
+                    thickest_section = contour
+                    thickest_points = max_loc
+
+        return max_width, thickest_section, thickest_points, distance_transforms
+
+    def find_contours(self, binary_image):
+        contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # for debugging
+        print("Number of contours:", len(contours))
+
+        max_width, thickest_section, thickest_points, distance_transforms = self.find_thickest_contour(contours, binary_image)
+
+        return max_width, thickest_section, thickest_points, distance_transforms
+
+    @staticmethod
+    def calculate_width(y, x, pixel_width, calibration_factor, distance):
+        angle = math.atan2(y, x)
+        width = angle * pixel_width * distance * calibration_factor
+        return width
+    
+    def draw_circle_on_image(self, image, center, radius, color=(57, 255, 20), thickness=-1):
+        cv2.circle(image, center, radius, color, thickness)
+

utils/model_utils.py

@@ -0,0 +1,98 @@
+from ultralytics import YOLO
+import gradio as gr
+from PIL import Image
+import torch
+import cv2
+from utils.image_utils import preprocess_image, count_instance
+from utils.data_utils import get_all_file_paths, generate_uuid
+import numpy as np
+import os
+
+def load_model():
+    """
+    Load the YOLO model with pre-trained weights.
+    
+    Returns:
+        model: Loaded YOLO model.
+    """
+    return YOLO('./weights/best.pt')
+def detect_pattern(image_path):
+    """
+    Detect concrete cracks in the binary image.
+
+    Parameters:
+        image_path (str): Path to the binary image.
+
+    Returns:
+        tuple: Principal orientation and orientation category.
+    """
+    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+    skeleton = cv2.erode(image, np.ones((3, 3), dtype=np.uint8), iterations=1)
+    contours, _ = cv2.findContours(skeleton, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    data_pts = np.vstack([contour.squeeze() for contour in contours])
+    mean, eigenvectors = cv2.PCACompute(data_pts.astype(np.float32), mean=None)
+    principal_orientation = np.arctan2(eigenvectors[0, 1], eigenvectors[0, 0])
+
+    if -0.05 <= principal_orientation <= 0.05:
+        orientation_category = "Horizontal"
+    elif 1 <= principal_orientation <= 1.8:
+        orientation_category = "Vertical"
+    elif -0.99 <= principal_orientation <= 0.99:
+        orientation_category = "Diagonal"
+    else:
+        orientation_category = "Other"
+
+    return principal_orientation, orientation_category
+
+def predict_segmentation(image, conf):
+    """
+    Perform segmentation prediction on a list of images.
+    
+    Parameters:
+        image (list): List of images for segmentation.
+        conf (float): Confidence score for prediction.
+
+    Returns:
+        tuple: Paths of the processed images, CSV file, DataFrame, and Markdown.
+    """
+    uuid = generate_uuid()
+    image_list = [preprocess_image(Image.open(file.name)) for file in image]
+    filenames = [file.name for file in image]
+    conf= conf * 0.01
+    model = load_model()
+    results = model.predict(image_list, conf=conf, save=True, project='output', name=uuid, stream=True)
+    processed_image_paths = []
+    annotated_image_paths = []
+    for i, r in enumerate(results):
+        for m in r:
+            masks = r.masks.data
+            boxes = r.boxes.data
+            clss = boxes[:, 5]
+            people_indices = torch.where(clss == 0)
+            people_masks = masks[people_indices]
+            people_mask = torch.any(people_masks, dim=0).int() * 255
+            processed_image_path = str(model.predictor.save_dir / f'binarize{i}.jpg')
+            cv2.imwrite(processed_image_path, people_mask.cpu().numpy())
+            processed_image_paths.append(processed_image_path)
+            
+            crack_image_path = processed_image_path
+            principal_orientation, orientation_category = detect_pattern(crack_image_path)
+            
+            # Print the results if needed
+            print(f"Crack Detection Results for {crack_image_path}:")
+            print("Principal Component Analysis Orientation:", principal_orientation)
+            print("Orientation Category:", orientation_category)
+
+    csv, df = count_instance(results, filenames, uuid)
+
+    csv = gr.File(value=csv, visible=True)
+    df = gr.DataFrame(value=df, visible=True)
+    md = gr.Markdown(visible=True)
+    
+    # # Delete binarized images after processing
+    # for path in processed_image_paths:
+    #     if os.path.exists(path):
+    #         os.remove(path)
+    
+    return get_all_file_paths(f'output/{uuid}'), csv, df, md
+

utils/plot.py

@@ -0,0 +1,184 @@
+import pandas as pd
+from IPython.display import display, HTML
+import os
+import imgkit
+import pdfkit
+
+def classify_wall_damage(crack_width):
+    if crack_width <= 0.1:
+        return "Negligible"
+    elif 0.1 <= crack_width <= 1:
+        return "Very slight"
+    elif 1.1 <= crack_width  <= 5:
+        return "Slight"
+    elif 5 <= crack_width <= 15:
+        return "Moderate"
+    elif 15 <= crack_width <= 25:
+        return "Severe"
+    elif crack_width > 25:
+        return "Very severe"
+    else:
+        return "Invalid input"
+    
+
+from collections import Counter
+
+def generate_html_summary(crack_list):
+    # Define the possible damage levels
+    damage_levels = ["Negligible", "Very Slight", "Slight", "Moderate", "Severe", "Very Severe"]
+
+    # Count the occurrences of each damage level
+    string_counts = Counter(crack_list)
+
+    # Build the HTML string
+    html_summary = "<html>\n<body>\n"
+    html_summary += "<h2>Summary of this batch</h2>\n"
+    html_summary += "<p><strong>Number of Cracks Detected:</strong></p>\n"
+    html_summary += "<ul>\n"
+
+    # Append the damage level and count to the HTML string
+    for level in damage_levels:
+        count = string_counts.get(level, 0)
+        html_summary += f"<li>{level} = {count}</li>\n"
+
+    html_summary += "</ul>\n"
+    html_summary += "</body>\n</html>"
+    print(html_summary)
+    return html_summary
+
+def merge_html_files(file1_path, file2_path, output_path):
+    # Read contents of the first HTML file
+    with open(file1_path, 'r', encoding='utf-8') as file1:
+        content1 = file1.read()
+
+    # Read contents of the second HTML file
+    with open(file2_path, 'r', encoding='utf-8') as file2:
+        content2 = file2.read()
+
+    # Concatenate the contents
+    merged_content = content1 + content2
+
+    # Write the merged content to the output file
+    with open(output_path, 'w', encoding='utf-8') as output_file:
+        output_file.write(merged_content)
+
+def count_instance(result, filenames, uuid, width_list, orientation_list, image_path, reference, remark, damage):
+        """
+        Counts the instances in the result and generates a CSV with the counts.
+
+        Parameters:
+            result (list): List containing results for each instance.
+            filenames (list): Corresponding filenames for each result.
+            uuid (str): Unique ID for the output folder name.
+            width_list (list): List containing width values for each instance.
+            orientation_list (list): List containing orientation values for each instance.
+
+        Returns:
+            tuple: Path to the generated CSV and dataframe with counts.
+        """
+        # Initializing the dataframe
+        print(damage)
+        data = {
+            'Index': [],
+            'FileName': [],
+            'Orientation': [],
+            'Width (mm)': [],
+            'Instance': [],
+            'Damage Level': []
+        }
+        
+        df_ref = pd.DataFrame({'Reference': [f'<img src="{ref}" width="640" >' for ref in reference]})
+
+
+        df = pd.DataFrame(data)
+
+        # Populate the dataframe with counts, width, and orientation
+        for i, res in enumerate(result):
+            instance_count = len(res)
+            df.loc[i] = [i, os.path.basename(filenames[i]), orientation_list[i], width_list[i], instance_count, damage[i]]
+
+        # Reorder columns
+        df = df[['Index', 'FileName', 'Orientation', 'Width (mm)','Damage Level', 'Instance']]
+
+        # Create a new dataframe (df2) with all columns from df
+        df2 = df.copy()
+        summary = generate_html_summary(damage)
+        # Add another column for the image (modify as per your requirement)
+        print("IMG PATHS")
+        print(image_path)
+        base_path = [os.path.basename(path) for path in image_path]
+        df2['Image'] = base_path
+        df2['Remarks'] = remark
+        # convert your links to html tags 
+        def path_to_image_html(path):
+            return '<img src="'+ path + '" width="320" >'
+        print("This executed 1")
+        pd.set_option('display.max_colwidth', None)
+
+        image_cols = ['Image']
+
+        format_dict = {}
+        for image_col in image_cols:
+            format_dict[image_col] = path_to_image_html
+
+        print("This executed 2")
+        col_widths = [100, 50, 50, 50, 50, 120, 150] 
+        df2 = df2.drop(df.columns[0], axis=1)
+
+        # Create the HTML file
+        df_html = df2.to_html(f'output/{uuid}/df_batch.html', escape=False, formatters=format_dict, col_space=col_widths, justify='left')
+        df_refs = df_ref.to_html(f'output/{uuid}/df_ref.html', escape=False, justify='left')
+        print("This executed 3")
+        # Save the modified dataframe to a CSV file
+        from bs4 import BeautifulSoup
+
+        # Load the HTML file
+        with open(f'output/{uuid}/df_ref.html', 'r') as file:
+            html_content = file.read()
+
+        # Parse the HTML using BeautifulSoup
+        soup = BeautifulSoup(html_content, 'html.parser')
+
+        # Find the table in the HTML (assuming there is only one table)
+        table = soup.find('table')
+
+        # Append the new summary HTML after the table
+        table.insert_after(BeautifulSoup(summary, 'html.parser'))
+
+        # Save the modified HTML to a new file
+        with open(f'output/{uuid}/df_ref_summary.html', 'w') as file:
+            file.write(str(soup))
+
+        html_table = HTML(df2.to_html(escape=False))
+        display(html_table)
+              
+        print('This executed 4')
+        file1 = f'output/{uuid}/df_ref_summary.html'
+        file2 = f'output/{uuid}/df_batch.html'
+        merge_html_files(file1, file2, f'output/{uuid}/out.html')
+        opt = {"enable-local-file-access": ""}
+        # new_parser = HtmlToDocx()
+        # new_parser.parse_html_file(f'output/{uuid}/df_batch.html', f'output/{uuid}/report_batch')
+        # new_parser.parse_html_file(f'output/{uuid}/df_ref_summary.html', f'output/{uuid}/report_ref')
+
+        # convert(f"output/{uuid}/report_batch.docx", f"output/{uuid}/Mine.pdf")
+        pdfkit.from_file(f'output/{uuid}/df_batch.html', f'output/{uuid}/report_batch.pdf', options=opt)
+        pdfkit.from_file(f'output/{uuid}/df_ref_summary.html', f'output/{uuid}/report_ref.pdf', options=opt)
+
+        print("This executed 5")
+
+        # pdfs = [f'output/{uuid}/report_ref.pdf', f'output/{uuid}/report_batch.pdf']
+
+        # merger = PdfMerger()
+
+        # for pdf in pdfs:
+        #     merger.append(pdf)
+
+        # merger.write(f'output/{uuid}/report.pdf')
+        # merger.close()
+        # options = {'width': 1280, 'disable-smart-width': ''}
+        imgkit.from_file(f'output/{uuid}/out.html', f'output/{uuid}/out.jpg', options=opt)
+        return f'output/{uuid}/out.jpg', df
+
+
+

weights/best.pt

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