app.py

from flask import Flask, request, jsonify
from flask_cors import CORS
import vtracer
from PIL import Image
import io
import os
import logging
import base64

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = Flask(__name__)
CORS(app, resources={r"/convert": {"origins": ["https://www.figma.com", "*"]}})

# VTracer conversion function
def convert_to_vector(
    image,
    colormode="color",
    hierarchical="stacked",
    mode="spline",
    filter_speckle=4,
    color_precision=6,
    layer_difference=16,
    corner_threshold=60,
    length_threshold=4.0,
    max_iterations=10,
    splice_threshold=45,
    path_precision=3
):
    input_path = "temp_input.jpg"
    output_path = "svg_output.svg"

    try:
        # Save the input image to a temporary file
        image.save(input_path)
        logger.info(f"Saved image to {input_path}")

        # Convert the image to SVG using VTracer
        vtracer.convert_image_to_svg_py(
            input_path,
            output_path,
            colormode=colormode,
            hierarchical=hierarchical,
            mode=mode,
            filter_speckle=int(filter_speckle),
            color_precision=int(color_precision),
            layer_difference=int(layer_difference),
            corner_threshold=int(corner_threshold),
            length_threshold=float(length_threshold),
            max_iterations=int(max_iterations),
            splice_threshold=int(splice_threshold),
            path_precision=int(path_precision)
        )
        logger.info(f"Converted image to SVG at {output_path}")

        # Read the SVG output
        with open(output_path, "r") as f:
            svg_content = f.read()

        return svg_content
    except Exception as e:
        logger.error(f"Error in convert_to_vector: {str(e)}")
        raise Exception(f"Conversion failed: {str(e)}")
    finally:
        # Clean up temporary files
        for path in [input_path, output_path]:
            if os.path.exists(path):
                try:
                    os.remove(path)
                    logger.info(f"Removed {path}")
                except Exception as e:
                    logger.warning(f"Failed to remove {path}: {str(e)}")

# Flask endpoint for vector conversion
@app.route('/convert', methods=['POST'])
def convert_image():
    try:
        # Handle JSON payload
        data = request.get_json()
        if not data or 'file' not in data:
            return jsonify({'error': 'No image data provided'}), 400

        # Decode base64 image
        base64_string = data['file']
        if base64_string.startswith('data:image'):
            base64_string = base64_string.split(',')[1]
        image_data = base64.b64decode(base64_string)
        image = Image.open(io.BytesIO(image_data)).convert('RGB')

        # Get parameters (with defaults)
        colormode = data.get('colormode', 'color')
        hierarchical = data.get('hierarchical', 'stacked')
        mode = data.get('mode', 'spline')
        filter_speckle = int(data.get('filter_speckle', 4))
        color_precision = int(data.get('color_precision', 6))
        layer_difference = int(data.get('layer_difference', 16))
        corner_threshold = int(data.get('corner_threshold', 60))
        length_threshold = float(data.get('length_threshold', 4.0))
        max_iterations = int(data.get('max_iterations', 10))
        splice_threshold = int(data.get('splice_threshold', 45))
        path_precision = int(data.get('path_precision', 3))

        logger.info("Received request to /convert")

        # Convert to SVG
        svg_content = convert_to_vector(
            image,
            colormode=colormode,
            hierarchical=hierarchical,
            mode=mode,
            filter_speckle=filter_speckle,
            color_precision=color_precision,
            layer_difference=layer_difference,
            corner_threshold=corner_threshold,
            length_threshold=length_threshold,
            max_iterations=max_iterations,
            splice_threshold=splice_threshold,
            path_precision=path_precision
        )

        # Return SVG as JSON
        return jsonify({'svg': svg_content})
    except Exception as e:
        logger.error(f"Error in convert_image: {str(e)}")
        return jsonify({'error': str(e)}), 500

# Health check endpoint
@app.route('/')
def health_check():
    logger.info("Health check requested")
    return jsonify({'status': 'Image to Vector Converter API is running'})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=7860)