Methodology

┌─────────────────────────────────────────────────────────────────┐
│                   DOCUGRAPH FUNCTIONAL FLOW                      │
└─────────────────────────────────────────────────────────────────┘

User Action: Upload Document
       ↓
   ┌───────────────────────────┐
   │  1. IMAGE PREPROCESSING   │
   │  ─────────────────────    │
   │  • Load image             │
   │  • Deskew & normalize     │
   │  • Convert to grayscale   │
   │  • Apply enhancement      │
   └───────────────┬───────────┘
                   ↓
   ┌───────────────────────────┐
   │  2. GRAPH CONSTRUCTION    │
   │  ─────────────────────    │
   │  • Detect text blocks     │
   │  • Extract block regions  │
   │  • Create node features   │
   │  • Build spatial edges    │
   └───────────────┬───────────┘
                   ↓
   ┌───────────────────────────┐
   │  3. GNN LAYOUT ANALYSIS   │
   │  ─────────────────────    │
   │  • Pass graph to GNN      │
   │  • Infer layout patterns  │
   │  • Predict reading order  │
   │  • Score regions          │
   └───────────────┬───────────┘
                   ↓
   ┌───────────────────────────┐
   │  4. OCR PROCESSING        │
   │  ─────────────────────    │
   │  • Extract text regions   │
   │  • Run Tesseract OCR      │
   │  • Post-process output    │
   │  • Confidence scoring     │
   └───────────────┬───────────┘
                   ↓
   ┌───────────────────────────┐
   │  5. RECONSTRUCTION        │
   │  ─────────────────────    │
   │  • Merge OCR + layout     │
   │  • Apply reading order    │
   │  • Format output          │
   │  • Generate metadata      │
   └───────────────┬───────────┘
                   ↓
   ┌───────────────────────────┐
   │  6. VALIDATION & OUTPUT   │
   │  ─────────────────────    │
   │  • Validate structure     │
   │  • Check consistency      │
   │  • Return results         │
   │  • Store analysis log     │
   └───────────────┬───────────┘
                   ↓
            User receives
          structured output

┌─────────────────────────────────────────────────────────────────────────────┐
│                      DOCUGRAPH SYSTEM ARCHITECTURE                           │
└─────────────────────────────────────────────────────────────────────────────┘

   ┌─────────────────────────────────────────────────────────────────────┐
   │                   PRESENTATION LAYER (Web UI)                       │
   │  ─────────────────────────────────────────────────────────────────  │
   │  • HTML5 Interface  • File Upload  • Progress Visualization         │
   │  • Results Display  • User Dashboard  • Export/Download             │
   │  • Firebase Auth    • Session Management  • Error Handling          │
   └──────────────────────────────┬──────────────────────────────────────┘
                                  │
                                  ↓ REST API / WebSocket
   ┌─────────────────────────────────────────────────────────────────────┐
   │                   APPLICATION LOGIC LAYER                           │
   │  ─────────────────────────────────────────────────────────────────  │
   │                                                                     │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  IMAGE PREPROCESSING ENGINE                                  │  │
   │  │  • Grayscale Conversion  • Deskewing  • Normalization       │  │
   │  │  • Noise Reduction  • Contrast Enhancement                  │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                          ↓                                          │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  GRAPH CONSTRUCTION MODULE                                   │  │
   │  │  • Text Block Detection  • Feature Extraction               │  │
   │  │  • Spatial Relationship Mapping  • Graph Generation         │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                          ↓                                          │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  GRAPH NEURAL NETWORK ENGINE                                │  │
   │  │  • Node Feature Processing  • Graph Convolution             │  │
   │  │  • Layout Classification  • Reading Order Prediction        │  │
   │  │  • Confidence Scoring  • Region Prioritization             │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                          ↓                                          │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  OCR PROCESSING ENGINE                                      │  │
   │  │  • Tesseract Integration  • Text Extraction                 │  │
   │  │  • Confidence Tracking  • Post-Processing                   │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                          ↓                                          │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  STRUCTURE RECONSTRUCTION ENGINE                            │  │
   │  │  • Layout-Guided Assembly  • Reading Order Application      │  │
   │  │  • Metadata Generation  • Output Formatting                 │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                          ↓                                          │
   │  ┌──────────────────────────────────────────────────────────────┐  │
   │  │  VALIDATION & QUALITY ASSURANCE                             │  │
   │  │  • Structure Validation  • Consistency Checks               │  │
   │  │  • Quality Scoring  • Error Detection                       │  │
   │  └──────────────────────────────────────────────────────────────┘  │
   │                                                                     │
   └──────────────────────────────┬──────────────────────────────────────┘
                                  │
                                  ↓ Data & Results
   ┌─────────────────────────────────────────────────────────────────────┐
   │                      DATA & STORAGE LAYER                           │
   │  ─────────────────────────────────────────────────────────────────  │
   │  • Cloud Storage (Document Images)  • Database (Results/Metadata)   │
   │  • User Accounts & Sessions  • Processing Logs  • Model Versioning │
   │  • Cache Layer (Redis)  • Backup & Replication                     │
   └─────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│                    SPRINT DEVELOPMENT STRUCTURE                          │
└──────────────────────────────────────────────────────────────────────────┘

PROJECT TIMELINE: 16 weeks (4 sprints of 4 weeks each)

┌─────────────────────────────────────────────────────────────────────────┐
│ SPRINT 1 (Weeks 1-4): Foundation & Infrastructure                       │
├─────────────────────────────────────────────────────────────────────────┤
│ • Project setup & environment configuration                              │
│ • Web application scaffolding (HTML/CSS/JS)                             │
│ • Firebase authentication integration                                    │
│ • Basic image upload functionality                                       │
│ • Backend API framework setup (Flask/FastAPI)                           │
│ Deliverables: Working web app with user auth + image upload            │
└─────────────────────────────────────────────────────────────────────────┘
        │
        ↓ Code Review & Testing
┌─────────────────────────────────────────────────────────────────────────┐
│ SPRINT 2 (Weeks 5-8): Image Processing & Graph Construction            │
├─────────────────────────────────────────────────────────────────────────┤
│ • Image preprocessing module development                                 │
│ • Text block detection algorithm                                         │
│ • Graph construction from document images                                │
│ • Feature extraction pipeline                                            │
│ • Unit testing for preprocessing components                              │
│ Deliverables: End-to-end image → graph pipeline                        │
└─────────────────────────────────────────────────────────────────────────┘
        │
        ↓ User Feedback & Integration
┌─────────────────────────────────────────────────────────────────────────┐
│ SPRINT 3 (Weeks 9-12): GNN Model & OCR Integration                     │
├─────────────────────────────────────────────────────────────────────────┤
│ • Graph Neural Network model design                                      │
│ • Model training on annotated dataset                                    │
│ • OCR integration with Tesseract                                         │
│ • Post-processing algorithm implementation                               │
│ • Structure reconstruction module                                        │
│ Deliverables: Working GNN + OCR pipeline                               │
└─────────────────────────────────────────────────────────────────────────┘
        │
        ↓ Performance Optimization
┌─────────────────────────────────────────────────────────────────────────┐
│ SPRINT 4 (Weeks 13-16): UI/UX Polish & Deployment                      │
├─────────────────────────────────────────────────────────────────────────┤
│ • Frontend results display interface                                     │
│ • User dashboard and history                                             │
│ • Performance optimization & caching                                     │
│ • Full system testing (unit, integration, acceptance)                    │
│ • Deployment preparation & documentation                                 │
│ Deliverables: Production-ready DOCUGRAPH system                         │
└─────────────────────────────────────────────────────────────────────────┘

DAILY STANDUP (15 minutes)
└─ Each team member reports:
   1. What was completed yesterday?
   2. What will be done today?
   3. Are there blockers?

SPRINT REVIEW & RETROSPECTIVE (End of each sprint)
└─ Demo working features to stakeholders
└─ Gather feedback & adjust backlog
└─ Team discusses improvements for next sprint

KEY METRICS
├─ Velocity: User stories completed per sprint
├─ Code Coverage: Target 85%+
├─ Bug Escape Rate: <2% of deployed features
└─ Performance: Process 1-5 pages in <2 seconds

ALGORITHM: ImagePreprocessing
INPUT: raw_image (captured/uploaded document)
OUTPUT: processed_image (normalized and enhanced)

1. LoadImage(raw_image)
   if image.format ∉ {JPEG, PNG, PDF} then
      return ERROR("Invalid image format")
   end if

2. Deskew(image)
   angle ← DetectSkewAngle(image)
   if |angle| > threshold then
      image ← RotateImage(image, angle)
   end if

3. GrayscaleConversion(image)
   image ← ConvertToGray(image)
   // Preserve structural information

4. NoiseReduction(image)
   image ← ApplyGaussianBlur(image, kernel=3×3)
   image ← ApplyMedianFilter(image, kernel=5×5)

5. ContrastEnhancement(image)
   // Adaptive histogram equalization
   image ← ApplyCLAHE(image, clipLimit=2.0)

6. Thresholding(image)
   threshold ← OtsuThreshold(image)
   image ← ApplyBinaryThreshold(image, threshold)

7. Normalization(image)
   image.size ← StandardizeSize(image)
   image.dpi ← NormalizeDPI(image)

8. return processed_image

Complexity: O(w × h) where w, h = image dimensions
Typical Processing Time: 100-500ms per image

ALGORITHM: GraphConstruction
INPUT: processed_image
OUTPUT: G = (V, E) - Document graph representation

1. TextBlockDetection(image)
   // Detect connected components as potential text regions
   blocks ← FindConnectedComponents(image)
   blocks ← FilterBySize(blocks, min_size, max_size)
   return blocks

2. FeatureExtraction(block)
   for each block ∈ blocks do
      feature ← {
         bbox: GetBoundingBox(block),
         position: (x, y) coordinates,
         size: (width, height),
         density: TextDensity(block),
         intensity: MeanIntensity(block),
         shape: AspectRatio(block)
      }
      V ← V ∪ {feature}
   end for

3. SpatialRelationshipMapping(blocks)
   for each pair (block_i, block_j) ∈ blocks × blocks do
      if AreAdjacent(block_i, block_j) then
         distance ← EuclideanDistance(block_i, block_j)
         direction ← ComputeDirection(block_i, block_j)
         
         edge ← {
            source: block_i,
            target: block_j,
            weight: 1/distance,
            type: direction  // {LEFT, RIGHT, ABOVE, BELOW}
         }
         
         E ← E ∪ {edge}
      end if
   end for

4. return G = (V, E)

Graph Complexity: |V| = O(number_of_blocks)
                  |E| = O(|V|²) worst case, typically O(|V|)

ALGORITHM: GraphNeuralNetworkInference
INPUT: G = (V, E) - Document graph
OUTPUT: predictions - Layout classifications and reading order

1. NodeEmbedding(V)
   for each node v ∈ V do
      h_v^(0) ← FeatureEmbedding(v.features)
      // Initial node embedding from visual features
   end for

2. GraphConvolution(iterations=L)
   for layer ℓ = 1 to L do
      for each node v ∈ V do
         // Aggregate neighbor information
         a_v ← AGGREGATE({h_u^(ℓ-1) : u ∈ N(v)})
         
         // Update node representation
         h_v^(ℓ) ← ReLU(W^(ℓ) · [h_v^(ℓ-1) || a_v])
         // Concatenate self and neighbor embeddings
      end for
   end for

3. ReadingOrderPrediction()
   // Topological sort based on learned node importance
   scores ← ClassificationHead(h_v^(L) for all v)
   // MLP: (node_embedding) → [0, 1]
   
   reading_order ← TopologicalSort(G, scores)
   return reading_order

4. LayoutClassification()
   for each node v ∈ V do
      class_v ← ClassifyNode(h_v^(L))
      // Classify as: HEADER, BODY, FOOTER, FIGURE, TABLE, etc.
   end for

5. ConfidenceScoring()
   for each prediction do
      confidence ← SoftmaxScore(scores)
      // Normalized probability [0, 1]
   end for

6. return {layout_classifications, reading_order, confidence_scores}

Model Complexity: O(L × |E|) where L = number of GNN layers
Inference Time: 200-800ms for typical document

ALGORITHM: OCRAndStructureReconstruction
INPUT: image, layout_predictions, reading_order
OUTPUT: structured_document (text + metadata + layout)

1. RegionBasedOCR(image, layout_predictions)
   for each region ∈ layout_predictions do
      // Extract OCR parameters based on predicted class
      if region.class = HEADER then
         ocr_config ← HEADER_CONFIG  // Higher sensitivity
      else if region.class = TABLE then
         ocr_config ← TABLE_CONFIG   // Preserve spacing
      else
         ocr_config ← DEFAULT_CONFIG
      end if
      
      text_result ← TesseractOCR(image[region.bbox], ocr_config)
      confidence_score ← text_result.confidence
      
      // Only keep high-confidence extractions
      if confidence_score > threshold then
         region.text ← text_result.text
         region.confidence ← confidence_score
      end if
   end for

2. PostProcessing(regions)
   for each region do
      // Remove common OCR errors
      text ← RemoveArtifacts(region.text)
      text ← CorrectCommonErrors(text)
      text ← FixHyphenation(text)
      
      // Spell check with context awareness
      text ← ContextualSpellCheck(text, region.context)
      
      region.text_processed ← text
   end for

3. StructureReconstruction(regions, reading_order)
   document ← CreateDocument()
   
   // Sort regions according to predicted reading order
   sorted_regions ← Sort(regions, by=reading_order)
   
   for each region ∈ sorted_regions do
      element ← CreateElement(
         type=region.class,
         content=region.text_processed,
         position=region.bbox,
         confidence=region.confidence
      )
      document.Add(element)
   end for
   
   return document

4. MetadataGeneration(document)
   document.metadata ← {
      creation_date: Now(),
      processing_time: elapsed_time,
      accuracy_score: CalculateAccuracy(document),
      layout_confidence: Mean(all_region_confidences),
      page_count: CountPages(document)
   }

5. return structured_document

Total Processing Time: 500-2000ms per page
OCR Accuracy Improvement: Typically 15-25% over baseline Tesseract

┌──────────────────────────────────────────────────────────────────────────┐
│              GNN MODEL TRAINING & VALIDATION WORKFLOW                    │
└──────────────────────────────────────────────────────────────────────────┘

STAGE 1: DATA PREPARATION
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  Annotated Dataset (5,000 documents)                                  │
│        └─ Each document has:                                          │
│           • Layout annotations (text blocks, layout class)            │
│           • Ground truth reading order                                │
│           • OCR reference text                                        │
│                                                                        │
│  Train/Val/Test Split                                                │
│        ├─ Training: 3,500 documents (70%)                            │
│        ├─ Validation: 750 documents (15%)                            │
│        └─ Testing: 750 documents (15%)                               │
│                                                                        │
│  Data Augmentation (Training Set)                                     │
│        ├─ Rotation: ±5° random angle                                 │
│        ├─ Scaling: 0.9-1.1× zoom                                     │
│        ├─ Noise injection: Gaussian σ=0.01                           │
│        └─ Elastic distortion (simulate scanning artifacts)           │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

STAGE 2: MODEL ARCHITECTURE
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  Input: Graph G = (V, E)                                             │
│       └─ |V| nodes (text blocks), |E| edges (spatial relations)     │
│                                                                        │
│  GraphConvolution Layers: 3 layers                                    │
│       ├─ Layer 1: 64 features                                        │
│       ├─ Layer 2: 128 features                                       │
│       └─ Layer 3: 256 features                                       │
│       └─ Activation: ReLU with Dropout (p=0.2)                      │
│                                                                        │
│  Readout Layer (Graph Pooling)                                        │
│       └─ GlobalMeanPooling → 256 dims                                │
│                                                                        │
│  Classification Head: MLP                                             │
│       ├─ Dense(512) → ReLU                                           │
│       ├─ Dropout(p=0.3)                                              │
│       ├─ Dense(128) → ReLU                                           │
│       └─ Dense(num_classes) → Softmax                                │
│                                                                        │
│  Model Parameters: ~1.2M weights                                      │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

STAGE 3: TRAINING LOOP
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  Hyperparameters:                                                      │
│       ├─ Optimizer: Adam (lr=0.001, β₁=0.9, β₂=0.999)                │
│       ├─ Loss Function: CrossEntropyLoss                             │
│       ├─ Batch Size: 32                                              │
│       ├─ Epochs: 100 (early stopping at patience=10)                │
│       └─ Learning Rate Schedule: ExponentialDecay(γ=0.95)           │
│                                                                        │
│  For each epoch:                                                       │
│       1. Shuffle training data                                        │
│       2. For each batch:                                              │
│          • Forward pass: ŷ = Model(G)                                │
│          • Loss calculation: L = CrossEntropy(ŷ, y_true)            │
│          • Backward pass: ∇θ ← backprop(L)                          │
│          • Update: θ ← θ - α·∇θ                                      │
│       3. Validation on val_set                                       │
│       4. Early stopping if val_loss increases                        │
│                                                                        │
│  Training Time: ~2-4 hours on GPU (NVIDIA RTX 3090)                 │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

STAGE 4: EVALUATION & VALIDATION
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  Metrics on Test Set:                                                 │
│       ├─ Accuracy: % correct predictions                             │
│       ├─ Precision: Correct positives / predicted positives          │
│       ├─ Recall: Correct positives / all positives                   │
│       ├─ F1-Score: 2·(Precision·Recall)/(Precision+Recall)          │
│       └─ Confusion Matrix: Per-class analysis                        │
│                                                                        │
│  Cross-Validation (5-Fold):                                          │
│       └─ Ensures stable performance across document types            │
│                                                                        │
│  Target Performance:                                                  │
│       ├─ Layout Classification Accuracy: > 92%                       │
│       ├─ Reading Order Correctness: > 88%                            │
│       └─ OCR Enhancement Improvement: > 15%                          │
│                                                                        │
│  Performance by Document Type:                                        │
│       ├─ Single-column: 95% accuracy                                 │
│       ├─ Multi-column: 88% accuracy                                  │
│       ├─ Tables/Charts: 82% accuracy                                 │
│       └─ Mixed layout: 85% accuracy                                  │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

STAGE 5: MODEL DEPLOYMENT & MONITORING
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  Model Versioning:                                                     │
│       ├─ v1.0: Initial release                                       │
│       ├─ v1.1: Improved multi-column handling                        │
│       └─ v1.2+: Continuous improvements from user feedback           │
│                                                                        │
│  Inference Time: 200-500ms per document graph                        │
│                                                                        │
│  Production Monitoring:                                               │
│       ├─ Accuracy drift detection                                    │
│       ├─ User correction feedback                                    │
│       ├─ Performance bottleneck analysis                             │
│       └─ Retraining trigger: If accuracy_drop > 3%                  │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│              PREPROCESSING OPERATORS & DATA FLOW                          │
└──────────────────────────────────────────────────────────────────────────┘

INPUT DOCUMENT
     │
     ├─→ [LOAD] ──────────────→ Read image file (JPEG/PNG/PDF)
     │
     ├─→ [RESIZE] ─────────→ Normalize to standard dimensions
     │   └─ Target: 2048×2560 pixels (A4 standard)
     │
     ├─→ [GRAYSCALE] ──────→ Convert RGB → 8-bit grayscale
     │   └─ Reduces noise, speeds up processing
     │
     ├─→ [DESKEW] ──────────→ Correct document rotation
     │   └─ Detect angle: Hough Transform
     │   └─ Rotate if |angle| > 0.5°
     │
     ├─→ [DENOISE] ──────────→ Remove noise and artifacts
     │   └─ Gaussian Blur: σ=0.5
     │   └─ Median Filter: kernel=5×5
     │
     ├─→ [CONTRAST] ─────────→ Enhance text visibility
     │   └─ CLAHE (Contrast Limited Adaptive Histogram Equalization)
     │   └─ ClipLimit = 2.0, tileSize = 8×8
     │
     ├─→ [THRESHOLDING] ──────→ Convert to binary image
     │   └─ Method: Otsu's method
     │   └─ Output: Black text on white background
     │
     ├─→ [MORPHOLOGY] ───────→ Clean up binary image
     │   └─ Erosion: Remove small artifacts
     │   └─ Dilation: Fill text gaps
     │   └─ Kernel: 3×3 rectangle
     │
     └─→ [OUTPUT] ──────────→ Preprocessed image ready for analysis

OUTPUT STATISTICS
├─ Image size: typically 2-5 MB
├─ Processing time: 100-500ms
├─ Quality score: 0.0-1.0 (based on contrast & clarity)
└─ Compression ratio: Original → Processed (typically 20-30% reduction)

QUALITY GATES
├─ ✓ If quality_score > 0.7: Proceed to GNN analysis
├─ ⚠ If 0.5 < quality_score ≤ 0.7: Flag for manual review
└─ ✗ If quality_score ≤ 0.5: Request user to recapture image

EXAMPLE METRICS
└─ High-quality document (scanned): 0.92 quality score
└─ Mobile phone photo: 0.78 quality score  
└─ Very poor lighting: 0.45 quality score (flag for retry)

┌──────────────────────────────────────────────────────────────────────────┐
│         END-TO-END INTEGRATION TEST SCENARIOS & DATA FLOW                │
└──────────────────────────────────────────────────────────────────────────┘

TEST SCENARIO 1: SINGLE-COLUMN DOCUMENT
┌────────────────────────────────────────────────────────────────────────┐
│ Input: Scanned PDF or image of standard single-column document        │
│                                                                        │
│  1. Upload ──→ 2. Preprocess ──→ 3. Graph Build ──→ 4. GNN Inference │
│     ✓ Accept      ✓ Quality>0.8    ✓ 200 nodes      ✓ Confidence>0.9  │
│                   ✓ Time<500ms     ✓ 400 edges      ✓ Time<300ms      │
│                                                                        │
│  5. OCR ──────→ 6. Reconstruct ──→ 7. Validate ──→ 8. Output        │
│     ✓ Accuracy>94%  ✓ Ordered       ✓ Structure OK    ✓ JSON/PDF      │
│     ✓ Time<800ms    ✓ Time<200ms    ✓ Time<100ms      ✓ Confidence    │
│                                                                        │
│ Expected Output: Structured document with 95%+ accuracy               │
│ Total Processing Time: ~2 seconds                                     │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

TEST SCENARIO 2: MULTI-COLUMN DOCUMENT
┌────────────────────────────────────────────────────────────────────────┐
│ Input: Research paper or magazine layout (2-3 columns)                │
│                                                                        │
│  Graph Complexity Higher:                                              │
│     ├─ More nodes: ~400 nodes (vs. 200 for single-column)            │
│     └─ More edges: ~800 edges (higher spatial complexity)            │
│                                                                        │
│  GNN Challenge: Predict correct reading order (L→R, top→bottom)      │
│     ├─ Column 1 → Column 2 → Column 3                                │
│     ├─ Expected accuracy: 88% (vs. 95% for single-column)           │
│     └─ Confidence score lower: 0.82-0.90                             │
│                                                                        │
│ Total Processing Time: ~2.5 seconds                                   │
│ User Manual Verification Required: ~30% of cases                      │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

TEST SCENARIO 3: TABLE/CHART HEAVY DOCUMENT
┌────────────────────────────────────────────────────────────────────────┐
│ Input: Document with tables, figures, and mixed content               │
│                                                                        │
│  Classification Challenges:                                            │
│     ├─ Table detection: 85% accuracy                                  │
│     ├─ Chart recognition: 78% accuracy                                │
│     ├─ Caption extraction: 92% accuracy                               │
│     └─ Spatial layout: Complex edge relationships                     │
│                                                                        │
│  Special Handling:                                                     │
│     ├─ Tables: Preserve spacing for OCR alignment                    │
│     ├─ Figures: Extract caption + metadata                            │
│     ├─ Charts: Mark as non-text for manual review                    │
│     └─ Footnotes: Identify and tag properly                          │
│                                                                        │
│ Total Processing Time: ~3.5 seconds                                   │
│ Manual Review Recommended: ~40% of cases                              │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

QUALITY GATES AT EACH STAGE
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│ GATE 1 (After Upload):                                                │
│    ├─ File size < 50 MB? ✓                                           │
│    ├─ Format valid (JPG/PNG/PDF)? ✓                                  │
│    └─ Continue → YES / → REJECT                                      │
│                                                                        │
│ GATE 2 (After Preprocessing):                                         │
│    ├─ Quality score > 0.7? ✓                                         │
│    ├─ Image dimensions normalized? ✓                                 │
│    └─ Continue → YES / → Request retry → NO                          │
│                                                                        │
│ GATE 3 (After Layout Analysis):                                       │
│    ├─ GNN confidence > 0.75? ✓                                       │
│    ├─ Reading order coherent? ✓                                      │
│    ├─ All regions detected? ✓                                        │
│    └─ Continue → YES / → Manual review → NO                          │
│                                                                        │
│ GATE 4 (After OCR):                                                   │
│    ├─ OCR accuracy > 85%? ✓                                          │
│    ├─ Confidence average > 0.80? ✓                                   │
│    └─ Continue → YES / → Flag regions → Manual review → NO           │
│                                                                        │
│ GATE 5 (Final Output):                                                │
│    ├─ Structure valid? ✓                                             │
│    ├─ Metadata complete? ✓                                           │
│    ├─ All checks passed? ✓                                           │
│    └─ Return to user → YES / → Error → NO                            │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

PERFORMANCE EXPECTATIONS BY DOCUMENT TYPE
┌────────────────────────────────────────────────────────────────────────┐
│ Document Type      │ Layout Acc. │ OCR Acc. │ Time   │ Confidence   │
├────────────────────────────────────────────────────────────────────────┤
│ Single-Column      │ 95%         │ 94%      │ 2.0s   │ 0.92         │
│ Multi-Column       │ 88%         │ 89%      │ 2.5s   │ 0.85         │
│ Tables/Charts      │ 82%         │ 85%      │ 3.5s   │ 0.78         │
│ Mixed Content      │ 85%         │ 87%      │ 2.8s   │ 0.82         │
│ Handwritten        │ 72%         │ 68%      │ 4.0s   │ 0.65         │
│ Poor Quality Image │ 65%         │ 60%      │ 4.5s   │ 0.58         │
└────────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│          PERFORMANCE METRICS & EVALUATION DASHBOARD LAYOUT               │
└──────────────────────────────────────────────────────────────────────────┘

METRIC COLLECTION PIPELINE
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│ Each document processing generates:                                    │
│                                                                        │
│ ┌─ LAYOUT METRICS                                                     │
│ │  ├─ Total blocks detected: N                                       │
│ │  ├─ Layout classification accuracy: 0.0-1.0                        │
│ │  ├─ Reading order correctness: TRUE/FALSE                          │
│ │  ├─ Edge detection confidence: 0.0-1.0                             │
│ │  └─ Graph complexity score: O(|V|²) or O(|V|)                     │
│ │                                                                     │
│ ├─ OCR METRICS                                                        │
│ │  ├─ Character accuracy: 85-99%                                     │
│ │  ├─ Word accuracy: 80-95%                                          │
│ │  ├─ Confidence distribution: [mean, std_dev, min, max]            │
│ │  ├─ Regions flagged for manual review: count                       │
│ │  └─ Error categories: [substitution%, deletion%, insertion%]       │
│ │                                                                     │
│ ├─ PERFORMANCE METRICS                                                │
│ │  ├─ Preprocessing time: ms                                         │
│ │  ├─ Graph construction time: ms                                    │
│ │  ├─ GNN inference time: ms                                         │
│ │  ├─ OCR processing time: ms                                        │
│ │  ├─ Reconstruction time: ms                                        │
│ │  ├─ Total pipeline time: ms                                        │
│ │  ├─ Memory usage: MB                                               │
│ │  └─ CPU utilization: %                                             │
│ │                                                                     │
│ ├─ DOCUMENT METADATA                                                  │
│ │  ├─ Document type: [single-column, multi-column, table, etc.]     │
│ │  ├─ File size: bytes                                               │
│ │  ├─ Image dimensions: pixels                                       │
│ │  ├─ Number of pages: count                                         │
│ │  ├─ Text block count: N                                            │
│ │  ├─ Language detected: [EN, ES, FR, etc.]                         │
│ │  └─ Quality assessment: 0.0-1.0                                   │
│ │                                                                     │
│ ├─ ERROR & RECOVERY DATA                                             │
│ │  ├─ Errors encountered: [type1_count, type2_count, ...]           │
│ │  ├─ Recovery attempts: count                                       │
│ │  ├─ Success rate: %                                                │
│ │  ├─ Fallback activation: TRUE/FALSE                                │
│ │  └─ Manual review required: TRUE/FALSE                             │
│ │                                                                     │
│ └─ USER INTERACTION DATA                                             │
│    ├─ User corrections: count                                        │
│    ├─ Manual modifications: [region1, region2, ...]                  │
│    ├─ User confidence rating: 1-5                                    │
│    ├─ Session duration: seconds                                      │
│    └─ Export format requested: [JSON, PDF, TEXT]                     │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

AGGREGATED METRICS (Per Week)
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│ Documents Processed                    │ 245 documents               │
│ Total Processing Hours                 │ 8.2 hours                  │
│ Average Processing Time                │ 2.1 seconds/doc            │
│ Success Rate                           │ 96.3%                      │
│ Average Layout Accuracy                │ 89.4%                      │
│ Average OCR Accuracy                   │ 90.7%                      │
│ Manual Review Required                 │ 3.7% of documents         │
│                                                                        │
│ Performance Percentiles:                                               │
│   ├─ 50th percentile (median):         1.8 seconds                  │
│   ├─ 75th percentile:                  2.4 seconds                  │
│   ├─ 90th percentile:                  3.2 seconds                  │
│   └─ 99th percentile:                  4.8 seconds                  │
│                                                                        │
│ Error Distribution:                                                    │
│   ├─ Preprocessing failures:           0.4%                         │
│   ├─ GNN inference errors:             0.8%                         │
│   ├─ OCR misrecognition:               2.1%                         │
│   ├─ Layout misclassification:         1.2%                         │
│   └─ Other errors:                     0.4%                         │
│                                                                        │
│ By Document Type:                                                      │
│   ├─ Single-column (180 docs):         95.2% accuracy              │
│   ├─ Multi-column (45 docs):           87.8% accuracy              │
│   ├─ Mixed layout (20 docs):           82.5% accuracy              │
│   └─ Handwritten (5 docs):             68.0% accuracy              │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

KEY PERFORMANCE INDICATORS (KPIs)
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│ KPI                          Target    Current   Status               │
│ ────────────────────────────────────────────────────────────────────  │
│ Layout Detection Accuracy    > 92%      89.4%     ⚠ Below target     │
│ OCR Accuracy Improvement     > 15%      18.2%     ✓ Above target     │
│ Processing Speed             < 2.5s     2.1s      ✓ Above target     │
│ Manual Review Rate           < 5%       3.7%      ✓ Above target     │
│ System Uptime                > 99.5%    99.8%     ✓ Above target     │
│ User Satisfaction            > 4.2/5    4.5/5     ✓ Above target     │
│ Error Recovery Success       > 95%      96.3%     ✓ Above target     │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

CONTINUOUS MONITORING & ALERTS
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│ Metric Thresholds with Alerts:                                        │
│                                                                        │
│ ALERT LEVEL  │ Condition                      │ Action                │
│ ─────────────┼────────────────────────────────┼─────────────────      │
│ CRITICAL     │ Processing time > 8s           │ Scale up servers      │
│              │ Error rate > 10%               │ Halt processing       │
│              │ Uptime < 99%                   │ Emergency response    │
│              │                                                        │
│ WARNING      │ Processing time > 5s           │ Monitor closely       │
│              │ Error rate > 5%                │ Log details           │
│              │ Accuracy drift > 3%            │ Retrain model         │
│              │                                                        │
│ INFO         │ Processing time > 3s           │ Log for analysis      │
│              │ Accuracy drift 1-3%            │ Plan optimization     │
│              │ Manual review > 4%             │ Review patterns       │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────────────────────┐
│            COMPLETE METHODOLOGY OVERVIEW & RESEARCH FRAMEWORK             │
└──────────────────────────────────────────────────────────────────────────┘

RESEARCH METHODOLOGY FLOW
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  PHASE 1: DESIGN & PLANNING (Weeks 1-2)                              │
│  ├─ Research objectives definition                                     │
│  ├─ Literature review & baseline studies                               │
│  ├─ Dataset acquisition & annotation                                   │
│  ├─ System architecture design                                         │
│  └─ Technology stack selection                                         │
│                     ↓                                                  │
│  PHASE 2: DEVELOPMENT (Weeks 3-12)                                   │
│  ├─ Sprint 1: Infrastructure & Authentication                          │
│  ├─ Sprint 2: Image Processing & Graph Construction                   │
│  ├─ Sprint 3: GNN Model & OCR Integration                             │
│  ├─ Sprint 4: UI/UX & System Optimization                             │
│  └─ Continuous Integration & Testing                                   │
│                     ↓                                                  │
│  PHASE 3: EVALUATION & VALIDATION (Weeks 13-16)                      │
│  ├─ Unit Testing (Components)                                          │
│  ├─ Integration Testing (Pipeline)                                     │
│  ├─ Functional Testing (End-to-end)                                   │
│  ├─ Performance Testing (Speed & Efficiency)                           │
│  ├─ User Acceptance Testing (Real-world)                              │
│  └─ Data Collection & Analysis                                         │
│                     ↓                                                  │
│  PHASE 4: REPORTING & DEPLOYMENT (Final Week)                         │
│  ├─ Results compilation & analysis                                     │
│  ├─ Thesis document finalization                                       │
│  ├─ System deployment to production                                    │
│  └─ Documentation & knowledge transfer                                 │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

EVALUATION FRAMEWORK COMPONENTS
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  1. TECHNICAL PERFORMANCE METRICS                                     │
│     ├─ Accuracy: Layout detection, OCR quality                        │
│     ├─ Efficiency: Processing time, resource usage                    │
│     ├─ Reliability: Error rates, recovery success                     │
│     └─ Scalability: Throughput, concurrent users                      │
│                                                                        │
│  2. QUALITY ATTRIBUTES (ISO/IEC 25010)                                │
│     ├─ Functional Suitability                                         │
│     ├─ Performance Efficiency                                         │
│     ├─ Compatibility                                                  │
│     ├─ Usability                                                      │
│     ├─ Reliability                                                    │
│     ├─ Security                                                       │
│     ├─ Maintainability                                                │
│     └─ Portability                                                    │
│                                                                        │
│  3. USER EXPERIENCE METRICS                                           │
│     ├─ Usability Score (Task Success Rate)                            │
│     ├─ User Satisfaction (Likert Scale 1-5)                          │
│     ├─ System Ease of Use                                             │
│     └─ Adoption Rate                                                  │
│                                                                        │
│  4. BUSINESS/RESEARCH METRICS                                         │
│     ├─ Time to Solution vs. Baseline                                  │
│     ├─ Cost Efficiency                                                │
│     ├─ Accuracy Improvement over Baseline                             │
│     └─ Research Publication Impact                                    │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

KEY ASSUMPTIONS & CONSTRAINTS
┌────────────────────────────────────────────────────────────────────────┐
│                                                                        │
│  ASSUMPTIONS                                                           │
│  ├─ Document quality varies widely (scanned, phone photos, PDFs)      │
│  ├─ Diverse document layouts (single, multi-column, tables, charts)   │
│  ├─ User base includes researchers, students, organizations           │
│  ├─ Internet connectivity available for cloud processing              │
│  └─ GNN will generalize across document types                         │
│                                                                        │
│  CONSTRAINTS                                                           │
│  ├─ Development timeline: 16 weeks                                    │
│  ├─ Computing resources: Standard GPU (NVIDIA RTX 3090)               │
│  ├─ Dataset size: ~5,000 annotated documents                          │
│  ├─ Team size: 1 developer (thesis project)                           │
│  ├─ No real-time processing required (batch processing okay)          │
│  └─ Production deployment: Cloud-based (AWS/Google Cloud/Azure)       │
│                                                                        │
│  RISKS & MITIGATION                                                    │
│  ├─ Risk: GNN model may not generalize well                           │
│     Mitigation: Extensive cross-validation & transfer learning        │
│  ├─ Risk: Dataset annotation may take longer than planned             │
│     Mitigation: Use semi-automated annotation tools                   │
│  ├─ Risk: OCR errors propagate to downstream modules                  │
│     Mitigation: Implement human-in-the-loop verification              │
│  ├─ Risk: Processing time exceeds acceptable limits                   │
│     Mitigation: Model optimization & inference caching                │
│  └─ Risk: User adoption may be slow                                   │
│     Mitigation: Pilot testing & iterative UI improvements             │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘

VALIDATION CHECKLIST
┌────────────────────────────────────────────────────────────────────────┐
│  Requirement                              Status    Target            │
│  ─────────────────────────────────────────────────────────────────   │
│  □ System processes documents             Ongoing   100% success      │
│  □ Layout accuracy > 90%                  Ongoing   95%+ by week 16   │
│  □ OCR improvement > 15%                  Ongoing   18%+ by week 16   │
│  □ Processing time < 2.5s per page       Ongoing   2.1s by week 16   │
│  □ Manual review rate < 5%                Ongoing   <4% by week 16   │
│  □ User satisfaction > 4.0/5              Pending   4.2+ in testing  │
│  □ System uptime > 99%                    Pending   99.5% in prod    │
│  □ Cross-platform support verified        Pending   All major OSs    │
│  □ Security & privacy standards met       Pending   GDPR compliant   │
│  □ Documentation complete                 Pending   Full thesis +code │
│                                                                        │
└────────────────────────────────────────────────────────────────────────┘