Refactor image processing functions and add effects

- Cleaned up code formatting
- Added black and white effect
- Implemented sepia tone effect
- Introduced negative image effect
- Added watercolor and posterization effects

filters.py

@@ -167,15 +167,15 @@ def warm_filter(image, intensity: int = 30):
     """
     # Convert intensity to actual adjustment values
     intensity_scale = intensity / 100.0
-    
+
     # Split the image into BGR channels
     b, g, r = cv2.split(image.astype(np.float32))
-    
+
     # Increase red, slightly increase green, decrease blue
     r = np.clip(r * (1 + 0.5 * intensity_scale), 0, 255)
     g = np.clip(g * (1 + 0.1 * intensity_scale), 0, 255)
     b = np.clip(b * (1 - 0.1 * intensity_scale), 0, 255)
-    
+
     return cv2.merge([b, g, r]).astype(np.uint8)
 
 
@@ -201,15 +201,15 @@ def cool_filter(image, intensity: int = 30):
     """
     # Convert intensity to actual adjustment values
     intensity_scale = intensity / 100.0
-    
+
     # Split the image into BGR channels
     b, g, r = cv2.split(image.astype(np.float32))
-    
+
     # Increase blue, slightly increase green, decrease red
     b = np.clip(b * (1 + 0.5 * intensity_scale), 0, 255)
     g = np.clip(g * (1 + 0.1 * intensity_scale), 0, 255)
     r = np.clip(r * (1 - 0.1 * intensity_scale), 0, 255)
-    
+
     return cv2.merge([b, g, r]).astype(np.uint8)
 
 
@@ -235,13 +235,13 @@ def adjust_saturation(image, factor: int = 50):
     """
     # Convert factor to multiplication value (0.0 to 2.0)
     factor = (factor / 50.0)
-    
+
     # Convert to HSV
     hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV).astype(np.float32)
-    
+
     # Adjust saturation
     hsv[:, :, 1] = np.clip(hsv[:, :, 1] * factor, 0, 255)
-    
+
     # Convert back to BGR
     return cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
 
@@ -267,23 +267,23 @@ def vintage_filter(image, intensity: int = 50):
     * `numpy.ndarray`: Image with vintage effect
     """
     intensity_scale = intensity / 100.0
-    
+
     # Split channels
     b, g, r = cv2.split(image.astype(np.float32))
-    
+
     # Adjust colors for vintage look
     r = np.clip(r * (1 + 0.3 * intensity_scale), 0, 255)
     g = np.clip(g * (1 - 0.1 * intensity_scale), 0, 255)
     b = np.clip(b * (1 - 0.2 * intensity_scale), 0, 255)
-    
+
     # Create sepia-like effect
     result = cv2.merge([b, g, r]).astype(np.uint8)
-    
+
     # Add slight blur for softness
     if intensity > 0:
         blur_amount = int(3 * intensity_scale) * 2 + 1
         result = cv2.GaussianBlur(result, (blur_amount, blur_amount), 0)
-    
+
     return result
 
 
@@ -308,21 +308,21 @@ def vignette_effect(image, intensity: int = 50):
     * `numpy.ndarray`: Image with vignette effect
     """
     height, width = image.shape[:2]
-    
+
     # Create a vignette mask
     X_resultant = np.abs(np.linspace(-1, 1, width)[None, :])
     Y_resultant = np.abs(np.linspace(-1, 1, height)[:, None])
     mask = np.sqrt(X_resultant**2 + Y_resultant**2)
     mask = 1 - np.clip(mask, 0, 1)
-    
+
     # Adjust mask based on intensity
     mask = (mask - mask.min()) / (mask.max() - mask.min())
     mask = mask ** (1 + intensity/50)
-    
+
     # Apply mask to image
     mask = mask[:, :, None]
     result = image.astype(np.float32) * mask
-    
+
     return np.clip(result, 0, 255).astype(np.uint8)
 
 
@@ -347,27 +347,30 @@ def hdr_effect(image, strength: int = 50):
     * `numpy.ndarray`: Image with HDR-like effect
     """
     strength_scale = strength / 100.0
-    
+
     # Convert to LAB color space
     lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB).astype(np.float32)
-    
+
     # Split channels
     l, a, b = cv2.split(lab)
-    
+
     # Apply CLAHE to L channel
-    clahe = cv2.createCLAHE(clipLimit=3.0 * strength_scale, tileGridSize=(8, 8))
+    clahe = cv2.createCLAHE(
+        clipLimit=3.0 * strength_scale, tileGridSize=(8, 8))
     l = clahe.apply(l.astype(np.uint8)).astype(np.float32)
-    
+
     # Enhance local contrast
     if strength > 0:
         blur = cv2.GaussianBlur(l, (0, 0), 3)
-        detail = cv2.addWeighted(l, 1 + strength_scale, blur, -strength_scale, 0)
-        l = cv2.addWeighted(l, 1 - strength_scale/2, detail, strength_scale/2, 0)
-    
+        detail = cv2.addWeighted(
+            l, 1 + strength_scale, blur, -strength_scale, 0)
+        l = cv2.addWeighted(l, 1 - strength_scale/2,
+                            detail, strength_scale/2, 0)
+
     # Merge channels and convert back
     enhanced_lab = cv2.merge([l, a, b])
     result = cv2.cvtColor(enhanced_lab.astype(np.uint8), cv2.COLOR_LAB2BGR)
-    
+
     return result
 
 
@@ -394,7 +397,7 @@ def gaussian_blur(image, kernel_size: int = 5):
     # Ensure kernel size is odd
     if kernel_size % 2 == 0:
         kernel_size += 1
-    
+
     return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
 
 
@@ -419,15 +422,15 @@ def sharpen(image, amount: int = 50):
     * `numpy.ndarray`: Sharpened image
     """
     amount = amount / 100.0
-    
+
     # Create the sharpening kernel
-    kernel = np.array([[-1,-1,-1],
-                      [-1, 9,-1],
-                      [-1,-1,-1]])
-    
+    kernel = np.array([[-1, -1, -1],
+                      [-1, 9, -1],
+                      [-1, -1, -1]])
+
     # Apply the kernel
     sharpened = cv2.filter2D(image, -1, kernel)
-    
+
     # Blend with original image based on amount
     return cv2.addWeighted(image, 1 - amount, sharpened, amount, 0)
 
@@ -458,43 +461,43 @@ def emboss(image, strength: int = 50, direction: int = 0):
     * `numpy.ndarray`: Embossed image
     """
     strength = strength / 100.0 * 2.0  # Scale to 0-2 range
-    
+
     # Define kernels for different directions
     kernels = [
-        np.array([[-1,-1, 0],
+        np.array([[-1, -1, 0],
                  [-1, 1, 1],
-                 [ 0, 1, 1]]),  # 0 - top left to bottom right
+                 [0, 1, 1]]),  # 0 - top left to bottom right
         np.array([[-1, 0, 1],
                  [-1, 1, 1],
                  [-1, 0, 1]]),  # 1 - left to right
-        np.array([[ 0, 1, 1],
+        np.array([[0, 1, 1],
                  [-1, 1, 1],
-                 [-1,-1, 0]]),  # 2 - bottom left to top right
-        np.array([[ 1, 1, 1],
-                 [ 0, 1, 0],
-                 [-1,-1,-1]]),  # 3 - bottom to top
-        np.array([[ 1, 1, 0],
-                 [ 1, 1,-1],
-                 [ 0,-1,-1]]),  # 4 - bottom right to top left
-        np.array([[ 1, 0,-1],
-                 [ 1, 1,-1],
-                 [ 1, 0,-1]]),  # 5 - right to left
-        np.array([[ 0,-1,-1],
-                 [ 1, 1,-1],
-                 [ 1, 1, 0]]),  # 6 - top right to bottom left
-        np.array([[-1,-1,-1],
-                 [ 0, 1, 0],
-                 [ 1, 1, 1]])   # 7 - top to bottom
+                 [-1, -1, 0]]),  # 2 - bottom left to top right
+        np.array([[1, 1, 1],
+                 [0, 1, 0],
+                 [-1, -1, -1]]),  # 3 - bottom to top
+        np.array([[1, 1, 0],
+                 [1, 1, -1],
+                 [0, -1, -1]]),  # 4 - bottom right to top left
+        np.array([[1, 0, -1],
+                 [1, 1, -1],
+                 [1, 0, -1]]),  # 5 - right to left
+        np.array([[0, -1, -1],
+                 [1, 1, -1],
+                 [1, 1, 0]]),  # 6 - top right to bottom left
+        np.array([[-1, -1, -1],
+                 [0, 1, 0],
+                 [1, 1, 1]])   # 7 - top to bottom
     ]
-    
+
     # Apply the kernel
     kernel = kernels[direction % 8]
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     embossed = cv2.filter2D(gray, -1, kernel * strength)
-    
+
     # Normalize to ensure good contrast
     embossed = cv2.normalize(embossed, None, 0, 255, cv2.NORM_MINMAX)
-    
+
     # Convert back to BGR
     return cv2.cvtColor(embossed.astype(np.uint8), cv2.COLOR_GRAY2BGR)
 
@@ -526,3 +529,116 @@ def oil_painting(image, size: int = 5, dynRatio: int = 1):
     """
     return cv2.xphoto.oilPainting(image, size, dynRatio)
 
+
+@registry.register("Black and White")
+def black_and_white(image):
+    """
+    ## Convert image to classic black and white.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Grayscale image
+    """
+    return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+
+@registry.register("Sepia")
+def sepia(image):
+    """
+    ## Apply a warm sepia tone effect.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Sepia toned image
+    """
+    # Convert to RGB
+    rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Apply sepia matrix
+    sepia_matrix = np.array([
+        [0.393, 0.769, 0.189],
+        [0.349, 0.686, 0.168],
+        [0.272, 0.534, 0.131]
+    ])
+
+    sepia_image = np.dot(rgb, sepia_matrix.T)
+    sepia_image = np.clip(sepia_image, 0, 255)
+
+    return cv2.cvtColor(sepia_image.astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+
+@registry.register("Negative")
+def negative(image):
+    """
+    ## Invert colors to create a negative effect.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Negative image
+    """
+    return cv2.bitwise_not(image)
+
+
+@registry.register("Watercolor")
+def watercolor(image):
+    """
+    ## Apply a watercolor painting effect.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Watercolor effect image
+    """
+    # Apply bilateral filter to create watercolor effect
+    return cv2.xphoto.oilPainting(image, 7, 1)
+
+
+@registry.register("Posterization")
+def posterize(image):
+    """
+    ## Reduce colors to create a posterization effect.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Posterized image
+    """
+    # Convert to HSV
+    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    # Reduce color levels
+    hsv[:, :, 1] = cv2.equalizeHist(hsv[:, :, 1])
+    hsv[:, :, 2] = cv2.equalizeHist(hsv[:, :, 2])
+
+    # Convert back to BGR
+    return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+
+
+@registry.register("Cross Process")
+def cross_process(image):
+    """
+    ## Apply a film cross-processing effect.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+
+    **Returns:**
+    * `numpy.ndarray`: Cross-processed image
+    """
+    # Split channels
+    b, g, r = cv2.split(image.astype(np.float32))
+
+    # Apply cross-process transformation
+    b = np.clip(b * 1.2, 0, 255)
+    g = np.clip(g * 0.8, 0, 255)
+    r = np.clip(r * 1.4, 0, 255)
+
+    return cv2.merge([b, g, r]).astype(np.uint8)