Python使用pdfminer.six实现精准控制PDF文本布局

pip install pdfminer.six

python -c "from pdfminer.pdfdocument import PDFDocument; print('安装成功')"

from pdfminer.high_level import extract_text

text = extract_text("sample.pdf")
print(text[:500])  # 打印前500个字符

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextContainer, LTChar

for page_layout in extract_pages("sample.pdf"):
    for element in page_layout:
        if isinstance(element, LTTextContainer):
            print(element.get_text())
            # 进一步获取每个字符的详细信息
            for text_line in element:
                for character in text_line:
                    if isinstance(character, LTChar):
                        print(f"字符: {character.get_text()}, 字体: {character.fontname}, 字号: {character.size}")

from pdfminer.layout import LAParams
from pdfminer.high_level import extract_text

# 针对多列布局优化
laparams = LAParams(
    char_margin=1.0,      # 更严格的行内字符合并
    line_margin=0.3,      # 降低行间距容忍度，避免跨列合并
    boxes_flow=0.5,       # 保持水平阅读顺序
    detect_vertical=False
)

text = extract_text("multi_column.pdf", laparams=laparams)

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextContainer, LTChar, LTFigure

def traverse_layout(element, level=0):
    """递归遍历PDF布局对象"""
    indent = "  " * level
    
    # 获取对象类型和基本信息
    obj_type = type(element).__name__
    
    if hasattr(element, "get_text"):
        text_preview = element.get_text()[:50].replace("\n", " ")
        print(f"{indent}{obj_type}: {text_preview}...")
    else:
        print(f"{indent}{obj_type}")
    
    # 递归遍历子元素
    if hasattr(element, "__iter__") and not isinstance(element, str):
        for child in element:
            traverse_layout(child, level + 1)

# 使用示例
for page_layout in extract_pages("sample.pdf"):
    print(f"\n{'='*50}")
    print(f"页面: {page_layout}")
    traverse_layout(page_layout)

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextBox, LTFigure

def filter_by_region(element, page_height, top_margin=100, bottom_margin=100):
    """
    根据坐标过滤元素
    - top_margin: 顶部排除区域（像素）
    - bottom_margin: 底部排除区域（像素）
    """
    y0 = getattr(element, "y0", 0)
    y1 = getattr(element, "y1", page_height)
    
    # 排除页眉区域（顶部）
    if y1 > page_height - top_margin:
        return False
    # 排除页脚区域（底部）
    if y0 < bottom_margin:
        return False
    return True

# 使用示例
for page_layout in extract_pages("document.pdf"):
    page_height = page_layout.height
    for element in page_layout:
        if isinstance(element, (LTTextBox, LTFigure)):
            if filter_by_region(element, page_height, top_margin=80, bottom_margin=80):
                print(element.get_text())

from pdfminer.converter import HTMLConverter
from pdfminer.layout import LTTextBox, LTFigure

class RegionAwareHTMLConverter(HTMLConverter):
    """支持区域过滤的HTML转换器"""
    
    def __init__(self, rsrcmgr, outfp, page_bbox=None, codec='utf-8', 
                 pageno=1, laparams=None, extract_region=None, **kwargs):
        super().__init__(rsrcmgr, outfp, codec=codec, pageno=pageno, 
                        laparams=laparams, **kwargs)
        self.extract_region = extract_region  # (x0, y0, x1, y1)
    
    def _in_region(self, obj):
        """判断对象是否在目标区域内"""
        if self.extract_region is None:
            return True
        x0, y0, x1, y1 = self.extract_region
        return (obj.x0 >= x0 and obj.y0 >= y0 and 
                obj.x1 <= x1 and obj.y1 <= y1)
    
    def receive_layout(self, ltpage):
        """重写布局接收方法，添加过滤逻辑"""
        for obj in ltpage:
            if self._in_region(obj):
                if isinstance(obj, LTTextBox):
                    self.write_text(obj.get_text())
                elif isinstance(obj, LTFigure):
                    self.receive_layout(obj)  # 递归处理嵌套对象

from pdfminer.layout import LTChar

def filter_watermark(element, watermark_fonts=None):
    """过滤水印"""
    if watermark_fonts is None:
        watermark_fonts = ['Watermark', 'Stamp']
    
    if hasattr(element, "__iter__"):
        for child in element:
            filter_watermark(child, watermark_fonts)
    elif isinstance(element, LTChar):
        if any(font in element.fontname for font in watermark_fonts):
            return True  # 是水印，跳过
    return False

from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.converter import HTMLConverter
from pdfminer.pdfpage import PDFPage
from pdfminer.layout import LAParams
import io

def extract_region_text(pdf_path, bbox, page_num=0):
    """
    提取指定区域的文本
    bbox: (x0, y0, x1, y1) 单位：像素（点）
    """
    rsrcmgr = PDFResourceManager()
    outfp = io.StringIO()
    laparams = LAParams()
    
    # 使用自定义的HTMLConverter
    device = RegionAwareHTMLConverter(
        rsrcmgr, outfp, laparams=laparams, 
        extract_region=bbox
    )
    interpreter = PDFPageInterpreter(rsrcmgr, device)
    
    with open(pdf_path, 'rb') as fp:
        for i, page in enumerate(PDFPage.get_pages(fp)):
            if i == page_num:
                interpreter.process_page(page)
                break
    
    device.close()
    text = outfp.getvalue()
    outfp.close()
    return text

# 使用示例：提取发票金额区域
bbox = (500, 600, 600, 700)  # 根据实际发票调整坐标
amount_text = extract_region_text("invoice.pdf", bbox)
print(f"提取的金额：{amount_text}")

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextBox

def find_element_coordinates(pdf_path, target_keyword):
    """查找包含特定关键词的元素坐标"""
    results = []
    for page_layout in extract_pages(pdf_path):
        for element in page_layout:
            if isinstance(element, LTTextBox):
                text = element.get_text()
                if target_keyword in text:
                    results.append({
                        'text': text,
                        'bbox': (element.x0, element.y0, element.x1, element.y1),
                        'page_height': page_layout.height
                    })
    return results

# 使用示例
coords = find_element_coordinates("invoice.pdf", "金额")
for c in coords:
    print(f"找到关键词: {c['text'][:50]}")
    print(f"坐标: x0={c['bbox'][0]}, y0={c['bbox'][1]}, x1={c['bbox'][2]}, y1={c['bbox'][3]}")

import io
from typing import List, Dict, Optional, Tuple
from pdfminer.high_level import extract_text, extract_pages
from pdfminer.layout import LAParams, LTTextBox, LTTextLine, LTChar
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.pdfpage import PDFPage
from pdfminer.converter import TextConverter, HTMLConverter


class PDFMinerParser:
    """pdfminer.six 封装工具类"""
    
    def __init__(self, laparams: Optional[LAParams] = None):
        self.laparams = laparams or LAParams()
    
    def extract_full_text(self, pdf_path: str) -> str:
        """提取全文"""
        return extract_text(pdf_path, laparams=self.laparams)
    
    def extract_metadata(self, pdf_path: str) -> Dict:
        """提取元数据"""
        from pdfminer.high_level import extract_metadata
        metadata = extract_metadata(pdf_path)
        return {
            'title': getattr(metadata, 'title', ''),
            'author': getattr(metadata, 'author', ''),
            'subject': getattr(metadata, 'subject', ''),
            'creator': getattr(metadata, 'creator', ''),
            'producer': getattr(metadata, 'producer', '')
        }
    
    def extract_text_with_position(self, pdf_path: str) -> List[Dict]:
        """提取带位置信息的文本"""
        results = []
        for page_layout in extract_pages(pdf_path, laparams=self.laparams):
            page_height = page_layout.height
            for element in page_layout:
                if isinstance(element, LTTextBox):
                    for line in element:
                        if isinstance(line, LTTextLine):
                            for char in line:
                                if isinstance(char, LTChar):
                                    results.append({
                                        'char': char.get_text(),
                                        'x0': char.x0,
                                        'y0': char.y0,
                                        'x1': char.x1,
                                        'y1': char.y1,
                                        'font': char.fontname,
                                        'size': char.size,
                                        'page_height': page_height
                                    })
        return results
    
    def extract_region_text(self, pdf_path: str, bbox: Tuple[float, float, float, float],
                            page_num: int = 0) -> str:
        """提取指定区域的文本"""
        class RegionHTMLConverter(HTMLConverter):
            def __init__(self, *args, region=None, **kwargs):
                super().__init__(*args, **kwargs)
                self.region = region
            
            def receive_layout(self, ltpage):
                for obj in ltpage:
                    if self.region is None:
                        self.render(obj)
                    else:
                        x0, y0, x1, y1 = self.region
                        if (obj.x0 >= x0 and obj.y0 >= y0 and 
                            obj.x1 <= x1 and obj.y1 <= y1):
                            self.render(obj)
        
        rsrcmgr = PDFResourceManager()
        outfp = io.StringIO()
        device = RegionHTMLConverter(rsrcmgr, outfp, laparams=self.laparams, 
                                      region=bbox)
        interpreter = PDFPageInterpreter(rsrcmgr, device)
        
        with open(pdf_path, 'rb') as fp:
            for i, page in enumerate(PDFPage.get_pages(fp)):
                if i == page_num:
                    interpreter.process_page(page)
                    break
        
        device.close()
        result = outfp.getvalue()
        outfp.close()
        return result
    
    def filter_header_footer(self, pdf_path: str, top_margin: float = 80, 
                              bottom_margin: float = 80) -> str:
        """过滤页眉页脚后提取文本"""
        class HeaderFooterFilterConverter(TextConverter):
            def __init__(self, *args, top_margin=80, bottom_margin=80, **kwargs):
                super().__init__(*args, **kwargs)
                self.top_margin = top_margin
                self.bottom_margin = bottom_margin
            
            def receive_layout(self, ltpage):
                for obj in ltpage:
                    y0 = getattr(obj, 'y0', 0)
                    y1 = getattr(obj, 'y1', ltpage.height)
                    if y1 > ltpage.height - self.top_margin:
                        continue  # 跳过页眉区域
                    if y0 < self.bottom_margin:
                        continue  # 跳过页脚区域
                    self.render(obj)
        
        rsrcmgr = PDFResourceManager()
        outfp = io.StringIO()
        device = HeaderFooterFilterConverter(rsrcmgr, outfp, laparams=self.laparams,
                                              top_margin=top_margin, 
                                              bottom_margin=bottom_margin)
        interpreter = PDFPageInterpreter(rsrcmgr, device)
        
        with open(pdf_path, 'rb') as fp:
            for page in PDFPage.get_pages(fp):
                interpreter.process_page(page)
        
        device.close()
        result = outfp.getvalue()
        outfp.close()
        return result


# 使用示例
if __name__ == "__main__":
    parser = PDFMinerParser()
    
    # 1. 提取全文
    full_text = parser.extract_full_text("sample.pdf")
    print(f"全文长度: {len(full_text)} 字符")
    
    # 2. 提取元数据
    metadata = parser.extract_metadata("sample.pdf")
    print(f"作者: {metadata['author']}")
    
    # 3. 提取带位置的信息
    chars = parser.extract_text_with_position("sample.pdf")
    print(f"共提取 {len(chars)} 个字符的位置信息")
    
    # 4. 提取指定区域
    region_text = parser.extract_region_text("sample.pdf", (100, 100, 500, 300))
    print(f"区域文本: {region_text[:100]}")
    
    # 5. 过滤页眉页脚
    clean_text = parser.filter_header_footer("sample.pdf", top_margin=80, bottom_margin=80)
    print(f"过滤后文本长度: {len(clean_text)} 字符")

# 针对双栏论文优化参数
laparams = LAParams(
    char_margin=1.0,
    line_margin=0.3,
    boxes_flow=0.5
)

parser = PDFMinerParser(laparams=laparams)
text = parser.extract_full_text("academic_paper.pdf")

# 定位到合同条款区域（通常在页面上半部分）
contract_bbox = (50, 500, 550, 750)  # 根据实际调整
clause_text = parser.extract_region_text("contract.pdf", contract_bbox)

import os
from concurrent.futures import ThreadPoolExecutor

def batch_parse(pdf_dir: str):
    """批量解析目录下的所有PDF"""
    parser = PDFMinerParser()
    results = {}
    
    pdf_files = [f for f in os.listdir(pdf_dir) if f.endswith('.pdf')]
    
    def parse_one(pdf_file):
        pdf_path = os.path.join(pdf_dir, pdf_file)
        return pdf_file, parser.extract_full_text(pdf_path)
    
    with ThreadPoolExecutor(max_workers=4) as executor:
        for pdf_file, text in executor.map(parse_one, pdf_files):
            results[pdf_file] = text
    
    return results

# 使用示例
texts = batch_parse("./pdfs/")
for name, content in texts.items():
    print(f"{name}: {len(content)} 字符")

from pdfminer.pdfdocument import PDFDocument
from pdfminer.pdfparser import PDFParser

# 使用更底层的API处理中文编码问题
parser = PDFParser(open('chinese.pdf', 'rb'))
document = PDFDocument(parser)
# 确保CID字体正确加载

# 使用逐页迭代而非一次性提取
for page in PDFPage.get_pages(fp, caching=False):  # 关闭缓存
    interpreter.process_page(page)

# 先使用PyMuPDF将PDF页面转为图像，再用OCR识别
import fitz
doc = fitz.open("scanned.pdf")
for page_num in range(len(doc)):
    page = doc[page_num]
    pix = page.get_pixmap()
    pix.save(f"page_{page_num}.png")
    # 然后使用OCR工具识别图像中的文字