Update app.py

app.py

@@ -6,7 +6,7 @@ from flask import Flask, request, jsonify
 from flask_cors import CORS
 from PIL import Image, ImageEnhance, ImageFilter, ImageDraw, ImageFont
 import qrcode
-from qrcode.constants import ERROR_CORRECT_H, ERROR_CORRECT_M
+from qrcode.constants import ERROR_CORRECT_H, ERROR_CORRECT_M, ERROR_CORRECT_L
 import cv2
 from io import BytesIO
 import requests
@@ -14,6 +14,7 @@ from werkzeug.utils import secure_filename
 import logging
 from sklearn.cluster import KMeans
 import colorsys
+import math
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -29,314 +30,248 @@ 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 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))
-    
-    # Convert to RGB array
-    data = np.array(image_small)
-    data = data.reshape((-1, 3))
-    
-    # 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 [tuple(color) for color in colors]
-
-def create_brand_style_qr(image, qr_data, style='brand_integration', size=400):
-    """Create brand-style QR codes like in the reference image"""
+def create_background_logo_qr(image, qr_data, style='overlay_dots', size=400):
+    """Create QR with logo as background and dots on top (like reference image)"""
     try:
-        # 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)
+        # Create QR code with high error correction
+        qr = qrcode.QRCode(
+            version=4,  # Higher version for better logo visibility
+            error_correction=ERROR_CORRECT_H,  # 30% error correction
+            box_size=10,
+            border=4,
+        )
+        qr.add_data(qr_data)
+        qr.make(fit=True)
         
-        # 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)
+        # Get QR modules
+        modules = qr.modules
+        module_count = len(modules)
         
-        if sum(background_color) < 400:  # If background is too dark
-            background_color = tuple(min(255, c + 100) for c in background_color)
-        
-        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)
+        if style == 'overlay_dots':
+            return create_overlay_dots_style(image, modules, module_count, size)
+        elif style == 'pattern_overlay':
+            return create_pattern_overlay_style(image, modules, module_count, size)
+        elif style == 'artistic_overlay':
+            return create_artistic_overlay_style(image, modules, module_count, size)
         else:
-            return create_brand_integration_qr(image, qr_data, primary_color, background_color, size)
+            return create_overlay_dots_style(image, modules, module_count, size)
             
     except Exception as e:
-        logger.error(f"Error creating brand QR: {str(e)}")
-        # Fallback to basic QR
+        logger.error(f"Error creating background logo QR: {str(e)}")
         return create_basic_qr(qr_data, size)
 
-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"""
-    
-    # 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 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)
-    
-    # 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)
+def create_overlay_dots_style(image, modules, module_count, size):
+    """Create QR with logo background and black dots overlay (main style)"""
     
-    # 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)
+    # Step 1: Create background with logo
+    background = Image.new('RGB', (size, size), (255, 255, 255))
     
-    # Convert QR to RGBA for compositing
-    qr_rgba = qr_img.convert('RGBA')
+    # Resize logo to fill most of the background
+    logo_size = int(size * 0.6)  # Logo takes 60% of the area
+    logo_resized = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # 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
+    # Center the logo on white background
     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"""
+    background.paste(logo_resized, logo_pos)
     
-    # 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)
+    # Step 2: Add semi-transparent white overlay for better contrast
+    overlay = Image.new('RGBA', (size, size), (255, 255, 255, 180))  # Semi-transparent white
+    background_rgba = background.convert('RGBA')
+    background_with_overlay = Image.alpha_composite(background_rgba, overlay)
     
-    # Get QR matrix
-    modules = qr.modules
-    module_count = len(modules)
-    module_size = size // (module_count + 6)  # +6 for border
+    # Step 3: Calculate QR area (centered, leaving border space)
+    qr_area_size = int(size * 0.85)  # QR takes 85% of canvas
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
     
-    # Create result image
-    result = Image.new('RGB', (size, size), bg_color)
-    draw = ImageDraw.Draw(result)
+    # Step 4: Draw QR dots ON TOP of the background
+    draw = ImageDraw.Draw(background_with_overlay)
     
-    # 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
+            if modules[i][j]:  # This should be a black dot
+                x = qr_offset + j * module_size
+                y = qr_offset + i * 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
+                # Draw black dots/squares for QR data
                 if is_finder_pattern(i, j, module_count):
-                    # Finder patterns as solid rectangles
+                    # Finder patterns as solid black squares
                     draw.rectangle([x, y, x + module_size - 1, y + module_size - 1], 
-                                 fill=primary_color)
+                                 fill=(0, 0, 0), outline=(0, 0, 0))
+                elif is_timing_pattern(i, j):
+                    # Timing patterns as solid black
+                    draw.rectangle([x, y, x + module_size - 1, y + module_size - 1], 
+                                 fill=(0, 0, 0))
                 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)
+                    # Regular data modules as black dots
+                    dot_margin = module_size // 4
+                    draw.ellipse([x + dot_margin, y + dot_margin, 
+                                x + module_size - dot_margin, y + module_size - dot_margin], 
+                               fill=(0, 0, 0))
     
-    # 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)
+    # Step 5: Add decorative corner elements (like in reference)
+    add_corner_decorations(draw, size, (0, 0, 0))
     
-    # 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
+    return background_with_overlay.convert('RGB')
 
-def create_pattern_fusion_qr(image, qr_data, primary_color, bg_color, size):
-    """Create QR with image patterns fused into the code"""
+def create_pattern_overlay_style(image, modules, module_count, size):
+    """Create QR with logo background and various pattern overlays"""
     
-    # 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)
+    # Create background with logo pattern
+    background = Image.new('RGB', (size, size), (240, 240, 240))
+    
+    # Create tiled logo background
+    logo_tile_size = size // 3
+    logo_tile = image.resize((logo_tile_size, logo_tile_size), Image.LANCZOS)
     
-    # Get modules and resize image to match
-    modules = qr.modules
-    module_count = len(modules)
+    # Tile the logo across background
+    for i in range(3):
+        for j in range(3):
+            pos = (i * logo_tile_size, j * logo_tile_size)
+            background.paste(logo_tile, pos)
     
-    # Resize image to QR dimensions
-    qr_size = module_count * 10
-    image_resized = image.resize((qr_size, qr_size), Image.LANCZOS)
+    # Add white overlay for contrast
+    overlay = Image.new('RGBA', (size, size), (255, 255, 255, 200))
+    background_rgba = background.convert('RGBA')
+    background_with_overlay = Image.alpha_composite(background_rgba, overlay)
     
-    # Convert to arrays
-    img_array = np.array(image_resized)
+    # Draw QR pattern on top
+    qr_area_size = int(size * 0.8)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
     
-    # Create result
-    result = np.full((qr_size, qr_size, 3), bg_color, dtype=np.uint8)
-    module_size = 10
+    draw = ImageDraw.Draw(background_with_overlay)
     
     for i in range(module_count):
         for j in range(module_count):
-            y1, x1 = i * module_size, j * module_size
-            y2, x2 = (i + 1) * module_size, (j + 1) * module_size
-            
-            if modules[i][j]:  # Black module
-                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
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                if is_finder_pattern(i, j, module_count):
+                    # Finder patterns as solid rectangles
+                    draw.rectangle([x, y, x + module_size, y + module_size], 
+                                 fill=(0, 0, 0))
                 else:
-                    # 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 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
+                    # Data modules as various shapes
+                    shape_type = (i + j) % 3
+                    margin = module_size // 5
+                    
+                    if shape_type == 0:  # Circle
+                        draw.ellipse([x + margin, y + margin, 
+                                    x + module_size - margin, y + module_size - margin], 
+                                   fill=(0, 0, 0))
+                    elif shape_type == 1:  # Square
+                        draw.rectangle([x + margin, y + margin,
+                                      x + module_size - margin, y + module_size - margin],
+                                     fill=(0, 0, 0))
+                    else:  # Diamond
+                        center_x, center_y = x + module_size // 2, y + module_size // 2
+                        radius = module_size // 2 - margin
+                        points = [
+                            (center_x, center_y - radius),
+                            (center_x + radius, center_y),
+                            (center_x, center_y + radius),
+                            (center_x - radius, center_y)
+                        ]
+                        draw.polygon(points, fill=(0, 0, 0))
     
-    # Resize to target size
-    result_img = Image.fromarray(result)
-    return result_img.resize((size, size), Image.LANCZOS)
+    return background_with_overlay.convert('RGB')
 
-def create_artistic_dots_qr(image, qr_data, primary_color, bg_color, size):
-    """Create QR with artistic dots and patterns like in the reference"""
+def create_artistic_overlay_style(image, modules, module_count, size):
+    """Create artistic QR with logo background and creative dot patterns"""
     
-    # 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)
+    # Create gradient background
+    background = Image.new('RGB', (size, size), (255, 255, 255))
     
-    modules = qr.modules
-    module_count = len(modules)
-    module_size = size // (module_count + 4)
+    # Add logo with artistic effects
+    logo_size = int(size * 0.7)
+    logo_resized = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # Create gradient background
-    result = Image.new('RGB', (size, size), bg_color)
-    draw = ImageDraw.Draw(result)
+    # Apply artistic effects to logo
+    logo_enhanced = logo_resized.filter(ImageFilter.GaussianBlur(radius=1))
+    logo_enhanced = ImageEnhance.Brightness(logo_enhanced).enhance(1.2)
+    logo_enhanced = ImageEnhance.Contrast(logo_enhanced).enhance(0.8)
     
-    # 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)
+    # Center logo
+    logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    background.paste(logo_enhanced, logo_pos)
+    
+    # Add artistic white overlay with patterns
+    overlay = Image.new('RGBA', (size, size), (255, 255, 255, 160))
+    draw_overlay = ImageDraw.Draw(overlay)
+    
+    # Add subtle pattern to overlay
+    for i in range(0, size, 20):
+        for j in range(0, size, 20):
+            if (i + j) % 40 == 0:
+                draw_overlay.ellipse([i, j, i + 4, j + 4], fill=(255, 255, 255, 100))
+    
+    background_rgba = background.convert('RGBA')
+    background_with_overlay = Image.alpha_composite(background_rgba, overlay)
+    
+    # Draw artistic QR dots
+    qr_area_size = int(size * 0.82)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
+    
+    draw = ImageDraw.Draw(background_with_overlay)
     
-    # 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 modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
                 
                 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)
+                    # Artistic finder patterns
+                    draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                         radius=module_size // 4, fill=(0, 0, 0))
                 else:
-                    # Regular modules as artistic dots
-                    dot_size = module_size - 2
+                    # Artistic data dots
                     center_x, center_y = x + module_size // 2, y + module_size // 2
+                    dot_size = 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)
-    
-    # Add logo in center
-    logo_size = size // 4
-    logo = image.resize((logo_size, logo_size), Image.LANCZOS)
-    
-    # Create decorative frame for logo
-    frame_size = logo_size + 20
-    frame_pos = ((size - frame_size) // 2, (size - frame_size) // 2)
-    
-    # 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 result
+                    # Create artistic dot with small decorative elements
+                    draw.ellipse([center_x - dot_size//2, center_y - dot_size//2,
+                                center_x + dot_size//2, center_y + dot_size//2], 
+                               fill=(0, 0, 0))
+                    
+                    # Add tiny decorative dots around main dot
+                    if (i + j) % 5 == 0:
+                        for angle in [0, 90, 180, 270]:
+                            offset_x = int(2 * math.cos(math.radians(angle)))
+                            offset_y = int(2 * math.sin(math.radians(angle)))
+                            draw.ellipse([center_x + offset_x - 1, center_y + offset_y - 1,
+                                        center_x + offset_x + 1, center_y + offset_y + 1], 
+                                       fill=(0, 0, 0))
+    
+    # Add corner decorative elements
+    add_corner_decorations(draw, size, (0, 0, 0))
+    
+    return background_with_overlay.convert('RGB')
+
+def add_corner_decorations(draw, size, color):
+    """Add decorative corner elements like in the reference image"""
+    corner_size = 40
+    positions = [
+        (15, 15),           # Top-left
+        (size - 55, 15),    # Top-right
+        (15, size - 55),    # Bottom-left
+        (size - 55, size - 55)  # Bottom-right
+    ]
+    
+    for x, y in positions:
+        # Draw concentric circles
+        for radius in [8, 16, 24]:
+            draw.ellipse([x + corner_size//2 - radius, y + corner_size//2 - radius,
+                         x + corner_size//2 + radius, y + corner_size//2 + radius],
+                        outline=color, width=2)
+        
+        # Add center dot
+        center_x, center_y = x + corner_size//2, y + corner_size//2
+        draw.ellipse([center_x - 3, center_y - 3, center_x + 3, center_y + 3], 
+                    fill=color)
 
 def is_finder_pattern(row, col, size):
     """Check if position is in finder pattern area"""
@@ -360,18 +295,23 @@ def calculate_compatibility_score(qr_image):
     """Calculate QR code compatibility score"""
     try:
         gray = cv2.cvtColor(np.array(qr_image), cv2.COLOR_RGB2GRAY)
+        
+        # Contrast analysis
         min_val, max_val = np.min(gray), np.max(gray)
         contrast_ratio = max_val / max(min_val, 1)
         
+        # Edge detection for sharpness
         edges = cv2.Canny(gray, 50, 150)
         edge_ratio = np.sum(edges > 0) / edges.size
         
+        # Noise analysis
         blur = cv2.GaussianBlur(gray, (5, 5), 0)
         noise = np.std(gray - blur)
         
-        contrast_score = min(contrast_ratio / 8, 1) * 40
-        edge_score = min(edge_ratio * 80, 1) * 35
-        noise_score = max(0, 1 - noise / 40) * 25
+        # Calculate scores
+        contrast_score = min(contrast_ratio / 6, 1) * 40  # Adjusted for overlay style
+        edge_score = min(edge_ratio * 100, 1) * 35
+        noise_score = max(0, 1 - noise / 50) * 25
         
         total_score = int(contrast_score + edge_score + noise_score)
         
@@ -384,17 +324,17 @@ def calculate_compatibility_score(qr_image):
         }
     except Exception as e:
         logger.error(f"Error calculating compatibility: {str(e)}")
-        return {'overall': 75, 'contrast': 75, 'sharpness': 75, 'noise_level': 75, 'recommendations': []}
+        return {'overall': 80, 'contrast': 80, 'sharpness': 80, 'noise_level': 80, 'recommendations': []}
 
 def get_recommendations(score):
     """Get improvement recommendations"""
     recommendations = []
     if score < 70:
-        recommendations.append("Try using a simpler logo with higher contrast")
+        recommendations.append("Try the 'overlay_dots' style for better scanning")
     if score < 60:
-        recommendations.append("Consider the 'Brand Integration' style for better scanning")
+        recommendations.append("Your logo might need more contrast with the overlay")
     if score < 50:
-        recommendations.append("Your logo might be too complex - try a simpler version")
+        recommendations.append("Consider using a simpler logo or higher contrast version")
     return recommendations
 
 def image_to_base64(image):
@@ -407,14 +347,14 @@ def image_to_base64(image):
 @app.route('/', methods=['GET'])
 def home():
     return jsonify({
-        'message': 'Enhanced Brand QR Generator is running',
+        'message': 'Background Logo QR Generator is running',
         'status': 'healthy',
-        'styles': ['brand_integration', 'logo_overlay', 'pattern_fusion', 'artistic_dots']
+        'styles': ['overlay_dots', 'pattern_overlay', 'artistic_overlay']
     })
 
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({'status': 'healthy', 'message': 'Enhanced QR Service is running'})
+    return jsonify({'status': 'healthy', 'message': 'Background Logo QR Service is running'})
 
 @app.route('/api/generate-artistic-qr', methods=['POST'])
 def generate_artistic_qr():
@@ -424,8 +364,8 @@ def generate_artistic_qr():
         
         file = request.files['image']
         url = request.form['url']
-        style = request.form.get('style', 'brand_integration')
-        size = int(request.form.get('size', 400))
+        style = request.form.get('style', 'overlay_dots')
+        size = int(request.form.get('size', 500))
         
         if file.filename == '' or not allowed_file(file.filename):
             return jsonify({'error': 'Invalid file'}), 400
@@ -438,8 +378,8 @@ def generate_artistic_qr():
         except Exception:
             return jsonify({'error': 'Invalid image file'}), 400
         
-        # Generate brand-style QR code
-        artistic_qr = create_brand_style_qr(image, url, style, size)
+        # Generate background logo QR code (correct style)
+        artistic_qr = create_background_logo_qr(image, url, style, size)
         compatibility = calculate_compatibility_score(artistic_qr)
         qr_base64 = image_to_base64(artistic_qr)
         
@@ -458,30 +398,25 @@ def generate_artistic_qr():
         
     except Exception as e:
         logger.error(f"Error in generate_artistic_qr: {str(e)}")
-        return jsonify({'error': 'Internal server error'}), 500
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
 
 @app.route('/api/styles', methods=['GET'])
 def get_available_styles():
     styles = {
-        'brand_integration': {
-            'name': 'Brand Integration',
-            'description': 'Logo in center with brand colors (like Pizza Hut, Starbucks)',
-            'compatibility': 85
-        },
-        'logo_overlay': {
-            'name': 'Logo Overlay',
-            'description': 'Logo overlaid with stylized QR dots',
-            'compatibility': 75
+        'overlay_dots': {
+            'name': 'Overlay Dots',
+            'description': 'Logo background with black dots overlay (like Pizza Hut, Starbucks)',
+            'compatibility': 95
         },
-        'pattern_fusion': {
-            'name': 'Pattern Fusion', 
-            'description': 'Brand patterns fused with QR code',
-            'compatibility': 70
+        'pattern_overlay': {
+            'name': 'Pattern Overlay',
+            'description': 'Tiled logo background with varied QR patterns',
+            'compatibility': 90
         },
-        'artistic_dots': {
-            'name': 'Artistic Dots',
-            'description': 'Decorative dots and shapes with logo',
-            'compatibility': 80
+        'artistic_overlay': {
+            'name': 'Artistic Overlay',
+            'description': 'Enhanced logo background with artistic QR elements',
+            'compatibility': 88
         }
     }