import cv2
import matplotlib.pyplot as plt


# Determine Canny parameters and image path
CANNY_THRESHOLD1 = 0
CANNY_THRESHOLD2 = 200
APERTURE_SIZE = 3
PATH = "/home/username/venv_folder/venv_name/image.jpg"


# Load image and preprocess with gaussian filter
k = 5 # Kernel size
image = cv2.imread(PATH, cv2.IMREAD_GRAYSCALE)
smoothed_image = cv2.GaussianBlur(image, (k, k), 0)


# Detect edges
edges = cv2.Canny(smoothed_image, CANNY_THRESHOLD1, CANNY_THRESHOLD2, apertureSize=APERTURE_SIZE)


# Display results
plt.figure(figsize=(12, 6))


# Plot original image
plt.subplot(1, 3, 1)
plt.imshow(image, cmap='gray')
plt.title("Original Image")
plt.axis('off')


# Plot smoothed image
plt.subplot(1, 3, 2)
plt.imshow(smoothed_image, cmap='gray')
plt.title("Smoothed Image")
plt.axis('off')


# Plot image with edges detected
plt.subplot(1, 3, 3)
plt.imshow(edges, cmap='gray')
plt.title("Canny edges")
plt.axis('off')


plt.tight_layout()
plt.show()

def draw_hough_lines(image, lines):
    # Draw detected Hough lines on image


    line_color = (0,0,255) # Blue
    line_thickness = 2


    output = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)  # Convert image to RGB to display colored lines.
    if lines is not None:
        for line in lines:
            # Calculate line endpoints
            rho, theta = line[0]
            a = np.cos(theta)
            b = np.sin(theta)
            x0 = a * rho
            y0 = b * rho
            x1 = int(x0 + 1000 * (-b))
            y1 = int(y0 + 1000 * (a))
            x2 = int(x0 - 1000 * (-b))
            y2 = int(y0 - 1000 * (a))
            cv2.line(output, (x1, y1), (x2, y2), line_color, line_thickness) 
    return output


# Define Hough parameters
rho = 1
theta = np.pi / 180
threshold_values = [80,100,120]
hough_lines = [] # Empty list to store values


# Display results
plt.figure(figsize=(12, 6))


for i in range(len(threshold_values)):
    H = cv2.HoughLines(edges, rho, theta, threshold_values[i])
    hough_lines.append(draw_hough_lines(image, H))


    # Hough lines plot
    plt.subplot(1, len(threshold_values), i+1)
    plt.imshow(hough_lines[i], cmap='gray')
    plt.title(f"Threshold = {threshold_values[i]}")
    plt.axis('off')


plt.tight_layout()
plt.show()

def straighten_image(image, edges):
    # Detect lines using Hough transform and apply affine transformation to straighten image
    
    # Define Hough parameters
    rho = 1
    theta = np.pi / 180
    threshold = 120 # Minimum number of points in Hough transform to consider as a line
        
    H = cv2.HoughLines(edges, rho, theta, threshold)
    
    # If no lines detected, return original image
    if H is None or len(H) == 0:
        print("No lines detected, image will not be rotated.")
        return image, None  
    
    # Calculate angles of detected lines
    angles = []
    for line in H:
        rho, theta = line[0]
        angle = np.degrees(theta)  # Radians to degrees
        if angle > 90:
            angle -= 180  # Normalize to range [-90, 90]


        # Determine the reference angle and calculate the difference
        if -90 <= angle <= -70:
            diff = angle + 90
        elif -20 <= angle <= 20:
            diff = angle - 0   
        elif 70 <= angle <= 90:
            diff = angle - 90
        else:
            diff = 0  # Ignore angles outside the specified ranges as they are probably not correct line detections
        angles.append(diff)
       
    # Calculate the average of nonzero angles
    nonzero_angles = [angle for angle in angles if angle != 0]
    average_angle = np.mean(nonzero_angles)
    print(f"Average angle offset detected: {average_angle:.1f} degrees")
    
    # Rotate the image to straighten it
    h, w = image.shape[:2]
    center = (w // 2, h // 2)
    rotation_matrix = cv2.getRotationMatrix2D(center, average_angle, 1.0) # make transformation matrix M which will be used for rotating an image.
    straightened_image = cv2.warpAffine(image, rotation_matrix, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_CONSTANT, borderValue=(0, 0, 0))
    
    return straightened_image, H


# Load original colour image and apply correction
image_colour = cv2.imread(PATH)
straightened_image, H = straighten_image(image_colour, edges)


# Draw Hough lines on the original image
hough_lines_original = draw_hough_lines(image, H)


# Display results
plt.figure(figsize=(12, 6))


# Original Image
plt.subplot(1, 3, 1)
plt.imshow(image, cmap='gray')
plt.title("Original image")
plt.axis('off')


# Hough lines
plt.subplot(1, 3, 2)
plt.imshow(hough_lines_original, cmap='gray')
plt.title("Original image with Hough lines")
plt.axis('off')


# Straightened image
plt.subplot(1, 3, 3)
plt.imshow(straightened_image, cmap='gray')
plt.title("Straightened image")
plt.axis('off')


plt.tight_layout()
plt.show()