@wentorai/research-plugins 1.0.0

package/skills/tools/ocr-translate/handwriting-recognition-guide/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: handwriting-recognition-guide
+description: "Apply handwriting OCR to digitize historical and archival documents"
+metadata:
+  openclaw:
+    emoji: "fountain_pen"
+    category: "tools"
+    subcategory: "ocr-translate"
+    keywords: ["handwriting recognition", "HTR", "OCR", "historical documents", "digitization", "manuscript transcription"]
+    source: "wentor-research-plugins"
+---
+
+# Handwriting Recognition Guide
+
+A skill for applying handwriting text recognition (HTR) to digitize historical documents, archival manuscripts, and handwritten research notes. Covers HTR platforms, image preprocessing, model training, post-correction, and integration into digital humanities research workflows.
+
+## Handwriting Recognition vs. Printed OCR
+
+### Key Differences
+
+```
+Printed Text OCR:
+  - Characters are standardized and uniform
+  - Well-solved problem (>99% accuracy on clean scans)
+  - Tools: Tesseract, ABBYY FineReader, Adobe Acrobat
+
+Handwriting Text Recognition (HTR):
+  - Characters vary by writer, mood, pen, era
+  - Much harder -- typically 85-95% character accuracy
+  - Requires training on specific handwriting styles
+  - Tools: Transkribus, Kraken, HTR-Flor, Google Cloud Vision
+
+Challenges specific to historical documents:
+  - Faded ink, bleed-through, stains, tears
+  - Archaic letterforms and abbreviations
+  - Multiple hands in one document
+  - Non-standard orthography
+  - Mixed languages and scripts
+```
+
+## HTR Platforms
+
+### Transkribus (State of the Art for Historical Documents)
+
+```
+Transkribus is the leading platform for historical HTR.
+
+Workflow:
+  1. Upload document images
+  2. Automatic layout analysis (detect text regions and baselines)
+  3. Manual correction of layout (if needed)
+  4. Apply a pre-trained HTR model (or train your own)
+  5. Review and correct transcription
+  6. Export as TEXT, PAGE XML, TEI, DOCX, or PDF
+
+Pre-trained models:
+  - Noscemus GM (general model for Latin scripts)
+  - English Writing M1 (18th-19th century English)
+  - German Kurrent models
+  - Dutch, French, Italian, Spanish models available
+
+Training a custom model:
+  - Requires ~15,000-25,000 words of ground truth (manually transcribed)
+  - Can start with a pre-trained base model and fine-tune
+  - Training takes 1-8 hours depending on dataset size
+```
+
+### Other Tools
+
+| Tool | Type | Strengths |
+|------|------|----------|
+| Transkribus | Cloud platform | Best for historical documents, active community |
+| Kraken | Open source (Python) | Flexible, scriptable, custom training |
+| eScriptorium | Open source (web) | Based on Kraken, collaborative interface |
+| Google Cloud Vision | API | Good for modern handwriting, many languages |
+| Azure AI Vision | API | Competitive with Google for modern text |
+| HTR-Flor | Open source | Research-focused, PyTorch-based |
+
+## Image Preprocessing
+
+### Preparing Scans for HTR
+
+```python
+from PIL import Image, ImageFilter, ImageEnhance
+
+
+def preprocess_document_image(image_path: str,
+                               output_path: str) -> dict:
+    """
+    Preprocess a document scan for optimal HTR performance.
+
+    Args:
+        image_path: Path to the input scan
+        output_path: Path to save the preprocessed image
+    """
+    img = Image.open(image_path)
+
+    # Convert to grayscale
+    img = img.convert("L")
+
+    # Enhance contrast
+    enhancer = ImageEnhance.Contrast(img)
+    img = enhancer.enhance(1.5)
+
+    # Remove noise
+    img = img.filter(ImageFilter.MedianFilter(size=3))
+
+    # Binarize (convert to black and white)
+    threshold = 128
+    img = img.point(lambda x: 255 if x > threshold else 0, "1")
+
+    img.save(output_path)
+
+    return {
+        "original": image_path,
+        "processed": output_path,
+        "steps_applied": [
+            "Grayscale conversion",
+            "Contrast enhancement (1.5x)",
+            "Median filter (noise removal)",
+            "Binarization (threshold=128)"
+        ],
+        "additional_steps_if_needed": [
+            "Deskewing (correct rotation)",
+            "Dewarping (correct page curvature)",
+            "Bleed-through removal",
+            "Background normalization"
+        ]
+    }
+```
+
+### Scanning Best Practices
+
+```
+Resolution:    300-400 DPI for most documents
+               600 DPI for fine handwriting or damaged originals
+Color:         Grayscale usually sufficient; color for illuminated MSS
+Format:        TIFF (lossless) for archival; PNG for working copies
+Lighting:      Even, diffused light; avoid shadows and glare
+Flatness:      Use a book cradle or V-shaped scanner for bound volumes
+Calibration:   Include a color/grayscale chart for batch consistency
+```
+
+## Post-OCR Correction
+
+### Semi-Automated Correction Workflow
+
+```python
+def post_correction_workflow(raw_transcription: str,
+                              dictionary: set,
+                              confidence_threshold: float = 0.8) -> dict:
+    """
+    Post-correction strategy for HTR output.
+
+    Args:
+        raw_transcription: Raw OCR/HTR text output
+        dictionary: Set of valid words for the document's language/period
+        confidence_threshold: Below this, flag for manual review
+    """
+    words = raw_transcription.split()
+    flagged = []
+    corrected = []
+
+    for word in words:
+        clean = word.strip(".,;:!?()[]")
+        if clean.lower() in dictionary:
+            corrected.append(word)
+        else:
+            flagged.append({
+                "word": word,
+                "position": len(corrected),
+                "suggestion": "Manual review needed"
+            })
+            corrected.append(word)
+
+    return {
+        "total_words": len(words),
+        "flagged_words": len(flagged),
+        "estimated_accuracy": 1 - len(flagged) / max(len(words), 1),
+        "flagged": flagged[:20],
+        "correction_strategies": [
+            "Dictionary-based spell checking (period-appropriate dictionary)",
+            "N-gram language model for context-aware correction",
+            "Crowdsourcing (Zooniverse, FromThePage)",
+            "Double-keying (two independent transcribers, compare)",
+            "AI-assisted correction with human verification"
+        ]
+    }
+```
+
+## Integration with Research Workflows
+
+### From Transcription to Analysis
+
+```
+1. Transcribe documents using HTR
+2. Correct and validate transcriptions
+3. Encode in TEI-XML for digital editions
+4. Apply NLP for named entity recognition, topic modeling
+5. Link entities to knowledge bases (Wikidata, VIAF)
+6. Publish as a searchable digital archive
+
+Tools for TEI encoding:
+  - oXygen XML Editor (standard for digital humanities)
+  - TEI Publisher (web-based publishing platform)
+  - FromThePage (collaborative transcription with TEI export)
+```
+
+## Evaluating HTR Accuracy
+
+Report Character Error Rate (CER) and Word Error Rate (WER) on a held-out test set. CER below 5% is generally considered production-quality for historical documents. Always compare against a manually created ground truth. Report accuracy separately for different document types, hands, or time periods if your corpus is heterogeneous.

package/skills/tools/ocr-translate/latex-ocr-guide/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: latex-ocr-guide
+description: "Extract and convert mathematical formulas from images and PDFs to LaTeX code"
+metadata:
+  openclaw:
+    emoji: "mag"
+    category: "tools"
+    subcategory: "ocr-translate"
+    keywords: ["math OCR", "formula recognition", "LaTeX OCR", "document OCR", "equation extraction"]
+    source: "wentor"
+---
+
+# LaTeX OCR Guide
+
+A skill for extracting mathematical formulas from images, PDFs, and handwritten notes and converting them to LaTeX code. Covers tool selection, batch processing workflows, and quality verification techniques.
+
+## Tool Landscape
+
+### Available Math OCR Tools
+
+| Tool | Type | Accuracy | Best For | License |
+|------|------|----------|----------|---------|
+| Mathpix | Cloud API | Very high | All math, diagrams | Commercial ($) |
+| LaTeX-OCR (Lukas Blecher) | Local model | High | Printed formulas | MIT |
+| Pix2Tex | Local model | High | Single equations | MIT |
+| Nougat (Meta) | Local model | High | Full papers with math | MIT |
+| InftyReader | Desktop | High | Printed math, Japanese | Commercial |
+| img2latex | Local model | Moderate | Simple equations | MIT |
+
+### Quick Start with LaTeX-OCR
+
+```bash
+# Install the open-source LaTeX-OCR package
+pip install "pix2tex[gui]"
+
+# Or install from GitHub for latest version
+pip install git+https://github.com/lukas-blecher/LaTeX-OCR.git
+```
+
+```python
+from pix2tex.cli import LatexOCR
+from PIL import Image
+
+def recognize_formula(image_path: str) -> str:
+    """
+    Convert a formula image to LaTeX code.
+
+    Args:
+        image_path: Path to image containing a mathematical formula
+    Returns:
+        LaTeX string representation of the formula
+    """
+    model = LatexOCR()
+    img = Image.open(image_path)
+    latex_code = model(img)
+    return latex_code
+
+# Single image
+result = recognize_formula('formula.png')
+print(result)
+# Output: E = mc^{2}
+```
+
+## Batch Processing Workflow
+
+### Processing Multiple Formulas from a PDF
+
+```python
+import fitz  # PyMuPDF
+from PIL import Image
+import io
+
+def extract_formulas_from_pdf(pdf_path: str, output_dir: str,
+                                min_height: int = 30) -> list[dict]:
+    """
+    Extract formula regions from a PDF and convert to LaTeX.
+
+    Args:
+        pdf_path: Path to the PDF file
+        output_dir: Directory to save extracted formula images
+        min_height: Minimum height (px) to consider as formula region
+    """
+    doc = fitz.open(pdf_path)
+    model = LatexOCR()
+    results = []
+
+    for page_num in range(len(doc)):
+        page = doc[page_num]
+        # Extract images from page
+        image_list = page.get_images(full=True)
+
+        for img_idx, img_info in enumerate(image_list):
+            xref = img_info[0]
+            pix = fitz.Pixmap(doc, xref)
+
+            if pix.height >= min_height:
+                img_data = pix.tobytes("png")
+                img = Image.open(io.BytesIO(img_data))
+
+                try:
+                    latex = model(img)
+                    results.append({
+                        'page': page_num + 1,
+                        'image_index': img_idx,
+                        'latex': latex,
+                        'confidence': 'high' if len(latex) > 3 else 'low'
+                    })
+                except Exception as e:
+                    results.append({
+                        'page': page_num + 1,
+                        'image_index': img_idx,
+                        'latex': None,
+                        'error': str(e)
+                    })
+
+    return results
+```
+
+### Processing Handwritten Notes
+
+For handwritten mathematics, preprocessing improves accuracy significantly:
+
+```python
+import cv2
+import numpy as np
+
+def preprocess_handwritten(image_path: str) -> Image.Image:
+    """
+    Preprocess a handwritten formula image for better OCR accuracy.
+    """
+    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+
+    # 1. Denoise
+    img = cv2.fastNlMeansDenoising(img, h=10)
+
+    # 2. Adaptive thresholding for varying illumination
+    img = cv2.adaptiveThreshold(
+        img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY, 15, 8
+    )
+
+    # 3. Dilation to connect broken strokes
+    kernel = np.ones((2, 2), np.uint8)
+    img = cv2.dilate(img, kernel, iterations=1)
+
+    # 4. Crop to content with padding
+    coords = cv2.findNonZero(255 - img)
+    x, y, w, h = cv2.boundingRect(coords)
+    pad = 20
+    img = img[max(0, y-pad):y+h+pad, max(0, x-pad):x+w+pad]
+
+    return Image.fromarray(img)
+```
+
+## Using Mathpix API
+
+For production-quality results, the Mathpix API provides the highest accuracy:
+
+```python
+import requests
+import base64
+
+def mathpix_ocr(image_path: str, app_id: str, app_key: str) -> dict:
+    """
+    Use Mathpix API for high-accuracy math OCR.
+    """
+    with open(image_path, 'rb') as f:
+        image_data = base64.b64encode(f.read()).decode()
+
+    response = requests.post(
+        'https://api.mathpix.com/v3/text',
+        headers={
+            'app_id': app_id,
+            'app_key': app_key,
+            'Content-type': 'application/json'
+        },
+        json={
+            'src': f'data:image/png;base64,{image_data}',
+            'formats': ['latex_styled', 'text'],
+            'data_options': {'include_asciimath': True}
+        }
+    )
+    return response.json()
+```
+
+## Verification and Correction
+
+Always verify OCR output by rendering the LaTeX:
+
+```python
+import matplotlib.pyplot as plt
+
+def verify_latex(latex_string: str, output_path: str = 'verify.png'):
+    """Render LaTeX formula and save as image for visual verification."""
+    fig, ax = plt.subplots(figsize=(8, 2))
+    ax.text(0.5, 0.5, f'${latex_string}$', fontsize=20,
+            ha='center', va='center', transform=ax.transAxes)
+    ax.axis('off')
+    fig.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Verification image saved to {output_path}")
+```
+
+Common OCR errors to watch for: confusing `l` with `1`, `O` with `0`, missing superscripts/subscripts, incorrect fraction nesting, and misrecognized Greek letters. Always proofread critical equations before submission.

package/skills/tools/ocr-translate/multilingual-research-guide/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: multilingual-research-guide
+description: "Strategies for translating academic papers while preserving technical accuracy"
+metadata:
+  openclaw:
+    emoji: "globe_with_meridians"
+    category: "tools"
+    subcategory: "ocr-translate"
+    keywords: ["translation strategies", "document OCR", "math OCR", "academic writing", "multilingual research"]
+    source: "wentor"
+---
+
+# Academic Translation Guide
+
+A skill for translating academic papers, theses, and research documents between languages while preserving technical precision, citation integrity, and discipline-specific terminology. Covers workflow design, terminology management, and quality assurance.
+
+## Translation Workflow
+
+### End-to-End Pipeline
+
+```
+Source Document
+  |
+  v
+1. Document Preparation
+   - Extract text (OCR if scanned)
+   - Identify formulas, figures, tables (do NOT translate these)
+   - Build terminology glossary
+  |
+  v
+2. Segmentation
+   - Split into translatable units (sentences/paragraphs)
+   - Tag non-translatable elements: equations, citations, proper nouns
+  |
+  v
+3. Translation
+   - Apply machine translation (first pass)
+   - Human post-editing (second pass)
+   - Terminology consistency check (third pass)
+  |
+  v
+4. Quality Assurance
+   - Back-translation verification (sample)
+   - Domain expert review
+   - Formatting and citation check
+  |
+  v
+Target Document
+```
+
+## Terminology Management
+
+### Building a Domain Glossary
+
+```python
+import json
+
+def build_terminology_glossary(source_text: str, domain: str,
+                                source_lang: str = 'zh',
+                                target_lang: str = 'en') -> list[dict]:
+    """
+    Extract and standardize technical terms from source text.
+
+    Args:
+        source_text: Raw text of the source document
+        domain: Research domain (e.g., 'machine_learning', 'biochemistry')
+        source_lang: Source language code
+        target_lang: Target language code
+    Returns:
+        List of terminology entries
+    """
+    # Common domain-specific glossaries
+    glossaries = {
+        'machine_learning': {
+            'zh_en': {
+                '过拟合': 'overfitting',
+                '欠拟合': 'underfitting',
+                '梯度下降': 'gradient descent',
+                '损失函数': 'loss function',
+                '卷积神经网络': 'convolutional neural network',
+                '注意力机制': 'attention mechanism',
+                '预训练模型': 'pre-trained model',
+                '微调': 'fine-tuning',
+                '批归一化': 'batch normalization',
+                '学习率': 'learning rate'
+            }
+        },
+        'biochemistry': {
+            'zh_en': {
+                '蛋白质折叠': 'protein folding',
+                '酶动力学': 'enzyme kinetics',
+                '基因表达': 'gene expression',
+                '转录因子': 'transcription factor',
+                '信号通路': 'signaling pathway',
+                '代谢组学': 'metabolomics'
+            }
+        }
+    }
+
+    domain_terms = glossaries.get(domain, {}).get(f'{source_lang}_{target_lang}', {})
+
+    entries = []
+    for source_term, target_term in domain_terms.items():
+        if source_term in source_text:
+            entries.append({
+                'source': source_term,
+                'target': target_term,
+                'domain': domain,
+                'verified': True,
+                'notes': ''
+            })
+    return entries
+```
+
+### Terminology Consistency Enforcement
+
+```python
+def enforce_terminology(translated_text: str,
+                         glossary: list[dict]) -> tuple[str, list[str]]:
+    """
+    Check and enforce terminology consistency in translated text.
+
+    Returns:
+        Tuple of (corrected_text, list of warnings)
+    """
+    warnings = []
+    corrected = translated_text
+
+    for entry in glossary:
+        target_term = entry['target']
+        # Check for common mistranslations or inconsistent usage
+        variants = entry.get('incorrect_variants', [])
+        for variant in variants:
+            if variant.lower() in corrected.lower():
+                warnings.append(
+                    f"Found '{variant}' -- should be '{target_term}'"
+                )
+                # Case-insensitive replacement
+                import re
+                corrected = re.sub(
+                    re.escape(variant), target_term, corrected,
+                    flags=re.IGNORECASE
+                )
+
+    return corrected, warnings
+```
+
+## Machine Translation Integration
+
+### Using DeepL API for Academic Text
+
+```python
+import deepl
+
+def translate_academic_text(text: str, source_lang: str, target_lang: str,
+                             auth_key: str, glossary_id: str = None) -> str:
+    """
+    Translate academic text using DeepL with optional glossary.
+    """
+    translator = deepl.Translator(auth_key)
+
+    result = translator.translate_text(
+        text,
+        source_lang=source_lang.upper(),
+        target_lang=target_lang.upper(),
+        formality="more",  # academic style
+        glossary=glossary_id,
+        preserve_formatting=True,
+        tag_handling="xml"  # preserve XML/HTML tags
+    )
+    return result.text
+```
+
+### Protecting Non-Translatable Elements
+
+Before sending text to any translation engine, protect elements that should not be translated:
+
+```python
+import re
+
+def protect_elements(text: str) -> tuple[str, dict]:
+    """
+    Replace non-translatable elements with placeholders.
+    Returns protected text and a mapping to restore later.
+    """
+    placeholders = {}
+    counter = 0
+
+    # Protect LaTeX equations
+    for pattern in [r'\$\$.*?\$\$', r'\$.*?\$', r'\\begin\{equation\}.*?\\end\{equation\}']:
+        for match in re.finditer(pattern, text, re.DOTALL):
+            key = f'__MATH_{counter}__'
+            placeholders[key] = match.group()
+            text = text.replace(match.group(), key, 1)
+            counter += 1
+
+    # Protect citations
+    for match in re.finditer(r'\\cite\{[^}]+\}|\([A-Z][a-z]+(?:\s+et\s+al\.)?,\s*\d{4}\)', text):
+        key = f'__CITE_{counter}__'
+        placeholders[key] = match.group()
+        text = text.replace(match.group(), key, 1)
+        counter += 1
+
+    # Protect URLs
+    for match in re.finditer(r'https?://\S+', text):
+        key = f'__URL_{counter}__'
+        placeholders[key] = match.group()
+        text = text.replace(match.group(), key, 1)
+        counter += 1
+
+    return text, placeholders
+
+def restore_elements(text: str, placeholders: dict) -> str:
+    """Restore protected elements from placeholders."""
+    for key, value in placeholders.items():
+        text = text.replace(key, value)
+    return text
+```
+
+## Quality Assurance
+
+### Back-Translation Verification
+
+For critical documents, perform back-translation on a random 10-20% sample of paragraphs. Compare the back-translated text with the original to identify semantic drift. Flag any paragraph where back-translation diverges significantly from the source.
+
+### Checklist Before Submission
+
+1. All technical terms match the domain glossary
+2. All equations, formulas, and figures are unchanged
+3. All citations and references are intact and correctly formatted
+4. Author names and institutional affiliations are not translated
+5. Abbreviations are defined on first use in the target language
+6. The abstract has been reviewed by a domain expert in the target language
+7. Journal-specific terminology preferences have been applied