init

2c67080 11 months ago

22.5 kB

# coding: utf-8
# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).

import os
import logging
import glob
import json
from multiprocessing import Process
from pprint import pformat

import click

from pix2text import set_logger, Pix2Text

_CONTEXT_SETTINGS = {"help_option_names": ['-h', '--help']}
logger = set_logger(log_level=logging.INFO)


@click.group(context_settings=_CONTEXT_SETTINGS)
def cli():
    pass


@cli.command('predict')
@click.option(
    "-l",
    "--languages",
    type=str,
    default='en,ch_sim',
    help="Language Codes for Text-OCR to recognize, separated by commas",
    show_default=True,
)
@click.option(
    "--layout-config",
    type=str,
    default=None,
    help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--mfd-config",
    type=str,
    default=None,
    help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--formula-ocr-config",
    type=str,
    default=None,
    help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--text-ocr-config",
    type=str,
    default=None,
    help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--enable-formula/--disable-formula",
    default=True,
    help="Whether to enable formula recognition",
    show_default=True,
)
@click.option(
    "--enable-table/--disable-table",
    default=True,
    help="Whether to enable table recognition",
    show_default=True,
)
@click.option(
    "-d",
    "--device",
    help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
    type=str,
    default='cpu',
    show_default=True,
)
@click.option(
    "--file-type",
    type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
    default='text_formula',
    help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
    show_default=True,
)
@click.option(
    "--resized-shape",
    help="Resize the image width to this size before processing",
    type=int,
    default=768,
    show_default=True,
)
@click.option(
    "-i",
    "--img-file-or-dir",
    required=True,
    help="File path of the input image/pdf or the specified directory",
)
@click.option(
    "--save-debug-res",
    default=None,
    help="If `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save",
    show_default=True,
)
@click.option(
    "--rec-kwargs",
    type=str,
    default=None,
    help="kwargs for calling .recognize(), in JSON string format",
    show_default=True,
)
@click.option(
    "--return-text/--no-return-text",
    default=True,
    help="Whether to return only the text result",
    show_default=True,
)
@click.option(
    "--auto-line-break/--no-auto-line-break",
    default=True,
    help="Whether to automatically determine to merge adjacent line results into a single line result",
    show_default=True,
)
@click.option(
    "-o",
    "--output-dir",
    default='output-md',
    help="Output directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
    show_default=True,
)
@click.option(
    "--log-level",
    default='INFO',
    help="Log Level, such as `INFO`, `DEBUG`",
    show_default=True,
)
def predict(
    languages,
    layout_config,
    mfd_config,
    formula_ocr_config,
    text_ocr_config,
    enable_formula,
    enable_table,
    device,
    file_type,
    resized_shape,
    img_file_or_dir,
    save_debug_res,
    rec_kwargs,
    return_text,
    auto_line_break,
    output_dir,
    log_level,
):
    """Use Pix2Text (P2T) to predict the text information in an image or PDF."""
    logger = set_logger(log_level=log_level)

    mfd_config = json.loads(mfd_config) if mfd_config else {}
    formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
    languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
    text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

    layout_config = json.loads(layout_config) if layout_config else {}
    text_formula_config = {
        'languages': languages,  # 'en,ch_sim
        'mfd': mfd_config,
        'formula': formula_ocr_config,
        'text': text_ocr_config,
    }
    total_config = {
        'layout': layout_config,
        'text_formula': text_formula_config,
    }
    p2t = Pix2Text.from_config(
        total_configs=total_config,
        enable_formula=enable_formula,
        enable_table=enable_table,
        device=device,
    )

    fp_list = []
    if os.path.isfile(img_file_or_dir):
        fp_list.append(img_file_or_dir)
        if save_debug_res:
            save_debug_res = [save_debug_res]
    elif os.path.isdir(img_file_or_dir):
        fn_list = glob.glob1(img_file_or_dir, '*g')
        fp_list = [os.path.join(img_file_or_dir, fn) for fn in fn_list]
        if save_debug_res:
            os.makedirs(save_debug_res, exist_ok=True)
            save_debug_res = [
                os.path.join(save_debug_res, 'output-debugs-' + fn) for fn in fn_list
            ]
    else:
        raise ValueError(f'{img_file_or_dir} is not a valid file or directory')

    rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
    rec_kwargs['resized_shape'] = resized_shape
    rec_kwargs['return_text'] = return_text
    rec_kwargs['auto_line_break'] = auto_line_break

    for idx, fp in enumerate(fp_list):
        if file_type in ('pdf', 'page'):
            rec_kwargs['save_debug_res'] = (
                save_debug_res[idx] if save_debug_res is not None else None
            )
        else:
            rec_kwargs['save_analysis_res'] = (
                save_debug_res[idx] if save_debug_res is not None else None
            )
        out = p2t.recognize(fp, file_type=file_type, **rec_kwargs)
        if file_type in ('pdf', 'page'):
            out = out.to_markdown(output_dir)
        logger.info(
            f'In image: {fp}\nOuts: \n{out if isinstance(out, str) else pformat(out)}\n'
        )


@cli.command('evaluate')
@click.option(
    "-l",
    "--languages",
    type=str,
    default='en,ch_sim',
    help="Language Codes for Text-OCR to recognize, separated by commas",
    show_default=True,
)
@click.option(
    "--layout-config",
    type=str,
    default=None,
    help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--mfd-config",
    type=str,
    default=None,
    help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--formula-ocr-config",
    type=str,
    default=None,
    help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--text-ocr-config",
    type=str,
    default=None,
    help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--enable-formula/--disable-formula",
    default=True,
    help="Whether to enable formula recognition",
    show_default=True,
)
@click.option(
    "--enable-table/--disable-table",
    default=True,
    help="Whether to enable table recognition",
    show_default=True,
)
@click.option(
    "-d",
    "--device",
    help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
    type=str,
    default='cpu',
    show_default=True,
)
@click.option(
    "--file-type",
    type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
    default='text_formula',
    help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
    show_default=True,
)
@click.option(
    "--resized-shape",
    help="Resize the image width to this size before processing",
    type=int,
    default=768,
    show_default=True,
)
@click.option(
    "-i",
    "--input-json",
    required=True,
    help="JSON file containing evaluation data with image paths and ground truth",
)
@click.option(
    "--gt-key",
    default="model_result",
    help="Key name for ground truth text in the JSON data",
    show_default=True,
)
@click.option(
    "--prefix-img-dir",
    default="data",
    help="Root directory for image files, will be prepended to img_path in JSON",
    show_default=True,
)
@click.option(
    "--rec-kwargs",
    type=str,
    default=None,
    help="kwargs for calling .recognize(), in JSON string format",
    show_default=True,
)
@click.option(
    "--auto-line-break/--no-auto-line-break",
    default=True,
    help="Whether to automatically determine to merge adjacent line results into a single line result",
    show_default=True,
)
@click.option(
    "-o",
    "--output-json",
    default='evaluation_results.json',
    help="Output JSON file for evaluation results",
    show_default=True,
)
@click.option(
    "--output-excel",
    default=None,
    help="Output Excel file with embedded images (optional)",
    show_default=True,
)
@click.option(
    "--output-html",
    default=None,
    help="Output HTML report with embedded images (optional)",
    show_default=True,
)
@click.option(
    "--max-img-width",
    default=400,
    help="Maximum width for embedded images in pixels",
    show_default=True,
)
@click.option(
    "--max-img-height",
    default=300,
    help="Maximum height for embedded images in pixels",
    show_default=True,
)
@click.option(
    "--max-samples",
    default=-1,
    help="Maximum number of samples to process (-1 for all samples)",
    show_default=True,
)
@click.option(
    "--log-level",
    default='INFO',
    help="Log Level, such as `INFO`, `DEBUG`",
    show_default=True,
)
def evaluate(
    languages,
    layout_config,
    mfd_config,
    formula_ocr_config,
    text_ocr_config,
    enable_formula,
    enable_table,
    device,
    file_type,
    resized_shape,
    input_json,
    gt_key,
    prefix_img_dir,
    rec_kwargs,
    auto_line_break,
    output_json,
    output_excel,
    output_html,
    max_img_width,
    max_img_height,
    max_samples,
    log_level,
):
    """Evaluate Pix2Text (P2T) performance using a JSON file with image paths and ground truth."""
    from pix2text.utils import (
        calculate_cer_batch, 
        calculate_cer,
        save_evaluation_results_to_excel_with_images,
        create_html_report_with_images
    )
    
    logger = set_logger(log_level=log_level)

    # Load evaluation data
    try:
        with open(input_json, 'r', encoding='utf-8') as f:
            eval_data = json.load(f)
    except Exception as e:
        logger.error(f"Failed to load evaluation data from {input_json}: {e}")
        return

    if not isinstance(eval_data, list):
        logger.error("Evaluation data must be a list of dictionaries")
        return

    # Validate data format
    for i, item in enumerate(eval_data):
        if not isinstance(item, dict):
            logger.error(f"Item {i} is not a dictionary")
            return
        if 'img_path' not in item or gt_key not in item:
            logger.error(f"Item {i} missing required keys 'img_path' or '{gt_key}'")
            return

    # Initialize Pix2Text
    mfd_config = json.loads(mfd_config) if mfd_config else {}
    formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
    languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
    text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

    layout_config = json.loads(layout_config) if layout_config else {}
    text_formula_config = {
        'languages': languages,
        'mfd': mfd_config,
        'formula': formula_ocr_config,
        'text': text_ocr_config,
    }
    total_config = {
        'layout': layout_config,
        'text_formula': text_formula_config,
    }
    p2t = Pix2Text.from_config(
        total_configs=total_config,
        enable_formula=enable_formula,
        enable_table=enable_table,
        device=device,
    )

    # Prepare recognition kwargs
    rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
    rec_kwargs['resized_shape'] = resized_shape
    rec_kwargs['return_text'] = True
    rec_kwargs['auto_line_break'] = auto_line_break

    def filter_and_clean_gt(gt):
        # 只针对部分的图片进行识别
        # 去掉收尾的'"'
        if not gt:
            return False, gt
        if gt.startswith(r'$$') and gt.endswith(r'$$'):
            gt = gt[2:-2]
            if '$$' not in gt:
                return True, gt.strip()
        return False, gt

    # Process each image and collect results
    predictions = []
    ground_truths = []
    results = []

    # Apply max_samples limit
    if max_samples > 0:
        import random
        random.seed(42)
        random.shuffle(eval_data)
    
    logger.info(f"Limited to {max_samples} samples for evaluation")
    logger.info(f"Starting evaluation on {len(eval_data)} images...")

    for i, item in enumerate(eval_data):
        if len(results) >= max_samples:
            break
        img_path = item['new_img_path']
        ground_truth = item[gt_key]
        
        # Handle ground truth that might be a JSON string
        if isinstance(ground_truth, str):
            try:
                ground_truth = json.loads(ground_truth)
            except json.JSONDecodeError:
                # If it's not valid JSON, use as is
                pass
        
        # Apply formula filtering if needed
        is_formula, ground_truth = filter_and_clean_gt(ground_truth)
        if not is_formula:
            continue

        # Prepend prefix_img_dir to img_path if it's not an absolute path
        if not os.path.isabs(img_path):
            img_path = os.path.join(prefix_img_dir, img_path)
        
        logger.info(f"Processing image {i+1}/{len(eval_data)}: {img_path}")
        
        try:
            # Check if image file exists
            if not os.path.exists(img_path):
                logger.warning(f"Image file not found: {img_path}")
                continue
                
            # Recognize text
            prediction = p2t.recognize(img_path, file_type=file_type, **rec_kwargs)
            
            # Convert to string if needed
            if not isinstance(prediction, str):
                if hasattr(prediction, 'to_markdown'):
                    prediction = prediction.to_markdown()
                else:
                    prediction = str(prediction)
            
            predictions.append(prediction)
            ground_truths.append(ground_truth)
            
            # Calculate individual CER
            cer = calculate_cer(prediction, ground_truth)
            
            result = {
                'img_path': img_path,
                'ground_truth': ground_truth,
                'prediction': prediction,
                'cer': cer
            }
            results.append(result)
            
            logger.info(f"Image {img_path} CER: {cer:.4f}")
            
        except Exception as e:
            logger.error(f"Error processing image {img_path}: {e}")
            continue

    # resort results by cer
    # results.sort(key=lambda x: x['cer'], reverse=True)

    # Calculate overall CER
    if predictions and ground_truths:
        cer_stats = calculate_cer_batch(predictions, ground_truths)
        
        # Prepare final results
        evaluation_results = {
            'summary': {
                'total_samples': len(results),
                'average_cer': cer_stats['average_cer'],
                'individual_cers': cer_stats['individual_cers']
            },
            'detailed_results': results
        }
        
        # Save results
        try:
            with open(output_json, 'w', encoding='utf-8') as f:
                json.dump(evaluation_results, f, ensure_ascii=False, indent=2)
            logger.info(f"Evaluation results saved to: {output_json}")
        except Exception as e:
            logger.error(f"Failed to save evaluation results: {e}")
        
        # Print summary
        logger.info("=" * 50)
        logger.info("EVALUATION SUMMARY")
        logger.info("=" * 50)
        logger.info(f"Total samples processed: {len(results)}")
        logger.info(f"Average CER: {cer_stats['average_cer']:.4f}")
        logger.info(f"Best CER: {min(cer_stats['individual_cers']):.4f}")
        logger.info(f"Worst CER: {max(cer_stats['individual_cers']):.4f}")
        logger.info("=" * 50)
        
    else:
        logger.error("No valid predictions generated")

    # Save results to Excel with embedded images (if requested)
    if output_excel and results:
        excel_success = save_evaluation_results_to_excel_with_images(
            results=results,
            output_file=output_excel,
            img_path_key='img_path',
            gt_key='ground_truth',
            pred_key='prediction',
            cer_key='cer',
            max_img_width=max_img_width,
            max_img_height=max_img_height
        )
        if excel_success:
            logger.info(f"Excel file with embedded images saved to: {output_excel}")
        else:
            logger.warning("Failed to save Excel file with embedded images")
    
    # Save results to HTML report with embedded images (if requested)
    if output_html and results:
        html_success = create_html_report_with_images(
            results=results,
            output_file=output_html,
            img_path_key='img_path',
            gt_key='ground_truth',
            pred_key='prediction',
            cer_key='cer',
            max_img_width=max_img_width,
            max_img_height=max_img_height
        )
        if html_success:
            logger.info(f"HTML report with embedded images saved to: {output_html}")
        else:
            logger.warning("Failed to save HTML report with embedded images")


@cli.command('serve')
@click.option(
    "-l",
    "--languages",
    type=str,
    default='en,ch_sim',
    help="Language Codes for Text-OCR to recognize, separated by commas",
    show_default=True,
)
@click.option(
    "--layout-config",
    type=str,
    default=None,
    help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--mfd-config",
    type=str,
    default=None,
    help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--formula-ocr-config",
    type=str,
    default=None,
    help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--text-ocr-config",
    type=str,
    default=None,
    help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
    show_default=True,
)
@click.option(
    "--enable-formula/--disable-formula",
    default=True,
    help="Whether to enable formula recognition",
    show_default=True,
)
@click.option(
    "--enable-table/--disable-table",
    default=True,
    help="Whether to enable table recognition",
    show_default=True,
)
@click.option(
    "-d",
    "--device",
    help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
    type=str,
    default='cpu',
    show_default=True,
)
@click.option(
    "-o",
    "--output-md-root-dir",
    default='output-md-root',
    help="Markdown output root directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
    show_default=True,
)
@click.option(
    '-H', '--host', type=str, default='0.0.0.0', help='server host', show_default=True,
)
@click.option(
    '-p', '--port', type=int, default=8503, help='server port', show_default=True,
)
@click.option(
    '--reload',
    is_flag=True,
    help='whether to reload the server when the codes have been changed',
    show_default=True,
)
@click.option(
    "--log-level",
    default='INFO',
    help="Log Level, such as `INFO`, `DEBUG`",
    show_default=True,
)
def serve(
    languages,
    layout_config,
    mfd_config,
    formula_ocr_config,
    text_ocr_config,
    enable_formula,
    enable_table,
    device,
    output_md_root_dir,
    host,
    port,
    reload,
    log_level,
):
    """Start the HTTP service."""
    from pix2text.serve import start_server

    logger = set_logger(log_level=log_level)

    analyzer_config = json.loads(mfd_config) if mfd_config else {}
    formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
    languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
    text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

    layout_config = json.loads(layout_config) if layout_config else {}
    text_formula_config = {
        'languages': languages,  # 'en,ch_sim
        'mfd': analyzer_config,
        'formula': formula_ocr_config,
        'text': text_ocr_config,
    }
    total_config = {
        'layout': layout_config,
        'text_formula': text_formula_config,
    }
    p2t_config = dict(
        total_configs=total_config,
        enable_formula=enable_formula,
        enable_table=enable_table,
        device=device,
    )
    api = Process(
        target=start_server,
        kwargs={
            'p2t_config': p2t_config,
            'output_md_root_dir': output_md_root_dir,
            'host': host,
            'port': port,
            'reload': reload,
        },
    )
    api.start()
    api.join()


if __name__ == "__main__":
    cli()

	# coding: utf-8
	# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
	# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).

	import os
	import logging
	import glob
	import json
	from multiprocessing import Process
	from pprint import pformat

	import click

	from pix2text import set_logger, Pix2Text

	_CONTEXT_SETTINGS = {"help_option_names": ['-h', '--help']}
	logger = set_logger(log_level=logging.INFO)


	@click.group(context_settings=_CONTEXT_SETTINGS)
	def cli():
	pass


	@cli.command('predict')
	@click.option(
	"-l",
	"--languages",
	type=str,
	default='en,ch_sim',
	help="Language Codes for Text-OCR to recognize, separated by commas",
	show_default=True,
	)
	@click.option(
	"--layout-config",
	type=str,
	default=None,
	help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--mfd-config",
	type=str,
	default=None,
	help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--formula-ocr-config",
	type=str,
	default=None,
	help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--text-ocr-config",
	type=str,
	default=None,
	help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--enable-formula/--disable-formula",
	default=True,
	help="Whether to enable formula recognition",
	show_default=True,
	)
	@click.option(
	"--enable-table/--disable-table",
	default=True,
	help="Whether to enable table recognition",
	show_default=True,
	)
	@click.option(
	"-d",
	"--device",
	help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
	type=str,
	default='cpu',
	show_default=True,
	)
	@click.option(
	"--file-type",
	type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
	default='text_formula',
	help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
	show_default=True,
	)
	@click.option(
	"--resized-shape",
	help="Resize the image width to this size before processing",
	type=int,
	default=768,
	show_default=True,
	)
	@click.option(
	"-i",
	"--img-file-or-dir",
	required=True,
	help="File path of the input image/pdf or the specified directory",
	)
	@click.option(
	"--save-debug-res",
	default=None,
	help="If `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save",
	show_default=True,
	)
	@click.option(
	"--rec-kwargs",
	type=str,
	default=None,
	help="kwargs for calling .recognize(), in JSON string format",
	show_default=True,
	)
	@click.option(
	"--return-text/--no-return-text",
	default=True,
	help="Whether to return only the text result",
	show_default=True,
	)
	@click.option(
	"--auto-line-break/--no-auto-line-break",
	default=True,
	help="Whether to automatically determine to merge adjacent line results into a single line result",
	show_default=True,
	)
	@click.option(
	"-o",
	"--output-dir",
	default='output-md',
	help="Output directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
	show_default=True,
	)
	@click.option(
	"--log-level",
	default='INFO',
	help="Log Level, such as `INFO`, `DEBUG`",
	show_default=True,
	)
	def predict(
	languages,
	layout_config,
	mfd_config,
	formula_ocr_config,
	text_ocr_config,
	enable_formula,
	enable_table,
	device,
	file_type,
	resized_shape,
	img_file_or_dir,
	save_debug_res,
	rec_kwargs,
	return_text,
	auto_line_break,
	output_dir,
	log_level,
	):
	"""Use Pix2Text (P2T) to predict the text information in an image or PDF."""
	logger = set_logger(log_level=log_level)

	mfd_config = json.loads(mfd_config) if mfd_config else {}
	formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
	languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
	text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

	layout_config = json.loads(layout_config) if layout_config else {}
	text_formula_config = {
	'languages': languages, # 'en,ch_sim
	'mfd': mfd_config,
	'formula': formula_ocr_config,
	'text': text_ocr_config,
	}
	total_config = {
	'layout': layout_config,
	'text_formula': text_formula_config,
	}
	p2t = Pix2Text.from_config(
	total_configs=total_config,
	enable_formula=enable_formula,
	enable_table=enable_table,
	device=device,
	)

	fp_list = []
	if os.path.isfile(img_file_or_dir):
	fp_list.append(img_file_or_dir)
	if save_debug_res:
	save_debug_res = [save_debug_res]
	elif os.path.isdir(img_file_or_dir):
	fn_list = glob.glob1(img_file_or_dir, '*g')
	fp_list = [os.path.join(img_file_or_dir, fn) for fn in fn_list]
	if save_debug_res:
	os.makedirs(save_debug_res, exist_ok=True)
	save_debug_res = [
	os.path.join(save_debug_res, 'output-debugs-' + fn) for fn in fn_list
	]
	else:
	raise ValueError(f'{img_file_or_dir} is not a valid file or directory')

	rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
	rec_kwargs['resized_shape'] = resized_shape
	rec_kwargs['return_text'] = return_text
	rec_kwargs['auto_line_break'] = auto_line_break

	for idx, fp in enumerate(fp_list):
	if file_type in ('pdf', 'page'):
	rec_kwargs['save_debug_res'] = (
	save_debug_res[idx] if save_debug_res is not None else None
	)
	else:
	rec_kwargs['save_analysis_res'] = (
	save_debug_res[idx] if save_debug_res is not None else None
	)
	out = p2t.recognize(fp, file_type=file_type, **rec_kwargs)
	if file_type in ('pdf', 'page'):
	out = out.to_markdown(output_dir)
	logger.info(
	f'In image: {fp}\nOuts: \n{out if isinstance(out, str) else pformat(out)}\n'
	)


	@cli.command('evaluate')
	@click.option(
	"-l",
	"--languages",
	type=str,
	default='en,ch_sim',
	help="Language Codes for Text-OCR to recognize, separated by commas",
	show_default=True,
	)
	@click.option(
	"--layout-config",
	type=str,
	default=None,
	help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--mfd-config",
	type=str,
	default=None,
	help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--formula-ocr-config",
	type=str,
	default=None,
	help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--text-ocr-config",
	type=str,
	default=None,
	help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--enable-formula/--disable-formula",
	default=True,
	help="Whether to enable formula recognition",
	show_default=True,
	)
	@click.option(
	"--enable-table/--disable-table",
	default=True,
	help="Whether to enable table recognition",
	show_default=True,
	)
	@click.option(
	"-d",
	"--device",
	help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
	type=str,
	default='cpu',
	show_default=True,
	)
	@click.option(
	"--file-type",
	type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
	default='text_formula',
	help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
	show_default=True,
	)
	@click.option(
	"--resized-shape",
	help="Resize the image width to this size before processing",
	type=int,
	default=768,
	show_default=True,
	)
	@click.option(
	"-i",
	"--input-json",
	required=True,
	help="JSON file containing evaluation data with image paths and ground truth",
	)
	@click.option(
	"--gt-key",
	default="model_result",
	help="Key name for ground truth text in the JSON data",
	show_default=True,
	)
	@click.option(
	"--prefix-img-dir",
	default="data",
	help="Root directory for image files, will be prepended to img_path in JSON",
	show_default=True,
	)
	@click.option(
	"--rec-kwargs",
	type=str,
	default=None,
	help="kwargs for calling .recognize(), in JSON string format",
	show_default=True,
	)
	@click.option(
	"--auto-line-break/--no-auto-line-break",
	default=True,
	help="Whether to automatically determine to merge adjacent line results into a single line result",
	show_default=True,
	)
	@click.option(
	"-o",
	"--output-json",
	default='evaluation_results.json',
	help="Output JSON file for evaluation results",
	show_default=True,
	)
	@click.option(
	"--output-excel",
	default=None,
	help="Output Excel file with embedded images (optional)",
	show_default=True,
	)
	@click.option(
	"--output-html",
	default=None,
	help="Output HTML report with embedded images (optional)",
	show_default=True,
	)
	@click.option(
	"--max-img-width",
	default=400,
	help="Maximum width for embedded images in pixels",
	show_default=True,
	)
	@click.option(
	"--max-img-height",
	default=300,
	help="Maximum height for embedded images in pixels",
	show_default=True,
	)
	@click.option(
	"--max-samples",
	default=-1,
	help="Maximum number of samples to process (-1 for all samples)",
	show_default=True,
	)
	@click.option(
	"--log-level",
	default='INFO',
	help="Log Level, such as `INFO`, `DEBUG`",
	show_default=True,
	)
	def evaluate(
	languages,
	layout_config,
	mfd_config,
	formula_ocr_config,
	text_ocr_config,
	enable_formula,
	enable_table,
	device,
	file_type,
	resized_shape,
	input_json,
	gt_key,
	prefix_img_dir,
	rec_kwargs,
	auto_line_break,
	output_json,
	output_excel,
	output_html,
	max_img_width,
	max_img_height,
	max_samples,
	log_level,
	):
	"""Evaluate Pix2Text (P2T) performance using a JSON file with image paths and ground truth."""
	from pix2text.utils import (
	calculate_cer_batch,
	calculate_cer,
	save_evaluation_results_to_excel_with_images,
	create_html_report_with_images
	)

	logger = set_logger(log_level=log_level)

	# Load evaluation data
	try:
	with open(input_json, 'r', encoding='utf-8') as f:
	eval_data = json.load(f)
	except Exception as e:
	logger.error(f"Failed to load evaluation data from {input_json}: {e}")
	return

	if not isinstance(eval_data, list):
	logger.error("Evaluation data must be a list of dictionaries")
	return

	# Validate data format
	for i, item in enumerate(eval_data):
	if not isinstance(item, dict):
	logger.error(f"Item {i} is not a dictionary")
	return
	if 'img_path' not in item or gt_key not in item:
	logger.error(f"Item {i} missing required keys 'img_path' or '{gt_key}'")
	return

	# Initialize Pix2Text
	mfd_config = json.loads(mfd_config) if mfd_config else {}
	formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
	languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
	text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

	layout_config = json.loads(layout_config) if layout_config else {}
	text_formula_config = {
	'languages': languages,
	'mfd': mfd_config,
	'formula': formula_ocr_config,
	'text': text_ocr_config,
	}
	total_config = {
	'layout': layout_config,
	'text_formula': text_formula_config,
	}
	p2t = Pix2Text.from_config(
	total_configs=total_config,
	enable_formula=enable_formula,
	enable_table=enable_table,
	device=device,
	)

	# Prepare recognition kwargs
	rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
	rec_kwargs['resized_shape'] = resized_shape
	rec_kwargs['return_text'] = True
	rec_kwargs['auto_line_break'] = auto_line_break

	def filter_and_clean_gt(gt):
	# 只针对部分的图片进行识别
	# 去掉收尾的'"'
	if not gt:
	return False, gt
	if gt.startswith(r'$$') and gt.endswith(r'$$'):
	gt = gt[2:-2]
	if '$$' not in gt:
	return True, gt.strip()
	return False, gt

	# Process each image and collect results
	predictions = []
	ground_truths = []
	results = []

	# Apply max_samples limit
	if max_samples > 0:
	import random
	random.seed(42)
	random.shuffle(eval_data)

	logger.info(f"Limited to {max_samples} samples for evaluation")
	logger.info(f"Starting evaluation on {len(eval_data)} images...")

	for i, item in enumerate(eval_data):
	if len(results) >= max_samples:
	break
	img_path = item['new_img_path']
	ground_truth = item[gt_key]

	# Handle ground truth that might be a JSON string
	if isinstance(ground_truth, str):
	try:
	ground_truth = json.loads(ground_truth)
	except json.JSONDecodeError:
	# If it's not valid JSON, use as is
	pass

	# Apply formula filtering if needed
	is_formula, ground_truth = filter_and_clean_gt(ground_truth)
	if not is_formula:
	continue

	# Prepend prefix_img_dir to img_path if it's not an absolute path
	if not os.path.isabs(img_path):
	img_path = os.path.join(prefix_img_dir, img_path)

	logger.info(f"Processing image {i+1}/{len(eval_data)}: {img_path}")

	try:
	# Check if image file exists
	if not os.path.exists(img_path):
	logger.warning(f"Image file not found: {img_path}")
	continue

	# Recognize text
	prediction = p2t.recognize(img_path, file_type=file_type, **rec_kwargs)

	# Convert to string if needed
	if not isinstance(prediction, str):
	if hasattr(prediction, 'to_markdown'):
	prediction = prediction.to_markdown()
	else:
	prediction = str(prediction)

	predictions.append(prediction)
	ground_truths.append(ground_truth)

	# Calculate individual CER
	cer = calculate_cer(prediction, ground_truth)

	result = {
	'img_path': img_path,
	'ground_truth': ground_truth,
	'prediction': prediction,
	'cer': cer
	}
	results.append(result)

	logger.info(f"Image {img_path} CER: {cer:.4f}")

	except Exception as e:
	logger.error(f"Error processing image {img_path}: {e}")
	continue

	# resort results by cer
	# results.sort(key=lambda x: x['cer'], reverse=True)

	# Calculate overall CER
	if predictions and ground_truths:
	cer_stats = calculate_cer_batch(predictions, ground_truths)

	# Prepare final results
	evaluation_results = {
	'summary': {
	'total_samples': len(results),
	'average_cer': cer_stats['average_cer'],
	'individual_cers': cer_stats['individual_cers']
	},
	'detailed_results': results
	}

	# Save results
	try:
	with open(output_json, 'w', encoding='utf-8') as f:
	json.dump(evaluation_results, f, ensure_ascii=False, indent=2)
	logger.info(f"Evaluation results saved to: {output_json}")
	except Exception as e:
	logger.error(f"Failed to save evaluation results: {e}")

	# Print summary
	logger.info("=" * 50)
	logger.info("EVALUATION SUMMARY")
	logger.info("=" * 50)
	logger.info(f"Total samples processed: {len(results)}")
	logger.info(f"Average CER: {cer_stats['average_cer']:.4f}")
	logger.info(f"Best CER: {min(cer_stats['individual_cers']):.4f}")
	logger.info(f"Worst CER: {max(cer_stats['individual_cers']):.4f}")
	logger.info("=" * 50)

	else:
	logger.error("No valid predictions generated")

	# Save results to Excel with embedded images (if requested)
	if output_excel and results:
	excel_success = save_evaluation_results_to_excel_with_images(
	results=results,
	output_file=output_excel,
	img_path_key='img_path',
	gt_key='ground_truth',
	pred_key='prediction',
	cer_key='cer',
	max_img_width=max_img_width,
	max_img_height=max_img_height
	)
	if excel_success:
	logger.info(f"Excel file with embedded images saved to: {output_excel}")
	else:
	logger.warning("Failed to save Excel file with embedded images")

	# Save results to HTML report with embedded images (if requested)
	if output_html and results:
	html_success = create_html_report_with_images(
	results=results,
	output_file=output_html,
	img_path_key='img_path',
	gt_key='ground_truth',
	pred_key='prediction',
	cer_key='cer',
	max_img_width=max_img_width,
	max_img_height=max_img_height
	)
	if html_success:
	logger.info(f"HTML report with embedded images saved to: {output_html}")
	else:
	logger.warning("Failed to save HTML report with embedded images")


	@cli.command('serve')
	@click.option(
	"-l",
	"--languages",
	type=str,
	default='en,ch_sim',
	help="Language Codes for Text-OCR to recognize, separated by commas",
	show_default=True,
	)
	@click.option(
	"--layout-config",
	type=str,
	default=None,
	help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--mfd-config",
	type=str,
	default=None,
	help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--formula-ocr-config",
	type=str,
	default=None,
	help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--text-ocr-config",
	type=str,
	default=None,
	help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
	show_default=True,
	)
	@click.option(
	"--enable-formula/--disable-formula",
	default=True,
	help="Whether to enable formula recognition",
	show_default=True,
	)
	@click.option(
	"--enable-table/--disable-table",
	default=True,
	help="Whether to enable table recognition",
	show_default=True,
	)
	@click.option(
	"-d",
	"--device",
	help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
	type=str,
	default='cpu',
	show_default=True,
	)
	@click.option(
	"-o",
	"--output-md-root-dir",
	default='output-md-root',
	help="Markdown output root directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
	show_default=True,
	)
	@click.option(
	'-H', '--host', type=str, default='0.0.0.0', help='server host', show_default=True,
	)
	@click.option(
	'-p', '--port', type=int, default=8503, help='server port', show_default=True,
	)
	@click.option(
	'--reload',
	is_flag=True,
	help='whether to reload the server when the codes have been changed',
	show_default=True,
	)
	@click.option(
	"--log-level",
	default='INFO',
	help="Log Level, such as `INFO`, `DEBUG`",
	show_default=True,
	)
	def serve(
	languages,
	layout_config,
	mfd_config,
	formula_ocr_config,
	text_ocr_config,
	enable_formula,
	enable_table,
	device,
	output_md_root_dir,
	host,
	port,
	reload,
	log_level,
	):
	"""Start the HTTP service."""
	from pix2text.serve import start_server

	logger = set_logger(log_level=log_level)

	analyzer_config = json.loads(mfd_config) if mfd_config else {}
	formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
	languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
	text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}

	layout_config = json.loads(layout_config) if layout_config else {}
	text_formula_config = {
	'languages': languages, # 'en,ch_sim
	'mfd': analyzer_config,
	'formula': formula_ocr_config,
	'text': text_ocr_config,
	}
	total_config = {
	'layout': layout_config,
	'text_formula': text_formula_config,
	}
	p2t_config = dict(
	total_configs=total_config,
	enable_formula=enable_formula,
	enable_table=enable_table,
	device=device,
	)
	api = Process(
	target=start_server,
	kwargs={
	'p2t_config': p2t_config,
	'output_md_root_dir': output_md_root_dir,
	'host': host,
	'port': port,
	'reload': reload,
	},
	)
	api.start()
	api.join()


	if __name__ == "__main__":
	cli()