import numpy as np
import cv2
import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk
import os
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
class GIBleedingDetector:
def __init__(self):
self.original_image = None
self.processed_image = None
self.mask = None
self.bleeding_percentage = 0
self.bleeding_status = "No image analyzed"
def load_image(self, image_path):
"""Load and prepare the image for processing"""
self.original_image = cv2.imread(image_path)
if self.original_image is None:
return False
return True
def process_image(self):
"""Process the image to detect GI bleeding"""
if self.original_image is None:
return False
# Convert to RGB for better color analysis
image_rgb = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2RGB)
# Resize image for faster processing if needed
resized = cv2.resize(image_rgb, (0, 0), fx=0.5, fy=0.5) if image_rgb.shape[0] > 1000 else image_rgb
# Reshape the image for K-means
pixels = resized.reshape(-1, 3).astype(np.float32)
# Define criteria and apply K-means
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
k = 5 # Number of clusters
_, labels, centers = cv2.kmeans(pixels, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
# Convert back to uint8
centers = np.uint8(centers)
segmented_image = centers[labels.flatten()]
segmented_image = segmented_image.reshape(resized.shape)
# Detect red regions (potential bleeding)
# Convert to HSV for better color segmentation
hsv_img = cv2.cvtColor(segmented_image, cv2.COLOR_RGB2HSV)
# Define range for red color in HSV
lower_red1 = np.array([0, 120, 70])
upper_red1 = np.array([10, 255, 255])
lower_red2 = np.array([170, 120, 70])
upper_red2 = np.array([180, 255, 255])
# Create masks for red regions
mask1 = cv2.inRange(hsv_img, lower_red1, upper_red1)
mask2 = cv2.inRange(hsv_img, lower_red2, upper_red2)
# Combine masks
self.mask = cv2.bitwise_or(mask1, mask2)
# Calculate bleeding percentage
total_pixels = self.mask.size
bleeding_pixels = cv2.countNonZero(self.mask)
self.bleeding_percentage = (bleeding_pixels / total_pixels) * 100
# Determine bleeding status
if self.bleeding_percentage > 5:
self.bleeding_status = "High probability of bleeding"
elif self.bleeding_percentage > 1:
self.bleeding_status = "Moderate probability of bleeding"
else:
self.bleeding_status = "Low probability of bleeding"
# Create visual result
self.processed_image = cv2.bitwise_and(segmented_image, segmented_image, mask=self.mask)
# Resize the mask to match the original image size if needed
if resized.shape != image_rgb.shape:
self.mask = cv2.resize(self.mask, (image_rgb.shape[1], image_rgb.shape[0]))
self.processed_image = cv2.resize(self.processed_image, (image_rgb.shape[1], image_rgb.shape[0]))
return True
def get_overlay_image(self):
"""Create an overlay of original image with bleeding highlighted"""
if self.original_image is None or self.mask is None:
return None
# Convert original image to RGB
original_rgb = cv2.cvtColor(self.original_image, cv2.COLOR_BGR2RGB)
# Create a mask with same dimensions as original
mask_resized = cv2.resize(self.mask, (original_rgb.shape[1], original_rgb.shape[0]))
# Create overlay
overlay = original_rgb.copy()
overlay[mask_resized > 0] = [255, 0, 0] # Mark bleeding areas in red
# Create blended image - 70% original, 30% overlay
blended = cv2.addWeighted(original_rgb, 0.7, overlay, 0.3, 0)
return blended
def get_analysis_result(self):
"""Return analysis results as a dictionary"""
return {
"bleeding_percentage": round(self.bleeding_percentage, 2),
"bleeding_status": self.bleeding_status
}
class GIBleedingDetectionApp:
def __init__(self, root):
self.root = root
self.root.title("GI Bleeding Detection Tool")
self.root.geometry("1200x800")
self.root.configure(bg="#f0f0f0")
self.detector = GIBleedingDetector()
self.create_widgets()
def create_widgets(self):
# Top frame for buttons
self.top_frame = tk.Frame(self.root, bg="#f0f0f0")
self.top_frame.pack(pady=10, fill=tk.X)
# Load button
self.load_btn = tk.Button(self.top_frame, text="Load Image",
command=self.load_image,
bg="#4CAF50", fg="white",
font=("Arial", 12), padx=10, pady=5)
self.load_btn.pack(side=tk.LEFT, padx=10)
# Analyze button
self.analyze_btn = tk.Button(self.top_frame, text="Analyze Image",
command=self.analyze_image,
bg="#2196F3", fg="white",
font=("Arial", 12), padx=10, pady=5,
state=tk.DISABLED)
self.analyze_btn.pack(side=tk.LEFT, padx=10)
# Save button
self.save_btn = tk.Button(self.top_frame, text="Save Results",
command=self.save_results,
bg="#FFC107", fg="white",
font=("Arial", 12), padx=10, pady=5,
state=tk.DISABLED)
self.save_btn.pack(side=tk.LEFT, padx=10)
# Main content frame
self.content_frame = tk.Frame(self.root, bg="#f0f0f0")
self.content_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=10)
# Original image frame
self.original_frame = tk.LabelFrame(self.content_frame, text="Original Image",
bg="#f0f0f0", font=("Arial", 12))
self.original_frame.grid(row=0, column=0, padx=10, pady=10, sticky=tk.NSEW)
self.original_canvas = tk.Label(self.original_frame, bg="black")
self.original_canvas.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Processed image frame
self.processed_frame = tk.LabelFrame(self.content_frame, text="Bleeding Detection Result",
bg="#f0f0f0", font=("Arial", 12))
self.processed_frame.grid(row=0, column=1, padx=10, pady=10, sticky=tk.NSEW)
self.processed_canvas = tk.Label(self.processed_frame, bg="black")
self.processed_canvas.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Results frame
self.results_frame = tk.LabelFrame(self.content_frame, text="Analysis Results",
bg="#f0f0f0", font=("Arial", 12))
self.results_frame.grid(row=1, column=0, columnspan=2, padx=10, pady=10, sticky=tk.NSEW)
# Results display
self.results_text = tk.Label(self.results_frame, text="No image analyzed",
font=("Arial", 14), bg="#f0f0f0", justify=tk.LEFT)
self.results_text.pack(side=tk.LEFT, padx=20, pady=20)
# Graph frame for visualization
self.graph_frame = tk.Frame(self.results_frame, bg="#f0f0f0")
self.graph_frame.pack(side=tk.RIGHT, padx=20, pady=20, fill=tk.BOTH, expand=True)
# Configure the grid
self.content_frame.grid_columnconfigure(0, weight=1)
self.content_frame.grid_columnconfigure(1, weight=1)
self.content_frame.grid_rowconfigure(0, weight=3)
self.content_frame.grid_rowconfigure(1, weight=1)
# Status bar
self.status_bar = tk.Label(self.root, text="Ready", bd=1, relief=tk.SUNKEN, anchor=tk.W)
self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
def load_image(self):
file_path = filedialog.askopenfilename(
title="Select Image",
filetypes=[("Image files", "*.jpg *.jpeg *.png *.bmp")])
if not file_path:
return
self.status_bar.config(text=f"Loading image: {file_path}")
if self.detector.load_image(file_path):
# Convert for display
img = cv2.cvtColor(self.detector.original_image, cv2.COLOR_BGR2RGB)
img = self.resize_for_display(img, 500)
# Display image
self.tk_img = ImageTk.PhotoImage(Image.fromarray(img))
self.original_canvas.config(image=self.tk_img)
# Update UI
self.analyze_btn.config(state=tk.NORMAL)
self.results_text.config(text="Image loaded. Click 'Analyze Image' to detect bleeding.")
self.status_bar.config(text=f"Image loaded: {os.path.basename(file_path)}")
else:
messagebox.showerror("Error", "Could not load the image. Please try again with a different file.")
self.status_bar.config(text="Error loading image")
def analyze_image(self):
if self.detector.original_image is None:
messagebox.showinfo("Info", "Please load an image first.")
return
self.status_bar.config(text="Analyzing image for GI bleeding...")
# Process the image
if self.detector.process_image():
# Get the overlay image with bleeding highlighted
overlay_img = self.detector.get_overlay_image()
overlay_img = self.resize_for_display(overlay_img, 500)
# Display processed image
self.processed_tk_img = ImageTk.PhotoImage(Image.fromarray(overlay_img))
self.processed_canvas.config(image=self.processed_tk_img)
# Get analysis results
results = self.detector.get_analysis_result()
# Update results text
result_text = f"Bleeding Detection Analysis:\n\n"
result_text += f"Bleeding Area: {results['bleeding_percentage']}% of image\n"
result_text += f"Assessment: {results['bleeding_status']}"
self.results_text.config(text=result_text)
# Create visualization graph
self.create_results_graph(results['bleeding_percentage'])
# Update UI
self.save_btn.config(state=tk.NORMAL)
self.status_bar.config(text="Analysis complete")
else:
messagebox.showerror("Error", "Could not analyze the image. Please try again.")
self.status_bar.config(text="Error during analysis")
def create_results_graph(self, bleeding_percentage):
# Clear previous graph
for widget in self.graph_frame.winfo_children():
widget.destroy()
# Create figure and axis
fig, ax = plt.subplots(figsize=(4, 3))
# Data for the gauge chart
categories = ['Healthy', 'Bleeding']
values = [100 - bleeding_percentage, bleeding_percentage]
colors = ['#4CAF50', '#F44336']
# Create the pie chart
ax.pie(values, labels=categories, colors=colors, autopct='%1.1f%%',
startangle=90, wedgeprops={'edgecolor': 'white', 'linewidth': 1})
ax.set_title("Tissue Analysis", fontsize=12)
# Add to tkinter window
canvas = FigureCanvasTkAgg(fig, self.graph_frame)
canvas.draw()
canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
def resize_for_display(self, image, max_dim):
"""Resize image while maintaining aspect ratio"""
h, w = image.shape[:2]
if h > w:
new_h = max_dim
new_w = int(w * (max_dim / h))
else:
new_w = max_dim
new_h = int(h * (max_dim / w))
return cv2.resize(image, (new_w, new_h))
def save_results(self):
if self.detector.processed_image is None:
messagebox.showinfo("Info", "Please analyze an image first.")
return
# Ask for directory to save results
save_dir = filedialog.askdirectory(title="Select Directory to Save Results")
if not save_dir:
return
try:
# Save the overlay image
overlay_img = self.detector.get_overlay_image()
cv2.imwrite(os.path.join(save_dir, "bleeding_detection_result.jpg"),
cv2.cvtColor(overlay_img, cv2.COLOR_RGB2BGR))
# Save the analysis results as text
results = self.detector.get_analysis_result()
with open(os.path.join(save_dir, "analysis_results.txt"), "w") as f:
f.write(f"GI Bleeding Detection Analysis Results\n")
f.write(f"=====================================\n\n")
f.write(f"Bleeding Area: {results['bleeding_percentage']}% of image\n")
f.write(f"Assessment: {results['bleeding_status']}\n")
f.write(f"\nAnalysis performed on {os.path.basename(save_dir)}\n")
messagebox.showinfo("Success", f"Results saved to {save_dir}")
self.status_bar.config(text=f"Results saved to {save_dir}")
except Exception as e:
messagebox.showerror("Error", f"Could not save results: {str(e)}")
self.status_bar.config(text="Error saving results")
if __name__ == "__main__":
# Create main window
root = tk.Tk()
app = GIBleedingDetectionApp(root)
# Run the application
root.mainloop()
Datasets
Models
