Upload 88 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+outputs/proper_input_template.jpg filter=lfs diff=lfs merge=lfs -text
+temp_grid.jpg filter=lfs diff=lfs merge=lfs -text
+ui/logo.png filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[server]
+fileWatcherType = "none"
+headless = true

DEPLOY.md

@@ -0,0 +1,48 @@
+# How to Deploy Type.ai to Hugging Face Spaces
+
+This guide will help you deploy your handwriting font generator for free on Hugging Face Spaces.
+
+## Prerequisites
+- A [Hugging Face Account](https://huggingface.co/join) (Free)
+
+## Step-by-Step Deployment
+
+### 1. Create a New Space
+1.  Go to [huggingface.co/spaces](https://huggingface.co/spaces).
+2.  Click **"Create new Space"**.
+3.  **Space Name**: Enter `type-ai` (or similar).
+4.  **License**: `MIT` (optional).
+5.  **SDK**: Select **Streamlit**.
+6.  **Hardware**: Keep the default **CPU Basic (Free)**.
+    > *Note: This builds slowly but works. If it fails, you can request a restart.*
+    > *For faster font generation, T4 GPU (small cost) is better, but CPU works for free.*
+7.  Click **"Create Space"**.
+
+### 2. Upload Your Code
+You will see a page with instructions. We will upload files via the web interface (easiest method).
+
+1.  On your Space page, click the **"Files"** tab.
+2.  Click **"Add file"** > **"Upload files"**.
+3.  Drag and drop **ALL** the files from your `Type.ai` folder into the upload area.
+    - **Crucial Files**:
+        - `app.py`
+        - `requirements.txt` (I just updated this for you)
+        - `packages.txt` (I just created this for you - installs Tesseract)
+        - `src/` folder (drag the whole folder)
+        - `models/` folder (if you have local models, otherwise the code downloads them)
+        - `ui/` folder
+4.  In the "Commit message" box, type "Initial deploy".
+5.  Click **"Commit changes to main"**.
+
+### 3. Watch it Build
+1.  Click the **"App"** tab.
+2.  You will see "Building".
+3.  Hugging Face will automatically:
+    - Install Python libraries from `requirements.txt`.
+    - Install Tesseract OCR from `packages.txt`.
+4.  This process may take **5-10 minutes** the first time.
+
+### Troubleshooting
+- **"Runtime Error"**: Check the **"Logs"** tab.
+- **Tesseract not found**: Ensure `packages.txt` exists in the root directory.
+- **Memory Error**: The free tier has 16GB RAM, which is usually enough. If it crashes loading the model, we can optimize the code to load lighter models.

README.md

@@ -1,19 +1,100 @@
----
-title: TypeAI
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: Type AI
+emoji: ✒️
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.25.0
+python_version: "3.10"
+app_file: app.py
+pinned: false
+---
+
+# Type.ai - AI Handwriting to Font Generator
+
+Convert your handwriting into a custom TrueType font file using AI-powered character detection.
+
+## Features
+
+- **AI Character Detection**: Uses advanced contour analysis and OCR to extract characters
+- **Style Analysis**: Captures stroke width, slant, and roughness of your handwriting
+- **Vector Conversion**: Converts bitmap characters to smooth vector paths
+- **Font Generation**: Creates installable TTF font files
+- **Web UI**: Modern drag-and-drop interface
+- **REST API**: Integrate into your own applications
+
+## Quick Start
+
+### 1. Install Dependencies
+
+```bash
+cd Type.ai
+pip install -r requirements.txt
+```
+
+### 2. Command Line Usage
+
+```bash
+# Basic usage
+python main.py handwriting.jpg --output MyFont.ttf --name "MyHandwriting"
+
+# With debug output
+python main.py sample.png -o CustomFont.ttf -n "Custom Font" --debug
+```
+
+### 3. Web Interface
+
+```bash
+# Start the server
+python server.py
+
+# Open in browser
+# http://localhost:8000/ui/
+```
+
+## Tips for Best Results
+
+1. **Write clearly** with consistent size
+2. **Include all letters** A-Z (uppercase and/or lowercase)
+3. **Use dark ink** on white paper
+4. **Good lighting** - avoid shadows
+5. **High resolution** scan or photo
+
+## Project Structure
+
+```
+Type.ai/
+├── src/
+│   ├── preprocessing.py    # Image enhancement
+│   ├── segmentation.py     # Character detection
+│   ├── style_extractor.py  # Style analysis
+│   ├── vectorizer.py       # Bitmap to vector
+│   ├── font_generator.py   # TTF creation
+│   └── pipeline.py         # Main orchestrator
+├── ui/
+│   └── index.html          # Web interface
+├── main.py                 # CLI
+├── server.py               # FastAPI server
+└── requirements.txt        # Dependencies
+```
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/upload` | POST | Upload handwriting image |
+| `/api/status/{job_id}` | GET | Check processing status |
+| `/api/download/{job_id}` | GET | Download generated font |
+| `/api/preview/{job_id}` | GET | Get segmentation preview |
+
+## Requirements
+
+- Python 3.8+
+- PyTorch 1.9+
+- OpenCV
+- fonttools
+- Tesseract OCR (optional, for character recognition)
+
+## License
+
+MIT

app.py

@@ -0,0 +1,161 @@
+"""
+Type.ai - Web Interface
+-----------------------
+A clean UI to generate handwriting fonts.
+Now supports Phase 1 (Grid) and Phase 2 (Sentence).
+"""
+import streamlit as st
+import os
+import cv2
+import numpy as np
+import sys
+from pathlib import Path
+
+# Fix imports
+sys.path.insert(0, str(Path(__file__).parent / 'src'))
+from process_grid import process_grid_final
+from process_sentence import process_sentence
+
+def main():
+    # Use logo as favicon/page icon
+    logo_path = "ui/logo.png"
+    st.set_page_config(
+        page_title="Type.ai", 
+        page_icon=logo_path if os.path.exists(logo_path) else "✒️", 
+        layout="centered"
+    )
+    
+    # --- LOGO & HEADER ---
+    logo_path = "ui/logo.png"
+    if os.path.exists(logo_path):
+        st.image(logo_path, width=200) 
+    else:
+        st.title("✒️ Type.ai")
+        
+    st.header("Turn your handwriting into a font.")
+    
+    tab1, tab2 = st.tabs(["📏 Grid Mode (Standard)", "📝 Sentence Mode (Experimental)"])
+    
+    # --- TAB 1: GRID MODE ---
+    with tab1:
+        st.subheader("Method 1: The Precision Grid")
+        st.markdown("Use this for 100% accuracy using the template.")
+        
+        col1, col2 = st.columns([1, 2])
+        template_path = "outputs/proper_input_template.jpg"
+        
+        # Ensure template exists
+        if not os.path.exists(template_path):
+            st.warning("Template not found. Please run cleanup or generate it.")
+            
+        with col1:
+            if os.path.exists(template_path):
+                st.image(template_path, caption="Grid Template", width=150)
+        
+        with col2:
+            st.write("1. Download blank template.\n2. Fill with **Blue Pen**.\n3. Upload.")
+            if os.path.exists(template_path):
+                with open(template_path, "rb") as f:
+                    st.download_button(
+                        label="📥 Download Blank Template",
+                        data=f,
+                        file_name="TypeAI_Template.jpg",
+                        mime="image/jpeg"
+                    )
+
+        uploaded_grid = st.file_uploader("Upload Grid Scan", type=["jpg", "png", "jpeg"], key="grid_up")
+        
+        if uploaded_grid is not None:
+            st.image(uploaded_grid, caption="Grid Upload", width=300)
+            
+            font_name = st.text_input("Name your font:", value="MyHandwriting", key="grid_font_name")
+            
+            if st.button("✨ Generate Grid Font"):
+                with st.spinner("Processing Grid..."):
+                    try:
+                        temp_path = "temp_grid.jpg"
+                        with open(temp_path, "wb") as f:
+                            f.write(uploaded_grid.getbuffer())
+                        
+                        # Clean filename
+                        safe_name = "".join(x for x in font_name if x.isalnum() or x in " -_")
+                        if not safe_name: safe_name = "MyHandwriting"
+                        
+                        output_filename = f"{safe_name.replace(' ', '_')}.ttf"
+                        output_path = os.path.join("outputs", output_filename)
+                        
+                        process_grid_final(temp_path, output_path, font_family_name=font_name)
+                        
+                        st.success(f"Font '{font_name}' Generated!")
+                        
+                        with open(output_path, "rb") as f:
+                            st.download_button(f"Download {output_filename}", f, output_filename)
+                    except Exception as e:
+                        st.error(f"Error: {e}")
+
+    # --- TAB 2: SENTENCE MODE ---
+    with tab2:
+        st.subheader("Method 2: Natural Sentence (Phase 2)")
+        st.markdown("Upload a photo of any handwritten sentence to detect letters automatically.")
+        
+        st.info("ℹ️ **First Run Note:** This mode uses AI models (TrOCR) which will download on the first run. Please be patient.")
+        
+        try:
+            import torch
+            if torch.cuda.is_available():
+                gpu_name = torch.cuda.get_device_name(0)
+                st.success(f"🚀 Acceleration Enabled: Using {gpu_name}")
+            else:
+                st.warning("⚠️ No GPU Detected. Running on CPU (this might be slow).")
+        except ImportError:
+            pass
+        
+        uploaded_sent = st.file_uploader("Upload Sentence Image", type=["jpg", "png", "jpeg"], key="sent_up")
+        
+        if uploaded_sent is not None:
+            st.image(uploaded_sent, caption="Sentence Upload", width=300)
+            if st.button("🧠 Analyze & Generate"):
+                with st.spinner("Analyzing handwriting (Segmentation + OCR)..."):
+                    try:
+                        temp_path = "temp_sentence.jpg"
+                        with open(temp_path, "wb") as f:
+                            f.write(uploaded_sent.getbuffer())
+                        
+                        output_path = "outputs/SentenceFont.ttf"
+                        result = process_sentence(temp_path, output_path)
+                        
+                        if result and result[0] and os.path.exists(result[0]):
+                             font_path, text_content = result
+                             st.success("Sentence Font Generated!")
+                             
+                             # Generate Preview
+                             if text_content:
+                                 st.subheader("Preview: Your Text in Your Font")
+                                 from font_renderer import render_font_preview
+                                 preview_path = "outputs/preview.png"
+                                 render_font_preview(font_path, text_content, preview_path)
+                                 if os.path.exists(preview_path):
+                                     st.image(preview_path, caption="Generated Preview", use_container_width=True)
+                                 else:
+                                     st.warning("Could not generate preview image.")
+                             else:
+                                 st.warning("Font generated, but no text content reconstructed for preview.")
+
+                             st.balloons()
+                             with open(output_path, "rb") as f:
+                                 st.download_button("Download SentenceFont.ttf", f, "SentenceFont.ttf")
+                             
+                             # Debug View
+                             if os.path.exists("outputs/debug_alphabet.png"):
+                                 with st.expander("👁️ Debug: what the AI saw"):
+                                     st.image("outputs/debug_alphabet.png", caption="Detected Characters")
+                        else:
+                            st.warning("No font generated. Maybe no characters were confidently detected?")
+                            
+                    except Exception as e:
+                        st.error(f"Error: {e}")
+                        import traceback
+                        st.text(traceback.format_exc()) # Debug info
+
+if __name__ == "__main__":
+    main()

models/easyocr/craft_mlt_25k.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a5efbfb48b4081100544e75e1e2b57f8de3d84f213004b14b85fd4b3748db17
+size 83152330

models/easyocr/english_g2.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2272681d9d67a04e2dff396b6e95077bc19001f8f6d3593c307b9852e1c29e8
+size 15143997