Assignment.py

"""
### 🧠 Edge Detection & Thresholding App

\======================================

This app allows users to explore essential edge detection and thresholding techniques using OpenCV,
including **Canny Edge Detection**, **Binary & Adaptive Thresholding**, and **Bitwise Operations**.

---

📋 **Instructions**:

1. Start the program.

2. ## Choose one of the following options:

   **\[1] Apply Canny Edge Detection**

   * Upload or select an image
   * Set lower and upper threshold values (e.g., 50, 150)
   * Result: Detects edges based on gradient intensity

   **\[2] Apply Binary Thresholding**

   * Upload or select an image
   * Provide threshold value (e.g., 127) and max value (e.g., 255)
   * Result: Converts image to binary (black & white)
   * Type: `cv2.THRESH_BINARY`, `cv2.THRESH_BINARY_INV`

   **\[3] Apply Adaptive Thresholding**

   * Upload or select an image
   * Choose method: `cv2.ADAPTIVE_THRESH_MEAN_C` or `cv2.ADAPTIVE_THRESH_GAUSSIAN_C`
   * Provide block size (odd number, e.g., 11) and C value (e.g., 2)
   * Result: Locally adaptive thresholding that works well in varying lighting

   **\[4] Apply Bitwise Operations**

   * Choose two thresholded or edge-detected images (e.g., from previous steps)
   * Choose operation: `AND`, `OR`, `XOR`, `NOT`
   * Result: Combines images based on binary logic

   **\[5] View Original Image**

   * Displays the original uploaded image without modifications

---

💡 **Notes**:

* All operations work with **grayscale images**, and the app converts if needed.
* Edge-detected and thresholded images are shown in popup windows (CLI) or on-screen (Streamlit).
* Users can **save/download** the result for further analysis.

---

🎓 **Learning Objectives**:

✅ Understand edge detection using gradients (Canny)
✅ Learn the difference between binary and adaptive thresholding
✅ Practice combining image masks using bitwise logic
✅ Strengthen knowledge of OpenCV image processing techniques

---

🔧 **Dependencies**:

* `OpenCV (cv2)`
* `NumPy`
* `Streamlit` *(optional for web app version)*
* `PIL (Pillow)` *(optional for image saving)*

"""

import cv2
import numpy as np


def load_image(path="sample.jpg"):
    img = cv2.imread(path)
    if img is None:
        print("Error: Could not load image.")
        exit()
    return img


def show_image(winname, img):
    cv2.imshow(winname, img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def canny_edge(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    low = int(input("Enter lower threshold: "))
    high = int(input("Enter upper threshold: "))
    edges = cv2.Canny(gray, low, high)
    show_image("Canny Edge", edges)
    return edges


def binary_threshold(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    thresh = int(input("Enter threshold value: "))
    maxval = int(input("Enter max value: "))
    _, binary = cv2.threshold(gray, thresh, maxval, cv2.THRESH_BINARY)
    show_image("Binary Threshold", binary)
    return binary


def adaptive_threshold(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    block_size = int(input("Enter block size (odd number): "))
    C = int(input("Enter C value: "))
    method = input("Method? (mean/gaussian): ").strip().lower()
    if method == "mean":
        adaptive = cv2.adaptiveThreshold(
            gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, block_size, C
        )
    else:
        adaptive = cv2.adaptiveThreshold(
            gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, block_size, C
        )
    show_image("Adaptive Threshold", adaptive)
    return adaptive


def bitwise_ops(img1, img2):
    op = input("Choose operation: and/or/xor/not: ").strip().lower()
    if op == "and":
        result = cv2.bitwise_and(img1, img2)
    elif op == "or":
        result = cv2.bitwise_or(img1, img2)
    elif op == "xor":
        result = cv2.bitwise_xor(img1, img2)
    elif op == "not":
        result = cv2.bitwise_not(img1)
    else:
        print("Invalid operation.")
        return
    show_image("Bitwise Result", result)


def main():
    path = input("Enter image path: ")
    img = load_image(path)

    while True:
        print("""
        [1] Apply Canny Edge Detection
        [2] Apply Binary Thresholding
        [3] Apply Adaptive Thresholding
        [4] Apply Bitwise Operations
        [5] View Original Image
        [0] Exit
        """)
        choice = input("Choose an option: ")
        if choice == "1":
            edges = canny_edge(img)
        elif choice == "2":
            binary = binary_threshold(img)
        elif choice == "3":
            adaptive = adaptive_threshold(img)
        elif choice == "4":
            print("Make sure you already ran at least one threshold/edge function!")
            img1 = binary_threshold(img)
            img2 = adaptive_threshold(img)
            bitwise_ops(img1, img2)
        elif choice == "5":
            show_image("Original Image", img)
        elif choice == "0":
            break
        else:
            print("Invalid choice!")


if __name__ == "__main__":
    main()