Handwrite

https://github.com/yashlamba/handwrite
Admin
Handwrite generates a custom font based on your handwriting sample that can be used in text editors...
Tokens:5,151
Snippets:39
Trust Score:9.6
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### Python Error Handling for Font Conversion

Source: https://context7.com/yashlamba/handwrite/llms.txt

Provides a robust function for handling common errors during the font conversion process. This example includes checks for file existence, verifies that the input is a file (not a directory), and confirms the presence of the 'potrace' executable, which is a dependency for SVG conversion. It wraps the conversion logic in a try-except block to catch and report any exceptions.

```python
from handwrite import converters, PNGtoSVG
from handwrite.pngtosvg import PotraceNotFound
import os

# Check prerequisites before conversion
def safe_convert(sheet_path, output_path):
    # Validate input file exists
    if not os.path.exists(sheet_path):
        raise FileNotFoundError(f"Sheet not found: {sheet_path}")

    # Validate input is a file, not directory
    if os.path.isdir(sheet_path):
        raise IsADirectoryError("Sheet parameter must be a file, not directory")

    # Check for potrace installation
    import shutil
    if shutil.which("potrace") is None:
        raise PotraceNotFound(
            "Potrace is required. Install it:\n"
            "  Ubuntu/Debian: sudo apt-get install potrace\n"
            "  macOS: brew install potrace\n"
            "  Windows: Download from http://potrace.sourceforge.net/"
        )

    # Perform conversion
    try:
        converters(
            sheet=sheet_path,
            output_directory=output_path,
            config=None,  # Use default config
            metadata={"filename": "SafeFont"}
        )
        print(f"Font successfully created in {output_path}")
        return True
    except Exception as e:
        print(f"Conversion failed: {e}")
        return False

# Usage
result = safe_convert("sample.jpg", "./output/")

```

--------------------------------

### Python: Convert Character PNGs to SVG

Source: https://context7.com/yashlamba/handwrite/llms.txt

Converts character PNG images to vector SVG format using the `PNGtoSVG` class. This process relies on Potrace and requires it to be installed and available in the system's PATH. It converts all `.png` files found in the specified directory structure.

```python
from handwrite import PNGtoSVG
import os

# Initialize converter
converter = PNGtoSVG()

# Convert all PNGs in directory structure to SVG
characters_dir = "./characters/"
converter.convert(directory=characters_dir)

# Processes all .png files in subdirectories:
# ./characters/65/65.png -> ./characters/65/65.bmp -> ./characters/65/65.svg
# ./characters/97/97.png -> ./characters/97/97.bmp -> ./characters/97/97.svg

# Note: Requires potrace to be installed and available in system PATH
# Raises PotraceNotFound exception if potrace is not found
```

--------------------------------

### Command Line: Basic Handwriting to Font Conversion

Source: https://context7.com/yashlamba/handwrite/llms.txt

Executes the full handwriting-to-font conversion pipeline from the command line with minimal arguments. It takes a sample sheet image and an output directory as input. The output is a .ttf font file.

```bash
# Basic usage with minimal arguments
handwrite sample_sheet.jpg ./output/

# Full usage with all optional parameters
handwrite sample_sheet.jpg ./output/ \
  --directory ./temp_files/ \
  --config custom_config.json \
  --filename "MyHandwriting" \
  --family "Smith Family" \
  --style "Regular"

# The output will be: ./output/MyHandwriting.ttf
```

--------------------------------

### Python Complete Font Creation Pipeline

Source: https://context7.com/yashlamba/handwrite/llms.txt

Demonstrates the end-to-end font creation process using the handwrite library. This pipeline covers extracting characters from a sheet image, converting these characters to vector format (SVG), and finally generating a TrueType font file. It utilizes `SHEETtoPNG`, `PNGtoSVG`, and `SVGtoTTF` converters, with temporary file management and error handling.

```python
from handwrite import SHEETtoPNG, PNGtoSVG, SVGtoTTF
import os
import tempfile
import shutil

# Setup paths
input_sheet = "handwriting_sample.jpg"
output_dir = "./my_fonts/"
temp_dir = tempfile.mkdtemp()
config_file = "custom_config.json"

try:
    # Stage 1: Extract characters from sheet
    print("Extracting characters from sheet...")
    sheet_converter = SHEETtoPNG()
    sheet_converter.convert(
        sheet=input_sheet,
        characters_dir=temp_dir,
        config=config_file,
        cols=8,
        rows=10
    )
    print(f"Characters saved to: {temp_dir}")

    # Stage 2: Convert PNGs to SVGs
    print("Converting characters to vector format...")
    svg_converter = PNGtoSVG()
    svg_converter.convert(directory=temp_dir)
    print("SVG conversion complete")

    # Stage 3: Generate TrueType font
    print("Generating font file...")
    font_metadata = {
        "filename": "MyHandwritingFont",
        "family": "Personal",
        "style": "Regular"
    }
    ttf_converter = SVGtoTTF()
    ttf_converter.convert(
        directory=temp_dir,
        outdir=output_dir,
        config=config_file,
        metadata=font_metadata
    )

    print(f"Font created: {output_dir}/MyHandwritingFont.ttf")
    print("Install the font and use it in your word processor!")

except Exception as e:
    print(f"Error during conversion: {e}")
    raise

finally:
    # Cleanup temporary files
    if os.path.exists(temp_dir):
        shutil.rmtree(temp_dir)
        print("Temporary files cleaned up")

```

--------------------------------

### JSON Configuration for Font Properties

Source: https://context7.com/yashlamba/handwrite/llms.txt

Defines font properties, glyphs, and typography parameters in JSON format. This file is crucial for customizing the generated font's appearance and behavior. It includes settings for character encoding, font metadata, glyph definitions, and advanced typography tables like kerning and bearing.

```json
{
  "threshold_value": 200,
  "props": {
    "ascent": 800,
    "descent": 200,
    "em": 1000,
    "encoding": "UnicodeFull",
    "lang": "English (US)",
    "filename": "MyFont",
    "style": "Regular"
  },
  "sfnt_names": {
    "Copyright": "Copyright (c) 2024 by Your Name",
    "Family": "MyFont",
    "SubFamily": "Regular",
    "Version": "Version 1.0",
    "PostScriptName": "MyFont-Regular"
  },
  "glyphs": [
    65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
    81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
    97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
    111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
    48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
    46, 44, 59, 58, 33, 63, 34, 39, 45, 43, 61, 47, 37, 38, 40, 41, 91, 93
  ],
  "typography_parameters": {
    "bearing_table": {
      "Default": [60, 60],
      "A": [60, -50],
      "a": [30, 40],
      "T": [null, -10],
      ".": [null, 10]
    },
    "kerning_table": {
      "autokern": true,
      "seperation": 0,
      "rows": [
        null,
        "f-+=/?",
        "t",
        "i",
        "MNHI",
        "OQDU"
      ],
      "cols": [
        null,
        "oacedgqw%&",
        "ft-+=/?",
        "hbli.,;:!\"'()[]"
      ]
    }
  }
}
```

--------------------------------

### Python: Extract Characters from Handwriting Sheet

Source: https://context7.com/yashlamba/handwrite/llms.txt

Uses the `SHEETtoPNG` class to extract individual character images from a scanned handwriting sample sheet. Supports basic conversion and character detection with custom thresholding. Requires the number of columns and rows in the template.

```python
from handwrite import SHEETtoPNG
import os

# Initialize converter
converter = SHEETtoPNG()

# Convert sheet to character PNGs
sheet_image = "filled_sample.jpg"
characters_dir = "./characters/"
config_file = "config.json"

converter.convert(
    sheet=sheet_image,
    characters_dir=characters_dir,
    config=config_file,
    cols=8,  # 8 columns in the template
    rows=10  # 10 rows in the template
)

# Output structure:
# ./characters/65/65.png  (character 'A')
# ./characters/97/97.png  (character 'a')
# ./characters/48/48.png  (character '0')
# ... (one directory per character with ord() value as name)

# Detect characters with custom thresholding
detected_chars = converter.detect_characters(
    sheet_image="sample.jpg",
    threshold_value=180,  # Lower value for darker scans
    cols=8,
    rows=10
)
# Returns: List of 80 character images with coordinates
```

--------------------------------

### Python: Programmatic Handwriting to Font Conversion

Source: https://context7.com/yashlamba/handwrite/llms.txt

Programmatically converts a handwriting sample sheet to a TrueType font using the `converters` function. Supports basic conversion with default settings and advanced conversion with custom configuration files and metadata.

```python
from handwrite import converters
import os

# Basic conversion with default settings
sheet_path = "handwriting_sample.jpg"
output_dir = "./fonts/"
converters(sheet_path, output_dir)
# Creates: ./fonts/MyFont.ttf (default name)

# Advanced conversion with custom configuration
config_path = "custom_config.json"
temp_dir = "./temp_characters/"
metadata = {
    "filename": "JohnSmith",
    "family": "Smith Family",
    "style": "Italic"
}

converters(
    sheet=sheet_path,
    output_directory=output_dir,
    directory=temp_dir,
    config=config_path,
    metadata=metadata
)
# Creates: ./fonts/JohnSmith.ttf
# Preserves intermediate files in: ./temp_characters/
```

--------------------------------

### Python: Generate TTF Font from SVG Characters

Source: https://context7.com/yashlamba/handwrite/llms.txt

Generates a TrueType font file from SVG character files using the `SVGtoTTF` class. This process requires FontForge Python bindings and a configuration file detailing font properties, glyphs, and typography parameters. It outputs the font file to a specified directory.

```python
from handwrite import SVGtoTTF
import json

# Initialize converter
converter = SVGtoTTF()

# Convert SVG directory to TrueType font
characters_dir = "./characters/"
output_dir = "./fonts/"
config_file = "font_config.json"

metadata = {
    "filename": "MyCustomFont",
    "family": "Custom Family",
    "style": "Regular"
}

converter.convert(
    directory=characters_dir,
    outdir=output_dir,
    config=config_file,
    metadata=metadata
)
# Creates: ./fonts/MyCustomFont.ttf

# Note: Requires FontForge Python bindings to be installed
# The config file must include:
# - props: font properties (ascent, descent, encoding)
# - glyphs: list of character codes to include
# - typography_parameters: bearing_table and kerning_table
```
Tokens:
Raw