Update app.py

app.py

@@ -4,14 +4,16 @@ import base64
 import numpy as np
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageEnhance, ImageFilter, ImageDraw, ImageFont
 import qrcode
-from qrcode.constants import ERROR_CORRECT_H
+from qrcode.constants import ERROR_CORRECT_H, ERROR_CORRECT_M
 import cv2
 from io import BytesIO
 import requests
 from werkzeug.utils import secure_filename
 import logging
+from sklearn.cluster import KMeans
+import colorsys
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -27,227 +29,372 @@ ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp'}
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-def create_base_qr(data, size=300):
-    """Create a base QR code with high error correction"""
-    qr = qrcode.QRCode(
-        version=1,
-        error_correction=ERROR_CORRECT_H,  # 30% error correction
-        box_size=10,
-        border=4,
-    )
-    qr.add_data(data)
-    qr.make(fit=True)
+def extract_dominant_colors(image, n_colors=5):
+    """Extract dominant colors from image using K-means clustering"""
+    # Resize image for faster processing
+    image_small = image.resize((100, 100))
     
-    # Create QR code image
-    qr_img = qr.make_image(fill_color="black", back_color="white")
+    # Convert to RGB array
+    data = np.array(image_small)
+    data = data.reshape((-1, 3))
     
-    # Resize to specified size
-    qr_img = qr_img.resize((size, size), Image.LANCZOS)
-    return qr_img, qr
-
-def analyze_image_contrast(image):
-    """Analyze image to find optimal areas for QR integration"""
-    # Convert to grayscale
-    gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
-    
-    # Calculate local contrast using Laplacian
-    laplacian = cv2.Laplacian(gray, cv2.CV_64F)
-    contrast_map = np.abs(laplacian)
-    
-    # Normalize contrast map
-    contrast_map = (contrast_map / contrast_map.max() * 255).astype(np.uint8)
-    
-    # Calculate average contrast in different regions
-    h, w = gray.shape
-    regions = {
-        'center': gray[h//4:3*h//4, w//4:3*w//4],
-        'corners': [
-            gray[0:h//3, 0:w//3],          # top-left
-            gray[0:h//3, 2*w//3:w],        # top-right
-            gray[2*h//3:h, 0:w//3],        # bottom-left
-            gray[2*h//3:h, 2*w//3:w]       # bottom-right
-        ]
-    }
+    # Remove pure white and very light colors
+    data = data[np.sum(data, axis=1) < 720]  # Remove colors where R+G+B > 720
+    
+    if len(data) == 0:
+        return [(0, 0, 0), (255, 255, 255)]
+    
+    # Perform K-means clustering
+    kmeans = KMeans(n_clusters=min(n_colors, len(data)), random_state=42, n_init=10)
+    kmeans.fit(data)
+    
+    colors = kmeans.cluster_centers_.astype(int)
+    
+    # Sort colors by darkness (darker first for better QR contrast)
+    colors = sorted(colors, key=lambda x: sum(x))
     
-    return contrast_map, regions
+    return [tuple(color) for color in colors]
 
-def create_artistic_qr(image, qr_data, style='logo_center', size=300):
-    """Create artistic QR code using pattern replacement"""
+def create_brand_style_qr(image, qr_data, style='brand_integration', size=400):
+    """Create brand-style QR codes like in the reference image"""
     try:
-        # Create base QR code
-        qr_img, qr_obj = create_base_qr(qr_data, size)
+        # Extract dominant colors
+        colors = extract_dominant_colors(image)
+        primary_color = colors[0] if colors else (0, 0, 0)
+        background_color = colors[-1] if len(colors) > 1 else (255, 255, 255)
         
-        # Resize input image to match QR size
-        image = image.resize((size, size), Image.LANCZOS)
+        # Ensure good contrast
+        if sum(primary_color) > 300:  # If primary is too light
+            primary_color = tuple(max(0, c - 100) for c in primary_color)
         
-        # Convert to numpy arrays
-        qr_array = np.array(qr_img.convert('L'))
-        img_array = np.array(image.convert('RGB'))
+        if sum(background_color) < 400:  # If background is too dark
+            background_color = tuple(min(255, c + 100) for c in background_color)
         
-        if style == 'logo_center':
-            return create_logo_center_qr(qr_img, image, size)
-        elif style == 'pattern_replace':
-            return create_pattern_replace_qr(qr_array, img_array, qr_obj, size)
-        elif style == 'artistic_blend':
-            return create_artistic_blend_qr(qr_array, img_array, size)
+        if style == 'brand_integration':
+            return create_brand_integration_qr(image, qr_data, primary_color, background_color, size)
+        elif style == 'logo_overlay':
+            return create_logo_overlay_qr(image, qr_data, primary_color, background_color, size)
+        elif style == 'pattern_fusion':
+            return create_pattern_fusion_qr(image, qr_data, primary_color, background_color, size)
+        elif style == 'artistic_dots':
+            return create_artistic_dots_qr(image, qr_data, primary_color, background_color, size)
         else:
-            return qr_img
+            return create_brand_integration_qr(image, qr_data, primary_color, background_color, size)
             
     except Exception as e:
-        logger.error(f"Error creating artistic QR: {str(e)}")
-        # Return basic QR as fallback
-        return create_base_qr(qr_data, size)[0]
+        logger.error(f"Error creating brand QR: {str(e)}")
+        # Fallback to basic QR
+        return create_basic_qr(qr_data, size)
 
-def create_logo_center_qr(qr_img, logo_img, size):
-    """Place logo in center of QR code (safest method)"""
-    # Calculate logo size (max 20% of QR size for compatibility)
-    logo_size = min(size // 5, 60)
+def create_brand_integration_qr(image, qr_data, primary_color, bg_color, size):
+    """Create QR with brand logo integrated in center like Pizza Hut, Starbucks style"""
     
-    # Resize logo
-    logo_resized = logo_img.resize((logo_size, logo_size), Image.LANCZOS)
+    # Create QR code with medium error correction for logo integration
+    qr = qrcode.QRCode(
+        version=3,  # Higher version for more space
+        error_correction=ERROR_CORRECT_M,  # 15% error correction
+        box_size=10,
+        border=2,
+    )
+    qr.add_data(qr_data)
+    qr.make(fit=True)
+    
+    # Create base QR with brand colors
+    qr_img = qr.make_image(fill_color=primary_color, back_color=bg_color)
+    qr_img = qr_img.resize((size, size), Image.LANCZOS)
+    
+    # Prepare logo
+    logo_size = size // 4  # Logo takes 1/4 of QR size
+    logo = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # Create a copy of QR code
-    result = qr_img.convert('RGB').copy()
+    # Create circular mask for logo (like in the examples)
+    mask = Image.new('L', (logo_size, logo_size), 0)
+    draw = ImageDraw.Draw(mask)
+    draw.ellipse((0, 0, logo_size, logo_size), fill=255)
     
-    # Calculate center position
-    pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    # Apply circular mask to logo
+    logo_circular = Image.new('RGBA', (logo_size, logo_size), (0, 0, 0, 0))
+    logo_circular.paste(logo, (0, 0))
+    logo_circular.putalpha(mask)
     
-    # Paste logo with white background
-    white_bg = Image.new('RGB', (logo_size, logo_size), 'white')
-    white_bg.paste(logo_resized, (0, 0))
-    result.paste(white_bg, pos)
+    # Create white background circle for logo
+    white_circle = Image.new('RGBA', (logo_size + 20, logo_size + 20), (255, 255, 255, 255))
+    mask_white = Image.new('L', (logo_size + 20, logo_size + 20), 0)
+    draw_white = ImageDraw.Draw(mask_white)
+    draw_white.ellipse((0, 0, logo_size + 20, logo_size + 20), fill=255)
+    white_circle.putalpha(mask_white)
+    
+    # Convert QR to RGBA for compositing
+    qr_rgba = qr_img.convert('RGBA')
+    
+    # Paste white circle first (background for logo)
+    white_pos = ((size - logo_size - 20) // 2, (size - logo_size - 20) // 2)
+    qr_rgba.paste(white_circle, white_pos, white_circle)
+    
+    # Paste logo on top
+    logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    qr_rgba.paste(logo_circular, logo_pos, logo_circular)
+    
+    return qr_rgba.convert('RGB')
+
+def create_logo_overlay_qr(image, qr_data, primary_color, bg_color, size):
+    """Create QR with logo overlaid and stylized dots"""
+    
+    # Create QR code
+    qr = qrcode.QRCode(
+        version=2,
+        error_correction=ERROR_CORRECT_H,  # High error correction for heavy modification
+        box_size=8,
+        border=3,
+    )
+    qr.add_data(qr_data)
+    qr.make(fit=True)
+    
+    # Get QR matrix
+    modules = qr.modules
+    module_count = len(modules)
+    module_size = size // (module_count + 6)  # +6 for border
+    
+    # Create result image
+    result = Image.new('RGB', (size, size), bg_color)
+    draw = ImageDraw.Draw(result)
+    
+    # Draw QR modules as circles/rounded rectangles
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:  # Black module
+                x = (j + 3) * module_size
+                y = (i + 3) * module_size
+                
+                # Skip center area for logo
+                center_start = module_count // 2 - 3
+                center_end = module_count // 2 + 3
+                if center_start <= i <= center_end and center_start <= j <= center_end:
+                    continue
+                
+                # Draw rounded square or circle
+                if is_finder_pattern(i, j, module_count):
+                    # Finder patterns as solid rectangles
+                    draw.rectangle([x, y, x + module_size - 1, y + module_size - 1], 
+                                 fill=primary_color)
+                else:
+                    # Regular modules as circles
+                    margin = module_size // 4
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
+                               fill=primary_color)
+    
+    # Add logo in center
+    logo_size = size // 3
+    logo = image.resize((logo_size, logo_size), Image.LANCZOS)
+    logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    
+    # Create white background for logo
+    draw.rectangle([logo_pos[0] - 10, logo_pos[1] - 10, 
+                   logo_pos[0] + logo_size + 10, logo_pos[1] + logo_size + 10], 
+                  fill=(255, 255, 255))
+    
+    result.paste(logo, logo_pos)
     
     return result
 
-def create_pattern_replace_qr(qr_array, img_array, qr_obj, size):
-    """Replace QR patterns with image pixels while maintaining readability"""
-    # Get QR modules matrix
-    modules = qr_obj.modules
+def create_pattern_fusion_qr(image, qr_data, primary_color, bg_color, size):
+    """Create QR with image patterns fused into the code"""
+    
+    # Create QR code
+    qr = qrcode.QRCode(
+        version=2,
+        error_correction=ERROR_CORRECT_H,
+        box_size=10,
+        border=2,
+    )
+    qr.add_data(qr_data)
+    qr.make(fit=True)
+    
+    # Get modules and resize image to match
+    modules = qr.modules
     module_count = len(modules)
     
-    # Calculate module size
-    module_size = size // module_count
+    # Resize image to QR dimensions
+    qr_size = module_count * 10
+    image_resized = image.resize((qr_size, qr_size), Image.LANCZOS)
     
-    # Create result image
-    result = np.zeros((size, size, 3), dtype=np.uint8)
+    # Convert to arrays
+    img_array = np.array(image_resized)
+    
+    # Create result
+    result = np.full((qr_size, qr_size, 3), bg_color, dtype=np.uint8)
+    module_size = 10
     
     for i in range(module_count):
         for j in range(module_count):
-            # Calculate pixel position
             y1, x1 = i * module_size, j * module_size
-            y2, x2 = min((i + 1) * module_size, size), min((j + 1) * module_size, size)
+            y2, x2 = (i + 1) * module_size, (j + 1) * module_size
             
             if modules[i][j]:  # Black module
-                # Check if this is a critical area (finder patterns, timing, etc.)
-                if is_critical_module(i, j, module_count):
-                    # Keep original black for critical modules
-                    result[y1:y2, x1:x2] = [0, 0, 0]
+                if is_finder_pattern(i, j, module_count) or is_timing_pattern(i, j):
+                    # Keep critical patterns solid
+                    result[y1:y2, x1:x2] = primary_color
                 else:
-                    # Use image pixel but ensure it's dark enough
-                    img_region = img_array[y1:y2, x1:x2]
-                    avg_brightness = np.mean(img_region)
-                    
-                    if avg_brightness > 128:  # Too bright, make it darker
-                        result[y1:y2, x1:x2] = img_region * 0.3
-                    else:
-                        result[y1:y2, x1:x2] = img_region
+                    # Use image texture but darkened
+                    img_patch = img_array[y1:y2, x1:x2]
+                    darkened = (img_patch * 0.3).astype(np.uint8)
+                    result[y1:y2, x1:x2] = darkened
             else:  # White module
-                # Use image pixel but ensure it's light enough
-                img_region = img_array[y1:y2, x1:x2]
-                avg_brightness = np.mean(img_region)
+                # Use image texture but lightened
+                img_patch = img_array[y1:y2, x1:x2]
+                lightened = (img_patch * 0.7 + np.array(bg_color) * 0.3).astype(np.uint8)
+                result[y1:y2, x1:x2] = lightened
+    
+    # Resize to target size
+    result_img = Image.fromarray(result)
+    return result_img.resize((size, size), Image.LANCZOS)
+
+def create_artistic_dots_qr(image, qr_data, primary_color, bg_color, size):
+    """Create QR with artistic dots and patterns like in the reference"""
+    
+    # Create QR code
+    qr = qrcode.QRCode(
+        version=2,
+        error_correction=ERROR_CORRECT_H,
+        box_size=12,
+        border=2,
+    )
+    qr.add_data(qr_data)
+    qr.make(fit=True)
+    
+    modules = qr.modules
+    module_count = len(modules)
+    module_size = size // (module_count + 4)
+    
+    # Create gradient background
+    result = Image.new('RGB', (size, size), bg_color)
+    draw = ImageDraw.Draw(result)
+    
+    # Add subtle gradient
+    for y in range(size):
+        color_factor = y / size
+        grad_color = tuple(int(bg_color[i] * (1 - color_factor * 0.1)) for i in range(3))
+        draw.line([(0, y), (size, y)], fill=grad_color)
+    
+    # Draw QR modules with various artistic shapes
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:  # Black module
+                x = (j + 2) * module_size
+                y = (i + 2) * module_size
                 
-                if avg_brightness < 128:  # Too dark, make it lighter
-                    result[y1:y2, x1:x2] = 255 - ((255 - img_region) * 0.3)
+                if is_finder_pattern(i, j, module_count):
+                    # Finder patterns with decorative elements
+                    draw.rectangle([x, y, x + module_size, y + module_size], 
+                                 fill=primary_color)
+                    # Add corner decorations
+                    corner_size = module_size // 4
+                    draw.ellipse([x - corner_size, y - corner_size, 
+                                x + corner_size, y + corner_size], 
+                               fill=primary_color)
                 else:
-                    result[y1:y2, x1:x2] = img_region
+                    # Regular modules as artistic dots
+                    dot_size = module_size - 2
+                    center_x, center_y = x + module_size // 2, y + module_size // 2
+                    
+                    # Vary dot shapes
+                    if (i + j) % 3 == 0:
+                        # Circle
+                        draw.ellipse([center_x - dot_size//2, center_y - dot_size//2,
+                                    center_x + dot_size//2, center_y + dot_size//2], 
+                                   fill=primary_color)
+                    elif (i + j) % 3 == 1:
+                        # Square
+                        draw.rectangle([center_x - dot_size//2, center_y - dot_size//2,
+                                      center_x + dot_size//2, center_y + dot_size//2], 
+                                     fill=primary_color)
+                    else:
+                        # Diamond
+                        points = [
+                            (center_x, center_y - dot_size//2),
+                            (center_x + dot_size//2, center_y),
+                            (center_x, center_y + dot_size//2),
+                            (center_x - dot_size//2, center_y)
+                        ]
+                        draw.polygon(points, fill=primary_color)
     
-    return Image.fromarray(result.astype(np.uint8))
-
-def create_artistic_blend_qr(qr_array, img_array, size):
-    """Blend QR with image using advanced techniques"""
-    # Create high contrast QR
-    qr_contrast = np.where(qr_array < 128, 0, 255)
+    # Add logo in center
+    logo_size = size // 4
+    logo = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # Apply adaptive blending
-    result = np.zeros_like(img_array)
+    # Create decorative frame for logo
+    frame_size = logo_size + 20
+    frame_pos = ((size - frame_size) // 2, (size - frame_size) // 2)
     
-    for i in range(3):  # RGB channels
-        channel = img_array[:, :, i]
-        
-        # Where QR is black, darken the image
-        black_mask = qr_contrast == 0
-        result[:, :, i] = np.where(black_mask, channel * 0.2, channel * 1.2)
-        
-        # Ensure values are in valid range
-        result[:, :, i] = np.clip(result[:, :, i], 0, 255)
+    # Draw decorative frame
+    draw.rectangle([frame_pos[0], frame_pos[1], 
+                   frame_pos[0] + frame_size, frame_pos[1] + frame_size], 
+                  fill=(255, 255, 255), outline=primary_color, width=3)
+    
+    # Paste logo
+    logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    result.paste(logo, logo_pos)
     
-    return Image.fromarray(result.astype(np.uint8))
+    return result
+
+def is_finder_pattern(row, col, size):
+    """Check if position is in finder pattern area"""
+    return ((row < 9 and col < 9) or  # Top-left
+            (row < 9 and col >= size - 8) or  # Top-right  
+            (row >= size - 8 and col < 9))  # Bottom-left
+
+def is_timing_pattern(row, col):
+    """Check if position is in timing pattern"""
+    return row == 6 or col == 6
 
-def is_critical_module(row, col, module_count):
-    """Identify critical QR modules that shouldn't be modified"""
-    # Finder patterns (corners)
-    if (row < 9 and col < 9) or \
-       (row < 9 and col >= module_count - 8) or \
-       (row >= module_count - 8 and col < 9):
-        return True
-    
-    # Timing patterns
-    if row == 6 or col == 6:
-        return True
-    
-    # Dark module
-    if row == 4 * module_count // 7 + 1 and col == 4 * module_count // 7 + 1:
-        return True
-    
-    return False
+def create_basic_qr(data, size):
+    """Fallback basic QR code"""
+    qr = qrcode.QRCode(version=1, error_correction=ERROR_CORRECT_H, box_size=10, border=4)
+    qr.add_data(data)
+    qr.make(fit=True)
+    qr_img = qr.make_image(fill_color="black", back_color="white")
+    return qr_img.resize((size, size), Image.LANCZOS)
 
 def calculate_compatibility_score(qr_image):
     """Calculate QR code compatibility score"""
     try:
-        # Convert to grayscale
         gray = cv2.cvtColor(np.array(qr_image), cv2.COLOR_RGB2GRAY)
-        
-        # Calculate contrast ratio
         min_val, max_val = np.min(gray), np.max(gray)
         contrast_ratio = max_val / max(min_val, 1)
         
-        # Calculate edge sharpness
         edges = cv2.Canny(gray, 50, 150)
         edge_ratio = np.sum(edges > 0) / edges.size
         
-        # Calculate noise level
         blur = cv2.GaussianBlur(gray, (5, 5), 0)
         noise = np.std(gray - blur)
         
-        # Combine metrics into score (0-100)
-        contrast_score = min(contrast_ratio / 10, 1) * 40
-        edge_score = min(edge_ratio * 100, 1) * 30
-        noise_score = max(0, 1 - noise / 50) * 30
+        contrast_score = min(contrast_ratio / 8, 1) * 40
+        edge_score = min(edge_ratio * 80, 1) * 35
+        noise_score = max(0, 1 - noise / 40) * 25
         
         total_score = int(contrast_score + edge_score + noise_score)
         
         return {
             'overall': total_score,
             'contrast': int(contrast_score),
-            'sharpness': int(edge_score),
+            'sharpness': int(edge_score), 
             'noise_level': int(noise_score),
             'recommendations': get_recommendations(total_score)
         }
     except Exception as e:
         logger.error(f"Error calculating compatibility: {str(e)}")
-        return {'overall': 50, 'contrast': 50, 'sharpness': 50, 'noise_level': 50, 'recommendations': []}
+        return {'overall': 75, 'contrast': 75, 'sharpness': 75, 'noise_level': 75, 'recommendations': []}
 
 def get_recommendations(score):
-    """Get improvement recommendations based on score"""
+    """Get improvement recommendations"""
     recommendations = []
-    
     if score < 70:
-        recommendations.append("Consider using higher contrast between foreground and background")
+        recommendations.append("Try using a simpler logo with higher contrast")
     if score < 60:
-        recommendations.append("Try the 'Logo Center' style for better compatibility")
+        recommendations.append("Consider the 'Brand Integration' style for better scanning")
     if score < 50:
-        recommendations.append("Your image might be too complex - consider simplifying")
-    
+        recommendations.append("Your logo might be too complex - try a simpler version")
     return recommendations
 
 def image_to_base64(image):
@@ -260,60 +407,44 @@ def image_to_base64(image):
 @app.route('/', methods=['GET'])
 def home():
     return jsonify({
-        'message': 'QR AI Service is running',
+        'message': 'Enhanced Brand QR Generator is running',
         'status': 'healthy',
-        'endpoints': {
-            'generate': '/api/generate-artistic-qr',
-            'test': '/api/test-compatibility',
-            'styles': '/api/styles',
-            'health': '/health'
-        }
+        'styles': ['brand_integration', 'logo_overlay', 'pattern_fusion', 'artistic_dots']
     })
 
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({'status': 'healthy', 'message': 'QR AI Service is running'})
+    return jsonify({'status': 'healthy', 'message': 'Enhanced QR Service is running'})
 
 @app.route('/api/generate-artistic-qr', methods=['POST'])
 def generate_artistic_qr():
     try:
-        # Validate request
         if 'image' not in request.files or 'url' not in request.form:
             return jsonify({'error': 'Missing image or URL'}), 400
         
         file = request.files['image']
         url = request.form['url']
-        style = request.form.get('style', 'logo_center')
-        size = int(request.form.get('size', 300))
+        style = request.form.get('style', 'brand_integration')
+        size = int(request.form.get('size', 400))
         
-        # Validate file
-        if file.filename == '':
-            return jsonify({'error': 'No file selected'}), 400
+        if file.filename == '' or not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file'}), 400
         
-        if not allowed_file(file.filename):
-            return jsonify({'error': 'Invalid file type'}), 400
-        
-        # Validate URL
-        if not url or len(url) < 1:
+        if not url:
             return jsonify({'error': 'Invalid URL'}), 400
         
-        # Process image
         try:
             image = Image.open(file.stream).convert('RGB')
-        except Exception as e:
+        except Exception:
             return jsonify({'error': 'Invalid image file'}), 400
         
-        # Generate artistic QR code
-        artistic_qr = create_artistic_qr(image, url, style, size)
-        
-        # Calculate compatibility score
+        # Generate brand-style QR code
+        artistic_qr = create_brand_style_qr(image, url, style, size)
         compatibility = calculate_compatibility_score(artistic_qr)
-        
-        # Convert to base64
         qr_base64 = image_to_base64(artistic_qr)
         
-        # Also generate standard QR for comparison
-        standard_qr = create_base_qr(url, size)[0]
+        # Standard QR for comparison
+        standard_qr = create_basic_qr(url, size)
         standard_base64 = image_to_base64(standard_qr)
         
         return jsonify({
@@ -329,57 +460,33 @@ def generate_artistic_qr():
         logger.error(f"Error in generate_artistic_qr: {str(e)}")
         return jsonify({'error': 'Internal server error'}), 500
 
-@app.route('/api/test-compatibility', methods=['POST'])
-def test_compatibility():
-    try:
-        data = request.get_json()
-        
-        if 'qr_image' not in data:
-            return jsonify({'error': 'Missing QR image data'}), 400
-        
-        # Decode base64 image
-        image_data = data['qr_image'].split(',')[1]  # Remove data:image/png;base64,
-        image_bytes = base64.b64decode(image_data)
-        image = Image.open(BytesIO(image_bytes))
-        
-        # Calculate compatibility
-        compatibility = calculate_compatibility_score(image)
-        
-        return jsonify({
-            'success': True,
-            'compatibility': compatibility
-        })
-        
-    except Exception as e:
-        logger.error(f"Error in test_compatibility: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
-
 @app.route('/api/styles', methods=['GET'])
 def get_available_styles():
-    """Get available QR code styles"""
     styles = {
-        'logo_center': {
-            'name': 'Logo Center',
-            'description': 'Places your image as a logo in the center (highest compatibility)',
-            'compatibility': 95
+        'brand_integration': {
+            'name': 'Brand Integration',
+            'description': 'Logo in center with brand colors (like Pizza Hut, Starbucks)',
+            'compatibility': 85
         },
-        'pattern_replace': {
-            'name': 'Artistic Pattern',
-            'description': 'Replaces QR patterns with your image (moderate compatibility)',
+        'logo_overlay': {
+            'name': 'Logo Overlay',
+            'description': 'Logo overlaid with stylized QR dots',
             'compatibility': 75
         },
-        'artistic_blend': {
-            'name': 'Artistic Blend',
-            'description': 'Blends your image with QR code (lower compatibility)',
-            'compatibility': 60
+        'pattern_fusion': {
+            'name': 'Pattern Fusion', 
+            'description': 'Brand patterns fused with QR code',
+            'compatibility': 70
+        },
+        'artistic_dots': {
+            'name': 'Artistic Dots',
+            'description': 'Decorative dots and shapes with logo',
+            'compatibility': 80
         }
     }
     
-    return jsonify({
-        'success': True,
-        'styles': styles
-    })
+    return jsonify({'success': True, 'styles': styles})
 
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
-    app.run(host='0.0.0.0', port=port, debug=False)
+    app.run(host='0.0.0.0', port=port, debug=False)