Quality Processing

Score extracted text on a 0.0–1.0 scale, where 1.0 is highest quality. Scoring starts from 1.0 for clean prose: OCR, script, and navigation noise subtract penalties, while document structure and metadata add bonuses. The result is clamped to [0.0, 1.0]. Empty text scores 0.0; text shorter than 10 characters scores 0.1.

Factor	Max weight	Effect	Detects
OCR Artifacts	30%	Penalty	Scattered chars, repeated punctuation, malformed words
Script Content	20%	Penalty	JavaScript, CSS, HTML tags
Navigation Elements	10%	Penalty	Breadcrumbs, pagination, skip links
Document Structure	20%	Bonus	Sentence/paragraph length, punctuation distribution
Metadata Quality	10%	Bonus	Title, author, subject, description, keywords

Script and navigation penalties apply only to text longer than 1000 characters; shorter text is scored on OCR artifacts and structure alone.

Configuration

Python

Python

import asyncio
from xberg import ExtractInput, ExtractionConfig, extract

async def main() -> None:
    config: ExtractionConfig = ExtractionConfig(
        enable_quality_processing=True
    )
    result = await extract(ExtractInput.from_uri("document.pdf"), config)

    quality_score: float = result.quality_score or 0.0
    print(f"Quality score: {quality_score:.2f}")

asyncio.run(main())

TypeScript

TypeScript

import { extract } from "@xberg-io/xberg";

const config = {
  enableQualityProcessing: true,
};

const result = await extract({ kind: "uri", uri: "document.pdf" }, config);
console.log(result.content);

Rust

Rust

use xberg::ExtractionConfig;

let config = ExtractionConfig {
    enable_quality_processing: true,
    ..Default::default()
};

Go

Go

package main

import (
  "fmt"

  "github.com/xberg-io/xberg/packages/go"
)

func main() {
  config := &xberg.ExtractionConfig{
    EnableQualityProcessing: true,  // Default
  }

  fmt.Printf("Quality processing enabled: %v\n", config.EnableQualityProcessing)
}

Java

Java

import io.xberg.ExtractionConfig;

ExtractionConfig config = ExtractionConfig.builder()
    .enableQualityProcessing(true)  // Default
    .build();

C#

C#

using Xberg;

var config = new ExtractionConfig
{
    EnableQualityProcessing = true
};

var result = (await XbergConverter.ExtractAsync(ExtractInput.FromUri(
    "document.pdf"), config
)).Results[0];

var qualityScore = result.QualityScore;

Console.WriteLine($"Quality score: {qualityScore:F2}");

Ruby

Ruby

require 'xberg'

config = Xberg::ExtractionConfig.new(
  enable_quality_processing: true
)

Example

Python

Python

from xberg import ExtractInput, extract, ExtractionConfig

config = ExtractionConfig(enable_quality_processing=True)
result = extract(ExtractInput.from_uri("scanned_document.pdf"), config)

quality_score = result.quality_score or 0.0

if quality_score < 0.5:
    print(f"Warning: Low quality extraction ({quality_score:.2f})")
    print("Consider re-scanning with higher DPI or adjusting OCR settings")
else:
    print(f"Quality score: {quality_score:.2f}")

TypeScript

TypeScript

import { extract } from "@xberg-io/xberg";

const config = {
  enableQualityProcessing: true,
};

const result = await extract({ kind: "uri", uri: "scanned_document.pdf" }, config);
console.log(`Content length: ${result.content.length} characters`);
console.log(`Metadata: ${JSON.stringify(result.metadata)}`);

Rust

Rust

use xberg::{extract, ExtractionConfig, ExtractInput};

let config = ExtractionConfig {
    enable_quality_processing: true,
    ..Default::default()
};
let output = extract(ExtractInput::from_uri("scanned_document.pdf"), &config).await?;

if let Some(score) = output.results[0].quality_score {
    if score < 0.5 {
        println!("Warning: Low quality extraction ({:.2})", score);
    } else {
        println!("Quality score: {:.2}", score);
    }
}

Go

Go

package main

import (
  "fmt"
  "log"

  "github.com/xberg-io/xberg/packages/go"
)

func main() {
  enableQualityProcessing := true

  cfg := xberg.ExtractionConfig{
    EnableQualityProcessing: &enableQualityProcessing,
  }

  input := xberg.ExtractInputFromURI("scanned_document.pdf")
  result, err := xberg.Extract(*input, cfg)
  if err != nil {
    log.Fatalf("extraction failed: %v", err)
  }

  qualityScore := 0.0
  if result.Results[0].QualityScore != nil {
    qualityScore = *result.Results[0].QualityScore
  }

  if qualityScore < 0.5 {
    fmt.Printf("Warning: Low quality extraction (%.2f)\n", qualityScore)
    fmt.Println("Consider re-scanning with higher DPI or adjusting OCR settings")
  } else {
    fmt.Printf("Quality score: %.2f\n", qualityScore)
  }
}

Java

Java

import io.xberg.Xberg;
import io.xberg.ExtractInputKind;
import io.xberg.ExtractionResult;
import io.xberg.ExtractedDocument;
import io.xberg.ExtractionConfig;
import io.xberg.ExtractInput;
import java.util.Map;

ExtractionConfig config = ExtractionConfig.builder()
    .enableQualityProcessing(true)
    .build();
ExtractionResult output = Xberg.extract(
    ExtractInput.builder().withKind(ExtractInputKind.Uri).withUri("scanned_document.pdf").build(),
    config
);
ExtractedDocument result = output.results().get(0);
double qualityScore = result.qualityScore() != null ? result.qualityScore() : 0.0;
if (qualityScore < 0.5) {
    System.out.println(String.format("Warning: Low quality extraction (%.2f)", qualityScore));
    System.out.println("Consider re-scanning with higher DPI or adjusting OCR settings");
} else {
    System.out.println(String.format("Quality score: %.2f", qualityScore));
}

C#

C#

using Xberg;

var config = new ExtractionConfig
{
    EnableQualityProcessing = true
};

var result = (await XbergConverter.ExtractAsync(ExtractInput.FromUri(
    "scanned_document.pdf"), config
)).Results[0];

var qualityScore = result.QualityScore;

if (qualityScore < 0.5)
{
    Console.WriteLine(
        $"Warning: Low quality extraction ({qualityScore:F2})"
    );
    Console.WriteLine(
        "Consider re-scanning with higher DPI or adjusting OCR settings"
    );
}
else
{
    Console.WriteLine($"Quality score: {qualityScore:F2}");
}

Ruby

Ruby

require 'xberg'

config = Xberg::ExtractionConfig.new(
  enable_quality_processing: true
)

input = Xberg::ExtractInput.new(uri: 'scanned_document.pdf')
result = Xberg.extract(input, config)
first_result = result.results.first

quality_score = first_result.quality_score || 0.0

if quality_score < 0.5
  puts "Warning: Low quality extraction (#{quality_score.round(2)})"
  puts "Consider re-scanning with higher DPI or adjusting OCR settings"
else
  puts "Quality score: #{quality_score.round(2)}"
end

See also

• Configuration Reference — the enable_quality_processing option
• Extraction Basics — core extraction pipeline