Upload 24 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+predict_testing/Car_damages_1185.png filter=lfs diff=lfs merge=lfs -text
+predict_testing/Car_damages_1219.png filter=lfs diff=lfs merge=lfs -text
+predict_testing/Car_damages_251.png filter=lfs diff=lfs merge=lfs -text

Damage_calculation.py

@@ -0,0 +1,183 @@
+import os
+from shapely.geometry import Polygon
+
+class DamageCalculator:
+    def __init__(self):
+        self.cost_ranges = {
+            "Scratch": {
+                "Minor": (1000, 3000),
+                "Moderate": (3000, 5000),
+                "Severe": (5000, 10000)
+            },
+            "Dent": {
+                "Minor": (2000, 4000),
+                "Moderate": (4000, 10000),
+                "Severe": (10000, 15000)
+            },
+            "Paint chip": {
+                "Minor": (1000, 2000),
+                "Moderate": (2000, 4000),
+                "Severe": (4000, 10000)
+            },
+            "Broken part": (1000, 7000)
+        }
+
+    def parse_coordinates(self, file_path):
+        polygons = []
+        class_names = []
+        with open(file_path, 'r') as file:
+            for line in file:
+                parts = line.strip().split()
+                class_name = []
+                coordinates = []
+                for part in parts:
+                    try:
+                        coordinates.append(float(part))
+                    except ValueError:
+                        class_name.append(part)
+                if class_name and coordinates:
+                    class_name = " ".join(class_name)
+                    try:
+                        if len(coordinates) % 2 != 0:
+                            raise ValueError("Coordinates are not in pairs.")
+                        polygon = Polygon([(coordinates[i], coordinates[i+1]) for i in range(0, len(coordinates), 2)])
+                        polygons.append(polygon)
+                        class_names.append(class_name)
+                    except ValueError as e:
+                        print(f"Skipping line due to error: {e}")
+                else:
+                    print(f"Skipping line due to insufficient data: {line.strip()}")
+        return class_names, polygons
+
+    def calculate_severity(self, coverage_percentage):
+        if 3 < coverage_percentage <= 30:
+            return "Minor"
+        elif 30 < coverage_percentage <= 60:
+            return "Moderate"
+        elif coverage_percentage > 60:
+            return "Severe"
+        return "N/A"
+
+    def calculate_cost(self, damage_class, severity):
+        if damage_class == "Broken part":
+            return self.cost_ranges["Broken part"]
+        elif severity in self.cost_ranges[damage_class]:
+            return self.cost_ranges[damage_class][severity]
+        return (0, 0)
+    
+    def summarize_damage_by_part(self, damage_polygons, part_polygons):
+        intersection_info = self.calculate_intersection_area(damage_polygons, part_polygons)
+
+        summary = {}
+        for info in intersection_info:
+            part_class = info['part_class']
+            damage_class = info['damage_class']
+            coverage_percentage = info['coverage_percentage']
+
+            if part_class not in summary:
+                summary[part_class] = {'total_coverage': 0, 'damage_types': {}}
+
+            summary[part_class]['total_coverage'] += coverage_percentage
+
+            if damage_class not in summary[part_class]['damage_types']:
+                summary[part_class]['damage_types'][damage_class] = 0
+
+            summary[part_class]['damage_types'][damage_class] += coverage_percentage
+
+        for part_class in summary:
+            total_coverage = summary[part_class]['total_coverage']
+            for damage_class in summary[part_class]['damage_types']:
+                summary[part_class]['damage_types'][damage_class] = (
+                    summary[part_class]['damage_types'][damage_class] / total_coverage * 100
+                )
+
+            summary[part_class]['undamaged'] = 100 - total_coverage
+
+        return summary
+
+    def calculate_intersection_area(self, damage_polygons, part_polygons):
+        intersection_info = []
+        front_back_door_detected = any(part_class in ['Front-door', 'Back-door'] for part_class, _ in part_polygons)
+
+        for damage_class, damage_polygon in damage_polygons:
+            for part_class, part_polygon in part_polygons:
+                if damage_polygon.intersects(part_polygon):
+                    intersection = damage_polygon.intersection(part_polygon)
+                    intersection_area = intersection.area
+                    part_area = part_polygon.area
+                    coverage_percentage = (intersection_area / part_area) * 100
+
+                    # Condition 1: Ignore damage coverage <= 3%
+                    if coverage_percentage <= 3:
+                        continue
+
+                    # Condition 2: Apply weights based on the new conditions
+                    if part_class in ['Front-bumper', 'Back-bumper']:
+                        if front_back_door_detected:
+                            coverage_percentage *= 0.2
+                        else:
+                            coverage_percentage *= 0.6
+                            
+                    if coverage_percentage <= 3:
+                        continue
+
+                    # Updated Condition 3: Include Headlight and tail light only with broken part if damage > 50%
+                    if part_class in ['Headlight', 'Tail-light']:
+                        if damage_class == 'Broken part' and coverage_percentage > 50:
+                            intersection_info.append({
+                                "damage_class": damage_class,
+                                "part_class": part_class,
+                                "intersection_area": intersection_area,
+                                "part_area": part_area,
+                                "coverage_percentage": coverage_percentage
+                            })
+                        continue
+
+                    # Condition 4: Exclude damage with front-wheel, back wheel, and license plate
+                    if part_class in ['Front-wheel', 'Back-wheel', 'License-plate']:
+                        continue
+
+                    intersection_info.append({
+                        "damage_class": damage_class,
+                        "part_class": part_class,
+                        "intersection_area": intersection_area,
+                        "part_area": part_area,
+                        "coverage_percentage": coverage_percentage
+                    })
+
+        # Condition 5: Sum coverage for the same type of defect on the same part
+        summarized_info = {}
+        for info in intersection_info:
+            key = (info['damage_class'], info['part_class'])
+            if key not in summarized_info:
+                summarized_info[key] = {
+                    "intersection_area": 0,
+                    "part_area": info['part_area'],
+                    "coverage_percentage": 0,
+                    "count": 0
+                }
+            summarized_info[key]["intersection_area"] += info["intersection_area"]
+            summarized_info[key]["coverage_percentage"] += info["coverage_percentage"]
+            summarized_info[key]["count"] += 1
+
+        final_info = []
+        for (damage_class, part_class), values in summarized_info.items():
+            part_area = values["part_area"]
+            intersection_area = values["intersection_area"]
+            coverage_percentage = values["coverage_percentage"]
+            count = values["count"]
+            severity = self.calculate_severity(coverage_percentage)
+            cost_min, cost_max = self.calculate_cost(damage_class, severity)
+            final_info.append({
+                "damage_class": damage_class,
+                "part_class": part_class,
+                "intersection_area": intersection_area,
+                "part_area": part_area,
+                "coverage_percentage": coverage_percentage,
+                "severity": severity,
+                "cost_min": cost_min,
+                "cost_max": cost_max,
+                "count": count
+            })
+
+        return final_info

app.py

@@ -0,0 +1,141 @@
+import streamlit as st
+from PIL import Image
+import os
+import shutil
+from ultralytics import YOLO
+import tempfile
+import pandas as pd
+import plotly.express as px
+from fetch_original import FileProcessor
+from Damage_calculation import DamageCalculator
+from generator import CSVGenerator
+from pdf_report import PDFReportGenerator
+
+class SegmentationModel:
+    def __init__(self, model_path):
+        self.model = YOLO(model_path)
+
+    def predict(self, input_path):
+        result = self.model.predict(source=input_path, save=True, show_conf=False, conf=0.70, save_txt=True)
+        img_path = result[0].save_dir
+        return img_path
+
+class SegmentationApp:
+    def __init__(self, car_parts_model_path, damage_model_path, output_folder):
+        self.car_parts_model = SegmentationModel(car_parts_model_path)
+        self.damage_model = SegmentationModel(damage_model_path)
+        self.output_folder = output_folder
+
+    def copy_folder(self, src_folder, dest_folder):
+        if not os.path.exists(dest_folder):
+            os.makedirs(dest_folder)
+        for item in os.listdir(src_folder):
+            s = os.path.join(src_folder, item)
+            d = os.path.join(dest_folder, item)
+            if os.path.isdir(s):
+                shutil.copytree(s, d, dirs_exist_ok=True)
+            else:
+                shutil.copy2(s, d)
+
+    def clean_output_folder(self):
+        parts_output_folder = os.path.join(self.output_folder, 'parts')
+        damage_output_folder = os.path.join(self.output_folder, 'damage')
+        if os.path.exists(parts_output_folder):
+            shutil.rmtree(parts_output_folder)
+        if os.path.exists(damage_output_folder):
+            shutil.rmtree(damage_output_folder)
+
+    def run(self):
+        st.title("Car Damage Analyses And Cost Estimation")
+        st.markdown("### Important Guidelines for Using the App")
+        st.write("""
+        <div style="background-color: pink; color: black; padding: 10px; border-radius: 5px;">
+        <ul>
+            <li>Provide 4 images of the car from the following views: front, back, left, and right.</li>
+            <li>Ensure the images are taken at proper angles, standing parallel to the car, and that they are clear.</li>
+            <li>Make sure there are no obstacles between the car and the camera.</li>
+            <li>The car should not be behind any objects in the images.</li>
+        </ul>
+        </div>
+        """, unsafe_allow_html=True)
+
+        uploaded_files = st.file_uploader("Choose up to 4 images...", type=["jpg", "jpeg", "png", "webp"], accept_multiple_files=True)
+
+        if uploaded_files and len(uploaded_files) == 4:
+            st.write("Running segmentation models on uploaded images...")
+            car_parts_results_paths = []
+            damage_results_paths = []
+
+            self.clean_output_folder()
+
+            with st.spinner("Analyzing total damage..."):
+                for i, uploaded_file in enumerate(uploaded_files):
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
+                        temp_file.write(uploaded_file.getvalue())
+                        temp_image_path = temp_file.name
+
+                    car_parts_results = self.car_parts_model.predict(temp_image_path)
+                    car_parts_results_paths.append(car_parts_results)
+
+                    damage_results = self.damage_model.predict(temp_image_path)
+                    damage_results_paths.append(damage_results)
+
+                self.car_parts_results_paths = car_parts_results_paths
+                self.damage_results_paths = damage_results_paths
+
+                for car_parts_results in car_parts_results_paths:
+                    parts_output_folder = os.path.join(self.output_folder, 'parts')
+                    self.copy_folder(car_parts_results, parts_output_folder)
+
+                for damage_results in damage_results_paths:
+                    damage_output_folder = os.path.join(self.output_folder, 'damage')
+                    self.copy_folder(damage_results, damage_output_folder)
+
+                file_processor = FileProcessor()
+                file_processor.process_output_folder(self.output_folder)
+
+                csv_generator = CSVGenerator(self.output_folder)
+                damage_data = csv_generator.process_files()
+
+                df = pd.read_csv(csv_generator.output_csv)
+                st.write("Damage Estimation Report")
+                st.dataframe(df)
+
+                # Generate PDF report
+                pdf_report = PDFReportGenerator(csv_generator.output_csv, self.output_folder, 'damage_estimation_report.pdf')
+                pdf_report.generate_report()
+
+                # # Add download button for the CSV file
+                # csv_data = df.to_csv(index=False).encode('utf-8')
+                # st.download_button(
+                #     label="Download CSV",
+                #     data=csv_data,
+                #     file_name='damage_estimation.csv',
+                #     mime='text/csv',
+                # )
+
+                # Add download button for the PDF report
+                with open(pdf_report.pdf_path, 'rb') as f:
+                    pdf_data = f.read()
+                st.download_button(
+                    label="Download PDF Report",
+                    data=pdf_data,
+                    file_name='damage_estimation_report.pdf',
+                    mime='application/pdf',
+                )
+
+                damage_df = pd.DataFrame(damage_data)
+                fig = px.pie(damage_df, values='coverage_percentage', names='damage_class', title='Total Damage Percentages by Type')
+                st.plotly_chart(fig)
+
+            st.success("Analysis Completed.")
+
+        elif uploaded_files:
+            st.error("Please upload exactly four images.")
+
+if __name__ == "__main__":
+    CAR_PARTS_MODEL_PATH = 'model/car_parts.pt'
+    DAMAGE_MODEL_PATH = 'model/damage_4_class.pt'
+    OUTPUT_FOLDER = 'Output'
+    app = SegmentationApp(CAR_PARTS_MODEL_PATH, DAMAGE_MODEL_PATH, OUTPUT_FOLDER)
+    app.run()

fetch_original.py

@@ -0,0 +1,65 @@
+import os
+from PIL import Image
+
+class FileProcessor:
+    PARTS_NAMES = [
+        "Quarter-panel", "Front-wheel", "Back-window", "Trunk", "Front-door", "Rocker-panel",
+        "Grille", "Windshield", "Front-window", "Back-door", "Headlight", "Back-wheel",
+        "Back-windshield", "Hood", "Fender", "Tail-light", "License-plate", "Front-bumper",
+        "Back-bumper", "Mirror", "Roof"
+    ]
+
+    DAMAGE_NAMES = [
+        "Broken part", "Scratch", "Dent", "Paint chip"
+    ]
+
+    @staticmethod
+    def convert_normalized_to_original(coords, width, height):
+        original_coords = []
+        for i in range(0, len(coords), 2):
+            x = coords[i] * width
+            y = coords[i + 1] * height
+            original_coords.extend([x, y])
+        return original_coords
+
+    def process_file(self, file_path, class_names, image_size):
+        width, height = image_size
+        with open(file_path, "r") as f:
+            lines = f.readlines()
+        
+        new_lines = []
+        for line in lines:
+            parts = line.strip().split()
+            class_index = int(parts[0])
+            coords = list(map(float, parts[1:]))
+            original_coords = self.convert_normalized_to_original(coords, width, height)
+            class_name = class_names[class_index]
+            new_line = f"{class_name} " + " ".join(map(str, original_coords)) + "\n"
+            new_lines.append(new_line)
+        
+        with open(file_path, "w") as f:
+            f.writelines(new_lines)
+
+    def process_folder(self, folder_path, class_names):
+        labels_folder = os.path.join(folder_path, "labels")
+        for file in os.listdir(folder_path):
+            if file.endswith(".jpg"):
+                image_path = os.path.join(folder_path, file)
+                if os.path.exists(image_path):
+                    image = Image.open(image_path)
+                    image_size = image.size
+                    txt_file = file.replace(".jpg", ".txt")
+                    txt_file_path = os.path.join(labels_folder, txt_file)
+                    if os.path.exists(txt_file_path):
+                        self.process_file(txt_file_path, class_names, image_size)
+                    else:
+                        print(f"Text file {txt_file_path} not found.")
+                else:
+                    print(f"Image {image_path} not found.")
+
+    def process_output_folder(self, output_folder):
+        parts_folder = os.path.join(output_folder, "parts")
+        damage_folder = os.path.join(output_folder, "damage")
+
+        self.process_folder(parts_folder, self.PARTS_NAMES)
+        self.process_folder(damage_folder, self.DAMAGE_NAMES)

generator.py

@@ -0,0 +1,70 @@
+import os
+import csv
+from Damage_calculation import DamageCalculator
+
+class CSVGenerator:
+    def __init__(self, output_folder):
+        self.damage_folder = os.path.join(output_folder, 'damage/labels')
+        self.parts_folder = os.path.join(output_folder, 'parts/labels')
+        self.output_csv = os.path.join(output_folder, 'damage_estimation.csv')
+        self.calculator = DamageCalculator()
+
+    def process_files(self):
+        damage_files = sorted(os.listdir(self.damage_folder))
+        parts_files = sorted(os.listdir(self.parts_folder))
+
+        total_cost_min = 0
+        total_cost_max = 0
+        damage_data = []
+
+        with open(self.output_csv, 'w', newline='') as csvfile:
+            fieldnames = ['Car Parts', 'Damage Type', 'Damage Count', 'Severity', 'Estimated Cost Range']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+
+            for damage_file, parts_file in zip(damage_files, parts_files):
+                damage_path = os.path.join(self.damage_folder, damage_file)
+                parts_path = os.path.join(self.parts_folder, parts_file)
+
+                damage_classes, damage_polygons = self.calculator.parse_coordinates(damage_path)
+                part_classes, part_polygons = self.calculator.parse_coordinates(parts_path)
+
+                damage_polygons = list(zip(damage_classes, damage_polygons))
+                part_polygons = list(zip(part_classes, part_polygons))
+
+                intersection_info = self.calculator.calculate_intersection_area(damage_polygons, part_polygons)
+
+                for info in intersection_info:
+                    writer.writerow({
+                        'Car Parts': info['part_class'],
+                        'Damage Type': info['damage_class'],
+                        'Damage Count': info['count'],
+                        'Severity': info['severity'],
+                        'Estimated Cost Range': f"Rs. {info['cost_min']}-{info['cost_max']}"
+                    })
+                    total_cost_min += info['cost_min']
+                    total_cost_max += info['cost_max']
+
+                    damage_data.append({
+                        'damage_class': info['damage_class'],
+                        'part_class': info['part_class'],
+                        'coverage_percentage': info['coverage_percentage']
+                    })
+
+            writer.writerow({
+                'Car Parts': 'Total',
+                'Damage Type': '',
+                'Damage Count': '',
+                'Severity': '',
+                'Estimated Cost Range': f"Rs. {total_cost_min}-{total_cost_max}"
+            })
+
+        return damage_data
+
+def main(output_folder):
+    generator = CSVGenerator(output_folder)
+    generator.process_files()
+
+if __name__ == "__main__":
+    output_folder = 'Output'
+    main(output_folder)

model/Med_seg_test.pt

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

model/car_parts.pt

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

model/damage.pt

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

model/damage_4_class.pt

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

model/damage_nano_416.pt

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

pdf_report.py

@@ -0,0 +1,130 @@
+import os
+import pandas as pd
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+import tempfile
+import matplotlib.pyplot as plt
+from reportlab.lib import colors
+from Damage_calculation import DamageCalculator
+from reportlab.platypus import Table, TableStyle
+
+class PDFReportGenerator:
+    def __init__(self, output_csv, output_folder, pdf_path):
+        self.output_csv = output_csv
+        self.damage_folder = os.path.join(output_folder, 'damage/labels')
+        self.parts_folder = os.path.join(output_folder, 'parts/labels')
+        self.pdf_path = pdf_path
+        self.calculator = DamageCalculator()
+
+    def create_pie_chart(self, part_class, damage_summary):
+        part_damage = damage_summary.get(part_class, {})
+        if not part_damage:
+            return None
+
+        damage_labels = list(part_damage['damage_types'].keys()) + ['Undamaged']
+        damage_values = list(part_damage['damage_types'].values()) + [part_damage['undamaged']]
+
+        fig, ax = plt.subplots(figsize=(6, 6))  # Adjust the figure size to ensure the pie is circular
+        ax.pie(damage_values, labels=damage_labels, autopct='%1.1f%%', startangle=140, textprops={'fontsize': 14})  # Increase font size
+        ax.axis('equal')
+
+        img_temp_path = tempfile.mktemp(suffix=".png")
+        plt.savefig(img_temp_path, bbox_inches='tight')  # Ensure the pie chart is properly sized
+        plt.close(fig)
+        return img_temp_path
+    
+    def add_table_to_pdf(self, pdf, dataframe, x_position, y_position):
+        # Replace NaN values with '-'
+        dataframe = dataframe.fillna('-')
+        
+        data = [dataframe.columns.to_list()] + dataframe.values.tolist()
+        table = Table(data)
+        
+        # Define table style
+        style = TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 12),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black)
+        ])
+        
+        table.setStyle(style)
+        
+        # Convert the table to a PDF flowable and draw it on the canvas
+        table.wrapOn(pdf, x_position, y_position)
+        table.drawOn(pdf, x_position, y_position)
+
+
+    def generate_report(self):
+        df = pd.read_csv(self.output_csv)
+        car_parts = df['Car Parts'].unique()
+
+        # Initialize damage summary dictionary
+        damage_summary = {}
+
+        # Populate damage and parts file paths
+        damage_files = sorted(os.listdir(self.damage_folder))
+        parts_files = sorted(os.listdir(self.parts_folder))
+
+        # Iterate over the damage and parts files
+        for damage_file, parts_file in zip(damage_files, parts_files):
+            damage_path = os.path.join(self.damage_folder, damage_file)
+            parts_path = os.path.join(self.parts_folder, parts_file)
+
+            damage_classes, damage_polygons = self.calculator.parse_coordinates(damage_path)
+            part_classes, part_polygons = self.calculator.parse_coordinates(parts_path)
+
+            damage_polygons = list(zip(damage_classes, damage_polygons))
+            part_polygons = list(zip(part_classes, part_polygons))
+
+            part_summary = self.calculator.summarize_damage_by_part(damage_polygons, part_polygons)
+            for part, summary in part_summary.items():
+                if part not in damage_summary:
+                    damage_summary[part] = summary
+                else:
+                    for damage_type, percentage in summary['damage_types'].items():
+                        if damage_type not in damage_summary[part]['damage_types']:
+                            damage_summary[part]['damage_types'][damage_type] = 0
+                        damage_summary[part]['damage_types'][damage_type] += percentage
+                    damage_summary[part]['undamaged'] += summary['undamaged']
+
+        pdf = canvas.Canvas(self.pdf_path, pagesize=letter)
+        pdf.setTitle("Car Damage Estimation Report")
+
+        width, height = letter
+        y_position = height - 40
+
+        for part_class in car_parts:
+            if part_class == 'Total':
+                continue
+
+            pdf.setFont("Helvetica-Bold", 12)
+            pdf.drawString(30, y_position, f'Damage Report for {part_class}')
+            y_position -= 20
+
+            pie_chart_path = self.create_pie_chart(part_class, damage_summary)
+            if pie_chart_path:
+                pdf.drawImage(pie_chart_path, 50, y_position - 300, width=275, height=275)  # Adjust size to maintain aspect ratio
+                y_position -= 320
+
+                # Clean up the temporary file
+                os.remove(pie_chart_path)
+
+            if y_position < 100:
+                pdf.showPage()
+                y_position = height - 40
+
+        # Add title above the table
+        y_position -= 40
+        pdf.setFont("Helvetica-Bold", 14)
+        pdf.drawString(50, y_position, "Cost Breakdown Table")
+        y_position -= 200
+        
+        # Add table from CSV to the PDF
+        self.add_table_to_pdf(pdf, df, 30, y_position-100)
+
+        pdf.save()