app.py

import streamlit as st
import streamlit.components.v1 as components
from demo import Hand
import os
from pathlib import Path
import re
import numpy as np

# Import drawing utilities if available
try:
    from drawing import skew, stretch, add_noise, denoise, interpolate, align
    DRAWING_UTILS_AVAILABLE = True
except ImportError:
    DRAWING_UTILS_AVAILABLE = False
    st.warning("⚠️ drawing.py not found. Advanced transformations disabled.")

# Page config
st.set_page_config(
    page_title="Handwriting Synthesis Pro",
    page_icon="✍️",
    layout="wide"
)

# Title
st.title("✍️ Handwriting Synthesis Generator Pro")
st.markdown("Generate beautiful handwritten text with advanced controls!")

# Create output directory if it doesn't exist
output_dir = Path("outputs")
output_dir.mkdir(exist_ok=True)

# Sidebar for controls
st.sidebar.header("⚙️ Basic Controls")

# Text input
text_input = st.sidebar.text_area(
    "Enter your text:",
    value="Hello World!\nThis is amazing!",
    height=150,
    help="Enter multiple lines of text. Each line will be rendered separately."
)

# Split text into lines
lines = [line.strip() for line in text_input.split('\n') if line.strip()]

# Style selector
style = st.sidebar.selectbox(
    "Handwriting Style:",
    options=list(range(10)),
    index=5,
    help="Choose from 10 different handwriting styles (0-9)"
)

# Bias (randomness) slider
bias = st.sidebar.slider(
    "Randomness (Bias):",
    min_value=0.1,
    max_value=2.0,
    value=0.75,
    step=0.05,
    help="Lower = more consistent, Higher = more variation"
)

# Stroke width slider
stroke_width = st.sidebar.slider(
    "Stroke Width:",
    min_value=1,
    max_value=5,
    value=2,
    step=1,
    help="Thickness of the pen stroke"
)

# Color picker
stroke_color = st.sidebar.color_picker(
    "Stroke Color:",
    value="#000000",
    help="Choose the pen color"
)

# Animation options
st.sidebar.markdown("---")
st.sidebar.header("🎬 Animation")

show_animation = st.sidebar.checkbox("✨ Animate handwriting", value=True)
if show_animation:
    animation_speed = st.sidebar.slider(
        "Animation speed:",
        min_value=0.5,
        max_value=5.0,
        value=2.0,
        step=0.5,
        help="Higher = faster drawing"
    )
else:
    animation_speed = 2.0

# Advanced transformation options
if DRAWING_UTILS_AVAILABLE:
    st.sidebar.markdown("---")
    st.sidebar.header("🎨 Transformations")
    
    with st.sidebar.expander("✨ Style Transformations", expanded=False):
        apply_skew = st.checkbox("Slant handwriting", value=False)
        if apply_skew:
            skew_degrees = st.slider(
                "Slant angle (degrees):",
                min_value=-45,
                max_value=45,
                value=15,
                step=5,
                help="Negative = left slant, Positive = right slant"
            )
        else:
            skew_degrees = 0
        
        apply_stretch = st.checkbox("Stretch handwriting", value=False)
        if apply_stretch:
            stretch_x = st.slider("Width factor:", 0.5, 2.0, 1.0, 0.1)
            stretch_y = st.slider("Height factor:", 0.5, 2.0, 1.0, 0.1)
        else:
            stretch_x, stretch_y = 1.0, 1.0
        
        apply_noise = st.checkbox("Add natural variation", value=False)
        if apply_noise:
            noise_scale = st.slider(
                "Variation amount:",
                min_value=0.0,
                max_value=2.0,
                value=0.5,
                step=0.1
            )
        else:
            noise_scale = 0.0
    
    with st.sidebar.expander("🔧 Processing Options", expanded=False):
        apply_denoise = st.checkbox("Smooth strokes", value=True)
        apply_interpolate = st.checkbox("Enhance curves", value=False)
        if apply_interpolate:
            interp_factor = st.slider("Smoothness:", 1, 4, 2, 1)
        else:
            interp_factor = 1

# Standard advanced options
st.sidebar.markdown("---")
st.sidebar.header("🎯 More Options")

with st.sidebar.expander("Additional Settings"):
    use_different_colors = st.checkbox("Different color per line", value=False)
    if use_different_colors:
        st.info("Each line will have a different color")
    
    use_different_styles = st.checkbox("Different style per line", value=False)
    if use_different_styles:
        st.info("Each line will use a different style")

# Generate button
generate_button = st.sidebar.button("🎨 Generate Handwriting", type="primary")

# Function to animate SVG
def animate_svg(svg_content, speed=2.0):
    """Add CSS animation to SVG for drawing effect"""
    animated_html = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <style>
            body {{
                margin: 0;
                padding: 20px;
                display: flex;
                justify-content: center;
                background: white;
            }}
            svg {{
                max-width: 100%;
                height: auto;
            }}
            svg path {{
                stroke-dasharray: 1000;
                stroke-dashoffset: 1000;
                animation: draw {10/speed}s ease-in-out forwards;
            }}
            svg path:nth-child(1) {{ animation-delay: 0s; }}
            svg path:nth-child(2) {{ animation-delay: {1/speed}s; }}
            svg path:nth-child(3) {{ animation-delay: {2/speed}s; }}
            svg path:nth-child(4) {{ animation-delay: {3/speed}s; }}
            svg path:nth-child(5) {{ animation-delay: {4/speed}s; }}
            svg path:nth-child(6) {{ animation-delay: {5/speed}s; }}
            svg path:nth-child(7) {{ animation-delay: {6/speed}s; }}
            svg path:nth-child(8) {{ animation-delay: {7/speed}s; }}
            svg path:nth-child(9) {{ animation-delay: {8/speed}s; }}
            svg path:nth-child(10) {{ animation-delay: {9/speed}s; }}
            
            @keyframes draw {{
                to {{
                    stroke-dashoffset: 0;
                }}
            }}
        </style>
    </head>
    <body>
        {svg_content}
    </body>
    </html>
    """
    return animated_html

# Main content area
col1, col2 = st.columns([1, 1])

with col1:
    st.subheader("📝 Preview Settings")
    st.write(f"**Lines to generate:** {len(lines)}")
    st.write(f"**Style:** {style}")
    st.write(f"**Randomness:** {bias}")
    st.write(f"**Stroke Width:** {stroke_width}")
    st.write(f"**Color:** {stroke_color}")
    
    if DRAWING_UTILS_AVAILABLE:
        st.write("**Transformations:**")
        if apply_skew:
            st.write(f"  • Slant: {skew_degrees}°")
        if apply_stretch:
            st.write(f"  • Stretch: {stretch_x}x × {stretch_y}y")
        if apply_noise:
            st.write(f"  • Variation: {noise_scale}")
        if apply_denoise:
            st.write(f"  • Smoothing: ON")
        if apply_interpolate:
            st.write(f"  • Enhanced curves: {interp_factor}x")
    
    if lines:
        st.write("**Text Preview:**")
        for i, line in enumerate(lines, 1):
            st.text(f"{i}. {line}")

with col2:
    st.subheader("✨ Generated Handwriting")
    
    if generate_button and lines:
        with st.spinner("Generating handwriting... 🎨"):
            try:
                # Prepare parameters
                biases = [bias] * len(lines)
                
                if use_different_styles:
                    styles = [i % 10 for i in range(len(lines))]
                else:
                    styles = [style] * len(lines)
                
                if use_different_colors:
                    color_palette = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A', '#98D8C8', '#F7DC6F', '#BB8FCE', '#85C1E2']
                    stroke_colors = [color_palette[i % len(color_palette)] for i in range(len(lines))]
                else:
                    stroke_colors = [stroke_color] * len(lines)
                
                stroke_widths = [stroke_width] * len(lines)
                
                # Generate handwriting
                output_file = output_dir / "generated_handwriting.svg"
                hand = Hand()
                hand.write(
                    filename=str(output_file),
                    lines=lines,
                    biases=biases,
                    styles=styles,
                    stroke_colors=stroke_colors,
                    stroke_widths=stroke_widths
                )
                
                # Display the SVG
                with open(output_file, "r") as f:
                    svg_content = f.read()
                
                if show_animation:
                    # Show animated version
                    animated_html = animate_svg(svg_content, animation_speed)
                    components.html(animated_html, height=400, scrolling=True)
                    
                    col_a, col_b = st.columns([1, 1])
                    with col_a:
                        if st.button("🔄 Replay Animation"):
                            st.rerun()
                else:
                    # Show static version
                    st.image(svg_content, use_column_width=True)
                
                # Download button
                st.download_button(
                    label="📥 Download SVG",
                    data=svg_content,
                    file_name="handwriting.svg",
                    mime="image/svg+xml"
                )
                
                st.success("✅ Handwriting generated successfully!")
                
                # Show transformation info if applied
                if DRAWING_UTILS_AVAILABLE:
                    transformations_applied = []
                    if apply_skew and skew_degrees != 0:
                        transformations_applied.append(f"Slanted {skew_degrees}°")
                    if apply_stretch and (stretch_x != 1.0 or stretch_y != 1.0):
                        transformations_applied.append(f"Stretched {stretch_x}x×{stretch_y}y")
                    if apply_noise and noise_scale > 0:
                        transformations_applied.append(f"Variation added")
                    
                    if transformations_applied:
                        st.info("🎨 Transformations: " + ", ".join(transformations_applied))
                
            except Exception as e:
                st.error(f"❌ Error generating handwriting: {str(e)}")
                st.exception(e)
    else:
        st.info("👈 Adjust settings in the sidebar and click 'Generate Handwriting' to see your result!")
        st.markdown("**Your handwriting will appear here after clicking Generate!**")

# Footer
st.sidebar.markdown("---")
st.sidebar.markdown("### 💡 Tips")
st.sidebar.markdown("""
- ✨ Enable animation for a cool drawing effect!
- 🎨 Try transformations for unique styles
- Try different styles (0-9) for variety
- Increase randomness for natural variation
- Experiment with slant and stretch!
""")

# Info section at bottom
st.markdown("---")
with st.expander("ℹ️ About this app"):
    st.markdown("""
    This app uses a neural network trained on handwriting data to generate realistic handwritten text.
    
    **Features:**
    - 10 different handwriting styles
    - Animated drawing effect
    - Adjustable randomness and stroke properties
    - Advanced transformations (slant, stretch, noise)
    - Processing options (smoothing, curve enhancement)
    - Multi-line text support
    - Color customization
    - SVG output format (scalable and editable)
    
    **How to use:**
    1. Enter your text in the sidebar
    2. Choose a style and adjust parameters
    3. Apply transformations for unique effects
    4. Click "Generate Handwriting"
    5. Download your result as SVG
    """)

if not DRAWING_UTILS_AVAILABLE:
    st.markdown("---")
    st.info("💡 **Pro Tip:** Place `drawing.py` in the same directory to unlock advanced transformation features!")