Upload 17 files

README.md

@@ -1,20 +1,61 @@
----
-title: BrailleMenuGen
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Convert Menu images to Braille
-license: mit
----
-
-# 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).
+# Menu to Braille Converter
+
+An AI-powered application that converts food menu images to Braille text for visually impaired users.
+
+## Features
+
+- Upload menu images
+- Extract text using AI-powered document understanding (LayoutLMv2)
+- Process and structure menu text using LLMs
+- Convert text to Braille
+- Display Braille in multiple formats (text, visual, side-by-side)
+- Download as PDF in different formats
+
+## Deployment on Hugging Face Spaces
+
+### Option 1: Direct GitHub Repository Deployment
+
+1. Fork this repository to your GitHub account
+2. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+3. Click "Create new Space"
+4. Choose "Streamlit" as the SDK
+5. Connect your GitHub account and select this repository
+6. Choose hardware requirements (recommend at least GPU for better performance)
+7. Click "Create Space"
+
+### Option 2: Manual Deployment
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose "Streamlit" as the SDK
+4. Give your Space a name
+5. Choose hardware requirements (recommend at least GPU for better performance)
+6. Click "Create Space"
+7. Clone the Space repository locally
+8. Copy all files from this project to the cloned repository
+9. Push the changes to the Space repository
+
+## Hardware Requirements
+
+- **Minimum**: CPU (2 vCPUs, 16 GB RAM)
+- **Recommended**: GPU (T4 or better)
+
+## Models Used
+
+- **Document AI**: microsoft/layoutlmv2-base-uncased
+- **Text Processing**: meta-llama/Meta-Llama-3-8B-Instruct (with fallback to mistralai/Mistral-7B-Instruct-v0.2)
+- **Context Enhancement**: facebook/bart-large-cnn
+
+## Local Development
+
+1. Clone this repository
+2. Install dependencies: `pip install -r requirements.txt` 
+3. Run the application: `streamlit run app.py`
+
+
+## Future Enhancements
+
+- Improved menu section recognition
+- Support for multiple languages
+- Physical Braille printer integration
+- Mobile app version

app.py

@@ -0,0 +1,171 @@
+import streamlit as st
+from PIL import Image
+import io
+import numpy as np
+import base64
+
+# Import our custom modules
+from utils.image_preprocessing import preprocess_image
+from models.document_ai import extract_text_and_layout
+from models.text_processor import process_menu_text
+from models.braille_translator import text_to_braille, get_braille_metadata
+from utils.braille_display import create_braille_html, create_braille_comparison
+from utils.pdf_generator import create_braille_pdf, create_braille_pdf_with_comparison
+
+# Function to create a download link for a PDF
+def get_pdf_download_link(pdf_bytes, filename="braille_menu.pdf", text="Download PDF"):
+    """Generate a link to download the PDF file."""
+    b64 = base64.b64encode(pdf_bytes.read()).decode()
+    href = f'<a href="data:application/pdf;base64,{b64}" download="{filename}">{text}</a>'
+    return href
+
+# App title and description
+st.title("Menu to Braille Converter")
+st.write("Upload a menu image to convert it to Braille text")
+
+# Sidebar for model settings
+st.sidebar.header("Settings")
+use_llm = st.sidebar.checkbox("Use LLM for text processing", value=True)
+use_context = st.sidebar.checkbox("Use AI for context enhancement", value=True)
+show_comparison = st.sidebar.checkbox("Show text/Braille comparison", value=True)
+
+# Add information about the application
+st.sidebar.markdown("---")
+st.sidebar.subheader("About")
+st.sidebar.info(
+    "This application converts menu images to Braille text using AI. "
+    "It extracts text from images using document AI, processes the text with LLMs, "
+    "and converts to Braille."
+)
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a menu image...", type=["jpg", "jpeg", "png"])
+
+# Display uploaded image and process it
+if uploaded_file is not None:
+    # Load and display image
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Uploaded Menu", use_column_width=True)
+    
+    # Add a button to process the image
+    if st.button("Process Menu"):
+        with st.spinner("Processing image..."):
+            # Preprocess the image
+            preprocessed_img = preprocess_image(image)
+            
+            # Extract text using LayoutLMv2
+            try:
+                result = extract_text_and_layout(preprocessed_img)
+                
+                # Display extracted words
+                if result['words']:
+                    raw_text = ' '.join(result['words'])
+                    
+                    # Show raw text in an expandable section
+                    with st.expander("Raw Extracted Text"):
+                        st.text_area("Raw OCR Output", raw_text, height=150)
+                    
+                    # Process text with LLM if enabled
+                    if use_llm:
+                        st.subheader("Processed Menu Text")
+                        with st.spinner("Enhancing text with AI..."):
+                            processed_result = process_menu_text(raw_text)
+                            
+                            if processed_result['success']:
+                                processed_text = processed_result['structured_text']
+                                st.text_area("Structured Menu Text", processed_text, height=200)
+                                
+                                # Store the processed result for later use
+                                st.session_state.processed_text = processed_text
+                                st.session_state.menu_data = processed_result.get('menu_data', {})
+                            else:
+                                st.warning(f"AI processing failed: {processed_result.get('error', 'Unknown error')}")
+                                processed_text = raw_text
+                                st.text_area("Text Output", processed_text, height=200)
+                                st.session_state.processed_text = processed_text
+                    else:
+                        # Just use the raw text
+                        st.subheader("Extracted Text")
+                        processed_text = raw_text
+                        st.text_area("Text Output", processed_text, height=200)
+                        st.session_state.processed_text = processed_text
+                    
+                    # Translate to Braille
+                    st.subheader("Braille Translation")
+                    with st.spinner("Translating to Braille..."):
+                        braille_result = text_to_braille(processed_text, use_context=use_context)
+                        
+                        if braille_result['success']:
+                            # Store for download
+                            st.session_state.braille_text = braille_result['formatted_braille']
+                            
+                            # Display options
+                            display_option = st.radio(
+                                "Display format:",
+                                ["Text Only", "Visual Braille", "Side-by-Side Comparison"]
+                            )
+                            
+                            if display_option == "Text Only":
+                                # Display Braille text as plain text
+                                st.text_area("Braille Output", braille_result['formatted_braille'], height=300)
+                            
+                            elif display_option == "Visual Braille":
+                                # Display Braille with visual representation
+                                braille_html = create_braille_html(braille_result['formatted_braille'])
+                                st.markdown(braille_html, unsafe_allow_html=True)
+                            
+                            else:  # Side-by-Side Comparison
+                                # Display side-by-side comparison
+                                comparison_html = create_braille_comparison(
+                                    processed_text, braille_result['formatted_braille']
+                                )
+                                st.markdown(comparison_html, unsafe_allow_html=True)
+                            
+                            # Display metadata
+                            metadata = get_braille_metadata(processed_text)
+                            st.info(f"Translation contains {metadata['word_count']} words, "
+                                   f"{metadata['character_count']} characters, "
+                                   f"{metadata['line_count']} lines.")
+                            
+                            # Show context summary if available
+                            if braille_result.get('context_summary'):
+                                with st.expander("AI Context Understanding"):
+                                    st.write(braille_result['context_summary'])
+                            
+                            # PDF Download section
+                            st.subheader("Download Options")
+                            
+                            pdf_option = st.selectbox(
+                                "Select PDF format:",
+                                ["Sequential (Text then Braille)", "Side-by-Side Comparison"]
+                            )
+                            
+                            pdf_title = st.text_input("PDF Title:", "Menu in Braille")
+                            
+                            if st.button("Generate PDF"):
+                                with st.spinner("Generating PDF..."):
+                                    if pdf_option == "Sequential (Text then Braille)":
+                                        pdf_buffer = create_braille_pdf(
+                                            processed_text, 
+                                            braille_result['formatted_braille'],
+                                            title=pdf_title
+                                        )
+                                    else:  # Side-by-Side Comparison
+                                        pdf_buffer = create_braille_pdf_with_comparison(
+                                            processed_text,
+                                            braille_result['formatted_braille'],
+                                            title=pdf_title
+                                        )
+                                    
+                                    # Create download link
+                                    st.markdown(
+                                        get_pdf_download_link(pdf_buffer, f"{pdf_title.lower().replace(' ', '_')}.pdf"),
+                                        unsafe_allow_html=True
+                                    )
+                        else:
+                            st.error(f"Braille translation failed: {braille_result.get('error', 'Unknown error')}")
+                else:
+                    st.warning("No text was extracted from the image.")
+                    
+            except Exception as e:
+                st.error(f"Error processing image: {str(e)}")

app_bk.py

@@ -0,0 +1,51 @@
+import streamlit as st
+from PIL import Image
+import io
+import numpy as np
+
+# Import our custom modules
+from utils.image_preprocessing import preprocess_image
+from models.document_ai import extract_text_and_layout
+
+# App title and description
+st.title("Menu to Braille Converter")
+st.write("Upload a menu image to convert it to Braille text")
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a menu image...", type=["jpg", "jpeg", "png"])
+
+# Display uploaded image and process it
+if uploaded_file is not None:
+    # Load and display image
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Uploaded Menu", use_column_width=True)
+    
+    # Add a button to process the image
+    if st.button("Extract Text"):
+        with st.spinner("Processing image..."):
+            # Preprocess the image
+            st.subheader("Preprocessed Image")
+            preprocessed_img = preprocess_image(image)
+            st.image(preprocessed_img, caption="Preprocessed Image", use_column_width=True)
+            
+            # Extract text using LayoutLMv2
+            st.subheader("Extracted Text")
+            try:
+                result = extract_text_and_layout(preprocessed_img)
+                
+                # Display extracted words
+                if result['words']:
+                    text = ' '.join(result['words'])
+                    st.text_area("Extracted Text", text, height=200)
+                else:
+                    st.warning("No text was extracted from the image.")
+                    
+            except Exception as e:
+                st.error(f"Error processing image: {str(e)}")
+    
+    # Placeholders for future functionality
+    st.subheader("Braille Translation")
+    st.info("Braille translation will be implemented in Phase 4")
+    
+    st.subheader("Download Options")
+    st.info("PDF download will be implemented in Phase 5")

app_bk2.py

@@ -0,0 +1,89 @@
+import streamlit as st
+from PIL import Image
+import io
+import numpy as np
+
+# Import our custom modules
+from utils.image_preprocessing import preprocess_image
+from models.document_ai import extract_text_and_layout
+from models.text_processor import process_menu_text
+
+# App title and description
+st.title("Menu to Braille Converter")
+st.write("Upload a menu image to convert it to Braille text")
+
+# Sidebar for model settings
+st.sidebar.header("Settings")
+use_llm = st.sidebar.checkbox("Use LLM for text processing", value=True)
+
+# Add information about the application
+st.sidebar.markdown("---")
+st.sidebar.subheader("About")
+st.sidebar.info(
+    "This application converts menu images to Braille text using AI. "
+    "It extracts text from images using document AI, processes the text with LLMs, "
+    "and will convert to Braille in future versions."
+)
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a menu image...", type=["jpg", "jpeg", "png"])
+
+# Display uploaded image and process it
+if uploaded_file is not None:
+    # Load and display image
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Uploaded Menu", use_column_width=True)
+    
+    # Add a button to process the image
+    if st.button("Process Menu"):
+        with st.spinner("Processing image..."):
+            # Preprocess the image
+            preprocessed_img = preprocess_image(image)
+            
+            # Extract text using LayoutLMv2
+            try:
+                result = extract_text_and_layout(preprocessed_img)
+                
+                # Display extracted words
+                if result['words']:
+                    raw_text = ' '.join(result['words'])
+                    
+                    # Show raw text in an expandable section
+                    with st.expander("Raw Extracted Text"):
+                        st.text_area("Raw OCR Output", raw_text, height=150)
+                    
+                    # Process text with LLM if enabled
+                    if use_llm:
+                        st.subheader("Processed Menu Text")
+                        with st.spinner("Enhancing text with AI..."):
+                            processed_result = process_menu_text(raw_text)
+                            
+                            if processed_result['success']:
+                                st.text_area("Structured Menu Text", 
+                                           processed_result['structured_text'], 
+                                           height=300)
+                                
+                                # Store the processed result for later use
+                                st.session_state.processed_text = processed_result['structured_text']
+                                st.session_state.menu_data = processed_result.get('menu_data', {})
+                            else:
+                                st.warning(f"AI processing failed: {processed_result.get('error', 'Unknown error')}")
+                                st.text_area("Text Output", raw_text, height=300)
+                                st.session_state.processed_text = raw_text
+                    else:
+                        # Just use the raw text
+                        st.subheader("Extracted Text")
+                        st.text_area("Text Output", raw_text, height=300)
+                        st.session_state.processed_text = raw_text
+                else:
+                    st.warning("No text was extracted from the image.")
+                    
+            except Exception as e:
+                st.error(f"Error processing image: {str(e)}")
+    
+    # Placeholders for future functionality
+    st.subheader("Braille Translation")
+    st.info("Braille translation will be implemented in Phase 4")
+    
+    st.subheader("Download Options")
+    st.info("PDF download will be implemented in Phase 5")

app_bk3.py

@@ -0,0 +1,135 @@
+import streamlit as st
+from PIL import Image
+import io
+import numpy as np
+
+# Import our custom modules
+from utils.image_preprocessing import preprocess_image
+from models.document_ai import extract_text_and_layout
+from models.text_processor import process_menu_text
+from models.braille_translator import text_to_braille, get_braille_metadata
+from utils.braille_display import create_braille_html, create_braille_comparison
+
+# App title and description
+st.title("Menu to Braille Converter")
+st.write("Upload a menu image to convert it to Braille text")
+
+# Sidebar for model settings
+st.sidebar.header("Settings")
+use_llm = st.sidebar.checkbox("Use LLM for text processing", value=True)
+use_context = st.sidebar.checkbox("Use AI for context enhancement", value=True)
+show_comparison = st.sidebar.checkbox("Show text/Braille comparison", value=True)
+
+# Add information about the application
+st.sidebar.markdown("---")
+st.sidebar.subheader("About")
+st.sidebar.info(
+    "This application converts menu images to Braille text using AI. "
+    "It extracts text from images using document AI, processes the text with LLMs, "
+    "and converts to Braille."
+)
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a menu image...", type=["jpg", "jpeg", "png"])
+
+# Display uploaded image and process it
+if uploaded_file is not None:
+    # Load and display image
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Uploaded Menu", use_column_width=True)
+    
+    # Add a button to process the image
+    if st.button("Process Menu"):
+        with st.spinner("Processing image..."):
+            # Preprocess the image
+            preprocessed_img = preprocess_image(image)
+            
+            # Extract text using LayoutLMv2
+            try:
+                result = extract_text_and_layout(preprocessed_img)
+                
+                # Display extracted words
+                if result['words']:
+                    raw_text = ' '.join(result['words'])
+                    
+                    # Show raw text in an expandable section
+                    with st.expander("Raw Extracted Text"):
+                        st.text_area("Raw OCR Output", raw_text, height=150)
+                    
+                    # Process text with LLM if enabled
+                    if use_llm:
+                        st.subheader("Processed Menu Text")
+                        with st.spinner("Enhancing text with AI..."):
+                            processed_result = process_menu_text(raw_text)
+                            
+                            if processed_result['success']:
+                                processed_text = processed_result['structured_text']
+                                st.text_area("Structured Menu Text", processed_text, height=200)
+                                
+                                # Store the processed result for later use
+                                st.session_state.processed_text = processed_text
+                                st.session_state.menu_data = processed_result.get('menu_data', {})
+                            else:
+                                st.warning(f"AI processing failed: {processed_result.get('error', 'Unknown error')}")
+                                processed_text = raw_text
+                                st.text_area("Text Output", processed_text, height=200)
+                                st.session_state.processed_text = processed_text
+                    else:
+                        # Just use the raw text
+                        st.subheader("Extracted Text")
+                        processed_text = raw_text
+                        st.text_area("Text Output", processed_text, height=200)
+                        st.session_state.processed_text = processed_text
+                    
+                    # Translate to Braille
+                    st.subheader("Braille Translation")
+                    with st.spinner("Translating to Braille..."):
+                        braille_result = text_to_braille(processed_text, use_context=use_context)
+                        
+                        if braille_result['success']:
+                            # Store for download
+                            st.session_state.braille_text = braille_result['formatted_braille']
+                            
+                            # Display options
+                            display_option = st.radio(
+                                "Display format:",
+                                ["Text Only", "Visual Braille", "Side-by-Side Comparison"]
+                            )
+                            
+                            if display_option == "Text Only":
+                                # Display Braille text as plain text
+                                st.text_area("Braille Output", braille_result['formatted_braille'], height=300)
+                            
+                            elif display_option == "Visual Braille":
+                                # Display Braille with visual representation
+                                braille_html = create_braille_html(braille_result['formatted_braille'])
+                                st.markdown(braille_html, unsafe_allow_html=True)
+                            
+                            else:  # Side-by-Side Comparison
+                                # Display side-by-side comparison
+                                comparison_html = create_braille_comparison(
+                                    processed_text, braille_result['formatted_braille']
+                                )
+                                st.markdown(comparison_html, unsafe_allow_html=True)
+                            
+                            # Display metadata
+                            metadata = get_braille_metadata(processed_text)
+                            st.info(f"Translation contains {metadata['word_count']} words, "
+                                   f"{metadata['character_count']} characters, "
+                                   f"{metadata['line_count']} lines.")
+                            
+                            # Show context summary if available
+                            if braille_result.get('context_summary'):
+                                with st.expander("AI Context Understanding"):
+                                    st.write(braille_result['context_summary'])
+                        else:
+                            st.error(f"Braille translation failed: {braille_result.get('error', 'Unknown error')}")
+                    
+                    # Download options placeholder
+                    st.subheader("Download Options")
+                    st.info("PDF download will be implemented in Phase 5")
+                else:
+                    st.warning("No text was extracted from the image.")
+                    
+            except Exception as e:
+                st.error(f"Error processing image: {str(e)}")

models/braille_translator.py

@@ -0,0 +1,135 @@
+import braille
+from transformers import pipeline
+import re
+
+# Initialize the summarization pipeline for context understanding
+summarizer = None
+
+def get_summarizer():
+    """Get or initialize the summarization model."""
+    global summarizer
+    if summarizer is None:
+        try:
+            # Use a small, efficient model for summarization
+            summarizer = pipeline(
+                "summarization", 
+                model="facebook/bart-large-cnn",
+                max_length=100,
+                min_length=30,
+                truncation=True
+            )
+        except Exception as e:
+            print(f"Error loading summarizer: {str(e)}")
+    return summarizer
+
+def text_to_braille(text, use_context=True):
+    """
+    Convert text to Braille, with optional context enhancement.
+    
+    Args:
+        text: Text to convert to Braille
+        use_context: Whether to use AI to enhance context understanding
+        
+    Returns:
+        Dictionary with Braille text and metadata
+    """
+    try:
+        # Basic Braille translation
+        braille_text = braille.grade2(text)
+        
+        # If context enhancement is enabled
+        context_summary = None
+        if use_context and len(text) > 200:  # Only for longer texts
+            summarizer = get_summarizer()
+            if summarizer:
+                try:
+                    # Generate a summary to understand context
+                    summary_result = summarizer(text)
+                    if summary_result and len(summary_result) > 0:
+                        context_summary = summary_result[0]['summary_text']
+                except Exception as e:
+                    print(f"Summarization error: {str(e)}")
+        
+        # Format the Braille text for better readability
+        formatted_braille = format_braille_text(braille_text)
+        
+        return {
+            'braille_text': braille_text,
+            'formatted_braille': formatted_braille,
+            'context_summary': context_summary,
+            'success': True
+        }
+    except Exception as e:
+        return {
+            'braille_text': '',
+            'error': str(e),
+            'success': False
+        }
+
+def format_braille_text(braille_text, line_length=32):
+    """
+    Format Braille text for better readability.
+    
+    Args:
+        braille_text: Raw Braille text
+        line_length: Maximum characters per line
+        
+    Returns:
+        Formatted Braille text
+    """
+    # Split text by existing newlines first
+    paragraphs = braille_text.split('\n')
+    formatted_paragraphs = []
+    
+    for paragraph in paragraphs:
+        # Skip empty paragraphs
+        if not paragraph.strip():
+            formatted_paragraphs.append('')
+            continue
+            
+        # Word wrap to line_length
+        words = paragraph.split(' ')
+        lines = []
+        current_line = []
+        current_length = 0
+        
+        for word in words:
+            # If adding this word exceeds line length, start a new line
+            if current_length + len(word) + (1 if current_length > 0 else 0) > line_length:
+                lines.append(' '.join(current_line))
+                current_line = [word]
+                current_length = len(word)
+            else:
+                if current_length > 0:
+                    current_length += 1  # Space
+                current_line.append(word)
+                current_length += len(word)
+                
+        # Add the last line if not empty
+        if current_line:
+            lines.append(' '.join(current_line))
+            
+        formatted_paragraphs.append('\n'.join(lines))
+    
+    # Join paragraphs with double newlines
+    return '\n\n'.join(formatted_paragraphs)
+
+def get_braille_metadata(text):
+    """
+    Get metadata about the Braille translation.
+    
+    Args:
+        text: Original text
+        
+    Returns:
+        Dictionary with metadata
+    """
+    word_count = len(re.findall(r'\b\w+\b', text))
+    character_count = len(text)
+    line_count = len(text.split('\n'))
+    
+    return {
+        'word_count': word_count,
+        'character_count': character_count,
+        'line_count': line_count
+    }

models/document_ai.py

@@ -0,0 +1,53 @@
+import torch
+from transformers import LayoutLMv2Processor, LayoutLMv2ForTokenClassification
+from PIL import Image
+import numpy as np
+
+# Initialize the model and processor with caching
+processor = None
+model = None
+
+def get_document_ai_models():
+    """Get or initialize document AI models with proper caching."""
+    global processor, model
+    if processor is None:
+        processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")
+    if model is None:
+        model = LayoutLMv2ForTokenClassification.from_pretrained("microsoft/layoutlmv2-base-uncased")
+    return processor, model
+
+def extract_text_and_layout(image):
+    """
+    Extract text and layout information using LayoutLMv2.
+    
+    Args:
+        image: PIL Image object
+        
+    Returns:
+        Dictionary with extracted text and layout information
+    """
+    # Get models with lazy loading
+    processor, model = get_document_ai_models()
+    
+    # Convert numpy array to PIL Image if needed
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image).convert("RGB")
+    
+    # Prepare inputs for the model
+    encoding = processor(image, return_tensors="pt")
+    
+    # Get the input_ids (tokenized text)
+    input_ids = encoding.input_ids
+    
+    # Get words from input_ids
+    tokens = processor.tokenizer.convert_ids_to_tokens(input_ids[0])
+    words = processor.tokenizer.convert_tokens_to_string(tokens).split()
+    
+    # Get bounding boxes
+    bbox = encoding.bbox[0]
+    
+    return {
+        'words': words,
+        'boxes': bbox.tolist(),
+        'encoding': encoding,  # Keep for future processing
+    }

models/text_processor.py

@@ -0,0 +1,180 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+import torch
+import json
+
+# Model ID for a smaller model suitable for Spaces
+MODEL_ID = "meta-llama/Meta-Llama-3-8B-Instruct"
+FALLBACK_MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.2"
+
+# Initialize with None - will be loaded on first use
+tokenizer = None
+text_generation_pipeline = None
+
+def get_text_pipeline():
+    """
+    Initialize or return the text generation pipeline.
+    Uses smaller models that work well on Spaces.
+    """
+    global tokenizer, text_generation_pipeline
+    
+    if text_generation_pipeline is None:
+        try:
+            # Try to load primary model
+            tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+            
+            # Use 8-bit quantization to reduce memory usage
+            model = AutoModelForCausalLM.from_pretrained(
+                MODEL_ID, 
+                device_map="auto",
+                torch_dtype=torch.float16,
+                load_in_8bit=True
+            )
+            
+            # Create the pipeline
+            text_generation_pipeline = pipeline(
+                "text-generation",
+                model=model,
+                tokenizer=tokenizer,
+                max_new_tokens=1024,
+                do_sample=True,
+                temperature=0.3,
+                top_p=0.95,
+                repetition_penalty=1.15
+            )
+            
+        except Exception as e:
+            print(f"Error loading primary model: {str(e)}")
+            print(f"Falling back to {FALLBACK_MODEL_ID}")
+            
+            try:
+                # Fall back to Mistral model which is more widely available
+                tokenizer = AutoTokenizer.from_pretrained(FALLBACK_MODEL_ID)
+                model = AutoModelForCausalLM.from_pretrained(
+                    FALLBACK_MODEL_ID,
+                    device_map="auto",
+                    torch_dtype=torch.float16,
+                    load_in_8bit=True
+                )
+                
+                text_generation_pipeline = pipeline(
+                    "text-generation",
+                    model=model,
+                    tokenizer=tokenizer,
+                    max_new_tokens=1024,
+                    do_sample=True,
+                    temperature=0.3,
+                    top_p=0.95,
+                    repetition_penalty=1.15
+                )
+            except Exception as e2:
+                print(f"Error loading fallback model: {str(e2)}")
+                return None
+    
+    return text_generation_pipeline
+
+def process_menu_text(raw_text):
+    """
+    Process raw OCR text using LLM to improve structure and readability.
+    
+    Args:
+        raw_text: Raw text extracted from menu image
+        
+    Returns:
+        Processed and structured menu text
+    """
+    # Get the pipeline
+    pipeline = get_text_pipeline()
+    
+    if pipeline is None:
+        # Fallback to simple processing if model not available
+        return {
+            'structured_text': raw_text,
+            'menu_sections': [],
+            'success': False,
+            'error': "LLM model not available"
+        }
+    
+    # Construct prompt for the LLM
+    prompt = f"""<|system|>
+You are an AI assistant that helps structure menu text from OCR.
+Your task is to clean up the text, correct obvious OCR errors, and structure it properly.
+Identify menu sections, items, and prices.
+Format your response as JSON with menu sections, items, and prices.
+<|user|>
+Here is the raw text extracted from a menu image:
+
+{raw_text}
+
+Please clean and structure this menu text. Format your response as JSON with the following structure:
+{{
+    "menu_sections": [
+        {{
+            "section_name": "Section name (e.g., Appetizers, Main Course, etc.)",
+            "items": [
+                {{
+                    "name": "Item name",
+                    "description": "Item description if available",
+                    "price": "Price if available"
+                }}
+            ]
+        }}
+    ]
+}}
+<|assistant|>
+"""
+    
+    try:
+        # Generate response from LLM
+        response = pipeline(prompt, return_full_text=False)[0]['generated_text']
+        
+        # Extract JSON from response
+        response_text = response.strip()
+        
+        # Find JSON in the response
+        json_start = response_text.find('{')
+        json_end = response_text.rfind('}') + 1
+        
+        if json_start >= 0 and json_end > json_start:
+            json_str = response_text[json_start:json_end]
+            menu_data = json.loads(json_str)
+            
+            # Reconstruct structured text
+            structured_text = ""
+            for section in menu_data.get('menu_sections', []):
+                structured_text += f"{section.get('section_name', 'Menu Items')}\n"
+                structured_text += "-" * len(section.get('section_name', 'Menu Items')) + "\n\n"
+                
+                for item in section.get('items', []):
+                    structured_text += f"{item.get('name', '')}"
+                    if item.get('price'):
+                        structured_text += f" - {item.get('price')}"
+                    structured_text += "\n"
+                    
+                    if item.get('description'):
+                        structured_text += f"  {item.get('description')}\n"
+                    
+                    structured_text += "\n"
+                
+                structured_text += "\n"
+            
+            return {
+                'structured_text': structured_text,
+                'menu_data': menu_data,
+                'success': True
+            }
+        else:
+            # Fallback to simple processing
+            return {
+                'structured_text': raw_text,
+                'menu_sections': [],
+                'success': False,
+                'error': "Failed to parse LLM response as JSON"
+            }
+            
+    except Exception as e:
+        return {
+            'structured_text': raw_text,
+            'menu_sections': [],
+            'success': False,
+            'error': str(e)
+        }

models/text_processor_bk.py

@@ -0,0 +1,133 @@
+from llama_cpp import Llama
+import os
+import json
+
+# Initialize the model (will download on first run)
+MODEL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../models/llama-3-8b-instruct.Q4_K_M.gguf")
+
+# Check if model exists, if not provide instructions
+if not os.path.exists(MODEL_PATH):
+    os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
+    print(f"Model not found at {MODEL_PATH}")
+    print("Please download the model from https://huggingface.co/TheBloke/Llama-3-8B-Instruct-GGUF")
+    print("and place it in the models directory")
+
+# Initialize model with lazy loading
+llm = None
+
+def get_llm():
+    """Get or initialize the LLM."""
+    global llm
+    if llm is None and os.path.exists(MODEL_PATH):
+        llm = Llama(
+            model_path=MODEL_PATH,
+            n_ctx=4096,  # Context window
+            n_gpu_layers=-1  # Use GPU if available
+        )
+    return llm
+
+def process_menu_text(raw_text):
+    """
+    Process raw OCR text using LLM to improve structure and readability.
+    
+    Args:
+        raw_text: Raw text extracted from menu image
+        
+    Returns:
+        Processed and structured menu text
+    """
+    llm = get_llm()
+    
+    if llm is None:
+        # Fallback to simple processing if model not available
+        return {
+            'structured_text': raw_text,
+            'menu_sections': [],
+            'success': False,
+            'error': "LLM model not available"
+        }
+    
+    # Construct prompt for the LLM
+    prompt = f"""
+    You are an AI assistant that helps structure menu text from OCR.
+    Below is the raw text extracted from a menu image. 
+    Please clean it up, correct any obvious OCR errors, and structure it properly.
+    Identify menu sections, items, and prices.
+    
+    RAW MENU TEXT:
+    {raw_text}
+    
+    Format your response as JSON with the following structure:
+    {{
+        "menu_sections": [
+            {{
+                "section_name": "Section name (e.g., Appetizers, Main Course, etc.)",
+                "items": [
+                    {{
+                        "name": "Item name",
+                        "description": "Item description if available",
+                        "price": "Price if available"
+                    }}
+                ]
+            }}
+        ]
+    }}
+    
+    Only respond with the JSON, nothing else.
+    """
+    
+    try:
+        # Generate response from LLM
+        response = llm(prompt, max_tokens=4000, temperature=0.1, stop=["```"])
+        
+        # Extract JSON from response
+        response_text = response['choices'][0]['text'].strip()
+        
+        # Find JSON in the response
+        json_start = response_text.find('{')
+        json_end = response_text.rfind('}') + 1
+        
+        if json_start >= 0 and json_end > json_start:
+            json_str = response_text[json_start:json_end]
+            menu_data = json.loads(json_str)
+            
+            # Reconstruct structured text
+            structured_text = ""
+            for section in menu_data.get('menu_sections', []):
+                structured_text += f"{section.get('section_name', 'Menu Items')}\n"
+                structured_text += "-" * len(section.get('section_name', 'Menu Items')) + "\n\n"
+                
+                for item in section.get('items', []):
+                    structured_text += f"{item.get('name', '')}"
+                    if item.get('price'):
+                        structured_text += f" - {item.get('price')}"
+                    structured_text += "\n"
+                    
+                    if item.get('description'):
+                        structured_text += f"  {item.get('description')}\n"
+                    
+                    structured_text += "\n"
+                
+                structured_text += "\n"
+            
+            return {
+                'structured_text': structured_text,
+                'menu_data': menu_data,
+                'success': True
+            }
+        else:
+            # Fallback to simple processing
+            return {
+                'structured_text': raw_text,
+                'menu_sections': [],
+                'success': False,
+                'error': "Failed to parse LLM response as JSON"
+            }
+            
+    except Exception as e:
+        return {
+            'structured_text': raw_text,
+            'menu_sections': [],
+            'success': False,
+            'error': str(e)
+        }

requirements.txt

@@ -1,3 +1,13 @@
-altair
-pandas
-streamlit
+streamlit>=1.22.0
+pillow>=9.0.0
+numpy>=1.22.0
+torch>=2.0.0
+transformers>=4.30.0
+layoutlmv2>=0.1.0
+pytesseract>=0.3.10
+opencv-python>=4.7.0
+sentence-transformers>=2.2.2
+python-braille>=0.1.0
+reportlab>=3.6.12
+
+

scripts/download_model.py

@@ -0,0 +1,50 @@
+import os
+import sys
+import requests
+from tqdm import tqdm
+import huggingface_hub
+
+# Add parent directory to path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+def download_model():
+    """
+    Download the Llama 3 model from Hugging Face.
+    """
+    model_name = "TheBloke/Llama-3-8B-Instruct-GGUF"
+    filename = "llama-3-8b-instruct.Q4_K_M.gguf"
+    
+    # Create models directory if it doesn't exist
+    models_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "models")
+    os.makedirs(models_dir, exist_ok=True)
+    
+    model_path = os.path.join(models_dir, filename)
+    
+    if os.path.exists(model_path):
+        print(f"Model already exists at {model_path}")
+        return model_path
+    
+    print(f"Downloading {filename} from {model_name}...")
+    
+    try:
+        # Download using huggingface_hub
+        huggingface_hub.hf_hub_download(
+            repo_id=model_name,
+            filename=filename,
+            local_dir=models_dir,
+            local_dir_use_symlinks=False
+        )
+        
+        print(f"Model downloaded successfully to {model_path}")
+        return model_path
+        
+    except Exception as e:
+        print(f"Error downloading model: {str(e)}")
+        print("\nManual download instructions:")
+        print(f"1. Go to https://huggingface.co/{model_name}/tree/main")
+        print(f"2. Download the file {filename}")
+        print(f"3. Place it in the models directory at {models_dir}")
+        return None
+
+if __name__ == "__main__":
+    download_model()

tests/test_braille.py

@@ -0,0 +1,107 @@
+import os
+import sys
+import time
+
+# Add the parent directory to the path so we can import our modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models.braille_translator import text_to_braille, get_braille_metadata
+
+def test_braille_translation(text):
+    """
+    Test Braille translation on a given text.
+    
+    Args:
+        text: Text to translate to Braille
+        
+    Returns:
+        Dictionary with test results
+    """
+    start_time = time.time()
+    
+    # Translate to Braille
+    try:
+        result = text_to_braille(text, use_context=True)
+        success = result['success']
+        braille_text = result.get('formatted_braille', '')
+        error = result.get('error', None)
+    except Exception as e:
+        success = False
+        braille_text = ''
+        error = str(e)
+    
+    end_time = time.time()
+    
+    # Get metadata
+    metadata = get_braille_metadata(text)
+    
+    # Compile results
+    test_results = {
+        'original_text': text,
+        'success': success,
+        'processing_time': end_time - start_time,
+        'braille_text': braille_text[:100] + '...' if len(braille_text) > 100 else braille_text,
+        'word_count': metadata['word_count'],
+        'character_count': metadata['character_count'],
+        'line_count': metadata['line_count']
+    }
+    
+    if not success:
+        test_results['error'] = error
+        
+    return test_results
+
+def run_braille_tests():
+    """
+    Run tests on sample menu texts.
+    
+    Returns:
+        List of test results
+    """
+    # Sample menu texts
+    sample_texts = [
+        # Simple menu item
+        "Cheeseburger - $10.99\nServed with fries and a pickle.",
+        
+        # Menu section
+        "APPETIZERS\n-----------\nMozzarella Sticks - $7.99\nLoaded Nachos - $9.99\nBuffalo Wings - $12.99",
+        
+        # Complex menu with formatting
+        """MAIN COURSE
+        -------------
+        Grilled Salmon - $18.99
+        Fresh Atlantic salmon served with seasonal vegetables and rice pilaf.
+        
+        Filet Mignon - $24.99
+        8oz center-cut filet served with mashed potatoes and asparagus.
+        
+        Vegetable Pasta - $14.99
+        Penne pasta with seasonal vegetables in a creamy garlic sauce."""
+    ]
+    
+    results = []
+    
+    for i, text in enumerate(sample_texts):
+        print(f"\nTesting sample {i+1}...")
+        result = test_braille_translation(text)
+        results.append(result)
+        
+        # Print progress
+        status = "SUCCESS" if result['success'] else "FAILED"
+        print(f"Sample {i+1}: {status}")
+        print(f"Words: {result['word_count']}, Time: {result['processing_time']:.2f}s")
+        print(f"Braille sample: {result['braille_text'][:50]}...")
+            
+    return results
+
+if __name__ == "__main__":
+    print("Testing Braille translation functionality...")
+    results = run_braille_tests()
+    
+    # Print summary
+    success_count = sum(1 for r in results if r['success'])
+    print(f"\nSummary: {success_count}/{len(results)} tests passed")
+    
+    if results:
+        avg_time = sum(r['processing_time'] for r in results) / len(results)
+        print(f"Average processing time: {avg_time:.2f} seconds")

tests/test_ocr.py

@@ -0,0 +1,104 @@
+import os
+import sys
+import time
+from PIL import Image
+import numpy as np
+
+# Add the parent directory to the path so we can import our modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.image_preprocessing import preprocess_image
+from models.document_ai import extract_text_and_layout
+
+def test_menu_extraction(image_path):
+    """
+    Test the OCR extraction on a single menu image.
+    
+    Args:
+        image_path: Path to the menu image
+        
+    Returns:
+        Dictionary with test results
+    """
+    start_time = time.time()
+    
+    # Load and preprocess image
+    image = Image.open(image_path)
+    preprocessed_img = preprocess_image(image)
+    
+    # Extract text
+    try:
+        result = extract_text_and_layout(preprocessed_img)
+        extracted_text = ' '.join(result['words']) if 'words' in result else ''
+        success = True
+    except Exception as e:
+        extracted_text = ''
+        success = False
+        error = str(e)
+    
+    end_time = time.time()
+    
+    # Compile results
+    test_results = {
+        'image_path': image_path,
+        'success': success,
+        'processing_time': end_time - start_time,
+        'extracted_text': extracted_text,
+        'text_length': len(extracted_text),
+        'word_count': len(extracted_text.split()) if extracted_text else 0
+    }
+    
+    if not success:
+        test_results['error'] = error
+        
+    return test_results
+
+def run_batch_test(image_dir):
+    """
+    Run tests on all images in a directory.
+    
+    Args:
+        image_dir: Directory containing menu images
+        
+    Returns:
+        List of test results
+    """
+    results = []
+    
+    for filename in os.listdir(image_dir):
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+            image_path = os.path.join(image_dir, filename)
+            result = test_menu_extraction(image_path)
+            results.append(result)
+            
+            # Print progress
+            status = "SUCCESS" if result['success'] else "FAILED"
+            print(f"{filename}: {status} - {result['word_count']} words extracted")
+            
+    return results
+
+if __name__ == "__main__":
+    # Test with sample menus in the assets directory
+    sample_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 
+                             "assets", "sample_menus")
+    
+    if not os.path.exists(sample_dir):
+        print(f"Sample directory not found: {sample_dir}")
+        print("Creating directory and downloading sample images...")
+        os.makedirs(sample_dir, exist_ok=True)
+        # You would add code here to download sample images
+        # For now, just create a note to add sample images manually
+        with open(os.path.join(sample_dir, "README.txt"), "w") as f:
+            f.write("Add sample menu images to this directory for testing.")
+    
+    results = run_batch_test(sample_dir)
+    
+    # Print summary
+    success_count = sum(1 for r in results if r['success'])
+    print(f"\nSummary: {success_count}/{len(results)} tests passed")
+    
+    if results:
+        avg_words = sum(r['word_count'] for r in results) / len(results)
+        avg_time = sum(r['processing_time'] for r in results) / len(results)
+        print(f"Average words extracted: {avg_words:.1f}")
+        print(f"Average processing time: {avg_time:.2f} seconds")

utils/braille_display.py

@@ -0,0 +1,111 @@
+def text_to_unicode_braille(braille_text):
+    """
+    Convert Braille dots notation to Unicode Braille symbols.
+    
+    Args:
+        braille_text: Braille text in dots notation
+        
+    Returns:
+        Text with Unicode Braille symbols
+    """
+    # Mapping from Braille dots to Unicode Braille patterns
+    # Unicode Braille patterns start at U+2800 (⠀)
+    unicode_base = 0x2800
+    
+    # Convert each Braille character to its Unicode equivalent
+    unicode_braille = ""
+    for char in braille_text:
+        # Check if the character is a standard Braille pattern
+        if char in "⠀⠁⠂⠃⠄⠅⠆⠇⠈⠉⠊⠋⠌⠍⠎⠏⠐⠑⠒⠓⠔⠕⠖⠗⠘⠙⠚⠛⠜⠝⠞⠟⠠⠡⠢⠣⠤⠥⠦⠧⠨⠩⠪⠫⠬⠭⠮⠯⠰⠱⠲⠳⠴⠵⠶⠷⠸⠹⠺⠻⠼⠽⠾⠿":
+            unicode_braille += char
+        else:
+            # For non-Braille characters, keep them as is
+            unicode_braille += char
+    
+    return unicode_braille
+
+def create_braille_html(braille_text):
+    """
+    Create HTML to display Braille with proper styling.
+    
+    Args:
+        braille_text: Braille text (either in dots or Unicode)
+        
+    Returns:
+        HTML string for displaying Braille
+    """
+    # Convert to Unicode Braille if not already
+    unicode_braille = text_to_unicode_braille(braille_text)
+    
+    # Create HTML with proper styling
+    html = f"""
+    <div style="font-family: 'Courier New', monospace; font-size: 20px; line-height: 1.5; 
+                background-color: #f5f5f5; padding: 15px; border-radius: 5px;">
+        {unicode_braille.replace('\n', '<br>')}
+    </div>
+    """
+    
+    return html
+
+def create_braille_comparison(text, braille_text):
+    """
+    Create a side-by-side comparison of text and its Braille representation.
+    
+    Args:
+        text: Original text
+        braille_text: Braille translation
+        
+    Returns:
+        HTML string for displaying the comparison
+    """
+    # Convert to Unicode Braille
+    unicode_braille = text_to_unicode_braille(braille_text)
+    
+    # Split into lines
+    text_lines = text.split('\n')
+    braille_lines = unicode_braille.split('\n')
+    
+    # Ensure both lists have the same length
+    max_lines = max(len(text_lines), len(braille_lines))
+    text_lines = text_lines + [''] * (max_lines - len(text_lines))
+    braille_lines = braille_lines + [''] * (max_lines - len(braille_lines))
+    
+    # Create HTML table for comparison
+    html = """
+    <style>
+        .braille-table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        .braille-table td {
+            padding: 8px;
+            vertical-align: top;
+            border-bottom: 1px solid #ddd;
+        }
+        .braille-text {
+            font-family: 'Courier New', monospace;
+            font-size: 20px;
+            background-color: #f5f5f5;
+        }
+        .original-text {
+            font-family: Arial, sans-serif;
+        }
+    </style>
+    <table class="braille-table">
+        <tr>
+            <th>Original Text</th>
+            <th>Braille Representation</th>
+        </tr>
+    """
+    
+    for i in range(max_lines):
+        html += f"""
+        <tr>
+            <td class="original-text">{text_lines[i]}</td>
+            <td class="braille-text">{braille_lines[i]}</td>
+        </tr>
+        """
+    
+    html += "</table>"
+    
+    return html

utils/image_processing.py

@@ -0,0 +1,39 @@
+import cv2
+import numpy as np
+from PIL import Image
+
+def preprocess_image(image, target_size=(1000, 1000)):
+    """
+    Preprocess image for document analysis.
+    
+    Args:
+        image: PIL Image object
+        target_size: Tuple of (width, height) to resize to
+        
+    Returns:
+        Preprocessed image as numpy array
+    """
+    # Convert PIL Image to numpy array if needed
+    if isinstance(image, Image.Image):
+        img_array = np.array(image)
+    else:
+        img_array = image
+    
+    # Convert to RGB if grayscale
+    if len(img_array.shape) == 2:
+        img_array = cv2.cvtColor(img_array, cv2.COLOR_GRAY2RGB)
+    elif img_array.shape[2] == 4:
+        img_array = cv2.cvtColor(img_array, cv2.COLOR_RGBA2RGB)
+    
+    # Resize image
+    img_array = cv2.resize(img_array, target_size)
+    
+    # Enhance contrast
+    lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
+    l, a, b = cv2.split(lab)
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    cl = clahe.apply(l)
+    enhanced_lab = cv2.merge((cl, a, b))
+    enhanced_img = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2RGB)
+    
+    return enhanced_img

utils/pdf_generator.py

@@ -0,0 +1,198 @@
+import os
+import tempfile
+from reportlab.lib.pagesizes import letter
+from reportlab.lib import colors
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import io
+
+# Try to register a font that supports Braille Unicode characters
+try:
+    # Check for common Braille fonts
+    font_paths = [
+        "DejaVuSans.ttf",  # Common on Linux
+        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+        "/System/Library/Fonts/Arial Unicode.ttf",  # Mac
+        "C:\\Windows\\Fonts\\arial.ttf"  # Windows
+    ]
+    
+    font_registered = False
+    for font_path in font_paths:
+        if os.path.exists(font_path):
+            pdfmetrics.registerFont(TTFont('BrailleFont', font_path))
+            font_registered = True
+            break
+    
+    if not font_registered:
+        # Use default font if none of the above are found
+        print("No suitable font found for Braille. Using default font.")
+except Exception as e:
+    print(f"Error registering font: {str(e)}")
+
+def create_braille_pdf(original_text, braille_text, title="Menu in Braille"):
+    """
+    Create a PDF file with original text and its Braille translation.
+    
+    Args:
+        original_text: Original text content
+        braille_text: Braille translation
+        title: PDF title
+        
+    Returns:
+        BytesIO object containing the PDF
+    """
+    # Create a BytesIO object to store the PDF
+    buffer = io.BytesIO()
+    
+    # Create the PDF document
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=72,
+        leftMargin=72,
+        topMargin=72,
+        bottomMargin=72
+    )
+    
+    # Define styles
+    styles = getSampleStyleSheet()
+    title_style = styles['Title']
+    heading_style = styles['Heading2']
+    normal_style = styles['Normal']
+    
+    # Create a custom style for Braille text
+    braille_style = ParagraphStyle(
+        'Braille',
+        parent=normal_style,
+        fontName='BrailleFont' if font_registered else 'Helvetica',
+        fontSize=14,
+        leading=18,
+        spaceAfter=12
+    )
+    
+    # Create the content
+    content = []
+    
+    # Add title
+    content.append(Paragraph(title, title_style))
+    content.append(Spacer(1, 12))
+    
+    # Add original text section
+    content.append(Paragraph("Original Text", heading_style))
+    content.append(Spacer(1, 6))
+    
+    # Split original text by lines and add each as a paragraph
+    for line in original_text.split('\n'):
+        if line.strip():
+            content.append(Paragraph(line, normal_style))
+        else:
+            content.append(Spacer(1, 12))
+    
+    content.append(Spacer(1, 24))
+    
+    # Add Braille section
+    content.append(Paragraph("Braille Translation", heading_style))
+    content.append(Spacer(1, 6))
+    
+    # Split Braille text by lines and add each as a paragraph
+    for line in braille_text.split('\n'):
+        if line.strip():
+            content.append(Paragraph(line, braille_style))
+        else:
+            content.append(Spacer(1, 12))
+    
+    # Build the PDF
+    doc.build(content)
+    
+    # Reset buffer position to the beginning
+    buffer.seek(0)
+    return buffer
+
+def create_braille_pdf_with_comparison(original_text, braille_text, title="Menu in Braille"):
+    """
+    Create a PDF file with side-by-side comparison of original text and Braille.
+    
+    Args:
+        original_text: Original text content
+        braille_text: Braille translation
+        title: PDF title
+        
+    Returns:
+        BytesIO object containing the PDF
+    """
+    # Create a BytesIO object to store the PDF
+    buffer = io.BytesIO()
+    
+    # Create the PDF document
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=letter,
+        rightMargin=72,
+        leftMargin=72,
+        topMargin=72,
+        bottomMargin=72
+    )
+    
+    # Define styles
+    styles = getSampleStyleSheet()
+    title_style = styles['Title']
+    heading_style = styles['Heading2']
+    normal_style = styles['Normal']
+    
+    # Create a custom style for Braille text
+    braille_style = ParagraphStyle(
+        'Braille',
+        parent=normal_style,
+        fontName='BrailleFont' if font_registered else 'Helvetica',
+        fontSize=14,
+        leading=18
+    )
+    
+    # Create the content
+    content = []
+    
+    # Add title
+    content.append(Paragraph(title, title_style))
+    content.append(Spacer(1, 12))
+    
+    # Split text into lines
+    original_lines = original_text.split('\n')
+    braille_lines = braille_text.split('\n')
+    
+    # Ensure both lists have the same length
+    max_lines = max(len(original_lines), len(braille_lines))
+    original_lines = original_lines + [''] * (max_lines - len(original_lines))
+    braille_lines = braille_lines + [''] * (max_lines - len(braille_lines))
+    
+    # Create a table for side-by-side comparison
+    table_data = [
+        [Paragraph("Original Text", heading_style), Paragraph("Braille Translation", heading_style)]
+    ]
+    
+    # Add each line as a row in the table
+    for i in range(max_lines):
+        original_para = Paragraph(original_lines[i], normal_style) if original_lines[i].strip() else Spacer(1, 12)
+        braille_para = Paragraph(braille_lines[i], braille_style) if braille_lines[i].strip() else Spacer(1, 12)
+        table_data.append([original_para, braille_para])
+    
+    # Create the table
+    table = Table(table_data, colWidths=[doc.width/2.0-12, doc.width/2.0-12])
+    
+    # Style the table
+    table.setStyle(TableStyle([
+        ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+        ('GRID', (0, 0), (-1, 0), 1, colors.black),
+        ('BOX', (0, 0), (-1, -1), 1, colors.black),
+        ('BACKGROUND', (0, 0), (1, 0), colors.lightgrey)
+    ]))
+    
+    content.append(table)
+    
+    # Build the PDF
+    doc.build(content)
+    
+    # Reset buffer position to the beginning
+    buffer.seek(0)
+    return buffer