test

.python-version

@@ -0,0 +1 @@
+3.10

app.py

@@ -1,7 +1,861 @@
 import gradio as gr
+import yaml
+import json
+import base64
+import tempfile
+import os
+from typing import Dict, List, Optional, Literal
+from datetime import datetime
+from PIL import Image, ImageDraw, ImageFont
+import io
 
-def greet(name):
-    return "Hello " + name + "!!"
+from htrflow.volume.volume import Collection
+from htrflow.pipeline.pipeline import Pipeline
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+PIPELINE_CONFIGS = {
+    "letter_english": {
+        "steps": [
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {
+                        "model": "Riksarkivet/yolov9-lines-within-regions-1"
+                    },
+                    "generation_settings": {"batch_size": 8},
+                },
+            },
+            {
+                "step": "TextRecognition",
+                "settings": {
+                    "model": "TrOCR",
+                    "model_settings": {"model": "microsoft/trocr-base-handwritten"},
+                    "generation_settings": {"batch_size": 16},
+                },
+            },
+            {"step": "OrderLines"},
+        ]
+    },
+    "letter_swedish": {
+        "steps": [
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {
+                        "model": "Riksarkivet/yolov9-lines-within-regions-1"
+                    },
+                    "generation_settings": {"batch_size": 8},
+                },
+            },
+            {
+                "step": "TextRecognition",
+                "settings": {
+                    "model": "TrOCR",
+                    "model_settings": {
+                        "model": "Riksarkivet/trocr-base-handwritten-hist-swe-2"
+                    },
+                    "generation_settings": {"batch_size": 16},
+                },
+            },
+            {"step": "OrderLines"},
+        ]
+    },
+    "spread_english": {
+        "steps": [
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {"model": "Riksarkivet/yolov9-regions-1"},
+                    "generation_settings": {"batch_size": 4},
+                },
+            },
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {
+                        "model": "Riksarkivet/yolov9-lines-within-regions-1"
+                    },
+                    "generation_settings": {"batch_size": 8},
+                },
+            },
+            {
+                "step": "TextRecognition",
+                "settings": {
+                    "model": "TrOCR",
+                    "model_settings": {"model": "microsoft/trocr-base-handwritten"},
+                    "generation_settings": {"batch_size": 16},
+                },
+            },
+            {"step": "ReadingOrderMarginalia", "settings": {"two_page": True}},
+        ]
+    },
+    "spread_swedish": {
+        "steps": [
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {"model": "Riksarkivet/yolov9-regions-1"},
+                    "generation_settings": {"batch_size": 4},
+                },
+            },
+            {
+                "step": "Segmentation",
+                "settings": {
+                    "model": "yolo",
+                    "model_settings": {
+                        "model": "Riksarkivet/yolov9-lines-within-regions-1"
+                    },
+                    "generation_settings": {"batch_size": 8},
+                },
+            },
+            {
+                "step": "TextRecognition",
+                "settings": {
+                    "model": "TrOCR",
+                    "model_settings": {
+                        "model": "Riksarkivet/trocr-base-handwritten-hist-swe-2"
+                    },
+                    "generation_settings": {"batch_size": 16},
+                },
+            },
+            {"step": "ReadingOrderMarginalia", "settings": {"two_page": True}},
+        ]
+    },
+}
+
+@spaces.GPU
+def process_htr(
+    image: Image.Image,
+    document_type: Literal[
+        "letter_english", "letter_swedish", "spread_english", "spread_swedish"
+    ] = "spread_swedish",
+    confidence_threshold: float = 0.8,
+    custom_settings: Optional[str] = None,
+) -> Dict:
+    """
+    Process handwritten text recognition on uploaded images using HTRflow pipelines.
+
+    Supports templates for different document types (letters vs spreads) and
+    languages (English vs Swedish). Uses HTRflow's modular pipeline system with
+    configurable segmentation and text recognition models.
+
+    Args:
+        image (Image.Image): PIL Image object to process
+        document_type (str): Type of document processing template to use
+        confidence_threshold (float): Minimum confidence threshold for text recognition
+        custom_settings (str, optional): JSON string with custom pipeline settings
+
+    Returns:
+        dict: Processing results including extracted text, metadata, and processing state
+    """
+    try:
+        if image is None:
+            return {"success": False, "error": "No image provided", "results": None}
+
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
+            image.save(temp_file.name, "PNG")
+            temp_image_path = temp_file.name
+
+        try:
+            if custom_settings:
+                try:
+                    config = json.loads(custom_settings)
+                except json.JSONDecodeError:
+                    return {
+                        "success": False,
+                        "error": "Invalid JSON in custom_settings parameter",
+                        "results": None,
+                    }
+            else:
+                config = PIPELINE_CONFIGS[document_type]
+
+            collection = Collection([temp_image_path])
+
+            pipeline = Pipeline.from_config(config)
+            processed_collection = pipeline.run(collection)
+
+            results = extract_processing_results(
+                processed_collection, confidence_threshold
+            )
+
+            img_buffer = io.BytesIO()
+            image.save(img_buffer, format="PNG")
+            image_base64 = base64.b64encode(img_buffer.getvalue()).decode("utf-8")
+
+            processing_state = {
+                "collection": serialize_collection(processed_collection),
+                "config": config,
+                "image_base64": image_base64,
+                "image_size": image.size,
+                "document_type": document_type,
+                "confidence_threshold": confidence_threshold,
+                "timestamp": datetime.now().isoformat(),
+            }
+
+            return {
+                "success": True,
+                "results": results,
+                "processing_state": json.dumps(processing_state),
+                "metadata": {
+                    "total_lines": len(results.get("text_lines", [])),
+                    "average_confidence": calculate_average_confidence(results),
+                    "document_type": document_type,
+                    "image_dimensions": image.size,
+                },
+            }
+
+        finally:
+            if os.path.exists(temp_image_path):
+                os.unlink(temp_image_path)
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"HTR processing failed: {str(e)}",
+            "results": None,
+        }
+
+
+def visualize_results(
+    processing_state: str,
+    visualization_type: Literal[
+        "overlay", "confidence_heatmap", "text_regions"
+    ] = "overlay",
+    show_confidence: bool = True,
+    highlight_low_confidence: bool = True,
+    image: Optional[Image.Image] = None,
+) -> Dict:
+    """
+    Generate interactive visualizations of HTR processing results.
+
+    Creates visual representations of text recognition results including bounding box
+    overlays, confidence heatmaps, and region segmentation displays. Supports multiple
+    visualization modes for different analysis needs.
+
+    Args:
+        processing_state (str): JSON string containing HTR processing results and metadata
+        visualization_type (str): Type of visualization to generate
+        show_confidence (bool): Whether to display confidence scores on visualization
+        highlight_low_confidence (bool): Whether to highlight low-confidence regions
+        image (Image.Image, optional): PIL Image object to use instead of state image
+
+    Returns:
+        dict: Visualization data including base64-encoded images and metadata
+    """
+    try:
+        state = json.loads(processing_state)
+        collection = deserialize_collection(state["collection"])
+        confidence_threshold = state["confidence_threshold"]
+
+        if image is not None:
+            original_image = image
+        else:
+            image_data = base64.b64decode(state["image_base64"])
+            original_image = Image.open(io.BytesIO(image_data))
+
+        if visualization_type == "overlay":
+            viz_image = create_text_overlay_visualization(
+                original_image, collection, show_confidence, highlight_low_confidence
+            )
+        elif visualization_type == "confidence_heatmap":
+            viz_image = create_confidence_heatmap(
+                original_image, collection, confidence_threshold
+            )
+        elif visualization_type == "text_regions":
+            viz_image = create_region_visualization(original_image, collection)
+
+        img_buffer = io.BytesIO()
+        viz_image.save(img_buffer, format="PNG")
+        img_base64 = base64.b64encode(img_buffer.getvalue()).decode("utf-8")
+
+        viz_metadata = generate_visualization_metadata(collection, visualization_type)
+
+        return {
+            "success": True,
+            "visualization": {
+                "image_base64": img_base64,
+                "image_format": "PNG",
+                "visualization_type": visualization_type,
+                "dimensions": viz_image.size,
+            },
+            "metadata": viz_metadata,
+            "interactive_elements": extract_interactive_elements(collection),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Visualization generation failed: {str(e)}",
+            "visualization": None,
+        }
+
+
+def export_results(
+    processing_state: str,
+    output_formats: List[Literal["txt", "json", "alto", "page"]] = ["txt"],
+    include_metadata: bool = True,
+    confidence_filter: float = 0.0,
+) -> Dict:
+    """
+    Export HTR results to multiple formats including plain text, structured JSON, ALTO XML, and PAGE XML.
+
+    Supports HTRflow's native export functionality with configurable output formats and
+    filtering options. Maintains document structure and metadata across all export formats.
+
+    Args:
+        processing_state (str): JSON string containing HTR processing results
+        output_formats (List[str]): List of output formats to generate
+        include_metadata (bool): Whether to include processing metadata in exports
+        confidence_filter (float): Minimum confidence threshold for included text
+
+    Returns:
+        dict: Export results with content for each requested format
+    """
+    try:
+        # Parse processing state
+        state = json.loads(processing_state)
+        collection = deserialize_collection(state["collection"])
+        config = state["config"]
+
+        # Generate exports for each requested format
+        exports = {}
+
+        for format_type in output_formats:
+            if format_type == "txt":
+                exports["txt"] = export_plain_text(
+                    collection, confidence_filter, include_metadata
+                )
+            elif format_type == "json":
+                exports["json"] = export_structured_json(
+                    collection, confidence_filter, include_metadata
+                )
+            elif format_type == "alto":
+                exports["alto"] = export_alto_xml(
+                    collection, confidence_filter, include_metadata
+                )
+            elif format_type == "page":
+                exports["page"] = export_page_xml(
+                    collection, confidence_filter, include_metadata
+                )
+
+        # Calculate export statistics
+        export_stats = calculate_export_statistics(collection, confidence_filter)
+
+        return {
+            "success": True,
+            "exports": exports,
+            "statistics": export_stats,
+            "export_metadata": {
+                "formats_generated": output_formats,
+                "confidence_filter": confidence_filter,
+                "include_metadata": include_metadata,
+                "timestamp": datetime.now().isoformat(),
+            },
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Export generation failed: {str(e)}",
+            "exports": None,
+        }
+
+
+# Helper Functions
+def extract_processing_results(
+    collection: Collection, confidence_threshold: float
+) -> Dict:
+    """Extract structured results from processed HTRflow Collection."""
+    results = {
+        "extracted_text": "",
+        "text_lines": [],
+        "regions": [],
+        "confidence_scores": [],
+    }
+
+    # Traverse collection hierarchy to extract text and metadata
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                if (
+                    hasattr(node, "confidence")
+                    and node.confidence >= confidence_threshold
+                ):
+                    results["text_lines"].append(
+                        {
+                            "text": node.text,
+                            "confidence": node.confidence,
+                            "bbox": getattr(node, "bbox", None),
+                            "node_id": getattr(node, "id", None),
+                        }
+                    )
+                    results["extracted_text"] += node.text + "\n"
+                    results["confidence_scores"].append(node.confidence)
+
+    return results
+
+
+def serialize_collection(collection: Collection) -> str:
+    """Serialize HTRflow Collection to JSON string for state storage."""
+    serialized_data = {"pages": [], "metadata": getattr(collection, "metadata", {})}
+
+    for page in collection.pages:
+        page_data = {
+            "nodes": [],
+            "image_path": getattr(page, "image_path", None),
+            "dimensions": getattr(page, "dimensions", None),
+        }
+
+        for node in page.traverse():
+            node_data = {
+                "text": getattr(node, "text", ""),
+                "confidence": getattr(node, "confidence", 1.0),
+                "bbox": getattr(node, "bbox", None),
+                "node_id": getattr(node, "id", None),
+                "node_type": type(node).__name__,
+            }
+            page_data["nodes"].append(node_data)
+
+        serialized_data["pages"].append(page_data)
+
+    return json.dumps(serialized_data)
+
+
+def deserialize_collection(serialized_data: str):
+    """Deserialize JSON string back to HTRflow Collection."""
+    data = json.loads(serialized_data)
+
+    # Mock collection classes for state reconstruction
+    class MockCollection:
+        def __init__(self, data):
+            self.pages = []
+            for page_data in data.get("pages", []):
+                page = MockPage(page_data)
+                self.pages.append(page)
+
+    class MockPage:
+        def __init__(self, page_data):
+            self.nodes = []
+            for node_data in page_data.get("nodes", []):
+                node = MockNode(node_data)
+                self.nodes.append(node)
+
+        def traverse(self):
+            return self.nodes
+
+    class MockNode:
+        def __init__(self, node_data):
+            self.text = node_data.get("text", "")
+            self.confidence = node_data.get("confidence", 1.0)
+            self.bbox = node_data.get("bbox")
+            self.id = node_data.get("node_id")
+
+    return MockCollection(data)
+
+
+def calculate_average_confidence(results: Dict) -> float:
+    """Calculate average confidence score from processing results."""
+    confidence_scores = results.get("confidence_scores", [])
+    if not confidence_scores:
+        return 0.0
+    return sum(confidence_scores) / len(confidence_scores)
+
+
+def create_text_overlay_visualization(
+    image, collection, show_confidence, highlight_low_confidence
+):
+    """Create image with text bounding boxes and recognition results overlaid."""
+    viz_image = image.copy()
+    draw = ImageDraw.Draw(viz_image)
+
+    # Define visualization styles
+    bbox_color = (0, 255, 0)  # Green for normal confidence
+    low_conf_color = (255, 165, 0)  # Orange for low confidence
+    text_color = (255, 255, 255)  # White text
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 12)
+    except:
+        font = ImageFont.load_default()
+
+    # Draw bounding boxes and text for each recognized element
+    for page in collection.pages:
+        for node in page.traverse():
+            if (
+                hasattr(node, "bbox")
+                and hasattr(node, "text")
+                and node.bbox
+                and node.text
+            ):
+                bbox = node.bbox
+                confidence = getattr(node, "confidence", 1.0)
+
+                # Choose color based on confidence
+                if highlight_low_confidence and confidence < 0.7:
+                    color = low_conf_color
+                else:
+                    color = bbox_color
+
+                # Draw bounding box
+                draw.rectangle(bbox, outline=color, width=2)
+
+                # Add confidence score if requested
+                if show_confidence:
+                    conf_text = f"{confidence:.2f}"
+                    draw.text((bbox[0], bbox[1] - 15), conf_text, fill=color, font=font)
+
+    return viz_image
+
+
+def create_confidence_heatmap(image, collection, confidence_threshold):
+    """Create confidence heatmap visualization."""
+    viz_image = image.copy()
+
+    # Create heatmap overlay based on confidence scores
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "bbox") and hasattr(node, "confidence") and node.bbox:
+                confidence = node.confidence
+                # Color mapping: red (low) -> yellow (medium) -> green (high)
+                if confidence < 0.5:
+                    color = (255, 0, 0, 100)  # Red with transparency
+                elif confidence < 0.8:
+                    color = (255, 255, 0, 100)  # Yellow with transparency
+                else:
+                    color = (0, 255, 0, 100)  # Green with transparency
+
+                # Create overlay image for transparency
+                overlay = Image.new("RGBA", viz_image.size, (0, 0, 0, 0))
+                overlay_draw = ImageDraw.Draw(overlay)
+                overlay_draw.rectangle(node.bbox, fill=color)
+                viz_image = Image.alpha_composite(viz_image.convert("RGBA"), overlay)
+
+    return viz_image.convert("RGB")
+
+
+def create_region_visualization(image, collection):
+    """Create region segmentation visualization."""
+    viz_image = image.copy()
+    draw = ImageDraw.Draw(viz_image)
+
+    # Draw different colors for different region types
+    region_colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)]
+    region_count = 0
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "bbox") and node.bbox:
+                color = region_colors[region_count % len(region_colors)]
+                draw.rectangle(node.bbox, outline=color, width=3)
+                region_count += 1
+
+    return viz_image
+
+
+def generate_visualization_metadata(collection, visualization_type):
+    """Generate metadata for visualization results."""
+    total_elements = 0
+    confidence_stats = []
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                total_elements += 1
+                if hasattr(node, "confidence"):
+                    confidence_stats.append(node.confidence)
+
+    return {
+        "total_elements": total_elements,
+        "visualization_type": visualization_type,
+        "confidence_stats": {
+            "min": min(confidence_stats) if confidence_stats else 0,
+            "max": max(confidence_stats) if confidence_stats else 0,
+            "avg": sum(confidence_stats) / len(confidence_stats)
+            if confidence_stats
+            else 0,
+        },
+    }
+
+
+def extract_interactive_elements(collection):
+    """Extract interactive elements for visualization."""
+    elements = []
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if (
+                hasattr(node, "bbox")
+                and hasattr(node, "text")
+                and node.bbox
+                and node.text
+            ):
+                elements.append(
+                    {
+                        "bbox": node.bbox,
+                        "text": node.text,
+                        "confidence": getattr(node, "confidence", 1.0),
+                        "node_id": getattr(node, "id", None),
+                    }
+                )
+
+    return elements
+
+
+def export_plain_text(
+    collection, confidence_filter: float, include_metadata: bool
+) -> str:
+    """Export recognition results as plain text."""
+    text_lines = []
+
+    if include_metadata:
+        text_lines.append(f"# HTR Export Results")
+        text_lines.append(f"# Confidence Filter: {confidence_filter}")
+        text_lines.append(f"# Export Time: {datetime.now().isoformat()}")
+        text_lines.append("")
+
+    # Extract text from collection hierarchy
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                confidence = getattr(node, "confidence", 1.0)
+                if confidence >= confidence_filter:
+                    text_lines.append(node.text)
+
+    return "\n".join(text_lines)
+
+
+def export_structured_json(
+    collection, confidence_filter: float, include_metadata: bool
+) -> str:
+    """Export results as structured JSON with full hierarchy."""
+    result = {"document": {"pages": []}}
+
+    if include_metadata:
+        result["metadata"] = {
+            "confidence_filter": confidence_filter,
+            "export_time": datetime.now().isoformat(),
+            "total_pages": len(collection.pages),
+        }
+
+    # Build hierarchical structure
+    for page_idx, page in enumerate(collection.pages):
+        page_data = {"page_id": page_idx, "regions": []}
+
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                confidence = getattr(node, "confidence", 1.0)
+                if confidence >= confidence_filter:
+                    node_data = {
+                        "text": node.text,
+                        "confidence": confidence,
+                        "bbox": getattr(node, "bbox", None),
+                        "node_id": getattr(node, "id", None),
+                    }
+                    page_data["regions"].append(node_data)
+
+        result["document"]["pages"].append(page_data)
+
+    return json.dumps(result, indent=2, ensure_ascii=False)
+
+
+def export_alto_xml(
+    collection, confidence_filter: float, include_metadata: bool
+) -> str:
+    """Export results as ALTO XML format."""
+    # Simplified ALTO XML generation
+    xml_lines = ['<?xml version="1.0" encoding="UTF-8"?>']
+    xml_lines.append('<alto xmlns="http://www.loc.gov/standards/alto/ns-v4#">')
+    xml_lines.append("  <Description>")
+    if include_metadata:
+        xml_lines.append(f"    <sourceImageInformation>")
+        xml_lines.append(f"      <fileName>htr_processed_image</fileName>")
+        xml_lines.append(f"    </sourceImageInformation>")
+    xml_lines.append("  </Description>")
+    xml_lines.append("  <Layout>")
+    xml_lines.append("    <Page>")
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                confidence = getattr(node, "confidence", 1.0)
+                if confidence >= confidence_filter:
+                    bbox = getattr(node, "bbox", [0, 0, 100, 20])
+                    xml_lines.append(
+                        f'      <TextLine HPOS="{bbox[0]}" VPOS="{bbox[1]}" WIDTH="{bbox[2] - bbox[0]}" HEIGHT="{bbox[3] - bbox[1]}">'
+                    )
+                    xml_lines.append(
+                        f'        <String CONTENT="{node.text}" WC="{confidence:.3f}"/>'
+                    )
+                    xml_lines.append("      </TextLine>")
+
+    xml_lines.append("    </Page>")
+    xml_lines.append("  </Layout>")
+    xml_lines.append("</alto>")
+
+    return "\n".join(xml_lines)
+
+
+def export_page_xml(
+    collection, confidence_filter: float, include_metadata: bool
+) -> str:
+    """Export results as PAGE XML format."""
+    # Simplified PAGE XML generation
+    xml_lines = ['<?xml version="1.0" encoding="UTF-8"?>']
+    xml_lines.append(
+        '<PcGts xmlns="http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15">'
+    )
+    if include_metadata:
+        xml_lines.append("  <Metadata>")
+        xml_lines.append(f"    <Created>{datetime.now().isoformat()}</Created>")
+        xml_lines.append("  </Metadata>")
+    xml_lines.append("  <Page>")
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                confidence = getattr(node, "confidence", 1.0)
+                if confidence >= confidence_filter:
+                    bbox = getattr(node, "bbox", [0, 0, 100, 20])
+                    xml_lines.append(f"    <TextRegion>")
+                    xml_lines.append(
+                        f'      <Coords points="{bbox[0]},{bbox[1]} {bbox[2]},{bbox[1]} {bbox[2]},{bbox[3]} {bbox[0]},{bbox[3]}"/>'
+                    )
+                    xml_lines.append(f"      <TextLine>")
+                    xml_lines.append(f'        <TextEquiv conf="{confidence:.3f}">')
+                    xml_lines.append(f"          <Unicode>{node.text}</Unicode>")
+                    xml_lines.append("        </TextEquiv>")
+                    xml_lines.append("      </TextLine>")
+                    xml_lines.append("    </TextRegion>")
+
+    xml_lines.append("  </Page>")
+    xml_lines.append("</PcGts>")
+
+    return "\n".join(xml_lines)
+
+
+def calculate_export_statistics(collection, confidence_filter: float) -> Dict:
+    """Calculate statistics for export results."""
+    total_text_elements = 0
+    filtered_text_elements = 0
+    confidence_scores = []
+    total_characters = 0
+
+    for page in collection.pages:
+        for node in page.traverse():
+            if hasattr(node, "text") and node.text:
+                total_text_elements += 1
+                confidence = getattr(node, "confidence", 1.0)
+                confidence_scores.append(confidence)
+
+                if confidence >= confidence_filter:
+                    filtered_text_elements += 1
+                    total_characters += len(node.text)
+
+    return {
+        "total_text_elements": total_text_elements,
+        "filtered_text_elements": filtered_text_elements,
+        "filter_retention_rate": filtered_text_elements / total_text_elements
+        if total_text_elements > 0
+        else 0,
+        "total_characters": total_characters,
+        "average_confidence": sum(confidence_scores) / len(confidence_scores)
+        if confidence_scores
+        else 0,
+        "confidence_range": {
+            "min": min(confidence_scores) if confidence_scores else 0,
+            "max": max(confidence_scores) if confidence_scores else 0,
+        },
+    }
+
+
+# Main Gradio Application with MCP Server
+def create_htrflow_mcp_server():
+    """Create the complete HTRflow MCP server with all three tools."""
+
+    demo = gr.TabbedInterface(
+        [
+            gr.Interface(
+                fn=process_htr,
+                inputs=[
+                    gr.Image(type="pil", label="Upload Image"),
+                    gr.Dropdown(
+                        choices=[
+                            "letter_english",
+                            "letter_swedish",
+                            "spread_english",
+                            "spread_swedish",
+                        ],
+                        value="letter_english",
+                        label="Document Type",
+                    ),
+                    gr.Slider(0.0, 1.0, value=0.8, label="Confidence Threshold"),
+                    gr.Textbox(
+                        label="Custom Settings (JSON)",
+                        placeholder="Optional custom pipeline settings",
+                    ),
+                ],
+                outputs=gr.JSON(label="Processing Results"),
+                title="HTR Processing Tool",
+                description="Process handwritten text using configurable HTRflow pipelines",
+                api_name="process_htr",
+            ),
+            gr.Interface(
+                fn=visualize_results,
+                inputs=[
+                    gr.Textbox(
+                        label="Processing State (JSON)",
+                        placeholder="Paste processing results from HTR tool",
+                    ),
+                    gr.Dropdown(
+                        choices=["overlay", "confidence_heatmap", "text_regions"],
+                        value="overlay",
+                        label="Visualization Type",
+                    ),
+                    gr.Checkbox(value=True, label="Show Confidence Scores"),
+                    gr.Checkbox(value=True, label="Highlight Low Confidence"),
+                    gr.Image(
+                        type="pil",
+                        label="Image (optional - will use image from processing state if not provided)",
+                    ),
+                ],
+                outputs=gr.JSON(label="Visualization Results"),
+                title="Results Visualization Tool",
+                description="Generate interactive visualizations of HTR results",
+                api_name="visualize_results",
+            ),
+            gr.Interface(
+                fn=export_results,
+                inputs=[
+                    gr.Textbox(
+                        label="Processing State (JSON)",
+                        placeholder="Paste processing results from HTR tool",
+                    ),
+                    gr.CheckboxGroup(
+                        choices=["txt", "json", "alto", "page"],
+                        value=["txt"],
+                        label="Output Formats",
+                    ),
+                    gr.Checkbox(value=True, label="Include Metadata"),
+                    gr.Slider(0.0, 1.0, value=0.0, label="Confidence Filter"),
+                ],
+                outputs=gr.JSON(label="Export Results"),
+                title="Export Tool",
+                description="Export HTR results to multiple formats",
+                api_name="export_results",
+            ),
+        ],
+        ["HTR Processing", "Results Visualization", "Export Results"],
+        title="HTRflow MCP Server",
+    )
+
+    return demo
+
+
+# Launch MCP Server
+if __name__ == "__main__":
+    demo = create_htrflow_mcp_server()
+    demo.launch(mcp_server=True, share=False, server_name="0.0.0.0", server_port=7860)

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "app"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "gradio>=5.33.0",
+    "htrflow==0.2.5",
+    "pillow>=11.2.1",
+    "ruff>=0.11.13",
+]

requirements.txt

@@ -0,0 +1,4 @@
+htrflow==0.2.5
+ruff
+gradio>=5.33.0
+pillow