ExampleProcessors.py

from SimpleFramework.SimpleFrameworkImageApplier import ImageProcessor
import cv2
import numpy as np


class PaddingProcessor(ImageProcessor):
    def name(self):
        return "Add Padding"

    def step_names(self):
        return ["Padding 20px"]

    def apply1(self, images):
        result = {}
        for k, img in images.items():
            result[f"{k}"] = img
            padded = cv2.copyMakeBorder(img, 20, 20, 20, 20,
                                        cv2.BORDER_CONSTANT,
                                        value=[255, 255, 255])
            result[f"{k} + Padded"] = padded
        return result


class GaussianBlurProcessor(ImageProcessor):
    def name(self):
        return "Gaussian Blur"

    def step_names(self):
        return ["Apply 5x5 Kernel"]

    def apply1(self, images):
        result = {}
        for k, img in images.items():
            blurred = cv2.GaussianBlur(img, (5, 5), sigmaX=0)
            result[f"{k} + Blurred"] = blurred
        return result


class AddNoiseProcessor(ImageProcessor):
    def name(self):
        return "Add Gaussian Noise"

    def step_names(self):
        return ["Mean=0, Var=0.01"]

    def apply1(self, images):
        result = {}
        for k, img in images.items():
            # normalize image and add noise
            img_float = img / 255.0
            noise = np.random.normal(0, 0.1, img_float.shape)
            noisy = np.clip(img_float + noise, 0, 1) * 255
            result[f"{k} + Noise"] = noisy.astype(np.uint8)
        return result


class RotateProcessor(ImageProcessor):
    def name(self):
        return "Rotate Image"

    def step_names(self):
        return ["Rotate 45°"]

    def apply1(self, images):
        result = {}
        for k, img in images.items():
            (h, w) = img.shape[:2]
            center = (w // 2, h // 2)
            M = cv2.getRotationMatrix2D(center, 45, 1.0)
            rotated = cv2.warpAffine(img, M, (w, h))
            result[f"{k} + Rotated"] = rotated
        return result


class CartoonEffectProcessor(ImageProcessor):
    def name(self):
        return "Cartoon Effect"

    def step_names(self):
        return ["Edge-Preserved Filter + Color Quantization"]

    def apply1(self, images):
        result = {}
        for k, img in images.items():
            # Convert to gray and apply median blur
            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
            blurred = cv2.medianBlur(gray, 7)
            # Detect edges
            edges = cv2.adaptiveThreshold(blurred, 255,
                                          cv2.ADAPTIVE_THRESH_MEAN_C,
                                          cv2.THRESH_BINARY, blockSize=9, C=2)
            # Color quantization
            data = np.float32(img).reshape((-1, 3))
            criteria = (cv2.TERM_CRITERIA_EPS +
                        cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
            _, labels, palette = cv2.kmeans(
                data, 8, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
            quant = palette[labels.flatten()].reshape(
                img.shape).astype(np.uint8)
            # Combine edges and quantized
            cartoon = cv2.bitwise_and(quant, quant, mask=edges)
            result[f"{k} + Cartoon"] = cartoon
        return result