### Quick Font Matching using Glyph Coordinate Comparison

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Provides fast character matching using glyph coordinate comparison, suitable for fonts with minimal coordinate variation. It includes functions to list characters, get coordinate tables, compare glyph similarity with fuzzy matching, and match fonts.

```python
from quick import list_ttf_characters, get_font_coor_table, is_glpyh_similar, match_font
from fontTools.ttLib import ttFont

# Load a TTFont object
ttf = ttFont.TTFont('./sample_font/font.ttf')

# List all characters in the font
characters = list_ttf_characters(ttf)
print(f"Font contains {len(characters)} characters: {characters[:10]}")

# Get coordinate table for a specific character
coords = get_font_coor_table(ttf)
# coords: {'字': [(x1, y1), (x2, y2), ...], ...}

# Compare two glyph coordinates with fuzzy matching
char_a_coords = [(100, 200), (150, 250), (200, 300)]
char_b_coords = [(105, 195), (148, 252), (203, 298)]
similar = is_glpyh_similar(char_a_coords, char_b_coords, fuzz=20)
print(f"Glyphs are similar: {similar}")  # True (within 20px tolerance)
```

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

### Download Font Files from URLs

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

A command-line script to download font files from provided URLs. It automatically extracts font links from input strings and saves them to the './sample_font/' directory. Includes automatic retries for failed downloads.

```bash
# Download fonts from URLs (extracts links from input string)
python download.py "Check these fonts: https://example.com/font1.woff2 https://example.com/font2.ttf"

# Files are saved to ./sample_font/ directory
# Automatic retry on failure (up to 5 attempts)
```

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

### Python: Main Processing Pipeline for Font Files

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

This Python script demonstrates the end-to-end workflow for processing font files. It handles configuration, loads necessary font data, initializes the processing environment, and then iterates through a directory of sample fonts to extract character mappings using an asynchronous unified workflow. The results are saved as JSON files.

```python
import json
import os
import asyncio
from paddle_ocr_extractor import extract_characters_unified_workflow
from slow import load_Font, load_std_guest_range, init_true_font
from commonly_used_character import character_list_7000 as character_list

async def main():
    # Configuration
    sample_font_path = './sample_font'
    TRUE_FONT_PATH = './true_font'
    COORD_TABLE_PATH = os.path.join(TRUE_FONT_PATH, 'coorTable.json')
    GEN_DIR = './gen'

    true_fonts = [
        "Microsoft-YaHei",
        "SourceHanSansSC-Normal",
        "SourceHanSansSC-Regular",
        "Founder-Lanting"
    ]

    os.makedirs(GEN_DIR, exist_ok=True)

    # Initialize standard fonts
    std_font_dict = {}
    for font_name in true_fonts:
        std_font_dict[font_name] = load_Font(
            os.path.join(TRUE_FONT_PATH, font_name + '.otf')
        )

    init_true_font(std_font_dict, TRUE_FONT_PATH, COORD_TABLE_PATH)
    guest_range = list({*load_std_guest_range(COORD_TABLE_PATH), *character_list})

    # Process all font files in sample_font directory
    for filename in os.listdir(sample_font_path):
        print(f'Processing {filename}')
        full_path = os.path.join(sample_font_path, filename)

        result = await asyncio.to_thread(
            extract_characters_unified_workflow,
            full_path,
            std_font_dict,
            guest_range,
            TRUE_FONT_PATH
        )

        # Save mapping to JSON
        output_path = os.path.join(GEN_DIR, filename + '.json')
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump(result, f)
        print(f"Saved to {output_path}")

if __name__ == '__main__':
    asyncio.run(main())

```

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

### Unified Workflow for Character Extraction (OCR + Image Similarity)

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Combines PaddleOCR and image similarity matching in a unified workflow. It first attempts OCR recognition for all characters and then applies image similarity fallback only for characters that failed OCR. This approach optimizes performance while maintaining accuracy for character mapping.

```python
from paddle_ocr_extractor import extract_characters_unified_workflow
from slow import load_Font, load_std_guest_range, init_true_font
import os

# Configure paths
TRUE_FONT_PATH = './true_font'
COORD_TABLE_PATH = os.path.join(TRUE_FONT_PATH, 'coorTable.json')

# Prepare standard font dictionary
true_fonts = ["Microsoft-YaHei", "SourceHanSansSC-Normal", "SourceHanSansSC-Regular"]
std_font_dict = {name: load_Font(os.path.join(TRUE_FONT_PATH, name + '.otf'))
                 for name in true_fonts}

init_true_font(std_font_dict, TRUE_FONT_PATH, COORD_TABLE_PATH)
guest_range = load_std_guest_range(COORD_TABLE_PATH)

# Run unified workflow
# Phase 1: OCR all characters (high confidence threshold 0.95)
# Phase 2: Fallback to image similarity for failed characters
# Phase 3: Combine results
character_mapping = extract_characters_unified_workflow(
    font_path='./sample_font/encrypted.ttf',
    std_font_dict=std_font_dict,
    guest_range=guest_range,
    TRUE_FONT_PATH=TRUE_FONT_PATH
)

# Output: {'randomGlyph1': '中', 'randomGlyph2': '国', ...}
print(f"Mapped {len(character_mapping)} characters")
```

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

### Async Font Processing Tool

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Provides an asynchronous wrapper for processing font files from given paths. It utilizes `asyncio` to handle font matching operations concurrently. The function returns a dictionary mapping characters.

```python
import asyncio
from tools import match_font_tool

async def process_font():
    TRUE_FONT_PATH = './true_font'
    COORD_TABLE_PATH = './true_font/coorTable.json'
    true_fonts = ["Microsoft-YaHei", "SourceHanSansSC-Normal"]

    # Process a WOFF2 font file asynchronously
    result = await match_font_tool(
        font_path='./sample_font/encrypted.woff2',
        TRUE_FONT_PATH=TRUE_FONT_PATH,
        true_font=true_fonts,
        COORD_TABLE_PATH=COORD_TABLE_PATH
    )

    # result is a character mapping dictionary
    return result

# Run async function
mapping = asyncio.run(process_font())
print(mapping)
```

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

### Font File Utilities (WOFF2, Hex, Coord Table)

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Offers utilities for font file manipulation, including WOFF2 decompression to TTF objects, asynchronous loading of font information (name, hash), retrieving character hex codes, and loading standard font coordinate tables for matching. Requires `asyncio` for some operations.

```python
from lib import woff2_to_ttf, get_font, get_charater_hex, load_std_font_coord_table
import asyncio

# Convert WOFF2 bytes to TTFont object
with open('./sample_font/font.woff2', 'rb') as f:
    woff2_bytes = f.read()

ttf_font = woff2_to_ttf(woff2_bytes)
# Now you can access font tables via ttf_font['cmap'], ttf_font['glyf'], etc.

# Get font info asynchronously (includes hash for caching)
async def load_font_info():
    font_info = await get_font('./sample_font/font.woff2')
    print(f"Font name: {font_info['name']}")
    print(f"Hash: {font_info['hashsum']}")
    # font_info['ttf'] contains the TTFont object
    # font_info['bytes'] contains the raw bytes
    return font_info

font_data = asyncio.run(load_font_info())

# Get Unicode hex representation for a character
hex_code = get_charater_hex('中')
print(hex_code)  # Output: U+4e2d

# Load standard font coordinate table for matching
coord_table = load_std_font_coord_table('./true_font/coorTable.json')
# Returns: [('char', [(x1, y1), (x2, y2), ...]), ...]
```

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

### Image Similarity Matching for Characters

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Uses image rendering and comparison to match characters based on pixel distribution. It involves loading fonts, drawing characters to images, comparing image arrays, and using cached matching for performance. Dependencies include numpy and Pillow.

```python
from slow import draw, compare_im_np, match_test_im_with_cache, load_Font
import numpy as np
from PIL import Image

# Load fonts
test_font = load_Font('./sample_font/test.otf')
std_font = load_Font('./true_font/SourceHanSansSC-Normal.otf')

# Render a character to image
char_image = draw('中', test_font)
# Returns: PIL Image (1-bit mode, centered character)

# Compare two character images
test_array = np.asarray(draw('测', test_font))
std_array = np.asarray(draw('测', std_font))

match_rate = compare_im_np(test_array, std_array)
print(f"Match rate: {match_rate:.2%}")  # e.g., "Match rate: 95.32%"

# Use cached image matching for better performance
std_font_dict = {
    'SourceHanSansSC-Normal': load_Font('./true_font/SourceHanSansSC-Normal.otf')
}
guest_range = ['中', '国', '人', '民']  # Characters to match against

matched_char = match_test_im_with_cache(
    test_im=char_image,
    std_font=std_font_dict,
    guest_range=guest_range,
    TRUE_FONT_PATH='./true_font'
)
print(f"Matched character: {matched_char}")
```

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

### Load Font with PIL ImageFont object

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Loads a font file into a PIL ImageFont object for rendering characters. This is the primary entry point for loading standard reference fonts used in character matching. The function uses caching to avoid reloading the same font multiple times.

```python
from slow import load_Font

# Load a TrueType or OpenType font
font = load_Font('/path/to/font.otf')

# Font is now ready for use in character rendering
# The function uses caching to avoid reloading the same font multiple times
```

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

### Match Font Against Coordinate Table

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Compares an entire font against a standard coordinate table to identify matching and unmatched characters. Returns a dictionary of matched characters and a status indicating success or a list of unmatched characters.

```python
result, status = match_font(ttf)
# result: {'obfuscated_char': 'real_char', ...}
# status: "OK" if all matched, or list of unmatched characters
```

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

### Extract Characters with PaddleOCR and Image Similarity Fallback

Source: https://context7.com/404-novel-project/font_tables_lib/llms.txt

Uses PaddleOCR to recognize characters from rendered font glyphs with an optional fallback to image similarity matching. It requires pre-configured standard fonts and coordinate tables for accurate character identification. This function is useful for extracting text from obfuscated font files.

```python
from paddle_ocr_extractor import extract_characters_with_paddleocr
from slow import load_Font, load_std_guest_range, init_true_font
import os

# Set up paths
TRUE_FONT_PATH = './true_font'
COORD_TABLE_PATH = os.path.join(TRUE_FONT_PATH, 'coorTable.json')

# Load standard fonts for fallback matching
true_fonts = ["Microsoft-YaHei", "SourceHanSansSC-Normal"]
std_font_dict = {}
for font_name in true_fonts:
    std_font_dict[font_name] = load_Font(
        os.path.join(TRUE_FONT_PATH, font_name + '.otf')
    )

# Initialize true font cache
init_true_font(std_font_dict, TRUE_FONT_PATH, COORD_TABLE_PATH)
guest_range = load_std_guest_range(COORD_TABLE_PATH)

# Extract characters from an obfuscated font file
result = extract_characters_with_paddleocr(
    font_path='./sample_font/obfuscated.woff2',
    std_font_dict=std_font_dict,
    guest_range=guest_range,
    TRUE_FONT_PATH=TRUE_FONT_PATH,
    limit_chars=100  # Optional: limit to first N characters for testing
)

# Result: {'': 'love', '': 'you', ...}
print(result)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.