Upload 3 files

frame_detector.py

@@ -0,0 +1,346 @@
+"""
+Frame Detection Module
+Automatically detects and extracts sprite frames from sprite sheets
+"""
+
+import cv2
+import numpy as np
+from typing import List, Tuple
+from scipy import ndimage
+from skimage import measure
+
+class FrameDetector:
+    """Detector for finding sprite frames in sprite sheets"""
+    
+    def __init__(self):
+        self.min_frame_size = 16  # Minimum frame size in pixels
+        self.max_frame_size = 512  # Maximum frame size in pixels
+    
+    def detect_frames_auto(self, image: np.ndarray, padding: int = 2) -> Tuple[List[np.ndarray], List[Tuple]]:
+        """
+        Automatically detect frames in a sprite sheet
+        
+        Args:
+            image: Input sprite sheet image
+            padding: Padding to add around each frame
+        
+        Returns:
+            Tuple of (list of frame images, list of bounding boxes)
+        """
+        # Handle alpha channel
+        if len(image.shape) == 3 and image.shape[2] == 4:
+            # Use alpha channel for detection
+            alpha = image[:, :, 3]
+            # Create binary mask where alpha > 0
+            _, binary = cv2.threshold(alpha, 10, 255, cv2.THRESH_BINARY)
+        else:
+            # Convert to grayscale and create mask
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            _, binary = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
+        
+        # Find connected components
+        labels = measure.label(binary, connectivity=2)
+        regions = measure.regionprops(labels)
+        
+        # Filter regions by size
+        valid_regions = []
+        for region in regions:
+            minr, minc, maxr, maxc = region.bbox
+            width = maxc - minc
+            height = maxr - minr
+            
+            if (self.min_frame_size <= width <= self.max_frame_size and
+                self.min_frame_size <= height <= self.max_frame_size):
+                valid_regions.append(region)
+        
+        # If no valid regions found, try grid-based detection
+        if len(valid_regions) == 0:
+            return self._detect_grid_based(image, padding)
+        
+        # Sort regions by x-coordinate (left to right)
+        valid_regions.sort(key=lambda r: r.bbox[1])
+        
+        # Extract frames
+        frames = []
+        frame_boxes = []
+        
+        for region in valid_regions:
+            minr, minc, maxr, maxc = region.bbox
+            
+            # Add padding
+            minr = max(0, minr - padding)
+            minc = max(0, minc - padding)
+            maxr = min(image.shape[0], maxr + padding)
+            maxc = min(image.shape[1], maxc + padding)
+            
+            # Extract frame
+            frame = image[minr:maxr, minc:maxc]
+            
+            frames.append(frame)
+            frame_boxes.append((minr, minc, maxr, maxc))
+        
+        # If too many small regions, use grid-based approach
+        if len(frames) > 20:
+            return self._detect_grid_based(image, padding)
+        
+        return frames, frame_boxes
+    
+    def _detect_grid_based(self, image: np.ndarray, padding: int = 2) -> Tuple[List[np.ndarray], List[Tuple]]:
+        """
+        Detect frames using grid-based approach with improved filtering
+        
+        Args:
+            image: Input sprite sheet image
+            padding: Padding to add around each frame
+        
+        Returns:
+            Tuple of (list of frame images, list of bounding boxes)
+        """
+        # Handle alpha channel
+        if len(image.shape) == 3 and image.shape[2] == 4:
+            alpha = image[:, :, 3]
+            _, binary = cv2.threshold(alpha, 10, 255, cv2.THRESH_BINARY)
+        else:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            _, binary = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
+        
+        # Apply morphological operations to clean up noise
+        kernel = np.ones((3, 3), np.uint8)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+        
+        # Find horizontal and vertical projections
+        h_proj = np.sum(binary, axis=1)
+        v_proj = np.sum(binary, axis=0)
+        
+        # Find gaps (low values in projection)
+        h_threshold = np.max(h_proj) * 0.1
+        v_threshold = np.max(v_proj) * 0.1
+        
+        h_gaps = h_proj < h_threshold
+        v_gaps = v_proj < v_threshold
+        
+        # Find row boundaries
+        row_boundaries = []
+        in_gap = True
+        for i, is_gap in enumerate(h_gaps):
+            if in_gap and not is_gap:
+                row_boundaries.append(i)
+                in_gap = False
+            elif not in_gap and is_gap:
+                row_boundaries.append(i)
+                in_gap = True
+        
+        # Find column boundaries
+        col_boundaries = []
+        in_gap = True
+        for i, is_gap in enumerate(v_gaps):
+            if in_gap and not is_gap:
+                col_boundaries.append(i)
+                in_gap = False
+            elif not in_gap and is_gap:
+                col_boundaries.append(i)
+                in_gap = True
+        
+        # Ensure even number of boundaries
+        if len(row_boundaries) % 2 != 0:
+            row_boundaries.append(binary.shape[0])
+        if len(col_boundaries) % 2 != 0:
+            col_boundaries.append(binary.shape[1])
+        
+        # Extract frames
+        frames = []
+        frame_boxes = []
+        
+        # If we have valid boundaries
+        if len(row_boundaries) >= 2 and len(col_boundaries) >= 2:
+            for i in range(0, len(row_boundaries), 2):
+                for j in range(0, len(col_boundaries), 2):
+                    minr = row_boundaries[i]
+                    maxr = row_boundaries[i + 1]
+                    minc = col_boundaries[j]
+                    maxc = col_boundaries[j + 1]
+                    
+                    # Add padding
+                    minr_p = max(0, minr - padding)
+                    minc_p = max(0, minc - padding)
+                    maxr_p = min(image.shape[0], maxr + padding)
+                    maxc_p = min(image.shape[1], maxc + padding)
+                    
+                    # Extract frame
+                    frame = image[minr_p:maxr_p, minc_p:maxc_p]
+                    
+                    # Check if frame has content and meets size requirements
+                    frame_width = maxc - minc
+                    frame_height = maxr - minr
+                    
+                    # Filter out very small frames (likely effects/particles)
+                    min_content_width = max(15, image.shape[1] // 50)  # At least 15px or 2% of image width
+                    min_content_height = max(20, image.shape[0] // 3)  # At least 20px or 33% of image height
+                    
+                    has_content = np.sum(frame) > 0
+                    has_valid_size = (frame_width >= min_content_width and 
+                                     frame_height >= min_content_height)
+                    
+                    if has_content and has_valid_size:
+                        frames.append(frame)
+                        frame_boxes.append((minr_p, minc_p, maxr_p, maxc_p))
+        
+        # If still no frames, use equal division
+        if len(frames) == 0:
+            return self._detect_equal_division(image, padding)
+        
+        return frames, frame_boxes
+    
+    def _detect_equal_division(self, image: np.ndarray, padding: int = 2, 
+                               num_frames: int = 8) -> Tuple[List[np.ndarray], List[Tuple]]:
+        """
+        Detect frames by equal division
+        
+        Args:
+            image: Input sprite sheet image
+            padding: Padding to add around each frame
+            num_frames: Number of frames to divide into
+        
+        Returns:
+            Tuple of (list of frame images, list of bounding boxes)
+        """
+        frames = []
+        frame_boxes = []
+        
+        img_width = image.shape[1]
+        img_height = image.shape[0]
+        
+        # Assume horizontal layout
+        frame_width = img_width // num_frames
+        frame_height = img_height
+        
+        for i in range(num_frames):
+            minc = i * frame_width
+            maxc = (i + 1) * frame_width if i < num_frames - 1 else img_width
+            minr = 0
+            maxr = img_height
+            
+            # Add padding
+            minc_p = max(0, minc - padding)
+            minr_p = max(0, minr - padding)
+            maxc_p = min(img_width, maxc + padding)
+            maxr_p = min(img_height, maxr + padding)
+            
+            frame = image[minr_p:maxr_p, minc_p:maxc_p]
+            frames.append(frame)
+            frame_boxes.append((minr_p, minc_p, maxr_p, maxc_p))
+        
+        return frames, frame_boxes
+    
+    def detect_frames_manual(self, image: np.ndarray, num_frames: int, 
+                            padding: int = 2) -> Tuple[List[np.ndarray], List[Tuple]]:
+        """
+        Manually specify number of frames
+        
+        Args:
+            image: Input sprite sheet image
+            num_frames: Number of frames
+            padding: Padding to add around each frame
+        
+        Returns:
+            Tuple of (list of frame images, list of bounding boxes)
+        """
+        return self._detect_equal_division(image, padding, num_frames)
+    
+    def refine_frame_boundaries(self, image: np.ndarray, frame: np.ndarray, 
+                                bbox: Tuple) -> Tuple[np.ndarray, Tuple]:
+        """
+        Refine frame boundaries to remove excess transparent space
+        
+        Args:
+            image: Original image
+            frame: Extracted frame
+            bbox: Bounding box (minr, minc, maxr, maxc)
+        
+        Returns:
+            Refined frame and bounding box
+        """
+        minr, minc, maxr, maxc = bbox
+        
+        # Handle alpha channel
+        if len(frame.shape) == 3 and frame.shape[2] == 4:
+            alpha = frame[:, :, 3]
+            # Find non-transparent pixels
+            rows = np.any(alpha > 10, axis=1)
+            cols = np.any(alpha > 10, axis=0)
+        else:
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            rows = np.any(gray > 10, axis=1)
+            cols = np.any(gray > 10, axis=0)
+        
+        # Find bounds
+        row_indices = np.where(rows)[0]
+        col_indices = np.where(cols)[0]
+        
+        if len(row_indices) > 0 and len(col_indices) > 0:
+            # Calculate new bounds
+            new_minr = minr + row_indices[0]
+            new_maxr = minr + row_indices[-1] + 1
+            new_minc = minc + col_indices[0]
+            new_maxc = minc + col_indices[-1] + 1
+            
+            # Extract refined frame
+            refined_frame = image[new_minr:new_maxr, new_minc:new_maxc]
+            
+            return refined_frame, (new_minr, new_minc, new_maxr, new_maxc)
+        
+        return frame, bbox
+    
+    def detect_frame_size(self, image: np.ndarray) -> Tuple[int, int]:
+        """
+        Detect the size of individual frames
+        
+        Args:
+            image: Input sprite sheet image
+        
+        Returns:
+            Tuple of (frame_width, frame_height)
+        """
+        # Handle alpha channel
+        if len(image.shape) == 3 and image.shape[2] == 4:
+            alpha = image[:, :, 3]
+            _, binary = cv2.threshold(alpha, 10, 255, cv2.THRESH_BINARY)
+        else:
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            _, binary = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
+        
+        # Find vertical projection
+        v_proj = np.sum(binary, axis=0)
+        
+        # Find gaps
+        threshold = np.max(v_proj) * 0.1
+        gaps = v_proj < threshold
+        
+        # Find gap positions
+        gap_starts = []
+        gap_ends = []
+        
+        in_gap = False
+        for i, is_gap in enumerate(gaps):
+            if not in_gap and is_gap:
+                gap_starts.append(i)
+                in_gap = True
+            elif in_gap and not is_gap:
+                gap_ends.append(i)
+                in_gap = False
+        
+        # Calculate frame width from gap positions
+        if len(gap_starts) > 0:
+            # Average distance between gaps
+            if len(gap_starts) > 1:
+                frame_width = int(np.mean(np.diff(gap_starts)))
+            else:
+                frame_width = gap_starts[0]
+        else:
+            # No gaps found, assume single frame
+            frame_width = image.shape[1]
+        
+        frame_height = image.shape[0]
+        
+        return frame_width, frame_height

frame_namer.py

@@ -0,0 +1,329 @@
+"""
+Smart Frame Naming Module
+Automatically names frames based on their content/pose
+"""
+
+import cv2
+import numpy as np
+from typing import List
+from scipy.spatial import distance
+
+# Optional imports for advanced features
+try:
+    import torch
+    from transformers import pipeline
+    HAS_TRANSFORMERS = True
+except ImportError:
+    HAS_TRANSFORMERS = False
+    torch = None
+    pipeline = None
+
+class FrameNamer:
+    """Intelligent frame naming based on pose analysis"""
+    
+    def __init__(self):
+        self.pose_keywords = {
+            'idle': ['standing', 'still', 'neutral', 'waiting'],
+            'walk': ['walking', 'moving', 'step'],
+            'run': ['running', 'fast', 'sprint'],
+            'jump': ['jumping', 'leap', 'air'],
+            'attack': ['attacking', 'strike', 'hit', 'swing'],
+            'hurt': ['hurt', 'damage', 'hit', 'pain'],
+            'die': ['dying', 'dead', 'fall'],
+            'cast': ['casting', 'spell', 'magic'],
+            'block': ['blocking', 'defend', 'guard'],
+            'shoot': ['shooting', 'bow', 'arrow', 'ranged']
+        }
+        
+        # Initialize pose classifier if available
+        self.classifier = None
+        self._init_classifier()
+    
+    def _init_classifier(self):
+        """Initialize image classifier for pose detection"""
+        try:
+            # Try to load a lightweight classifier
+            # Note: In production, you'd use a custom-trained model
+            self.classifier = None  # Placeholder for actual model
+        except Exception as e:
+            print(f"Could not load classifier: {e}")
+            self.classifier = None
+    
+    def name_frames(self, frames: List[np.ndarray]) -> List[str]:
+        """
+        Generate intelligent names for frames
+        
+        Args:
+            frames: List of frame images
+        
+        Returns:
+            List of frame names
+        """
+        if len(frames) == 0:
+            return []
+        
+        # Analyze each frame
+        frame_features = []
+        for frame in frames:
+            features = self._extract_features(frame)
+            frame_features.append(features)
+        
+        # Detect animation type
+        animation_type = self._detect_animation_type(frame_features)
+        
+        # Generate names
+        names = []
+        for i, features in enumerate(frame_features):
+            # Determine pose variation
+            pose_variation = self._get_pose_variation(features, frame_features, i)
+            
+            # Generate name
+            if animation_type == 'idle':
+                name = f"idle_{i+1:02d}"
+            elif animation_type == 'walk':
+                name = f"walk_{i+1:02d}"
+            elif animation_type == 'run':
+                name = f"run_{i+1:02d}"
+            elif animation_type == 'jump':
+                if i == 0:
+                    name = "jump_start"
+                elif i == len(frames) - 1:
+                    name = "jump_land"
+                else:
+                    name = f"jump_{i:02d}"
+            elif animation_type == 'attack':
+                if i == 0:
+                    name = "attack_windup"
+                elif i == len(frames) // 2:
+                    name = "attack_strike"
+                elif i == len(frames) - 1:
+                    name = "attack_recover"
+                else:
+                    name = f"attack_{i:02d}"
+            elif animation_type == 'hurt':
+                name = f"hurt_{i+1:02d}"
+            elif animation_type == 'die':
+                if i == len(frames) - 1:
+                    name = "die_dead"
+                else:
+                    name = f"die_{i+1:02d}"
+            elif animation_type == 'cast':
+                if i == 0:
+                    name = "cast_start"
+                elif i == len(frames) - 1:
+                    name = "cast_release"
+                else:
+                    name = f"cast_{i:02d}"
+            elif animation_type == 'block':
+                name = f"block_{i+1:02d}"
+            elif animation_type == 'shoot':
+                if i == 0:
+                    name = "shoot_draw"
+                elif i == len(frames) - 1:
+                    name = "shoot_release"
+                else:
+                    name = f"shoot_{i:02d}"
+            else:
+                name = f"frame_{i+1:03d}"
+            
+            names.append(name)
+        
+        return names
+    
+    def _extract_features(self, frame: np.ndarray) -> dict:
+        """
+        Extract features from a frame for analysis
+        
+        Args:
+            frame: Input frame image
+        
+        Returns:
+            Dictionary of features
+        """
+        features = {}
+        
+        # Handle alpha channel
+        if len(frame.shape) == 3 and frame.shape[2] == 4:
+            alpha = frame[:, :, 3]
+            bgr = frame[:, :, :3]
+            # Create mask from alpha
+            mask = alpha > 10
+        else:
+            bgr = frame
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            _, mask = cv2.threshold(gray, 10, 255, cv2.THRESH_BINARY)
+        
+        # Get bounding box of content
+        coords = np.column_stack(np.where(mask))
+        if len(coords) > 0:
+            y_min, x_min = coords.min(axis=0)
+            y_max, x_max = coords.max(axis=0)
+            
+            features['bbox'] = (x_min, y_min, x_max, y_max)
+            features['width'] = x_max - x_min
+            features['height'] = y_max - y_min
+            features['center_x'] = (x_min + x_max) / 2
+            features['center_y'] = (y_min + y_max) / 2
+            features['aspect_ratio'] = features['width'] / max(features['height'], 1)
+            
+            # Calculate centroid
+            moments = cv2.moments(mask.astype(np.uint8))
+            if moments['m00'] > 0:
+                features['centroid_x'] = moments['m10'] / moments['m00']
+                features['centroid_y'] = moments['m01'] / moments['m00']
+            else:
+                features['centroid_x'] = features['center_x']
+                features['centroid_y'] = features['center_y']
+            
+            # Calculate pixel count (area)
+            features['area'] = np.sum(mask)
+            
+            # Calculate center of mass height ratio
+            features['com_height_ratio'] = features['centroid_y'] / frame.shape[0]
+        else:
+            features['bbox'] = (0, 0, frame.shape[1], frame.shape[0])
+            features['width'] = frame.shape[1]
+            features['height'] = frame.shape[0]
+            features['center_x'] = frame.shape[1] / 2
+            features['center_y'] = frame.shape[0] / 2
+            features['aspect_ratio'] = 1.0
+            features['centroid_x'] = frame.shape[1] / 2
+            features['centroid_y'] = frame.shape[0] / 2
+            features['area'] = 0
+            features['com_height_ratio'] = 0.5
+        
+        return features
+    
+    def _detect_animation_type(self, frame_features: List[dict]) -> str:
+        """
+        Detect the type of animation based on frame features
+        
+        Args:
+            frame_features: List of feature dictionaries
+        
+        Returns:
+            Animation type string
+        """
+        if len(frame_features) < 2:
+            return 'idle'
+        
+        # Calculate motion metrics
+        center_x_changes = []
+        center_y_changes = []
+        area_changes = []
+        com_height_changes = []
+        
+        for i in range(1, len(frame_features)):
+            prev = frame_features[i - 1]
+            curr = frame_features[i]
+            
+            center_x_changes.append(abs(curr['center_x'] - prev['center_x']))
+            center_y_changes.append(abs(curr['center_y'] - prev['center_y']))
+            area_changes.append(abs(curr['area'] - prev['area']))
+            com_height_changes.append(abs(curr['com_height_ratio'] - prev['com_height_ratio']))
+        
+        avg_x_change = np.mean(center_x_changes) if center_x_changes else 0
+        avg_y_change = np.mean(center_y_changes) if center_y_changes else 0
+        avg_area_change = np.mean(area_changes) if area_changes else 0
+        avg_com_height_change = np.mean(com_height_changes) if com_height_changes else 0
+        
+        # Detect based on motion patterns
+        total_horizontal_movement = abs(frame_features[-1]['center_x'] - frame_features[0]['center_x'])
+        total_vertical_movement = abs(frame_features[-1]['center_y'] - frame_features[0]['center_y'])
+        
+        # Calculate height variation
+        heights = [f['height'] for f in frame_features]
+        height_variance = np.var(heights)
+        max_height = max(heights)
+        min_height = min(heights)
+        height_range = max_height - min_height
+        
+        # Calculate width variation
+        widths = [f['width'] for f in frame_features]
+        width_variance = np.var(widths)
+        
+        # Detect animation type
+        # Jump: Significant vertical movement and height variation
+        if avg_y_change > avg_x_change * 1.5 and height_range > max_height * 0.15:
+            return 'jump'
+        
+        # Attack: Large area changes (weapon swing) or horizontal extension
+        if avg_area_change > np.mean([f['area'] for f in frame_features]) * 0.1:
+            return 'attack'
+        
+        # Hurt/Die: Center of mass moves down
+        if frame_features[-1]['com_height_ratio'] > frame_features[0]['com_height_ratio'] + 0.1:
+            if frame_features[-1]['height'] < frame_features[0]['height'] * 0.7:
+                return 'die'
+            return 'hurt'
+        
+        # Cast: Arms up (height increases then decreases)
+        if height_variance > max_height * 0.1:
+            mid_idx = len(frame_features) // 2
+            if (frame_features[mid_idx]['height'] > frame_features[0]['height'] and
+                frame_features[mid_idx]['height'] > frame_features[-1]['height']):
+                return 'cast'
+        
+        # Block: Wide stance (width increases)
+        if frame_features[0]['width'] * 1.2 < max(widths):
+            return 'block'
+        
+        # Shoot: One arm extended
+        if width_variance > np.mean(widths) * 0.05:
+            return 'shoot'
+        
+        # Run vs Walk: Speed of horizontal movement
+        if avg_x_change > frame_features[0]['width'] * 0.15:
+            return 'run'
+        elif avg_x_change > frame_features[0]['width'] * 0.05:
+            return 'walk'
+        
+        # Default to idle
+        return 'idle'
+    
+    def _get_pose_variation(self, features: dict, all_features: List[dict], 
+                           index: int) -> str:
+        """
+        Get pose variation descriptor
+        
+        Args:
+            features: Current frame features
+            all_features: All frame features
+            index: Current frame index
+        
+        Returns:
+            Variation descriptor
+        """
+        if index == 0:
+            return 'start'
+        elif index == len(all_features) - 1:
+            return 'end'
+        else:
+            return 'mid'
+    
+    def suggest_animation_name(self, frames: List[np.ndarray]) -> str:
+        """
+        Suggest a name for the entire animation
+        
+        Args:
+            frames: List of frame images
+        
+        Returns:
+            Suggested animation name
+        """
+        animation_type = self._detect_animation_type([self._extract_features(f) for f in frames])
+        
+        suggestions = {
+            'idle': 'character_idle',
+            'walk': 'character_walk',
+            'run': 'character_run',
+            'jump': 'character_jump',
+            'attack': 'character_attack',
+            'hurt': 'character_hurt',
+            'die': 'character_die',
+            'cast': 'character_cast_spell',
+            'block': 'character_block',
+            'shoot': 'character_shoot'
+        }
+        
+        return suggestions.get(animation_type, 'character_animation')

sprite_processor.py

@@ -0,0 +1,206 @@
+"""
+Sprite Image Enhancement Module
+Uses Real-ESRGAN for high-quality upscaling
+"""
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+import os
+
+class SpriteProcessor:
+    """Processor for enhancing sprite sheet images"""
+    
+    def __init__(self):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.model = None
+        self._load_model()
+    
+    def _load_model(self):
+        """Load Real-ESRGAN model"""
+        try:
+            from realesrgan import RealESRGANer
+            from basicsr.archs.rrdbnet_arch import RRDBNet
+            
+            # Create model
+            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64,
+                           num_block=23, num_grow_ch=32, scale=4)
+            
+            # Initialize Real-ESRGAN
+            model_path = "weights/RealESRGAN_x4plus.pth"
+            
+            if os.path.exists(model_path):
+                self.model = RealESRGANer(
+                    scale=4,
+                    model_path=model_path,
+                    model=model,
+                    tile=0,
+                    pre_pad=0,
+                    half=False,
+                    device=self.device
+                )
+            else:
+                print("Warning: Real-ESRGAN model not found, using fallback enhancement")
+                self.model = None
+                
+        except Exception as e:
+            print(f"Error loading Real-ESRGAN: {e}")
+            self.model = None
+    
+    def enhance_image(self, image: np.ndarray, scale: int = 4) -> np.ndarray:
+        """
+        Enhance image quality using Real-ESRGAN or fallback methods
+        
+        Args:
+            image: Input image (BGR or BGRA)
+            scale: Upscaling factor (2 or 4)
+        
+        Returns:
+            Enhanced image
+        """
+        # Handle alpha channel
+        has_alpha = len(image.shape) == 3 and image.shape[2] == 4
+        
+        if has_alpha:
+            # Separate alpha channel
+            bgr = image[:, :, :3]
+            alpha = image[:, :, 3]
+        else:
+            bgr = image
+            alpha = None
+        
+        # Enhance RGB channels
+        if self.model is not None and scale > 1:
+            try:
+                # Convert BGR to RGB for the model
+                rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+                
+                # Apply Real-ESRGAN
+                enhanced_rgb, _ = self.model.enhance(rgb, outscale=scale)
+                
+                # Convert back to BGR
+                enhanced_bgr = cv2.cvtColor(enhanced_rgb, cv2.COLOR_RGB2BGR)
+                
+            except Exception as e:
+                print(f"Real-ESRGAN failed, using fallback: {e}")
+                enhanced_bgr = self._fallback_enhance(bgr, scale)
+        else:
+            enhanced_bgr = self._fallback_enhance(bgr, scale)
+        
+        # Enhance alpha channel if present
+        if alpha is not None and scale > 1:
+            enhanced_alpha = cv2.resize(alpha, None, fx=scale, fy=scale, 
+                                       interpolation=cv2.INTER_NEAREST)
+            
+            # Merge channels
+            enhanced_image = cv2.merge([enhanced_bgr, enhanced_alpha])
+        else:
+            enhanced_image = enhanced_bgr
+        
+        return enhanced_image
+    
+    def _fallback_enhance(self, image: np.ndarray, scale: int) -> np.ndarray:
+        """
+        Fallback enhancement using OpenCV
+        
+        Args:
+            image: Input BGR image
+            scale: Upscaling factor
+        
+        Returns:
+            Enhanced image
+        """
+        # Resize with high-quality interpolation
+        new_width = int(image.shape[1] * scale)
+        new_height = int(image.shape[0] * scale)
+        
+        enhanced = cv2.resize(image, (new_width, new_height), 
+                             interpolation=cv2.INTER_CUBIC)
+        
+        # Apply sharpening
+        kernel = np.array([[-1, -1, -1],
+                          [-1,  9, -1],
+                          [-1, -1, -1]])
+        enhanced = cv2.filter2D(enhanced, -1, kernel)
+        
+        # Denoise
+        enhanced = cv2.fastNlMeansDenoisingColored(enhanced, None, 5, 5, 7, 21)
+        
+        return enhanced
+    
+    def sharpen_image(self, image: np.ndarray, strength: float = 1.0) -> np.ndarray:
+        """
+        Apply sharpening filter
+        
+        Args:
+            image: Input image
+            strength: Sharpening strength
+        
+        Returns:
+            Sharpened image
+        """
+        kernel = np.array([[-1, -1, -1],
+                          [-1,  9, -1],
+                          [-1, -1, -1]]) * strength
+        
+        sharpened = cv2.filter2D(image, -1, kernel)
+        return sharpened
+    
+    def remove_blur(self, image: np.ndarray) -> np.ndarray:
+        """
+        Reduce blur using deconvolution
+        
+        Args:
+            image: Input image
+        
+        Returns:
+            Deblurred image
+        """
+        # Create a point spread function (PSF)
+        psf_size = 5
+        psf = np.ones((psf_size, psf_size)) / (psf_size ** 2)
+        
+        # Simple deconvolution (Wiener filter approximation)
+        result = image.copy()
+        
+        for i in range(3):  # For each channel
+            channel = image[:, :, i].astype(np.float32) / 255.0
+            
+            # FFT
+            psf_fft = np.fft.fft2(psf, s=channel.shape)
+            channel_fft = np.fft.fft2(channel)
+            
+            # Wiener deconvolution
+            K = 0.01  # Noise to signal ratio
+            deconv_fft = channel_fft * np.conj(psf_fft) / (np.abs(psf_fft) ** 2 + K)
+            
+            # Inverse FFT
+            deconv = np.fft.ifft2(deconv_fft).real
+            
+            # Clip and convert back
+            deconv = np.clip(deconv * 255, 0, 255).astype(np.uint8)
+            result[:, :, i] = deconv
+        
+        return result
+    
+    def enhance_contrast(self, image: np.ndarray) -> np.ndarray:
+        """
+        Enhance contrast using CLAHE
+        
+        Args:
+            image: Input image
+        
+        Returns:
+            Contrast-enhanced image
+        """
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        l = clahe.apply(l)
+        
+        enhanced = cv2.merge([l, a, b])
+        enhanced = cv2.cvtColor(enhanced, cv2.COLOR_LAB2BGR)
+        
+        return enhanced