Create app.py

app.py

@@ -0,0 +1,372 @@
+import os
+import io
+import base64
+import numpy as np
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from PIL import Image, ImageEnhance, ImageFilter
+import qrcode
+from qrcode.constants import ERROR_CORRECT_H
+import cv2
+from io import BytesIO
+import requests
+from werkzeug.utils import secure_filename
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+# Configuration
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+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)
+    
+    # Create QR code image
+    qr_img = qr.make_image(fill_color="black", back_color="white")
+    
+    # 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
+        ]
+    }
+    
+    return contrast_map, regions
+
+def create_artistic_qr(image, qr_data, style='logo_center', size=300):
+    """Create artistic QR code using pattern replacement"""
+    try:
+        # Create base QR code
+        qr_img, qr_obj = create_base_qr(qr_data, size)
+        
+        # Resize input image to match QR size
+        image = image.resize((size, size), Image.LANCZOS)
+        
+        # Convert to numpy arrays
+        qr_array = np.array(qr_img.convert('L'))
+        img_array = np.array(image.convert('RGB'))
+        
+        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)
+        else:
+            return qr_img
+            
+    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]
+
+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)
+    
+    # Resize logo
+    logo_resized = logo_img.resize((logo_size, logo_size), Image.LANCZOS)
+    
+    # Create a copy of QR code
+    result = qr_img.convert('RGB').copy()
+    
+    # Calculate center position
+    pos = ((size - logo_size) // 2, (size - logo_size) // 2)
+    
+    # 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)
+    
+    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
+    module_count = len(modules)
+    
+    # Calculate module size
+    module_size = size // module_count
+    
+    # Create result image
+    result = np.zeros((size, size, 3), dtype=np.uint8)
+    
+    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)
+            
+            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]
+                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
+            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)
+                
+                if avg_brightness < 128:  # Too dark, make it lighter
+                    result[y1:y2, x1:x2] = 255 - ((255 - img_region) * 0.3)
+                else:
+                    result[y1:y2, x1:x2] = img_region
+    
+    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)
+    
+    # Apply adaptive blending
+    result = np.zeros_like(img_array)
+    
+    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)
+    
+    return Image.fromarray(result.astype(np.uint8))
+
+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 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
+        
+        total_score = int(contrast_score + edge_score + noise_score)
+        
+        return {
+            'overall': total_score,
+            'contrast': int(contrast_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': []}
+
+def get_recommendations(score):
+    """Get improvement recommendations based on score"""
+    recommendations = []
+    
+    if score < 70:
+        recommendations.append("Consider using higher contrast between foreground and background")
+    if score < 60:
+        recommendations.append("Try the 'Logo Center' style for better compatibility")
+    if score < 50:
+        recommendations.append("Your image might be too complex - consider simplifying")
+    
+    return recommendations
+
+def image_to_base64(image):
+    """Convert PIL image to base64 string"""
+    buffer = BytesIO()
+    image.save(buffer, format='PNG', optimize=True)
+    img_str = base64.b64encode(buffer.getvalue()).decode()
+    return f"data:image/png;base64,{img_str}"
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({'status': 'healthy', 'message': 'QR AI 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))
+        
+        # Validate file
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+        
+        if not allowed_file(file.filename):
+            return jsonify({'error': 'Invalid file type'}), 400
+        
+        # Validate URL
+        if not url or len(url) < 1:
+            return jsonify({'error': 'Invalid URL'}), 400
+        
+        # Process image
+        try:
+            image = Image.open(file.stream).convert('RGB')
+        except Exception as e:
+            return jsonify({'error': 'Invalid image file'}), 400
+        
+        # Generate artistic QR code
+        artistic_qr = create_artistic_qr(image, url, style, size)
+        
+        # Calculate compatibility score
+        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_base64 = image_to_base64(standard_qr)
+        
+        return jsonify({
+            'success': True,
+            'artistic_qr': qr_base64,
+            'standard_qr': standard_base64,
+            'compatibility': compatibility,
+            'style_used': style,
+            'size': size
+        })
+        
+    except Exception as e:
+        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
+        },
+        'pattern_replace': {
+            'name': 'Artistic Pattern',
+            'description': 'Replaces QR patterns with your image (moderate compatibility)',
+            'compatibility': 75
+        },
+        'artistic_blend': {
+            'name': 'Artistic Blend',
+            'description': 'Blends your image with QR code (lower compatibility)',
+            'compatibility': 60
+        }
+    }
+    
+    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)