Add new image processing filters to filters.py

- Introduced four new professional image filters:
* Gaussian Blur: Softens image with adjustable kernel size
* Sharpen: Enhances image details with intensity control
* Emboss: Creates 3D-like effect with direction and strength options
* Oil Painting: Applies artistic oil painting style to images
- Implemented comprehensive parameter controls for each filter
- Used OpenCV for advanced image processing techniques
- Registered new filters with default, min, max, and step values
- Expanded image editing capabilities with diverse filter options

filters.py

@@ -370,3 +370,159 @@ def hdr_effect(image, strength: int = 50):
     
     return result
 
+
+@registry.register("Gaussian Blur", defaults={
+    "kernel_size": 5,
+}, min_vals={
+    "kernel_size": 1,
+}, max_vals={
+    "kernel_size": 31,
+}, step_vals={
+    "kernel_size": 2,
+})
+def gaussian_blur(image, kernel_size: int = 5):
+    """
+    ## Apply Gaussian blur effect to the image.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+    * `kernel_size` (int): Size of the Gaussian kernel (must be odd)
+
+    **Returns:**
+    * `numpy.ndarray`: Blurred image
+    """
+    # Ensure kernel size is odd
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    
+    return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
+
+
+@registry.register("Sharpen", defaults={
+    "amount": 50,
+}, min_vals={
+    "amount": 0,
+}, max_vals={
+    "amount": 100,
+}, step_vals={
+    "amount": 1,
+})
+def sharpen(image, amount: int = 50):
+    """
+    ## Sharpen the image.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+    * `amount` (int): Sharpening intensity (0-100)
+
+    **Returns:**
+    * `numpy.ndarray`: Sharpened image
+    """
+    amount = amount / 100.0
+    
+    # Create the sharpening kernel
+    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)
+
+
+@registry.register("Emboss", defaults={
+    "strength": 50,
+    "direction": 0,
+}, min_vals={
+    "strength": 0,
+    "direction": 0,
+}, max_vals={
+    "strength": 100,
+    "direction": 7,
+}, step_vals={
+    "strength": 1,
+    "direction": 1,
+})
+def emboss(image, strength: int = 50, direction: int = 0):
+    """
+    ## Apply emboss effect to create a 3D look.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+    * `strength` (int): Emboss strength (0-100)
+    * `direction` (int): Direction of emboss effect (0-7)
+
+    **Returns:**
+    * `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],
+                 [-1, 1, 1],
+                 [ 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],
+                 [-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
+    ]
+    
+    # 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)
+
+
+@registry.register("Oil Painting", defaults={
+    "size": 5,
+    "dynRatio": 1,
+}, min_vals={
+    "size": 1,
+    "dynRatio": 1,
+}, max_vals={
+    "size": 15,
+    "dynRatio": 7,
+}, step_vals={
+    "size": 2,
+    "dynRatio": 1,
+})
+def oil_painting(image, size: int = 5, dynRatio: int = 1):
+    """
+    ## Apply oil painting effect to the image.
+
+    **Args:**
+    * `image` (numpy.ndarray): Input image (BGR)
+    * `size` (int): Size of the neighborhood considered
+    * `dynRatio` (int): Dynamic ratio affecting the intensity binning
+
+    **Returns:**
+    * `numpy.ndarray`: Image with oil painting effect
+    """
+    return cv2.xphoto.oilPainting(image, size, dynRatio)
+