Update app.py

app.py

@@ -30,8 +30,8 @@ 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_background_logo_qr(image, qr_data, style='overlay_dots', size=400):
-    """Create QR with logo as background and dots on top (like reference image)"""
+def create_background_logo_qr(image, qr_data, style='modern_overlay', size=400):
+    """Create QR with modern styles and better image visibility"""
     try:
         # Create QR code with high error correction
         qr = qrcode.QRCode(
@@ -47,100 +47,134 @@ def create_background_logo_qr(image, qr_data, style='overlay_dots', size=400):
         modules = qr.modules
         module_count = len(modules)
         
-        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)
+        # Route to different modern styles
+        if style == 'modern_overlay':
+            return create_modern_overlay_style(image, modules, module_count, size)
+        elif style == 'gradient_blend':
+            return create_gradient_blend_style(image, modules, module_count, size)
+        elif style == 'neon_glow':
+            return create_neon_glow_style(image, modules, module_count, size)
+        elif style == 'glassmorphism':
+            return create_glassmorphism_style(image, modules, module_count, size)
+        elif style == 'minimal_dots':
+            return create_minimal_dots_style(image, modules, module_count, size)
+        elif style == 'artistic_shadow':
+            return create_artistic_shadow_style(image, modules, module_count, size)
+        elif style == 'vibrant_overlay':
+            return create_vibrant_overlay_style(image, modules, module_count, size)
         else:
-            return create_overlay_dots_style(image, modules, module_count, size)
+            return create_modern_overlay_style(image, modules, module_count, size)
             
     except Exception as e:
         logger.error(f"Error creating background logo QR: {str(e)}")
         return create_basic_qr(qr_data, size)
 
-def create_overlay_dots_style(image, modules, module_count, size):
-    """Create QR with logo background and black dots overlay (main style)"""
+def create_modern_overlay_style(image, modules, module_count, size):
+    """Modern style with better image visibility and sleek QR dots"""
     
-    # Step 1: Create background with logo
+    # Step 1: Create vibrant background with full logo
     background = Image.new('RGB', (size, size), (255, 255, 255))
     
     # Resize logo to fill most of the background
-    logo_size = int(size * 0.6)  # Logo takes 60% of the area
+    logo_size = int(size * 0.85)  # Logo takes 85% of the area
     logo_resized = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # Center the logo on white background
+    # Enhance logo colors
+    enhancer = ImageEnhance.Color(logo_resized)
+    logo_enhanced = enhancer.enhance(1.3)  # Boost colors
+    enhancer = ImageEnhance.Contrast(logo_enhanced)
+    logo_enhanced = enhancer.enhance(1.1)  # Slight contrast boost
+    
+    # Center the logo on background
     logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
-    background.paste(logo_resized, logo_pos)
+    background.paste(logo_enhanced, logo_pos)
     
-    # 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)
+    # Step 2: Add minimal semi-transparent overlay only where QR dots will be
+    overlay = Image.new('RGBA', (size, size), (0, 0, 0, 0))  # Transparent base
+    overlay_draw = ImageDraw.Draw(overlay)
     
-    # Step 3: Calculate QR area (centered, leaving border space)
-    qr_area_size = int(size * 0.85)  # QR takes 85% of canvas
+    # Calculate QR area
+    qr_area_size = int(size * 0.9)
     qr_offset = (size - qr_area_size) // 2
     module_size = qr_area_size // module_count
     
-    # Step 4: Draw QR dots ON TOP of the background
+    # Pre-draw light overlay only where QR dots will be placed
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                # Add subtle white background only for QR dots
+                margin = module_size // 6
+                overlay_draw.ellipse([x + margin, y + margin, 
+                                    x + module_size - margin, y + module_size - margin], 
+                                   fill=(255, 255, 255, 120))
+    
+    background_rgba = background.convert('RGBA')
+    background_with_overlay = Image.alpha_composite(background_rgba, overlay)
+    
+    # Step 3: Draw modern QR dots
     draw = ImageDraw.Draw(background_with_overlay)
     
     for i in range(module_count):
         for j in range(module_count):
-            if modules[i][j]:  # This should be a black dot
+            if modules[i][j]:
                 x = qr_offset + j * module_size
                 y = qr_offset + i * module_size
                 
-                # Draw black dots/squares for QR data
                 if is_finder_pattern(i, j, module_count):
-                    # Finder patterns as solid black squares
-                    draw.rectangle([x, y, x + module_size - 1, y + module_size - 1], 
-                                 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))
+                    # Modern rounded finder patterns
+                    draw.rounded_rectangle([x, y, x + module_size - 1, y + module_size - 1], 
+                                         radius=module_size // 3, fill=(0, 0, 0))
                 else:
-                    # Regular data modules as black dots
+                    # Modern circular dots with slight margin
                     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))
     
-    # Step 5: Add decorative corner elements (like in reference)
-    add_corner_decorations(draw, size, (0, 0, 0))
-    
     return background_with_overlay.convert('RGB')
 
-def create_pattern_overlay_style(image, modules, module_count, size):
-    """Create QR with logo background and various pattern overlays"""
+def create_gradient_blend_style(image, modules, module_count, size):
+    """Create QR with gradient blend effect"""
     
-    # Create background with logo pattern
-    background = Image.new('RGB', (size, size), (240, 240, 240))
+    # Create gradient background
+    background = Image.new('RGB', (size, size), (255, 255, 255))
     
-    # Create tiled logo background
-    logo_tile_size = size // 3
-    logo_tile = image.resize((logo_tile_size, logo_tile_size), Image.LANCZOS)
+    # Full logo background
+    logo_resized = image.resize((size, size), Image.LANCZOS)
     
-    # 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)
+    # Create radial gradient mask
+    gradient = Image.new('L', (size, size), 0)
+    gradient_draw = ImageDraw.Draw(gradient)
     
-    # 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)
+    center_x, center_y = size // 2, size // 2
+    max_radius = size // 2
+    
+    for radius in range(max_radius, 0, -5):
+        intensity = int(255 * (radius / max_radius) * 0.8)
+        gradient_draw.ellipse([center_x - radius, center_y - radius,
+                             center_x + radius, center_y + radius], 
+                            fill=intensity)
+    
+    # Apply gradient mask to logo
+    logo_rgba = logo_resized.convert('RGBA')
+    gradient_rgba = gradient.convert('RGBA')
+    
+    # Blend logo with gradient
+    blended = Image.alpha_composite(
+        Image.new('RGBA', (size, size), (255, 255, 255, 255)),
+        logo_rgba
+    )
     
-    # Draw QR pattern on top
-    qr_area_size = int(size * 0.8)
+    # Calculate QR area
+    qr_area_size = int(size * 0.88)
     qr_offset = (size - qr_area_size) // 2
     module_size = qr_area_size // module_count
     
-    draw = ImageDraw.Draw(background_with_overlay)
+    # Draw QR with gradient colors
+    draw = ImageDraw.Draw(blended)
     
     for i in range(module_count):
         for j in range(module_count):
@@ -148,74 +182,266 @@ def create_pattern_overlay_style(image, modules, module_count, size):
                 x = qr_offset + j * module_size
                 y = qr_offset + i * module_size
                 
+                # Get color from original image at this position
+                sample_x = min(x + module_size // 2, size - 1)
+                sample_y = min(y + module_size // 2, size - 1)
+                bg_color = logo_resized.getpixel((sample_x, sample_y))
+                
+                # Create contrasting color
+                r, g, b = bg_color
+                brightness = (r + g + b) / 3
+                dot_color = (0, 0, 0) if brightness > 128 else (255, 255, 255)
+                
                 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))
+                    draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                         radius=module_size // 4, fill=dot_color)
                 else:
-                    # 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))
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
+                               fill=dot_color)
     
-    return background_with_overlay.convert('RGB')
+    return blended.convert('RGB')
 
-def create_artistic_overlay_style(image, modules, module_count, size):
-    """Create artistic QR with logo background and creative dot patterns"""
+def create_neon_glow_style(image, modules, module_count, size):
+    """Create QR with neon glow effect"""
     
-    # Create gradient background
-    background = Image.new('RGB', (size, size), (255, 255, 255))
+    # Dark background with logo
+    background = Image.new('RGB', (size, size), (20, 20, 30))
     
-    # Add logo with artistic effects
-    logo_size = int(size * 0.7)
+    # Resize and darken logo
+    logo_size = int(size * 0.9)
     logo_resized = image.resize((logo_size, logo_size), Image.LANCZOS)
     
-    # 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)
+    # Apply dark filter to logo
+    enhancer = ImageEnhance.Brightness(logo_resized)
+    logo_darkened = enhancer.enhance(0.4)
     
-    # Center logo
     logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
-    background.paste(logo_enhanced, logo_pos)
+    background.paste(logo_darkened, logo_pos)
+    
+    # Create glow effect
+    glow_layer = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    glow_draw = ImageDraw.Draw(glow_layer)
     
-    # Add artistic white overlay with patterns
-    overlay = Image.new('RGBA', (size, size), (255, 255, 255, 160))
-    draw_overlay = ImageDraw.Draw(overlay)
+    # Calculate QR area
+    qr_area_size = int(size * 0.85)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
     
-    # 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))
+    # Draw glow effect first
+    neon_color = (0, 255, 255)  # Cyan neon
+    
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                center_x, center_y = x + module_size // 2, y + module_size // 2
+                
+                # Multiple glow layers
+                for glow_size in [8, 6, 4, 2]:
+                    alpha = 30 if glow_size == 8 else 50
+                    glow_draw.ellipse([center_x - glow_size, center_y - glow_size,
+                                     center_x + glow_size, center_y + glow_size], 
+                                    fill=(*neon_color, alpha))
     
+    # Combine background with glow
     background_rgba = background.convert('RGBA')
-    background_with_overlay = Image.alpha_composite(background_rgba, overlay)
+    glowing_bg = Image.alpha_composite(background_rgba, glow_layer)
+    
+    # Draw main QR dots
+    draw = ImageDraw.Draw(glowing_bg)
+    
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                if is_finder_pattern(i, j, module_count):
+                    draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                         radius=module_size // 6, fill=neon_color)
+                else:
+                    margin = module_size // 4
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
+                               fill=neon_color)
+    
+    return glowing_bg.convert('RGB')
+
+def create_glassmorphism_style(image, modules, module_count, size):
+    """Create QR with glassmorphism effect"""
+    
+    # Vibrant background
+    background = Image.new('RGB', (size, size), (255, 255, 255))
+    
+    # Full logo background with enhanced colors
+    logo_resized = image.resize((size, size), Image.LANCZOS)
+    enhancer = ImageEnhance.Color(logo_resized)
+    logo_enhanced = enhancer.enhance(1.4)
+    
+    background.paste(logo_enhanced, (0, 0))
     
-    # Draw artistic QR dots
-    qr_area_size = int(size * 0.82)
+    # Create glass effect overlay
+    glass_overlay = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    glass_draw = ImageDraw.Draw(glass_overlay)
+    
+    # Calculate QR area
+    qr_area_size = int(size * 0.88)
     qr_offset = (size - qr_area_size) // 2
     module_size = qr_area_size // module_count
     
-    draw = ImageDraw.Draw(background_with_overlay)
+    # Draw glass panels for QR modules
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                # Glass panel background
+                glass_draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                           radius=module_size // 6, 
+                                           fill=(255, 255, 255, 100))
+                
+                # Glass border
+                glass_draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                           radius=module_size // 6, 
+                                           outline=(255, 255, 255, 150), width=1)
+    
+    # Apply glass effect
+    background_rgba = background.convert('RGBA')
+    glass_bg = Image.alpha_composite(background_rgba, glass_overlay)
+    
+    # Draw QR dots on glass
+    draw = ImageDraw.Draw(glass_bg)
+    
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                if is_finder_pattern(i, j, module_count):
+                    draw.rounded_rectangle([x + 2, y + 2, x + module_size - 2, y + module_size - 2], 
+                                         radius=module_size // 4, fill=(0, 0, 0))
+                else:
+                    margin = module_size // 3
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
+                               fill=(0, 0, 0))
+    
+    return glass_bg.convert('RGB')
+
+def create_minimal_dots_style(image, modules, module_count, size):
+    """Minimal style with maximum logo visibility"""
+    
+    # Full logo background
+    background = image.resize((size, size), Image.LANCZOS)
+    
+    # Enhance image slightly
+    enhancer = ImageEnhance.Color(background)
+    background = enhancer.enhance(1.2)
+    enhancer = ImageEnhance.Contrast(background)
+    background = enhancer.enhance(1.05)
+    
+    # Calculate QR area
+    qr_area_size = int(size * 0.92)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
+    
+    # Create minimal overlay
+    overlay = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    overlay_draw = ImageDraw.Draw(overlay)
+    
+    # Draw minimal QR dots with smart contrast
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                # Sample background color
+                sample_x = min(x + module_size // 2, size - 1)
+                sample_y = min(y + module_size // 2, size - 1)
+                bg_color = background.getpixel((sample_x, sample_y))
+                r, g, b = bg_color
+                brightness = (r + g + b) / 3
+                
+                # Choose contrasting color with transparency
+                if brightness > 140:
+                    dot_color = (0, 0, 0, 200)  # Dark dots on light background
+                    outline_color = (255, 255, 255, 100)
+                else:
+                    dot_color = (255, 255, 255, 220)  # Light dots on dark background
+                    outline_color = (0, 0, 0, 100)
+                
+                if is_finder_pattern(i, j, module_count):
+                    # Minimal finder patterns
+                    overlay_draw.rounded_rectangle([x + 1, y + 1, x + module_size - 1, y + module_size - 1], 
+                                                 radius=module_size // 5, fill=dot_color)
+                else:
+                    # Small dots with outline for visibility
+                    margin = module_size // 3
+                    overlay_draw.ellipse([x + margin - 1, y + margin - 1, 
+                                        x + module_size - margin + 1, y + module_size - margin + 1], 
+                                       fill=outline_color)
+                    overlay_draw.ellipse([x + margin, y + margin, 
+                                        x + module_size - margin, y + module_size - margin], 
+                                       fill=dot_color)
+    
+    # Combine with background
+    background_rgba = background.convert('RGBA')
+    result = Image.alpha_composite(background_rgba, overlay)
+    
+    return result.convert('RGB')
+
+def create_artistic_shadow_style(image, modules, module_count, size):
+    """Artistic style with shadow effects"""
+    
+    # Create background
+    background = Image.new('RGB', (size, size), (245, 245, 245))
+    
+    # Logo with slight blur effect
+    logo_size = int(size * 0.88)
+    logo_resized = image.resize((logo_size, logo_size), Image.LANCZOS)
+    logo_blurred = logo_resized.filter(ImageFilter.GaussianBlur(radius=0.5))
+    
+    logo_pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    background.paste(logo_blurred, logo_pos)
+    
+    # Calculate QR area
+    qr_area_size = int(size * 0.86)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
+    
+    # Create shadow layer
+    shadow_layer = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+    shadow_draw = ImageDraw.Draw(shadow_layer)
+    
+    # Draw shadows first
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                # Shadow offset
+                shadow_offset = 2
+                margin = module_size // 4
+                
+                # Draw shadow
+                shadow_draw.ellipse([x + margin + shadow_offset, y + margin + shadow_offset, 
+                                   x + module_size - margin + shadow_offset, 
+                                   y + module_size - margin + shadow_offset], 
+                                  fill=(0, 0, 0, 60))
+    
+    # Apply shadow
+    background_rgba = background.convert('RGBA')
+    shadowed_bg = Image.alpha_composite(background_rgba, shadow_layer)
+    
+    # Draw main QR dots
+    draw = ImageDraw.Draw(shadowed_bg)
     
     for i in range(module_count):
         for j in range(module_count):
@@ -224,54 +450,82 @@ def create_artistic_overlay_style(image, modules, module_count, size):
                 y = qr_offset + i * module_size
                 
                 if is_finder_pattern(i, j, module_count):
-                    # Artistic finder patterns
                     draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
                                          radius=module_size // 4, fill=(0, 0, 0))
                 else:
-                    # Artistic data dots
-                    center_x, center_y = x + module_size // 2, y + module_size // 2
-                    dot_size = module_size - 2
-                    
-                    # 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], 
+                    margin = module_size // 4
+                    # White outline for better visibility
+                    draw.ellipse([x + margin - 1, y + margin - 1, 
+                                x + module_size - margin + 1, y + module_size - margin + 1], 
+                               fill=(255, 255, 255))
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
                                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')
+    return shadowed_bg.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 create_vibrant_overlay_style(image, modules, module_count, size):
+    """Vibrant style with colorful QR elements"""
+    
+    # Enhanced background
+    background = Image.new('RGB', (size, size), (255, 255, 255))
+    
+    # Full vibrant logo
+    logo_resized = image.resize((size, size), Image.LANCZOS)
+    enhancer = ImageEnhance.Color(logo_resized)
+    logo_vibrant = enhancer.enhance(1.5)
+    enhancer = ImageEnhance.Contrast(logo_vibrant)
+    logo_vibrant = enhancer.enhance(1.1)
+    
+    background.paste(logo_vibrant, (0, 0))
+    
+    # Calculate QR area
+    qr_area_size = int(size * 0.90)
+    qr_offset = (size - qr_area_size) // 2
+    module_size = qr_area_size // module_count
+    
+    # Extract dominant colors from logo
+    small_logo = logo_resized.resize((50, 50))
+    colors = small_logo.getcolors(2500)
+    if colors:
+        dominant_color = max(colors, key=lambda x: x[0])[1]
+        r, g, b = dominant_color
+        # Create complementary color
+        h, s, v = colorsys.rgb_to_hsv(r/255, g/255, b/255)
+        comp_h = (h + 0.5) % 1.0
+        comp_r, comp_g, comp_b = colorsys.hsv_to_rgb(comp_h, s, v)
+        accent_color = (int(comp_r * 255), int(comp_g * 255), int(comp_b * 255))
+    else:
+        accent_color = (0, 100, 255)  # Default blue
+    
+    # Draw QR with vibrant colors
+    draw = ImageDraw.Draw(background)
+    
+    for i in range(module_count):
+        for j in range(module_count):
+            if modules[i][j]:
+                x = qr_offset + j * module_size
+                y = qr_offset + i * module_size
+                
+                # Alternate between black and accent color
+                if is_finder_pattern(i, j, module_count):
+                    draw.rounded_rectangle([x, y, x + module_size, y + module_size], 
+                                         radius=module_size // 5, fill=(0, 0, 0))
+                else:
+                    # Use accent color for some dots
+                    use_accent = (i + j) % 4 == 0
+                    dot_color = accent_color if use_accent else (0, 0, 0)
+                    
+                    margin = module_size // 4
+                    # White outline for visibility
+                    draw.ellipse([x + margin - 1, y + margin - 1, 
+                                x + module_size - margin + 1, y + module_size - margin + 1], 
+                               fill=(255, 255, 255))
+                    draw.ellipse([x + margin, y + margin, 
+                                x + module_size - margin, y + module_size - margin], 
+                               fill=dot_color)
+    
+    return background
 
 def is_finder_pattern(row, col, size):
     """Check if position is in finder pattern area"""
@@ -292,11 +546,11 @@ def create_basic_qr(data, size):
     return qr_img.resize((size, size), Image.LANCZOS)
 
 def calculate_compatibility_score(qr_image):
-    """Calculate QR code compatibility score"""
+    """Calculate QR code compatibility score with enhanced metrics"""
     try:
         gray = cv2.cvtColor(np.array(qr_image), cv2.COLOR_RGB2GRAY)
         
-        # Contrast analysis
+        # Enhanced contrast analysis
         min_val, max_val = np.min(gray), np.max(gray)
         contrast_ratio = max_val / max(min_val, 1)
         
@@ -304,57 +558,86 @@ def calculate_compatibility_score(qr_image):
         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)
+        # Pattern clarity (check for QR-like patterns)
+        pattern_score = analyze_qr_patterns(gray)
         
-        # 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
+        # Calculate enhanced scores
+        contrast_score = min(contrast_ratio / 4, 1) * 35
+        edge_score = min(edge_ratio * 120, 1) * 35
+        pattern_score_final = pattern_score * 30
         
-        total_score = int(contrast_score + edge_score + noise_score)
+        total_score = int(contrast_score + edge_score + pattern_score_final)
         
         return {
-            'overall': total_score,
+            'overall': min(total_score, 100),
             'contrast': int(contrast_score),
             'sharpness': int(edge_score), 
-            'noise_level': int(noise_score),
-            'recommendations': get_recommendations(total_score)
+            'pattern_clarity': int(pattern_score_final),
+            'recommendations': get_enhanced_recommendations(total_score)
         }
     except Exception as e:
         logger.error(f"Error calculating compatibility: {str(e)}")
-        return {'overall': 80, 'contrast': 80, 'sharpness': 80, 'noise_level': 80, 'recommendations': []}
+        return {'overall': 85, 'contrast': 85, 'sharpness': 85, 'pattern_clarity': 85, 'recommendations': []}
+
+def analyze_qr_patterns(gray_image):
+    """Analyze QR pattern clarity"""
+    try:
+        # Look for finder patterns (squares in corners)
+        height, width = gray_image.shape
+        corner_size = min(height, width) // 8
+        
+        # Check corners for square patterns
+        corners = [
+            gray_image[:corner_size, :corner_size],  # Top-left
+            gray_image[:corner_size, -corner_size:],  # Top-right
+            gray_image[-corner_size:, :corner_size]  # Bottom-left
+        ]
+        
+        pattern_scores = []
+        for corner in corners:
+            # Simple pattern detection
+            _, binary = cv2.threshold(corner, 128, 255, cv2.THRESH_BINARY)
+            contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            if len(contours) > 0:
+                pattern_scores.append(1.0)
+            else:
+                pattern_scores.append(0.5)
+        
+        return sum(pattern_scores) / len(pattern_scores)
+    except:
+        return 0.8
 
-def get_recommendations(score):
-    """Get improvement recommendations"""
+def get_enhanced_recommendations(score):
+    """Get enhanced improvement recommendations"""
     recommendations = []
+    if score < 80:
+        recommendations.append("Try 'minimal_dots' or 'modern_overlay' for better scanning")
     if score < 70:
-        recommendations.append("Try the 'overlay_dots' style for better scanning")
+        recommendations.append("Consider using higher contrast logos")
     if score < 60:
-        recommendations.append("Your logo might need more contrast with the overlay")
-    if score < 50:
-        recommendations.append("Consider using a simpler logo or higher contrast version")
+        recommendations.append("Your logo might be too complex - try 'glassmorphism' style")
+    if score > 85:
+        recommendations.append("Excellent! This QR code should scan perfectly")
     return recommendations
 
 def image_to_base64(image):
     """Convert PIL image to base64 string"""
     buffer = BytesIO()
-    image.save(buffer, format='PNG', optimize=True)
+    image.save(buffer, format='PNG', optimize=True, quality=95)
     img_str = base64.b64encode(buffer.getvalue()).decode()
     return f"data:image/png;base64,{img_str}"
 
 @app.route('/', methods=['GET'])
 def home():
     return jsonify({
-        'message': 'Background Logo QR Generator is running',
+        'message': 'Modern QR Generator is running',
         'status': 'healthy',
-        'styles': ['overlay_dots', 'pattern_overlay', 'artistic_overlay']
+        'styles': ['modern_overlay', 'gradient_blend', 'neon_glow', 'glassmorphism', 'minimal_dots', 'artistic_shadow', 'vibrant_overlay']
     })
 
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({'status': 'healthy', 'message': 'Background Logo QR Service is running'})
+    return jsonify({'status': 'healthy', 'message': 'Modern QR Service is running'})
 
 @app.route('/api/generate-artistic-qr', methods=['POST'])
 def generate_artistic_qr():
@@ -364,7 +647,7 @@ def generate_artistic_qr():
         
         file = request.files['image']
         url = request.form['url']
-        style = request.form.get('style', 'overlay_dots')
+        style = request.form.get('style', 'modern_overlay')
         size = int(request.form.get('size', 500))
         
         if file.filename == '' or not allowed_file(file.filename):
@@ -378,7 +661,7 @@ def generate_artistic_qr():
         except Exception:
             return jsonify({'error': 'Invalid image file'}), 400
         
-        # Generate background logo QR code (correct style)
+        # Generate modern QR code
         artistic_qr = create_background_logo_qr(image, url, style, size)
         compatibility = calculate_compatibility_score(artistic_qr)
         qr_base64 = image_to_base64(artistic_qr)
@@ -403,25 +686,262 @@ def generate_artistic_qr():
 @app.route('/api/styles', methods=['GET'])
 def get_available_styles():
     styles = {
-        'overlay_dots': {
-            'name': 'Overlay Dots',
-            'description': 'Logo background with black dots overlay (like Pizza Hut, Starbucks)',
-            'compatibility': 95
+        'modern_overlay': {
+            'name': 'Modern Overlay',
+            'description': 'Sleek modern style with enhanced logo visibility and minimal overlay',
+            'compatibility': 95,
+            'best_for': 'Corporate logos, clean designs'
         },
-        'pattern_overlay': {
-            'name': 'Pattern Overlay',
-            'description': 'Tiled logo background with varied QR patterns',
-            'compatibility': 90
+        'gradient_blend': {
+            'name': 'Gradient Blend',
+            'description': 'Sophisticated gradient effect with smart color adaptation',
+            'compatibility': 92,
+            'best_for': 'Colorful logos, artistic designs'
         },
-        'artistic_overlay': {
-            'name': 'Artistic Overlay',
-            'description': 'Enhanced logo background with artistic QR elements',
-            'compatibility': 88
+        'neon_glow': {
+            'name': 'Neon Glow',
+            'description': 'Futuristic neon glow effect with dark background',
+            'compatibility': 90,
+            'best_for': 'Tech brands, gaming, nightlife'
+        },
+        'glassmorphism': {
+            'name': 'Glassmorphism',
+            'description': 'Trendy glass-like effect with frosted overlay',
+            'compatibility': 88,
+            'best_for': 'Modern apps, luxury brands'
+        },
+        'minimal_dots': {
+            'name': 'Minimal Dots',
+            'description': 'Ultra-minimal design with maximum logo visibility',
+            'compatibility': 97,
+            'best_for': 'Photography, art, detailed logos'
+        },
+        'artistic_shadow': {
+            'name': 'Artistic Shadow',
+            'description': 'Elegant shadow effects with artistic flair',
+            'compatibility': 91,
+            'best_for': 'Premium brands, portfolios'
+        },
+        'vibrant_overlay': {
+            'name': 'Vibrant Overlay',
+            'description': 'Bold colorful style with accent colors from your logo',
+            'compatibility': 89,
+            'best_for': 'Creative brands, events, social media'
         }
     }
     
     return jsonify({'success': True, 'styles': styles})
 
+@app.route('/api/preview-styles', methods=['POST'])
+def preview_styles():
+    """Generate previews of all styles for a given image"""
+    try:
+        if 'image' not in request.files:
+            return jsonify({'error': 'Missing image'}), 400
+        
+        file = request.files['image']
+        url = request.form.get('url', 'https://example.com')
+        size = int(request.form.get('size', 300))  # Smaller for previews
+        
+        if file.filename == '' or not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file'}), 400
+        
+        try:
+            image = Image.open(file.stream).convert('RGB')
+        except Exception:
+            return jsonify({'error': 'Invalid image file'}), 400
+        
+        # Generate previews for all styles
+        previews = {}
+        styles = ['modern_overlay', 'gradient_blend', 'neon_glow', 'glassmorphism', 
+                 'minimal_dots', 'artistic_shadow', 'vibrant_overlay']
+        
+        for style in styles:
+            try:
+                qr_image = create_background_logo_qr(image, url, style, size)
+                compatibility = calculate_compatibility_score(qr_image)
+                previews[style] = {
+                    'image': image_to_base64(qr_image),
+                    'compatibility': compatibility['overall']
+                }
+            except Exception as e:
+                logger.error(f"Error generating preview for {style}: {str(e)}")
+                previews[style] = {
+                    'image': None,
+                    'compatibility': 0,
+                    'error': str(e)
+                }
+        
+        return jsonify({
+            'success': True,
+            'previews': previews
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in preview_styles: {str(e)}")
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
+
+@app.route('/api/analyze-image', methods=['POST'])
+def analyze_image():
+    """Analyze uploaded image and suggest best styles"""
+    try:
+        if 'image' not in request.files:
+            return jsonify({'error': 'Missing image'}), 400
+        
+        file = request.files['image']
+        
+        if file.filename == '' or not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file'}), 400
+        
+        try:
+            image = Image.open(file.stream).convert('RGB')
+        except Exception:
+            return jsonify({'error': 'Invalid image file'}), 400
+        
+        # Analyze image characteristics
+        analysis = analyze_image_characteristics(image)
+        
+        # Suggest best styles based on analysis
+        suggestions = suggest_styles_for_image(analysis)
+        
+        return jsonify({
+            'success': True,
+            'analysis': analysis,
+            'suggestions': suggestions
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in analyze_image: {str(e)}")
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
+
+def analyze_image_characteristics(image):
+    """Analyze image characteristics to suggest best QR style"""
+    try:
+        # Resize for analysis
+        small_image = image.resize((100, 100))
+        
+        # Color analysis
+        colors = small_image.getcolors(10000)
+        if colors:
+            total_pixels = sum(count for count, color in colors)
+            
+            # Calculate color diversity
+            color_diversity = len(colors) / total_pixels
+            
+            # Find dominant color
+            dominant_color = max(colors, key=lambda x: x[0])[1]
+            
+            # Calculate average brightness
+            avg_brightness = sum(sum(color) for count, color in colors) / (len(colors) * 3)
+            
+            # Calculate color saturation
+            hsv_colors = [colorsys.rgb_to_hsv(r/255, g/255, b/255) for count, (r, g, b) in colors]
+            avg_saturation = sum(s for h, s, v in hsv_colors) / len(hsv_colors)
+            
+        else:
+            color_diversity = 0.5
+            dominant_color = (128, 128, 128)
+            avg_brightness = 128
+            avg_saturation = 0.5
+        
+        # Complexity analysis using edge detection
+        gray = cv2.cvtColor(np.array(small_image), cv2.COLOR_RGB2GRAY)
+        edges = cv2.Canny(gray, 50, 150)
+        complexity = np.sum(edges > 0) / edges.size
+        
+        return {
+            'color_diversity': color_diversity,
+            'dominant_color': dominant_color,
+            'avg_brightness': avg_brightness,
+            'avg_saturation': avg_saturation,
+            'complexity': complexity,
+            'is_dark': avg_brightness < 100,
+            'is_colorful': avg_saturation > 0.3,
+            'is_complex': complexity > 0.1
+        }
+        
+    except Exception as e:
+        logger.error(f"Error analyzing image: {str(e)}")
+        return {
+            'color_diversity': 0.5,
+            'dominant_color': (128, 128, 128),
+            'avg_brightness': 128,
+            'avg_saturation': 0.5,
+            'complexity': 0.1,
+            'is_dark': False,
+            'is_colorful': True,
+            'is_complex': False
+        }
+
+def suggest_styles_for_image(analysis):
+    """Suggest best QR styles based on image analysis"""
+    suggestions = []
+    
+    # For dark images
+    if analysis['is_dark']:
+        suggestions.append({
+            'style': 'neon_glow',
+            'reason': 'Perfect for dark images with striking neon effect',
+            'compatibility': 90
+        })
+        suggestions.append({
+            'style': 'minimal_dots',
+            'reason': 'Adapts well to dark backgrounds',
+            'compatibility': 95
+        })
+    
+    # For colorful images
+    if analysis['is_colorful']:
+        suggestions.append({
+            'style': 'vibrant_overlay',
+            'reason': 'Enhances colorful logos with accent colors',
+            'compatibility': 89
+        })
+        suggestions.append({
+            'style': 'gradient_blend',
+            'reason': 'Beautiful gradient effects with colorful images',
+            'compatibility': 92
+        })
+    
+    # For complex images
+    if analysis['is_complex']:
+        suggestions.append({
+            'style': 'glassmorphism',
+            'reason': 'Glass effect reduces visual noise in complex images',
+            'compatibility': 88
+        })
+        suggestions.append({
+            'style': 'artistic_shadow',
+            'reason': 'Shadow effects help separate QR from complex backgrounds',
+            'compatibility': 91
+        })
+    
+    # For simple/clean images
+    if not analysis['is_complex']:
+        suggestions.append({
+            'style': 'modern_overlay',
+            'reason': 'Clean modern style perfect for simple logos',
+            'compatibility': 95
+        })
+        suggestions.append({
+            'style': 'minimal_dots',
+            'reason': 'Maximum logo visibility for clean designs',
+            'compatibility': 97
+        })
+    
+    # Always include modern_overlay as a safe choice
+    if not any(s['style'] == 'modern_overlay' for s in suggestions):
+        suggestions.append({
+            'style': 'modern_overlay',
+            'reason': 'Reliable choice for any image type',
+            'compatibility': 95
+        })
+    
+    # Sort by compatibility score
+    suggestions.sort(key=lambda x: x['compatibility'], reverse=True)
+    
+    return suggestions[:4]  # Return top 4 suggestions
+
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
     app.run(host='0.0.0.0', port=port, debug=False)