@(m4ojph#d~n$f3`1j#EPi2Mm>Xj}eC-@eyvPjK2*|9ck@-3wjjfgMA=o44
z4yn(>H$~%0>urA!U&YRs-QWs;f%+k<+eIBBu-n`N1Tjhl)>DSki4P!e2ZZa4ZC
zsh8eRP(b}Xh&q_Q>7FlLZrQm5ejXH_v%5PU#2jvS--AMzyOCTrR6p33@9uq2UgEBN
z(AMpK+5Y2cd%jy~Hx)REvb2k)i>`
z!i;h5_fcD}4j=-c`3g#mzm*xO4G0RMsX<2~CHD3hc
zMi0Ymp;{aWbp6M$ruU^1ksxDf|6-TgB4`6?wP6{Pklb{sDRJ0>O8981PQ#gN<6(@5(!CVWz$j0(q
zG#QI9(e%+soD3tcFbg{Qe%HR4E>iIv$I*1h$ZhWUMvgqKLbgrDaPyZ+
zn`$@_1uK^d{eWHaGS+e!LO3#V=M~p@BqEm~gO4V794sSYh&Np_T>04-z~t8n;XDu?
zbAbi8K7`_#J&khiqmyXP2SN!DpmC)D9V@pGolfjTMkWx+he5Nfu0e*+P=PRze>94>
zxjpjGDM*X;hlY&}-S6RsC=8$m_98d1(qH)Yo=wtPP$8S7G`2*k(13(A!v7lir2_q+
zZ!pT>mnl}KGVR36p8>*XyXB#M3T4VZ#fUt}DxV1&zKBJru1GgNstD{bg!jrqRJMCU
zZm=#RG$11z8h^P0RzMkzJxv;ReD(!VzT~g<;*f}h9o)9}v
zWc(-Za0S=$$ZzTJZLW#U3TT*J)Lav_JV0@T6lB%}waS_v9;Y`H{6`FGf=3QU4>vs`
zXJ-$}YuqR74+h-s&Yyq|ZoY3rz^Y|gvfRW3`;7KPa1V3S21W=;SX(eI;|oM)Z(HhQGrM=?*I
zz4`hpk8Jq4FW7A^|8nYcXVnkAN4T*Ik9*IsNU^8CTi5
h%YXIocaDAg*z(!8UcUD7uf1~HRfVsaxT;xq|37Fh_xb<;
literal 0
HcmV?d00001
diff --git a/effects_settings.py b/effects_settings.py
deleted file mode 100644
index eacab45..0000000
--- a/effects_settings.py
+++ /dev/null
@@ -1,197 +0,0 @@
-from filters import *
-
-FILTERS = {}
-
-from filters.Color import escala_grises
-from filters.Color import inidie
-from filters.Color import matiz
-from filters.Color import saturador
-from filters.Desenfoque import bilateral
-from filters.Desenfoque import box
-from filters.Desenfoque import desenfoque_gausiano
-from filters.Desenfoque import desenfoque_horizontal
-from filters.Desenfoque import desenfoque_vertical
-from filters.Desenfoque import mediana
-from filters.espejo import espejo
-from filters.glitch import glitch
-from filters.glitch import shift
-from filters.glitch import shift_pro
-from filters.pixel import pixelar
-from filters.pixel import pixelar_pro
-from filters.Ruido import ruido_gausiano
-from filters.varios import dilatar
-from filters.varios import dilatar_pro
-from filters.varios import erode
-from filters.varios import super_queee
-
-FILTERS = {
- "Color": {
- "escala_grises": {
- "apply": escala_grises.apply_effect,
- },
- "inidie": {
- "apply": inidie.apply_effect,
- "parameters": {
- "blur_kernel_size": {'min': 3, 'max': 15, 'init': 5, 'interval': 2},
- "canny_threshold1": {'min': 50, 'max': 150, 'init': 100, 'interval': 10},
- "canny_threshold2": {'min': 100, 'max': 250, 'init': 200, 'interval': 10},
- "color_adjustment": {'min': 0.5, 'max': 2.0, 'init': 1.5, 'interval': 0.1},
- "noise_level": {'min': 10, 'max': 30, 'init': 20, 'interval': 5},
- }
- },
- "matiz": {
- "apply": matiz.apply_effect,
- "parameters": {
- "hue_shift": {'min': -180, 'max': 180, 'init': 0, 'interval': 1},
- }
- },
- "saturador": {
- "apply": saturador.apply_effect,
- "parameters": {
- "color": {'options': ['red', 'green', 'blue', 'yellow', 'cyan', 'magenta'], 'init': 'red'},
- "saturation_scale": {'min': 0, 'max': 100, 'init': 50, 'interval': 1},
- "brightness_boost": {'min': 0, 'max': 100, 'init': 50, 'interval': 1},
- }
- },
- },
- "Desenfoque": {
- "bilateral": {
- "apply": bilateral.apply_effect,
- "parameters": {
- "d": {'min': 1, 'max': 10, 'init': 3, 'interval': 1},
- "sigmaColor": {'min': 1, 'max': 100, 'init': 20, 'interval': 1},
- "sigmaSpace": {'min': 1, 'max': 100, 'init': 15, 'interval': 1},
- }
- },
- "box": {
- "apply": box.apply_effect,
- "parameters": {
- "ksize_x": {'min': 3, 'max': 15, 'init': 5, 'interval': 2},
- "ksize_y": {'min': 3, 'max': 15, 'init': 5, 'interval': 2},
- }
- },
- "desenfoque_gausiano": {
- "apply": desenfoque_gausiano.apply_effect,
- "parameters": {
- "kernel_size": {'min': 1, 'max': 31, 'init': 15, 'interval': 2},
- "sigma": {'min': 1, 'max': 10, 'init': 5, 'interval': 1},
- }
- },
- "desenfoque_horizontal": {
- "apply": desenfoque_horizontal.apply_effect,
- "parameters": {
- "kernel_size": {'min': 1, 'max': 101, 'init': 3, 'interval': 2},
- }
- },
- "desenfoque_vertical": {
- "apply": desenfoque_vertical.apply_effect,
- "parameters": {
- "multi": {'min': 1, 'max': 100, 'init': 30, 'interval': 1},
- }
- },
- "mediana": {
- "apply": mediana.apply_effect,
- "parameters": {
- "kernel_size": {'min': 1, 'max': 101, 'init': 3, 'interval': 2},
- }
- },
- },
- "espejo": {
- "espejo": {
- "apply": espejo.apply_effect,
- "parameters": {
- "angle": {'min': -45, 'max': 45, 'init': 0, 'interval': 1},
- "direction": {'options': ['Horizontal', 'Vertical'], 'init': 'Horizontal'},
- "flip_type": {'options': ['Full', 'Partial'], 'init': 'Full'},
- "split_ratio": {'min': 1, 'max': 9, 'init': 5, 'interval': 1},
- }
- },
- },
- "glitch": {
- "glitch": {
- "apply": glitch.apply_effect,
- "parameters": {
- "glitch_intensity": {'min': 1, 'max': 50, 'init': 10, 'interval': 1},
- "glitch_frequency": {'min': 1, 'max': 50, 'init': 5, 'interval': 1},
- }
- },
- "shift": {
- "apply": shift.apply_effect,
- "parameters": {
- "shift_value": {'min': -50, 'max': 50, 'init': 5, 'interval': 1},
- }
- },
- "shift_pro": {
- "apply": shift_pro.apply_effect,
- "parameters": {
- "shift_value_b": {'min': -50, 'max': 50, 'init': 5, 'interval': 1},
- "shift_value_g": {'min': -50, 'max': 50, 'init': -5, 'interval': 1},
- "shift_value_r": {'min': -50, 'max': 50, 'init': 2, 'interval': 1},
- "direction_b": {'options': ['horizontal', 'vertical'], 'init': 'horizontal'},
- "direction_g": {'options': ['horizontal', 'vertical'], 'init': 'horizontal'},
- "direction_r": {'options': ['horizontal', 'vertical'], 'init': 'vertical'},
- }
- },
- },
- "pixel": {
- "pixelar": {
- "apply": pixelar.apply_effect,
- "parameters": {
- "block_size": {'min': 2, 'max': 50, 'init': 5, 'interval': 1},
- }
- },
- "pixelar_pro": {
- "apply": pixelar_pro.apply_effect,
- "parameters": {
- "block_size": {'min': 2, 'max': 50, 'init': 5, 'interval': 1},
- "method": {'options': ['mean', 'median', 'mode'], 'init': 'mean'},
- "intensity": {'min': 0.1, 'max': 2.0, 'init': 1.0, 'interval': 0.1},
- "block_shape": {'options': ['square', 'rectangular'], 'init': 'square'},
- }
- },
- },
- "Ruido": {
- "ruido_gausiano": {
- "apply": ruido_gausiano.apply_effect,
- "parameters": {
- "mean": {'min': -100, 'max': 100, 'init': 0, 'interval': 10},
- "std_dev": {'min': 1, 'max': 10, 'init': 5, 'interval': 1},
- }
- },
- },
- "varios": {
- "dilatar": {
- "apply": dilatar.apply_effect,
- "parameters": {
- "kernel_size": {'min': 2, 'max': 50, 'init': 5, 'interval': 1},
- }
- },
- "dilatar_pro": {
- "apply": dilatar_pro.apply_effect,
- "parameters": {
- "kernel_size": {'min': 2, 'max': 50, 'init': 5, 'interval': 1},
- "anchor": {'min': -1, 'max': -1, 'init': -1, 'interval': 1},
- "iterations": {'min': 1, 'max': 10, 'init': 1, 'interval': 1},
- "border_value": {'min': 0, 'max': 255, 'init': 0, 'interval': 1},
- }
- },
- "erode": {
- "apply": erode.apply_effect,
- "parameters": {
- "kernel_size": {'min': 2, 'max': 50, 'init': 5, 'interval': 1},
- "anchor": {'min': -1, 'max': -1, 'init': -1, 'interval': 1},
- "iterations": {'min': 1, 'max': 10, 'init': 1, 'interval': 1},
- "border_type": {'min': 0, 'max': 4, 'init': 0, 'interval': 1},
- "border_value": {'min': 0, 'max': 255, 'init': 0, 'interval': 1},
- }
- },
- "super_queee": {
- "apply": super_queee.apply_effect,
- "parameters": {
- "blur_radius": {'min': 1, 'max': 10, 'init': 5, 'interval': 1},
- "morphology_iterations": {'min': 1, 'max': 5, 'init': 2, 'interval': 1},
- "pyramid_levels": {'min': 1, 'max': 5, 'init': 3, 'interval': 1},
- }
- },
- },
-}
diff --git a/filter_engine.py b/filter_engine.py
new file mode 100644
index 0000000..fe06481
--- /dev/null
+++ b/filter_engine.py
@@ -0,0 +1,439 @@
+"""
+Filter Engine Module
+
+This module contains all the built-in filter operations that can be combined
+to create custom filters. Each operation is a function that takes an image
+and parameters, returning the modified image.
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Dict, Callable
+
+
+class FilterEngine:
+ """
+ Engine that applies filter operations to images.
+
+ Operations are predefined functions that can be configured via JSON.
+ Filters can be single operations or pipelines of multiple operations.
+ """
+
+ def __init__(self):
+ """Initialize the filter engine with all available operations."""
+ self._operations: Dict[str, Callable] = {
+ # Color operations
+ "grayscale": self._grayscale,
+ "hue_shift": self._hue_shift,
+ "saturate_color": self._saturate_color,
+ "indie_effect": self._indie_effect,
+
+ # Blur operations
+ "gaussian_blur": self._gaussian_blur,
+ "box_blur": self._box_blur,
+ "bilateral_filter": self._bilateral_filter,
+ "median_blur": self._median_blur,
+ "horizontal_blur": self._horizontal_blur,
+ "vertical_blur": self._vertical_blur,
+
+ # Glitch operations
+ "glitch": self._glitch,
+ "channel_shift": self._channel_shift,
+ "channel_shift_pro": self._channel_shift_pro,
+
+ # Pixel operations
+ "pixelate": self._pixelate,
+ "pixelate_pro": self._pixelate_pro,
+
+ # Noise operations
+ "gaussian_noise": self._gaussian_noise,
+
+ # Morphology operations
+ "dilate": self._dilate,
+ "dilate_pro": self._dilate_pro,
+ "erode": self._erode,
+ "super_effect": self._super_effect,
+ }
+
+ def get_available_operations(self) -> list:
+ """Get list of all available operations."""
+ return list(self._operations.keys())
+
+ def apply_operation(self, image: np.ndarray, operation: str, **params) -> np.ndarray:
+ """
+ Apply a single operation to an image.
+
+ Args:
+ image: The input image
+ operation: Name of the operation to apply
+ **params: Parameters for the operation
+
+ Returns:
+ The modified image
+ """
+ if operation not in self._operations:
+ raise ValueError(f"Unknown operation: {operation}")
+
+ return self._operations[operation](image, **params)
+
+ def apply_filter(self, image: np.ndarray, filter_config: Dict[str, Any]) -> np.ndarray:
+ """
+ Apply a filter (which may be a pipeline of operations) to an image.
+
+ Args:
+ image: The input image
+ filter_config: Filter configuration from JSON
+
+ Returns:
+ The modified image
+ """
+ operation = filter_config.get("operation")
+ if not operation:
+ raise ValueError("Filter must have an 'operation' field")
+
+ # Extract parameter values (use 'init' as default)
+ params = {}
+ for param_name, param_config in filter_config.get("parameters", {}).items():
+ if isinstance(param_config, dict):
+ params[param_name] = param_config.get("init", param_config.get("value"))
+ else:
+ params[param_name] = param_config
+
+ return self.apply_operation(image, operation, **params)
+
+ def apply_filter_with_params(self, image: np.ndarray, filter_config: Dict[str, Any],
+ user_params: Dict[str, Any]) -> np.ndarray:
+ """
+ Apply a filter with user-provided parameter values.
+
+ Args:
+ image: The input image
+ filter_config: Filter configuration from JSON
+ user_params: Parameter values provided by the user
+
+ Returns:
+ The modified image
+ """
+ operation = filter_config.get("operation")
+ if not operation:
+ raise ValueError("Filter must have an 'operation' field")
+
+ return self.apply_operation(image, operation, **user_params)
+
+ # ==================== Color Operations ====================
+
+ def _grayscale(self, image: np.ndarray, **kwargs) -> np.ndarray:
+ """Convert image to grayscale."""
+ return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+ def _hue_shift(self, image: np.ndarray, hue_shift: int = 0, **kwargs) -> np.ndarray:
+ """Shift the hue of the image."""
+ hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+ hsv_image[:, :, 0] = (hsv_image[:, :, 0].astype(int) + hue_shift) % 180
+ return cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)
+
+ def _saturate_color(self, image: np.ndarray, color: str = "red",
+ saturation_scale: int = 50, brightness_boost: int = 50,
+ **kwargs) -> np.ndarray:
+ """Enhance saturation and brightness for a specific color."""
+ hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+ h, s, v = cv2.split(hsv_image)
+
+ color_ranges = {
+ 'red': [(0, 10), (160, 180)],
+ 'green': [(35, 85)],
+ 'blue': [(100, 140)],
+ 'yellow': [(25, 35)],
+ 'cyan': [(85, 100)],
+ 'magenta': [(140, 160)]
+ }
+
+ ranges = color_ranges.get(color, [(0, 180)])
+ masks = []
+ for (lower, upper) in ranges:
+ mask = cv2.inRange(h, lower, upper)
+ masks.append(mask)
+
+ color_mask = masks[0]
+ for mask in masks[1:]:
+ color_mask = cv2.bitwise_or(color_mask, mask)
+
+ s = cv2.add(s, (saturation_scale * (color_mask // 255)).astype(np.uint8))
+ v = cv2.add(v, (brightness_boost * (color_mask // 255)).astype(np.uint8))
+
+ s = np.clip(s, 0, 255)
+ v = np.clip(v, 0, 255)
+
+ enhanced_hsv = cv2.merge([h, s, v])
+ return cv2.cvtColor(enhanced_hsv, cv2.COLOR_HSV2BGR)
+
+ def _indie_effect(self, image: np.ndarray, blur_kernel_size: int = 5,
+ canny_threshold1: int = 100, canny_threshold2: int = 200,
+ color_adjustment: float = 1.5, noise_level: int = 20,
+ **kwargs) -> np.ndarray:
+ """Apply indie/retro effect."""
+ if blur_kernel_size % 2 == 0:
+ blur_kernel_size += 1
+
+ blurred = cv2.GaussianBlur(image, (blur_kernel_size, blur_kernel_size), 0)
+ edges = cv2.Canny(blurred, canny_threshold1, canny_threshold2)
+ edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+
+ indie_image = np.clip(
+ color_adjustment * blurred - (1 - color_adjustment) * edges_3ch,
+ 0, 255
+ ).astype(np.uint8)
+
+ noise = np.random.normal(0, noise_level, image.shape).astype(np.uint8)
+ indie_image = np.clip(indie_image + noise, 0, 255).astype(np.uint8)
+
+ return indie_image
+
+ # ==================== Blur Operations ====================
+
+ def _gaussian_blur(self, image: np.ndarray, kernel_size: int = 15,
+ sigma: int = 5, **kwargs) -> np.ndarray:
+ """Apply Gaussian blur."""
+ if kernel_size % 2 == 0:
+ kernel_size += 1
+ return cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma)
+
+ def _box_blur(self, image: np.ndarray, ksize_x: int = 5,
+ ksize_y: int = 5, **kwargs) -> np.ndarray:
+ """Apply box blur."""
+ if ksize_x % 2 == 0:
+ ksize_x += 1
+ if ksize_y % 2 == 0:
+ ksize_y += 1
+ return cv2.boxFilter(image, -1, (ksize_x, ksize_y))
+
+ def _bilateral_filter(self, image: np.ndarray, d: int = 3,
+ sigmaColor: int = 20, sigmaSpace: int = 15,
+ **kwargs) -> np.ndarray:
+ """Apply bilateral filter."""
+ return cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
+
+ def _median_blur(self, image: np.ndarray, kernel_size: int = 3,
+ **kwargs) -> np.ndarray:
+ """Apply median blur."""
+ if kernel_size % 2 == 0:
+ kernel_size += 1
+ return cv2.medianBlur(image, kernel_size)
+
+ def _horizontal_blur(self, image: np.ndarray, kernel_size: int = 3,
+ **kwargs) -> np.ndarray:
+ """Apply horizontal motion blur."""
+ if kernel_size % 2 == 0:
+ kernel_size += 1
+ kernel = np.zeros((kernel_size, kernel_size))
+ kernel[int((kernel_size - 1) / 2), :] = np.ones(kernel_size)
+ kernel /= kernel_size
+ return cv2.filter2D(image, -1, kernel)
+
+ def _vertical_blur(self, image: np.ndarray, multi: int = 30,
+ **kwargs) -> np.ndarray:
+ """Apply vertical motion blur."""
+ kernel_size = max(3, multi)
+ if kernel_size % 2 == 0:
+ kernel_size += 1
+ kernel = np.zeros((kernel_size, kernel_size))
+ kernel[:, int((kernel_size - 1) / 2)] = np.ones(kernel_size)
+ kernel /= kernel_size
+ return cv2.filter2D(image, -1, kernel)
+
+ # ==================== Glitch Operations ====================
+
+ def _glitch(self, image: np.ndarray, glitch_intensity: int = 10,
+ glitch_frequency: int = 5, **kwargs) -> np.ndarray:
+ """Apply glitch effect."""
+ rows, cols = image.shape[:2]
+ glitch_image = image.copy()
+
+ for i in range(0, rows, max(1, glitch_frequency)):
+ shift = np.random.randint(-glitch_intensity, glitch_intensity + 1)
+ glitch_image[i] = np.roll(image[i], shift, axis=0)
+
+ return glitch_image
+
+ def _channel_shift(self, image: np.ndarray, shift_value: int = 5,
+ **kwargs) -> np.ndarray:
+ """Shift color channels."""
+ result = image.copy()
+ result[:, :, 0] = np.roll(image[:, :, 0], shift_value, axis=1)
+ return result
+
+ def _channel_shift_pro(self, image: np.ndarray,
+ shift_value_b: int = 5, shift_value_g: int = -5,
+ shift_value_r: int = 2,
+ direction_b: str = "horizontal",
+ direction_g: str = "horizontal",
+ direction_r: str = "vertical",
+ **kwargs) -> np.ndarray:
+ """Advanced channel shifting with per-channel control."""
+ result = image.copy()
+
+ axis_b = 1 if direction_b == "horizontal" else 0
+ axis_g = 1 if direction_g == "horizontal" else 0
+ axis_r = 1 if direction_r == "horizontal" else 0
+
+ result[:, :, 0] = np.roll(image[:, :, 0], shift_value_b, axis=axis_b)
+ result[:, :, 1] = np.roll(image[:, :, 1], shift_value_g, axis=axis_g)
+ result[:, :, 2] = np.roll(image[:, :, 2], shift_value_r, axis=axis_r)
+
+ return result
+
+ # ==================== Pixel Operations ====================
+
+ def _pixelate(self, image: np.ndarray, block_size: int = 5,
+ **kwargs) -> np.ndarray:
+ """Apply pixelation effect."""
+ height, width = image.shape[:2]
+ block_size = max(2, block_size)
+
+ num_blocks_x = width // block_size
+ num_blocks_y = height // block_size
+
+ if num_blocks_x == 0 or num_blocks_y == 0:
+ return image
+
+ pixelated = np.zeros(
+ (num_blocks_y * block_size, num_blocks_x * block_size, 3),
+ dtype=np.uint8
+ )
+
+ for y in range(num_blocks_y):
+ for x in range(num_blocks_x):
+ start_x = x * block_size
+ end_x = (x + 1) * block_size
+ start_y = y * block_size
+ end_y = (y + 1) * block_size
+ block = image[start_y:end_y, start_x:end_x]
+ pixelated[start_y:end_y, start_x:end_x] = block.mean(axis=(0, 1))
+
+ return pixelated
+
+ def _pixelate_pro(self, image: np.ndarray, block_size: int = 5,
+ method: str = "mean", intensity: float = 1.0,
+ block_shape: str = "square", **kwargs) -> np.ndarray:
+ """Advanced pixelation with multiple methods."""
+ height, width = image.shape[:2]
+ block_size = max(2, block_size)
+
+ if block_shape == "rectangular":
+ block_w = block_size
+ block_h = max(2, block_size // 2)
+ else:
+ block_w = block_h = block_size
+
+ num_blocks_x = width // block_w
+ num_blocks_y = height // block_h
+
+ if num_blocks_x == 0 or num_blocks_y == 0:
+ return image
+
+ pixelated = np.zeros(
+ (num_blocks_y * block_h, num_blocks_x * block_w, 3),
+ dtype=np.uint8
+ )
+
+ for y in range(num_blocks_y):
+ for x in range(num_blocks_x):
+ start_x = x * block_w
+ end_x = (x + 1) * block_w
+ start_y = y * block_h
+ end_y = (y + 1) * block_h
+ block = image[start_y:end_y, start_x:end_x]
+
+ if method == "median":
+ color = np.median(block, axis=(0, 1))
+ elif method == "mode":
+ # Approximate mode using histogram
+ color = block.mean(axis=(0, 1))
+ else: # mean
+ color = block.mean(axis=(0, 1))
+
+ color = np.clip(color * intensity, 0, 255).astype(np.uint8)
+ pixelated[start_y:end_y, start_x:end_x] = color
+
+ return pixelated
+
+ # ==================== Noise Operations ====================
+
+ def _gaussian_noise(self, image: np.ndarray, mean: int = 0,
+ std_dev: int = 5, **kwargs) -> np.ndarray:
+ """Add Gaussian noise to image."""
+ noise = np.random.normal(mean, std_dev, image.shape).astype(np.int16)
+ noisy = np.clip(image.astype(np.int16) + noise, 0, 255).astype(np.uint8)
+ return noisy
+
+ # ==================== Morphology Operations ====================
+
+ def _dilate(self, image: np.ndarray, kernel_size: int = 5,
+ **kwargs) -> np.ndarray:
+ """Apply dilation."""
+ kernel = np.ones((kernel_size, kernel_size), np.uint8)
+ return cv2.dilate(image, kernel, iterations=1)
+
+ def _dilate_pro(self, image: np.ndarray, kernel_size: int = 5,
+ anchor: int = -1, iterations: int = 1,
+ border_value: int = 0, **kwargs) -> np.ndarray:
+ """Advanced dilation with more control."""
+ kernel = np.ones((kernel_size, kernel_size), np.uint8)
+ anchor_pt = (anchor, anchor) if anchor >= 0 else (-1, -1)
+ return cv2.dilate(
+ image, kernel,
+ anchor=anchor_pt,
+ iterations=iterations,
+ borderType=cv2.BORDER_CONSTANT,
+ borderValue=border_value
+ )
+
+ def _erode(self, image: np.ndarray, kernel_size: int = 5,
+ anchor: int = -1, iterations: int = 1,
+ border_type: int = 0, border_value: int = 0,
+ **kwargs) -> np.ndarray:
+ """Apply erosion."""
+ kernel = np.ones((kernel_size, kernel_size), np.uint8)
+ anchor_pt = (anchor, anchor) if anchor >= 0 else (-1, -1)
+ border_types = [
+ cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE,
+ cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101
+ ]
+ bt = border_types[min(border_type, len(border_types) - 1)]
+ return cv2.erode(
+ image, kernel,
+ anchor=anchor_pt,
+ iterations=iterations,
+ borderType=bt,
+ borderValue=border_value
+ )
+
+ def _super_effect(self, image: np.ndarray, blur_radius: int = 5,
+ morphology_iterations: int = 2, pyramid_levels: int = 3,
+ **kwargs) -> np.ndarray:
+ """Apply super effect (blur + morphology + pyramid)."""
+ blurred = cv2.boxFilter(image, -1, (blur_radius, blur_radius))
+
+ kernel = np.ones((5, 5), np.uint8)
+ morphed = cv2.morphologyEx(
+ blurred, cv2.MORPH_GRADIENT, kernel,
+ iterations=morphology_iterations
+ )
+
+ height, width = image.shape[:2]
+ result = cv2.pyrDown(morphed, dstsize=(width // 2, height // 2))
+ result = cv2.pyrUp(result, dstsize=(width, height))
+
+ return result
+
+
+# Singleton instance
+_filter_engine = None
+
+
+def get_filter_engine() -> FilterEngine:
+ """Get the singleton FilterEngine instance."""
+ global _filter_engine
+ if _filter_engine is None:
+ _filter_engine = FilterEngine()
+ return _filter_engine
diff --git a/filter_manager.py b/filter_manager.py
new file mode 100644
index 0000000..23fe49f
--- /dev/null
+++ b/filter_manager.py
@@ -0,0 +1,243 @@
+"""
+Filter Manager Module
+
+This module handles loading, saving, and managing filter configurations
+from the filters.json file. It provides a clean interface for the UI
+to interact with filter definitions.
+"""
+
+import json
+import os
+from typing import Dict, Any, Optional, Callable
+
+from filter_engine import get_filter_engine, FilterEngine
+
+
+FILTERS_JSON_PATH = os.path.join(os.path.dirname(__file__), "filters.json")
+
+
+class FilterManager:
+ """Manages filter configurations from JSON file."""
+
+ def __init__(self, json_path: str = FILTERS_JSON_PATH):
+ """
+ Initialize the FilterManager.
+
+ Args:
+ json_path: Path to the filters.json file
+ """
+ self.json_path = json_path
+ self._filters_config: Dict[str, Dict[str, Any]] = {}
+ self._engine: FilterEngine = get_filter_engine()
+ self.load_filters()
+
+ def load_filters(self) -> Dict[str, Dict[str, Any]]:
+ """
+ Load filter configurations from the JSON file.
+
+ Returns:
+ Dictionary containing all filter configurations
+ """
+ try:
+ with open(self.json_path, 'r', encoding='utf-8') as f:
+ self._filters_config = json.load(f)
+ except FileNotFoundError:
+ self._filters_config = {}
+ except json.JSONDecodeError as e:
+ raise ValueError(f"Error parsing filters.json: {e}")
+
+ return self._filters_config
+
+ def save_filters(self) -> None:
+ """Save current filter configurations to the JSON file."""
+ with open(self.json_path, 'w', encoding='utf-8') as f:
+ json.dump(self._filters_config, f, indent=4, ensure_ascii=False)
+
+ def get_categories(self) -> list:
+ """
+ Get all available filter categories.
+
+ Returns:
+ List of category names
+ """
+ return list(self._filters_config.keys())
+
+ def get_filters_in_category(self, category: str) -> Dict[str, Any]:
+ """
+ Get all filters in a specific category.
+
+ Args:
+ category: The category name
+
+ Returns:
+ Dictionary of filter configurations in the category
+ """
+ return self._filters_config.get(category, {})
+
+ def get_filter(self, category: str, filter_name: str) -> Optional[Dict[str, Any]]:
+ """
+ Get a specific filter configuration.
+
+ Args:
+ category: The category name
+ filter_name: The filter name
+
+ Returns:
+ Filter configuration dictionary or None if not found
+ """
+ return self._filters_config.get(category, {}).get(filter_name)
+
+ def get_filter_info(self, category: str, filter_name: str) -> Optional[Dict[str, Any]]:
+ """
+ Get filter info including the apply function.
+
+ Args:
+ category: The category name
+ filter_name: The filter name
+
+ Returns:
+ Filter info dictionary with 'apply' and 'parameters' keys
+ """
+ filter_config = self.get_filter(category, filter_name)
+ if not filter_config:
+ return None
+
+ operation = filter_config.get("operation")
+ if not operation:
+ return None
+
+ # Create an apply function that uses the filter engine
+ def apply_func(image, **params):
+ return self._engine.apply_operation(image, operation, **params)
+
+ return {
+ "apply": apply_func,
+ "parameters": filter_config.get("parameters", {}),
+ "description": filter_config.get("description", "")
+ }
+
+ def get_available_operations(self) -> list:
+ """
+ Get list of all available filter operations.
+
+ Returns:
+ List of operation names
+ """
+ return self._engine.get_available_operations()
+
+ def add_filter(self, category: str, filter_name: str,
+ operation: str, description: str = "",
+ parameters: Optional[Dict[str, Any]] = None) -> bool:
+ """
+ Add a new filter to the configuration.
+
+ Args:
+ category: The category name (created if doesn't exist)
+ filter_name: The name of the new filter
+ operation: The operation type (must be a valid operation)
+ description: Description of the filter
+ parameters: Dictionary of parameter configurations
+
+ Returns:
+ True if successful, False otherwise
+ """
+ # Validate operation exists
+ if operation not in self._engine.get_available_operations():
+ raise ValueError(f"Unknown operation: {operation}")
+
+ if category not in self._filters_config:
+ self._filters_config[category] = {}
+
+ self._filters_config[category][filter_name] = {
+ "operation": operation,
+ "description": description,
+ "parameters": parameters or {}
+ }
+
+ self.save_filters()
+ return True
+
+ def remove_filter(self, category: str, filter_name: str) -> bool:
+ """
+ Remove a filter from the configuration.
+
+ Args:
+ category: The category name
+ filter_name: The filter name
+
+ Returns:
+ True if successful, False if filter not found
+ """
+ if category in self._filters_config and filter_name in self._filters_config[category]:
+ del self._filters_config[category][filter_name]
+ if not self._filters_config[category]:
+ del self._filters_config[category]
+ self.save_filters()
+ return True
+ return False
+
+ def validate_parameters(self, parameters: Dict[str, Any]) -> tuple:
+ """
+ Validate parameter configurations.
+
+ Args:
+ parameters: Dictionary of parameter configurations
+
+ Returns:
+ Tuple of (is_valid: bool, error_message: str)
+ """
+ if not isinstance(parameters, dict):
+ return False, "Parameters must be a dictionary"
+
+ for param_name, param_config in parameters.items():
+ if not isinstance(param_name, str) or not param_name:
+ return False, "Parameter name must be a non-empty string"
+
+ if not isinstance(param_config, dict):
+ return False, f"Parameter '{param_name}' config must be a dictionary"
+
+ if "options" in param_config:
+ if not isinstance(param_config["options"], list) or len(param_config["options"]) == 0:
+ return False, f"Parameter '{param_name}': 'options' must be a non-empty list"
+ if "init" not in param_config:
+ return False, f"Parameter '{param_name}': missing 'init' value"
+ if param_config["init"] not in param_config["options"]:
+ return False, f"Parameter '{param_name}': 'init' must be one of the options"
+ else:
+ required_keys = ["min", "max", "init", "interval"]
+ for key in required_keys:
+ if key not in param_config:
+ return False, f"Parameter '{param_name}': missing required key '{key}'"
+
+ try:
+ min_val = float(param_config["min"])
+ max_val = float(param_config["max"])
+ init_val = float(param_config["init"])
+ interval = float(param_config["interval"])
+ except (TypeError, ValueError):
+ return False, f"Parameter '{param_name}': values must be numeric"
+
+ if min_val > max_val:
+ return False, f"Parameter '{param_name}': 'min' cannot be greater than 'max'"
+ if init_val < min_val or init_val > max_val:
+ return False, f"Parameter '{param_name}': 'init' must be between 'min' and 'max'"
+ if interval <= 0:
+ return False, f"Parameter '{param_name}': 'interval' must be positive"
+
+ return True, ""
+
+
+_filter_manager: Optional[FilterManager] = None
+
+
+def get_filter_manager() -> FilterManager:
+ """
+ Get the singleton FilterManager instance.
+
+ Returns:
+ The FilterManager instance
+ """
+ global _filter_manager
+ if _filter_manager is None:
+ _filter_manager = FilterManager()
+ return _filter_manager
diff --git a/filters.json b/filters.json
new file mode 100644
index 0000000..3083c8e
--- /dev/null
+++ b/filters.json
@@ -0,0 +1,181 @@
+{
+ "Color": {
+ "escala_grises": {
+ "operation": "grayscale",
+ "description": "Convierte la imagen a escala de grises",
+ "parameters": {}
+ },
+ "indie": {
+ "operation": "indie_effect",
+ "description": "Efecto retro/indie con bordes y ruido",
+ "parameters": {
+ "blur_kernel_size": {"min": 3, "max": 15, "init": 5, "interval": 2},
+ "canny_threshold1": {"min": 50, "max": 150, "init": 100, "interval": 10},
+ "canny_threshold2": {"min": 100, "max": 250, "init": 200, "interval": 10},
+ "color_adjustment": {"min": 0.5, "max": 2.0, "init": 1.5, "interval": 0.1},
+ "noise_level": {"min": 10, "max": 30, "init": 20, "interval": 5}
+ }
+ },
+ "matiz": {
+ "operation": "hue_shift",
+ "description": "Cambia el matiz/tono de los colores",
+ "parameters": {
+ "hue_shift": {"min": -180, "max": 180, "init": 0, "interval": 1}
+ }
+ },
+ "saturador": {
+ "operation": "saturate_color",
+ "description": "Aumenta la saturación de un color específico",
+ "parameters": {
+ "color": {"options": ["red", "green", "blue", "yellow", "cyan", "magenta"], "init": "red"},
+ "saturation_scale": {"min": 0, "max": 100, "init": 50, "interval": 1},
+ "brightness_boost": {"min": 0, "max": 100, "init": 50, "interval": 1}
+ }
+ }
+ },
+ "Desenfoque": {
+ "bilateral": {
+ "operation": "bilateral_filter",
+ "description": "Filtro bilateral que preserva bordes",
+ "parameters": {
+ "d": {"min": 1, "max": 10, "init": 3, "interval": 1},
+ "sigmaColor": {"min": 1, "max": 100, "init": 20, "interval": 1},
+ "sigmaSpace": {"min": 1, "max": 100, "init": 15, "interval": 1}
+ }
+ },
+ "box": {
+ "operation": "box_blur",
+ "description": "Desenfoque de caja",
+ "parameters": {
+ "ksize_x": {"min": 3, "max": 15, "init": 5, "interval": 2},
+ "ksize_y": {"min": 3, "max": 15, "init": 5, "interval": 2}
+ }
+ },
+ "desenfoque_gausiano": {
+ "operation": "gaussian_blur",
+ "description": "Desenfoque gaussiano suave",
+ "parameters": {
+ "kernel_size": {"min": 1, "max": 31, "init": 15, "interval": 2},
+ "sigma": {"min": 1, "max": 10, "init": 5, "interval": 1}
+ }
+ },
+ "desenfoque_horizontal": {
+ "operation": "horizontal_blur",
+ "description": "Desenfoque de movimiento horizontal",
+ "parameters": {
+ "kernel_size": {"min": 1, "max": 101, "init": 3, "interval": 2}
+ }
+ },
+ "desenfoque_vertical": {
+ "operation": "vertical_blur",
+ "description": "Desenfoque de movimiento vertical",
+ "parameters": {
+ "multi": {"min": 1, "max": 100, "init": 30, "interval": 1}
+ }
+ },
+ "mediana": {
+ "operation": "median_blur",
+ "description": "Desenfoque de mediana para eliminar ruido",
+ "parameters": {
+ "kernel_size": {"min": 1, "max": 101, "init": 3, "interval": 2}
+ }
+ }
+ },
+ "Glitch": {
+ "glitch": {
+ "operation": "glitch",
+ "description": "Efecto glitch con líneas desplazadas",
+ "parameters": {
+ "glitch_intensity": {"min": 1, "max": 50, "init": 10, "interval": 1},
+ "glitch_frequency": {"min": 1, "max": 50, "init": 5, "interval": 1}
+ }
+ },
+ "shift": {
+ "operation": "channel_shift",
+ "description": "Desplazamiento de canal de color",
+ "parameters": {
+ "shift_value": {"min": -50, "max": 50, "init": 5, "interval": 1}
+ }
+ },
+ "shift_pro": {
+ "operation": "channel_shift_pro",
+ "description": "Desplazamiento avanzado de canales RGB",
+ "parameters": {
+ "shift_value_b": {"min": -50, "max": 50, "init": 5, "interval": 1},
+ "shift_value_g": {"min": -50, "max": 50, "init": -5, "interval": 1},
+ "shift_value_r": {"min": -50, "max": 50, "init": 2, "interval": 1},
+ "direction_b": {"options": ["horizontal", "vertical"], "init": "horizontal"},
+ "direction_g": {"options": ["horizontal", "vertical"], "init": "horizontal"},
+ "direction_r": {"options": ["horizontal", "vertical"], "init": "vertical"}
+ }
+ }
+ },
+ "Pixel": {
+ "pixelar": {
+ "operation": "pixelate",
+ "description": "Efecto de pixelado básico",
+ "parameters": {
+ "block_size": {"min": 2, "max": 50, "init": 5, "interval": 1}
+ }
+ },
+ "pixelar_pro": {
+ "operation": "pixelate_pro",
+ "description": "Pixelado avanzado con múltiples métodos",
+ "parameters": {
+ "block_size": {"min": 2, "max": 50, "init": 5, "interval": 1},
+ "method": {"options": ["mean", "median", "mode"], "init": "mean"},
+ "intensity": {"min": 0.1, "max": 2.0, "init": 1.0, "interval": 0.1},
+ "block_shape": {"options": ["square", "rectangular"], "init": "square"}
+ }
+ }
+ },
+ "Ruido": {
+ "ruido_gausiano": {
+ "operation": "gaussian_noise",
+ "description": "Añade ruido gaussiano a la imagen",
+ "parameters": {
+ "mean": {"min": -100, "max": 100, "init": 0, "interval": 10},
+ "std_dev": {"min": 1, "max": 10, "init": 5, "interval": 1}
+ }
+ }
+ },
+ "Morfología": {
+ "dilatar": {
+ "operation": "dilate",
+ "description": "Operación de dilatación morfológica",
+ "parameters": {
+ "kernel_size": {"min": 2, "max": 50, "init": 5, "interval": 1}
+ }
+ },
+ "dilatar_pro": {
+ "operation": "dilate_pro",
+ "description": "Dilatación avanzada con más control",
+ "parameters": {
+ "kernel_size": {"min": 2, "max": 50, "init": 5, "interval": 1},
+ "anchor": {"min": -1, "max": 10, "init": -1, "interval": 1},
+ "iterations": {"min": 1, "max": 10, "init": 1, "interval": 1},
+ "border_value": {"min": 0, "max": 255, "init": 0, "interval": 1}
+ }
+ },
+ "erosionar": {
+ "operation": "erode",
+ "description": "Operación de erosión morfológica",
+ "parameters": {
+ "kernel_size": {"min": 2, "max": 50, "init": 5, "interval": 1},
+ "anchor": {"min": -1, "max": 10, "init": -1, "interval": 1},
+ "iterations": {"min": 1, "max": 10, "init": 1, "interval": 1},
+ "border_type": {"min": 0, "max": 4, "init": 0, "interval": 1},
+ "border_value": {"min": 0, "max": 255, "init": 0, "interval": 1}
+ }
+ },
+ "super_efecto": {
+ "operation": "super_effect",
+ "description": "Combinación de blur, morfología y pirámide",
+ "parameters": {
+ "blur_radius": {"min": 1, "max": 10, "init": 5, "interval": 1},
+ "morphology_iterations": {"min": 1, "max": 5, "init": 2, "interval": 1},
+ "pyramid_levels": {"min": 1, "max": 5, "init": 3, "interval": 1}
+ }
+ }
+ }
+}
diff --git a/filters/Color/__init__.py b/filters/Color/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/filters/Color/__pycache__/__init__.cpython-312.pyc b/filters/Color/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 05b96971d6852c1979cb41687f2d04cf0d2cf17d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 165
zcmX@j%ge<81fA->X(0MBh(HIQS%4zb87dhx8U0o=6fpsLpFwJVxg=Y~gche36~~lS
z#JJ>_=jG%lrWD8c7o_Gnhw0`fX6D7XhkEMf=BI?jq-ExmfK(>u=j0c~#K&jmWtPOp
j>lIY~;;;cKD9uT=D`Ev2$_T{8AjU^#Mn=XWW*`dyB^D`*
diff --git a/filters/Color/__pycache__/color.cpython-312.pyc b/filters/Color/__pycache__/color.cpython-312.pyc
deleted file mode 100644
index 54376b6bd1b6a22ffc9a14e06fa053efbfa7ac2c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 524
zcmZ8dzfZzY5WYvjAQez2b-}d*Ce+Ok6U2mQ6cQ8@NfSc)gOn87yjRgC4h$|#jyU)a
zpnr;s#z9lvoZO6TOx~;17{27byLb1!d++WcnM?rUZtc(*p#R{95RqvxUcq1p8fe6V
zI%ttAs1r>l_pjCtdtyGsCAeV-ZGLkG_tQH^Fd}71
z@CCIe`*F4B7H!L>eyUhGs8ky}rK()27EUGN$IMQ%r8EBM`lO(4DK(~3rt~h9UHiOi
z*-ecp6-VzDPqLk+*;Puly==$UjupeST&`4k<6quzJb$6-IF{GY4MSI5%J;=*W2;Dg
zco$RG`9c0BcFSHexu;C-S(G26@)(Pta{7;8Cw#;qctCkD0-8ieMNacb{!&YK8_Y5_
zoiiy`&lRZItZNuWFt{3y`Ow3@{8IM$h^Z__mD_&(S&(w9I8d4t4v
Nl#tEw93hKAyC1?ZXodg)
diff --git a/filters/Color/__pycache__/escala_grises.cpython-312.pyc b/filters/Color/__pycache__/escala_grises.cpython-312.pyc
deleted file mode 100644
index b6989fc69f6e7f402e6cdbc1a5bf01728f5b5829..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 530
zcmZ8dK}!Nr5T56*Vs2`5s*_zk7-+YUpf(Vr6fA>eVOe&cqO7jGw^>354?%S5XovoQ
z^iw)ibf~s&ow`MP^VGaeBm7{#nK$#jd2i+}9*+Uy^?t8@f&N1rrU*>}e+h#jSYQzw
zYG8%Vp++nTIn*a<`BTVBCYh*(lhGtJe+Ov@?q97n?TPs*&cL09&=NOia67rP4hs0PjlTDu0>34&U(SRQ55IeNu7{a?Zyhn1cQz*o_!<2z_887y*l;V~U_T
zBrn;ZuKxQY-7;K*B`_O7<6)!$yeP>)otBtL1pf&%GmXa4JPvnk(+!qHo!AOrMEa5l
SA#V`-mI+z&BZMpj?S23g6l;qB
diff --git a/filters/Color/__pycache__/inidie.cpython-312.pyc b/filters/Color/__pycache__/inidie.cpython-312.pyc
deleted file mode 100644
index 330e32eaeded29e27586aa4e8c2ef0dd11a9bc18..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1747
zcmb_cO>7%Q6yEjzcx`Wfy7^U7QuhZEw@OhHNLo~pA5(?2Q9^!Pl*Gc?dN$6w>$N+(
z4z;zBd_Y2+pci6L4;*?(l><43Tal26#AO#FIht~a#K{*F2nUo4%sAfIf&&+xwBP&Y
z?R)dy%)FT&nwtC+7V+cRwPzef{Xzz=cxvQ0h{+ZOC_rn}%BiMTJizl2wZZ@fBb%c`
zY=yYb#(AP@f@h={{2hyUt}V)<0iDPHf#=}>ML`aanS2vPZPF&~h9uprt^sQcM_Tk6
z&bUKn!?MXYM6jo}Mzna#V=-sm-Ujc+`f4GT*E|bO3TO0;?9^)76wH8YOo}e6Ym2q`
zJYF+kEH;n#)e^{vFyH~KTTQa19^o>xdJ1HeY;|pQy;IwrO<#kbRR8a?WQWV@8h9+u
zqLQ6;i_89pdi?*fA3n>U$LShZzv;7li&Ti4t&mNH1S({CmA^2AM8w25hLAWVXAMJ@
z^+_!Y5f_$qJ%@z&h8a$4X^5J`b2D=bv8jcL<)O)`1?15)h>dG%2Jy0C<}wQ6vZ`+0
zL_CyrkWL|9Ps5a~AA_SQEJfE;%_N@H
zZHcP7if6x`$stkBWVBpNSzA-$CcJ<%kUL`hilIOqdb^4j9dB>((U0EXfzVx?aD-QE
zq5BV>YLUv#eNJ;Cja+P9|d*Y565l$vJ?Q}}07>!;J7On;WJFT8Hwm?(*pg*(`K
zu6;{u6yb+uJ&}`k(aMJy*BicY5B~qwU)>&dnM7y=7-~+38uf
zSEKd^a!GnnmQ+Vle@bfQBy^InBpHQ!Bv}hdRu<1Y;`!qISAp%w*Q?K0OX97vIPQq!
z-$~zhf7@LW?-uU-EVYwN#cSJ~(=)jJX!mkS8Y$d640PIT=P_O}6(`^dxoFiV>0M0l
zqekQAWB>~|z&~Yy7YM)y{8jD)0U*|R6KDo4ptWlEgL6Q_5yZdkDW}r7o!e)TKO;jq
zrI7QekOUQS%`4;ugk3Ng@~|Kmt%pLNQ~f
zO%wyNDZ^oG?Zuz5hyk~X(0(uw+P$w*cSeKVk%tKcWPVuja-jdP#Op&!#dtNFLH^k5;q)
sqr?;8HtzJSro0W`#D3(ZFv!x57@DSEQvR2e^gG)@cO75%(WkTj4VM{~f&c&j
diff --git a/filters/Color/__pycache__/matiz.cpython-312.pyc b/filters/Color/__pycache__/matiz.cpython-312.pyc
deleted file mode 100644
index 7ae3e641c97b70ccb0e08bd1350bad0ece411200..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1395
zcmb7EO=uKJ6t4c6F^&`eNQ@INCFGC+6EL7GK@#G)#6UJ#65}B>47FV~V@Y@QSY6#Z
zAq#U*5Kp?7?7>4;_K;=wwtMjIMG%%9JSgo&@M3Pm#*>%$s(U8Jcv$v9y?#~o>U&?k
z_qty6_ZJYz?f2i+rfr1Y=}Aw_uCar`*gzCf!$Ygt*H|^Fc^9o()B6
zDLu=wY)?PY%8aS8VRBfhyWK42V_z4+F;wT#MkbRMo#z#tXk|G)`m9`=diYk2f(#LAd5
z90`KCPwGtINO6y^5kUj&5v(K;VJ(n8arv`91-`m`eY}uj&B%Hp$)^7zHpTqlptj69in
za%=1C=4^ZT+*Y$a{LRx!yENUJdq93V@o?sTy=|ZRkVmIV8_pwVv;4>MtFfu}*wo9x
z>DI#ABc*@r(hh_`u2wxc1V;K(odyGbOM{x!qBhOZJU#T-<_0&QJ^P}^u$`v-3X3D=
z#SD8vh#N#c`^9HUW_H@O2fHEb#IMRtxvM7eiojsFJP<@e3*CwshH@*;#QzAO>yi|J
z3jr#SZ>e7)KEJ!WD|KSC9?`Fb?h&60P~=WxbHP>82VKl$OuXNa9MaCmwCV?y9IG=`
z%}Q9ML=mY|Gz=pg0o6jC*CPnz?S>;{PVNz(tO77fK6rT0|`Y(23hhjr1KPlk0DJ6mkB1B693RE*?#8omHrQ)3yABxE
zk}Fjek*Z>(N=c;JID=nX*(8VLQUE07FR$6i5
z5Va^4rJ{^E>`J*XpW?6pU4$+{m!T`mQc+2vqT5z%E&?pa(Z_=b#UWbJQ}lMlQraQf
zz!q(f?OkDOgjV#~?m2H0cT3ynWW=E__6f-HJF~XinZfQ$#}OiZUGaJxtB$taUm`=W
z-Ppr2E&98xgB>de*^=$D{n&dA)^bfmXfEW;bhH(A@Z2T`b+nURd+()JM3im*e~u_y
z{Z2k}n;q2AwuC*na{|&UtmPN1<*wC4JDd)J)0J#F#XGxD?CG-qw;SBkb%VD$EFIn6
z#ef|+hhn~on2Ru)HCBT$*II?)driEH;i)FZ41dwY?A!^fEAV9(lDM0gQ4ly|bVs5*
z(J&QLMAHl^OsDf2l?qxqoxMVZWI;8koKaJnVX14ZPMR6~%~%4IPtFffB{^@6Wz$(g
z{bOfNpP5XIj!zDqJa>VLW-hH;RMw42)kp!Wn#*YhrhFO#d8T#iif(EN@Z(jCVb-(?
zIgPrE92N7rVI6|-X&pW?8UgPXIS>y)fLM@8)!o;BwaO)qYiawg^GsjuOlAS^=@VyWgOP_TH7KpK!Rp#mGEo~B^~
z_i4tgY9uwB=rH!Q#~Kk#R$$v-YR^w3N8(eaM$Gv9)%fx36(gNhu^B%D`!aT6Fr(^5
ze0=KEU?z*t$7l4k#Vi|p8*eTTXUV&{0`%CjbzItd&`K@|ywCt^ix0R1P@ylVUbb39E{DIPmdUSUsUyTkvMJ{p6LeGuaP+It;Rl_0Z3UYN69L<)hNE
zM~e49S~Av_ZFzq=SyQ6S+tc)JkAPM5^=~3yM=HlEmv8T=9IizMSA|V5yeYC6zZGBI
zdEj31!SHx>c)ZqsvNZA78(9@18?fIf$%NBbb+Lzi<2?}Y`{PmwyT0WxkA-Cy7O{k7
ztYG)D@B;QM^EwB`?VX^WoJ!P;#?GAhfP=7SKjxxxHpgzYNd?`|tw#Mds(5XP8L>Ay
zCQv@38z9uHWCRAN0`;Sjc{Ls5$(zh 1 else masks[0]
-
- s = cv2.add(s, (saturation_scale * (color_mask // 255)).astype(np.uint8))
- v = cv2.add(v, (brightness_boost * (color_mask // 255)).astype(np.uint8))
-
- s = np.clip(s, 0, 255)
- v = np.clip(v, 0, 255)
-
- enhanced_hsv_image = cv2.merge([h, s, v])
-
- enhanced_image = cv2.cvtColor(enhanced_hsv_image, cv2.COLOR_HSV2BGR)
-
- return enhanced_image
-
-def get_filter_data():
- return {
- "parameters": {
- "color": {"options": ["red", "green", "blue", "yellow", "cyan", "magenta"], "init": "red"},
- "saturation_scale": {"min": 0, "max": 100, "init": 50, "interval": 1},
- "brightness_boost": {"min": 0, "max": 100, "init": 50, "interval": 1}
- }
- }
\ No newline at end of file
diff --git a/filters/Desenfoque/__init__.py b/filters/Desenfoque/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/filters/Desenfoque/__pycache__/__init__.cpython-312.pyc b/filters/Desenfoque/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 039ad32b859f497fe49bdcea79f945b7e4b53600..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 170
zcmX@j%ge<81fA->X(0MBh(HIQS%4zb87dhx8U0o=6fpsLpFwJVc_v%Mgche36~~lS
z#JJ>_=jG%lrWD8c7o_Gnhw0`fX6D7XhkEMf=BI?jq-ExmfK;ZW7N_Q=B^G
o=4F<|$LkeT{^GC!sw&M%wJTx;n#>5q#URE
diff --git a/filters/Desenfoque/__pycache__/bilateral.cpython-312.pyc b/filters/Desenfoque/__pycache__/bilateral.cpython-312.pyc
deleted file mode 100644
index 74e7c23d5b2c3b91fecab60f2027d04c17c04648..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 732
zcmZ8fzi-n(7`?L{Cv_5ql%mpzN(iP5txzUZAzCR2L=i!#lp(Sd9lmp9s7M_a`Of
z0x#yJ&B(X{i&%v9*J}auLi@??)3qStuWWasuWT-q
z2;FFJU)cY=*W+$lU~%ksTf%jPlgK<+pp9AqI3&OF#UJ_AL4NhUIDOf-K5c)`Z+k3uX~Beh~CSs)+^HN;ehcz{Ec
zglP1@3jx?cYIvcSq&Y8y!4C6>9H*8LN;s;^EHsI`kqZDHh{O+(1q4(~OKp*~rkS)j
zOPIvJ0AEt~0S?LU+|v0<<+Rq{J7a_L*7=>g{rcJBm-3+U>?;40HI}WBZWhcDF*D}G
z0Nl%9h
zdb29BB=ZW8G2)109~~i1UZW$-DIghO+n8!uqeYi$y=36g`}rM!F^a)?QO{SNs{>ev
z;5)=a;*t+bk5_a^pCFqwroW+VlF(M~cCvOH_4hqL7Sc8n(+gNzB-t0rI~C3TiVTv%
zvEP+a@MbDd1~k})x~lEnbqygzKzzBUSmB;nB^>;TW#Yy}8-V1&L~rOU1DN%8#PG5
diff --git a/filters/Desenfoque/__pycache__/desenfoque.cpython-312.pyc b/filters/Desenfoque/__pycache__/desenfoque.cpython-312.pyc
deleted file mode 100644
index 04fdc0365241168e35f5a83c6272f0e17a781387..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 726
zcmZ9K&ubGw6vt=wN4m|X7Ng>iP@B>oT(F9QJ%~S08;b@bsP#}5!jPE_Yj-#4%qBJ=
zLJ$5A_0U7~RPmByj~)dt4IT`u2f@?cqPg|dH~9hLgZ<2#;rrg3eQ&tH-YZ&DyE#=cV^K)dWg;+|tgr!7kseV05t&y4#E(z{?
zHEyYq?)s$6B6E}RfO$pXHd&+#x9k%k6J@j6qkQS6y)GCRc75Akt-KDr3ZcS&T4lk5
zm&-nJ1AA@#(XwBmFKoy4LaC%ou)wKo)!0Aom1-kOk!saz6q)0&QpimxA`5cQey9Gw*Wkd?$0bc>AFC&CDHYxdDWrlElQOz>(Po
zO8}SvrV3T5Ms=Fl)4-pi22lFbdy0#pL&-vvtP)OqCT|_f7RU1vvjDCEEG<%fHvo|B
zNOJ=>j0`sbb)9&zd5_pvF7&e}(WdHyG
diff --git a/filters/Desenfoque/__pycache__/desenfoque_gausiano.cpython-312.pyc b/filters/Desenfoque/__pycache__/desenfoque_gausiano.cpython-312.pyc
deleted file mode 100644
index b212be1e81c66149dfc264ff9a7aee094201a1f4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 735
zcmZ9K&ubGw6vt=wN4m+T7Ng>iP@B>oT(F9Q9z+FgW6@v)Z9SAg7&5bA?d~R>*~BJ9
z$ie@i9(srusd&k;N5PBWrNM(?^&oiKTQs+xe3Ks_KG@H^8Qy!}+4ttl>}&#o#Xmi^
z-(iG)$<5T1i8DM0&K{zOVi#>8s=P*9n5saffh{ePVfm6eiI$5FpWF{00rpS}w=l)c
z7=qmGO9(aL^c4<3Z)`87O49>aTca#nX(=Bjm7gI?%||knOIS*%mg?8TW)XsEHt+n_nBK1PLqYYaLOJLvQQ?IIo?>kRoE1ai$Z<3uvU5LyA?u3;YpSG
ztItDpV#|>m8WrF#3Wv9meaf@Zp2I-7D;2OZv
zLe+D80ND*S$9ICzaD0fa6E~8tB9ddY6mH0jIN&|v@+t77gp3I1$}A|3TU4YZApAU>
z%FBw&fHwMRobE3zA3QxweLmSs=lb&(JG^`C<6`g3+HYMwn;58iGB!ZE9vc<4R4z3~
r%^Q{aPw&{c4MVB9>@L3maq_3cDZoI*7=K5JKbnFc;Gq%2<9dGqmF=%z
diff --git a/filters/Desenfoque/__pycache__/desenfoque_horizontal.cpython-312.pyc b/filters/Desenfoque/__pycache__/desenfoque_horizontal.cpython-312.pyc
deleted file mode 100644
index f5f74fefe8606218924dfa90ec643d3f1da024cb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 903
zcmZ8fO=uHA6rP!#O=EtnDTOM}(<3b2Db
zsL->Ov#kD|k9}Mu`+d$!a)wQVxPQBk1Ex>Bf#BZ94AX*%0ht+iF>?LT1YkR*0l>NPGLS5n93uGCE1
zlUiY8T!xFL<#91SnbxFkmW(AXqpMul+{(LVjmvP~S$0*4R4R44F!3Na?{eYhHY&ME
z=Y?%K26J;y%iNw=7%3U1otv6}JW_Jlvs^E^n`7MNcF|c|=Vy-jWk;Ab$My_sv|N=j
zqg=MCd0s5?f+rGCO;vQC1Ju#+U}CGXS=miCRu6{9TZ8xN)5n?7Pg8qSpJ!T`NA>A9
zbK7?s`0d@sSTk|66~Fax3ZhrU42(H?zf_u1DfeTZd6bZ
zn3|9(+X3m-U&4$qjZvnv5F2<$O>AP&I6NyOWkVPx4$`^eJaC1YeVZ##@j?ekQ>m3q
z8^EYYYTBkJ!yr5t8-}%qL{jmF6kGt1gG=1Y_XNu`!!yKHxK*=vZvfQM&+x^=*pnG=m%j+|&T7CJ#x4|P+ebpam=N!?yAm8(KMrz>SQ*?$#J!&w;8y2T%g
eYrs>##=Qh^qG61WP~->={U#KTbYeR0W&aDbhSRtJ
diff --git a/filters/Desenfoque/__pycache__/desenfoque_vertical.cpython-312.pyc b/filters/Desenfoque/__pycache__/desenfoque_vertical.cpython-312.pyc
deleted file mode 100644
index 02b6ed67da448dd007828df1eff7e1141d025d6f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 943
zcmZ8g&ubGw7@gUjZDN|(+BWD#2^GXZ>!FCK1VLN09$G0jf;AA<%xu`W*{rjhn1mH_
z&_lhng+g=i5b>a;1^pAmtCyB~DAOW>r`&?M^`hT2KP-MQZ{F;@dEd-8v)>|-5Q0d4
zoio-kLcipo7fP43V?Z_#MHE|Tsng>ng(|Pml1f!TQo(W3l=AsZZKL9q6
z2N^n%JE`h^^RbT&#p_8>j`V4tY~!u&%9qLsw}HN(Pkg-9&E_kxbM#vAPW2{zOqD8}
zo2u18gnBwdNr1ptd|W+;5ctDfCvxE)``7!35?|Spr-OKi;@W&13ypdehc#v9rrc=r
z4@5j56x$J6mGOcr0)|!4y=zwmDcH;vs%d*d&6K7@&@e5J@u``(Dl{{%XPMCQMawfq
z@EPMav(hD3ri;a5M~l-pQ%RR`H&rU9W(qHC@T6|)fy3(Pc*
zKfV3*Q*JZ&edtDQ_VCi>57~FwkL!se}svaU#^bX#?nGK}_59L=ei&cuBW55kD_ij7b;)5JOq!r8~t+
zQ{B_Kw2*&?I}T7oKZ9fY;nDg+!~J~c%kACh-Il7H4YgDf9%vz=4IEp=H6D>>nqAC0
w6&?hBT*zay|1us06L3LAi{0We(8)*RMgdwX#`pk*4$#PNLhxietl^IPU+Bi#`Tzg`
diff --git a/filters/Desenfoque/__pycache__/mediana.cpython-312.pyc b/filters/Desenfoque/__pycache__/mediana.cpython-312.pyc
deleted file mode 100644
index e75707527e0817535e0d00ee203293124366557e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 704
zcmZ8e&ubGw6n?WaNn?H}25XfdwnD)@q+mf0B7tf_B^VF29?C)(GLtfPcazR;ViQux
z!HXxowFeLJR`KG|KSA(fC`eg72nv#0Ft?t3lcW^-!TWf#eD9l`?|sc=l7LwG{-pYs
z0Q@$G6Ijz`bOoC|5Fm&P8z8J#ut5Yxwpzqy10yR{PSobauqf8ZLE3{5ohJ~aLq1NG
zyV!S#u-b6|LAP!Kv{AH6LNhtW3*&PJ9XNGZ1Dllw#(ZErwIQ2E)Z;r5tu&XTq$h>q
z{(ZNhZ7Yf?k8jE-wI#JL-EyGXGB6|a^T&@Wcb)Y>>cDC4IIFdnzFXrWaGuts|KNGv
zcY^r|Dwv3gxR`mz6j20INtB{woont%^QYRZSeq;d(vX?gF(jK|R?6470En3K
zRTw3dk0VX)egHjdbQwb_Be<|B!}8?uWx+$PFXPv9SiudXF8oSdI!a&d-8xwNyzu2>
zKUW-5Yc4sYEFB*Li^a!QHr3_{<6y=HXKp!8+{2I?t}N&|)S2A|S)?H)g#3WyKgP(?
JC>RcVrzS
zKx9KAgWakPk!-7mZixbBbrbW34lOLCRNcOVx%k{o>`5BPd}?UMR3?}fomfzl@)X3Z
zVPfwLL^{-BmiipV(kI;vqWfV-`4{Xnkr9WM1(jGS-=bZ&mgVR{?_Fukg2aPDfO%C{?E*bl
z!AF4-xIniQdCVnMoq(K1eiFbg!Vie%WUWA%Eb^$4DCD8wr9h8KqLh%>{V*IE9*Bj9
zgCX2lwtI)dBSCzo?DR)^`UZoc(RF~DXzp2>J4`j^w)|+gC<*CLixk&g9A4r0sPC*3jo0->>B_51p{v+Shuv
zX1~b!mVrMF!Ugvs=kz!Zfm3jlnh=F@?}DC6ni)iIqC}-q8>o%CwO)^0_Xsmn8tg(H
eWPx6Y)lA@!V;E*1xc5QRU!G$w72PhTT>T#z3kVhf
diff --git a/filters/Desenfoque/__pycache__/shift.cpython-312.pyc b/filters/Desenfoque/__pycache__/shift.cpython-312.pyc
deleted file mode 100644
index deb9c311e25a19f460f267816e88b5ba67d5496d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 695
zcmZ8e&ubGw6rS1HP2-xRAd0_=2(6X{E0}`^5ih9~g>KPW4`m??JF{_QGrP`gVgnI!
z@Zf*YOAj6^dhpnz$AYJTXjm_TUUG}(){}4Y_{K_qYe=o?1p
zmuco<&B*uykbT4u!!g=L%zA@%F(ZIh2YdF=jQJs%O`GCCntps6U>{|mJdGD~&G`Y;
zF6!d0^$~xVDZD0KvW+~;_pIE~DWn2M!ge)3mv+=9r*iwbh_Ve4XIu%{@a)_XP1@jj
zMW-|qG_EVkL`&zTFo_d2?+DYGwqfH{h?9-lonS|ErGxffu%5h@;$f!BAaCxWF9Y<@Z@2v2
zUGBTf@9rPU&r4rjzgHWauJj&_;V}vg%wqw_#IqG3;5KF!Bg_VL4h#}jnDK=JOJH!Q
z=;v-q6>W0xK@W||LuSDIQZR)yg#@5`xh;qPZ{IPRrDEv5y2S$K<;0g;Ki|9z*D(@
DX}+pL
diff --git a/filters/Desenfoque/__pycache__/stack.cpython-312.pyc b/filters/Desenfoque/__pycache__/stack.cpython-312.pyc
deleted file mode 100644
index d6a3a7021e614851aec2cf61f666f8841a38103d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 660
zcmZ8fF>ljA6u$G>iJLa6R0SnvAp;DSC`cVERH?Ko>X0B*%1~KYhwogO+K#z%(xeJf
z2KWJ;vUFf9V&NySvw&Etg8_*tTOeB}-Z_a>c+!3P?%n72-hJoK<#Gu@?7wXW&oM&3
z^kyE$j7(}khKM1CBXo$E@dh1YMgWZ-cFd8MHT}6-?@U+()?^)Eh%%@=jhEL|vs@qb
z@rPOdwb3{Bk%OC#p@`pER|_(u{_(@8EgYh(Fs4UbS;sOw<*NJwvVt=&&r02|Uaw#6
zZg02;k_+i}y6#TvB#By-N%wKelkI0~F%1*<(ZSwY++t7NAdE7t+~JZZLF-kUyLrER
zX-_TDG>v*54+8FILc63pNbSV{{isxjjkCtPI~O;;RqhWOmy5M8W^Dpz$k#BBB9PpO
z+d#lV%nU}D$t+elH~-lb?c~OT5{ouJrd8z;UUD*%7?RLaB#ZA!ZpFyqwj0wj0
QJ1YG#4ZJ$B3wT=YFLH05ZU6uP
diff --git a/filters/Desenfoque/__pycache__/super_queee.cpython-312.pyc b/filters/Desenfoque/__pycache__/super_queee.cpython-312.pyc
deleted file mode 100644
index c8b7c309da23296ef650f6705f9994adf9f2d417..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1473
zcmZ`(U2NM_6uypsl7^&|{$&GER&Aq1s1ut6YgvUftzB2vq>wI~)JF5%`lfT@*xt2M
znk_|<;DsmXQ$eZ(PpGJq=p-aM?SbxzOg!Ldl~&#D0SR96Rwz$+8qW=)Rn&TnYYF;n61d4%46b;0y|3O53Rrc%&gD6LX
znuCerXr^IT*)CSuqa_UBqF=QgTf2>;LCVk0pP?-?=E6lyhYIR5EGn1=wyBuc3}=9b
zawf5Enz}hx7+IjLv5CY-m*mmJ`QfpV_!a863S`*)#Gs;mQ?W1=VV$(1EmYKU${eOI
z&FFa|6GheXHtpJzlK0x9tx%)nG*#B|Jl1U*W;Fz>a$Q2oVq##Ow(YO3iL*jk1@}f~
zh^_NhePy@6y&h}E^YIJsr;;`%c4~eh#X8naMYU5C7B((i?awKiks3{o_2*3WN-AA@
z6n1JD+t^5(xAHh;=PgWRU>KjW3N)lxmR^u?I*n%?(gRLx*6bevO6af7$Z~8c_T9|Y7Bwtac+i)&vcSI&Gp@Xf&E@QKpJXOUN*MEWX`zSZzg_LH+?
zm9t~z_uT9DR>X0IPN?ZVx;(u!?e?DD82RP${mW(Ue!P6XG88N4f4}qSjys)t^rmj_&2brNOVSuj8My_p+P4_l!;aYxZH*O-w#C+;@{(9al@^I}!>V
zafQe(w2WpMG=sgDwQs;XK;SFFsXmog1we6yp`c3pxWB;zE4;?RG`7TP&{AMOF-((9
z{Gd@~Z*YAs14AaZ@&-;?(kAb+Ch>i)f}QCVGUE!$md|7*yp9T!!?fsjXVzw!NlZs`~i6z
e^4N=Jv)*@jj^m!9;8WE8j}YdL?DqJ%y88bysbPlz
diff --git a/filters/Desenfoque/bilateral.py b/filters/Desenfoque/bilateral.py
deleted file mode 100644
index fc05a28..0000000
--- a/filters/Desenfoque/bilateral.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import cv2 as cv
-
-def apply_effect(image, d=3, sigmaColor=20, sigmaSpace=15):
- return cv.bilateralFilter(image, d, sigmaColor, sigmaSpace)
-
-def get_filter_data():
- return {
- "parameters": {
- "d": {"min": 1, "max": 10, "init": 3, "interval": 1},
- "sigmaColor": {"min": 1, "max": 100, "init": 20, "interval": 1},
- "sigmaSpace": {"min": 1, "max": 100, "init": 15, "interval": 1}
- }
- }
diff --git a/filters/Desenfoque/box.py b/filters/Desenfoque/box.py
deleted file mode 100644
index 094c5a8..0000000
--- a/filters/Desenfoque/box.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import cv2
-
-def apply_effect(image, ksize_x, ksize_y):
- blurred_image = cv2.boxFilter(image, -1, (ksize_x, ksize_y))
- return blurred_image
-
-def get_filter_data():
- return {
- "parameters": {
- "ksize_x": {"min": 3, "max": 15, "init": 5, "interval": 2},
- "ksize_y": {"min": 3, "max": 15, "init": 5, "interval": 2}
- }
- }
diff --git a/filters/Desenfoque/desenfoque_gausiano.py b/filters/Desenfoque/desenfoque_gausiano.py
deleted file mode 100644
index 31cdcdf..0000000
--- a/filters/Desenfoque/desenfoque_gausiano.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import cv2
-
-def apply_effect(image, kernel_size, sigma):
- kernel_size = kernel_size + (kernel_size % 2 == 0)
- return cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma)
-
-def get_filter_data():
- return {
- "parameters": {
- "kernel_size": {"min": 1, "max": 31, "init": 15, "interval": 2},
- "sigma": {"min": 1, "max": 10, "init": 5, "interval": 1}
- }
- }
-
\ No newline at end of file
diff --git a/filters/Desenfoque/desenfoque_horizontal.py b/filters/Desenfoque/desenfoque_horizontal.py
deleted file mode 100644
index 983a5b6..0000000
--- a/filters/Desenfoque/desenfoque_horizontal.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import cv2
-import numpy as np
-def apply_effect(image, kernel_size):
- kernel_h = np.zeros((kernel_size, kernel_size))
- kernel_h[int((kernel_size - 1)/2), :] = np.ones(kernel_size)
- kernel_h /= kernel_size
- return cv2.filter2D(image, -1, kernel_h)
-
-def get_filter_data():
- return {
- "parameters": {
- "kernel_size": {"min": 1, "max": 101, "init": 3, "interval": 2}
- }
- }
\ No newline at end of file
diff --git a/filters/Desenfoque/desenfoque_vertical.py b/filters/Desenfoque/desenfoque_vertical.py
deleted file mode 100644
index 74fb315..0000000
--- a/filters/Desenfoque/desenfoque_vertical.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import cv2
-import numpy as np
-
-def apply_effect(image, multi):
- kernel_v = np.zeros((multi, multi), dtype=np.float64)
- kernel_v[:, int((multi - 1)/2)] = np.ones(multi)
- kernel_v /= multi
- return cv2.filter2D(image, -1, kernel_v)
-
-def get_filter_data():
- return {
- "parameters": {
- "multi": {"min": 1, "max": 100, "init": 30, "interval": 1}
- }
- }
diff --git a/filters/Desenfoque/mediana.py b/filters/Desenfoque/mediana.py
deleted file mode 100644
index 7fcae1f..0000000
--- a/filters/Desenfoque/mediana.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import cv2
-
-def apply_effect(image, kernel_size):
- kernel_size = max(1, kernel_size)
- kernel_size = kernel_size + (kernel_size % 2 == 0)
- return cv2.medianBlur(image, kernel_size)
-
-def get_filter_data():
- return {
- "parameters": {
- "kernel_size": {"min": 1, "max": 101, "init": 3, "interval": 2}
- }
- }
diff --git a/filters/Ruido/__init__.py b/filters/Ruido/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/filters/Ruido/__pycache__/__init__.cpython-312.pyc b/filters/Ruido/__pycache__/__init__.cpython-312.pyc
deleted file mode 100644
index 156ffe8d0bf8babf7deb1cb467229d89a2096763..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 165
zcmX@j%ge<81fA->X(0MBh(HIQS%4zb87dhx8U0o=6fpsLpFwJVxg=Y~gche36~~lS
z#JJ>_=jG%lrWD8c7o_Gnhw0`fX6D7XhkEMf=BI?jq-ExmfK(QhW~SuF#K&jmWtPOp
j>lIY~;;;cKD9uT=D`Ev2$_T{8AjU^#Mn=XWW*`dyCJ!l(
diff --git a/filters/Ruido/__pycache__/ruido.cpython-312.pyc b/filters/Ruido/__pycache__/ruido.cpython-312.pyc
deleted file mode 100644
index 32628bfe6c3bdb748e394a00fb9927a317641e9d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 973
zcmZWnO=uHA6rS1t{Iu9@t%?<_SV|5pda)u!sI8PBRDDJmnV6t(W*FO^T!s_Iqz;zxU0X_vTw)Ulf5wrk`ei
zV1$0NMc24a(7X!44kCzP6D?!Hy+g|!;Q{#qP6%~ITgdPoHght3Y~4Ho*g+x6f$y~x
zFp7LpD2hS%B$N|+SqSBrT91V|&KXX+1sc~}
z*DR#cQ?d^PNru6##=t;bPJGqrSijUOdBfCrGsmk*z
zuHLOA599Yrk5AO0o$(LjyJO|Cj}w)F%Iu+f=SZEZsZ(FLugYiTP@O3~IgSl~7lxal
zjxr3ocK&E?!wx(*7!%=%Ktv+#2}B030J1o;#~B!!A6=kPSMxMWXV)_JTCG-{K=Rp0
z*uzc;l(!5UK-;8(VH*Kepz*r5u9!dw!F~ije-faCeknr@30=EUUaXEDsI^OT$Ja;7FRB9vxHkCck1Rx_hA73N
z4J3)twlI_>+Ih<@coGP-Ti({}Ir>zYhPmZU{h`Nt!s_)^fCi5-{)yDTf`G3y<1#)|
F{RcVu-v0mq
diff --git a/filters/Ruido/__pycache__/ruido_gausiano.cpython-312.pyc b/filters/Ruido/__pycache__/ruido_gausiano.cpython-312.pyc
deleted file mode 100644
index b905fa4e481a49e100070889aee3ab71618aefb9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 980
zcmZWnO-vI(6rSz=(iW5jQ6nZ|B%}w3Uc?w)piKpJG+_=;?r6s1kWWM)i=6gT$-hAusjv|nw@6R$n
zIfQ<*O@3b-(q~NTEtkU5C+Yp7)8_)z^(Dup3
z&h!4OCVu{Q2fD$A7rXvxWw
z$@|(%U-x`%WlfuMR&CS4#Mhp?x;^=7)WU|XO}|WzS`L}lGKLv2=4{R&j^;5;E#jPS
zVA~mU^E8fK*UYE%Oh!)!-X%!G8tN|q6wyIX-^TL#^4sa+MDg|ep~HC3Mshv5A0Mp7
z2e;-+u5zcG+>75WK0Z|YH%C5!&KaQ4r%aeQR?R|B;s*Zn&d{sUxd+J2-
z=|ODZhcIvq(NUT~Th4yZEjWRH2lFC45r{~nZGp(36+mWpZAT0arVyQ>Q5SpI(%Jir
z?M96TMxh|g9b6kM%~pDMxoY2|KeEsz
z)kP^5ts_Z{Hp4og#)2ROdYvAJx
diff --git a/filters/Ruido/__pycache__/sal_y_pimienta.cpython-312.pyc b/filters/Ruido/__pycache__/sal_y_pimienta.cpython-312.pyc
deleted file mode 100644
index 72c264c73afa2f3c47b5423a805dfaf97e41c965..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1465
zcmcgsO>7fK6rS0gU7L`#n>31xkP-^1s6`W$7Np8T%^_}~iR2_r=>fU27Vp}OwccH3
z*95z^GkPI2TT*h(oOwdwU
z__||4Q^Y%cps|E}+@2}4HQNKwSJ7%~z9#Qsl0B3btl}yvsIQM#6!f
