def __init__(self, rsrcmgr, codec='utf-8', pageno=1, laparams=None):
PDFLayoutAnalyzer.__init__(self,
rsrcmgr,
pageno=pageno,
laparams=laparams)
self.codec = codec
return
def __init__(self, rsrcmgr, pageno=1, laparams=None):
PDFLayoutAnalyzer.__init__(self,
rsrcmgr,
pageno=pageno,
laparams=laparams)
self.result = None
return
def __init__(self, rsrcmgr, outfp, ignore, lib, fontMap, icu, tags, laparams=None):
PDFLayoutAnalyzer.__init__(self, rsrcmgr, laparams=laparams)
#self.__codec = codec
self.__outfp = outfp # plik do ktorego eksportujemy hOCR
self.__lib = lib #
self.__num = -1 # numer strony (liczony od 0)
self.__fontMap = fontMap # mapowanie postscriptowych nazw fontow na rodziny
self.__icu = icu # lokalizacja ktora ma byc uzyta przez ICU do podzialu
# na slowa; jezeli jest rowna None to znaczy, ze mamy nie dzielic na
# slowa
self.__specialTags = tags # czy uzywamy specjalnych tagow ocrx_bold i
# ocrx_italic?
#self.__fontDict = {}
#self.__font = None
self.__font = None # ostatnio wypisany font
#self.__page = None
self.__hasFont = False # czy jestesmy wewnatrz tagu <span> z definicja fontu
#self.__isLine = False
self.__ignore = ignore # czy ignorujemy elementy "textgroup"
self.__page = None # aktualnie przetwarzana strona (obiekt PDFPage)
self.__pagebbox = None # bounding box aktualnie przetwarzanej strony
self.__chars = [] # tu zapamietujemy znaki podczas przetwarzania elementow
# "textline" - dzieki temu potem mamy cala zawartosc tekstowa "textline"
# i mozemy ja wykorzystac do dzielenia na slowa
self.__divs = [] # por. HOCRExporter
self.__ind = 0
self.__inWord = False
self.__wordInd = 0
self.__divbboxes = None
self.__whites = None
return
def __init__(self,
rsrcmgr,
laparams=None,
stop_at=None,
top=None,
bottom=None):
PDFLayoutAnalyzer.__init__(self, rsrcmgr, pageno=1, laparams=laparams)
self.stop_at = stop_at
self.reset(top, bottom)
def __init__(self, resource_mgr, laparams=None, imagewriter=None) -> None:
PDFLayoutAnalyzer.__init__(self,
resource_mgr,
pageno=1,
laparams=laparams)
self.imagewriter = imagewriter
self.curr_text = ""
self.texts: List[TextInfo] = []
def __init__(self, rsrcmgr, pageno=1, laparams=None):
PDFLayoutAnalyzer.__init__(self, rsrcmgr, pageno=pageno, laparams=laparams)
self._parameters = ConverterParameters()
# attributes result of the parsing
self.meta = Meta()
self._titles = []
self._all_tables = []
# intermediary results
self._result_lines = []
# attributes reset on each new page
self._tables = []
self._images = []
# state of the device across pages
self.previous_line = None
self._is_citing = False
def __init__(self,
rsrcmgr,
ignore,
codec='utf-8',
pageno=1,
laparams=None,
outdir=None,
lib=None,
hocr=None,
columnizer=None):
PDFLayoutAnalyzer.__init__(self,
rsrcmgr,
pageno=pageno,
laparams=laparams)
#self.__codec = codec
self.__ignore = ignore # patrz parametry pdfa2hocr.py
#self.__outdir = outdir
if hocr == None: # nie eksportujemy do hOCR
#self.__root.__isRoot = True # ustawiane w PDFMinerParserze.getResult()
self.__node = PDFMinerNode(
"pages") # korzen drzewa struktury, jezeli
# eksportujemy do hOCR niepotrzebny, bo eksportujemy strona po stronie
self.__root = self.__node # korzen generowanego drzewa struktury
else: # eksportujemy
self.__node = None # aktualnie przetwarzany wezel
self.__hocr = hocr # eksporter do hOCR
self.__columnizer = columnizer # obiekt przeprowadzajacy dodatkowa analize
# uklady strony
self.__fontDict = {} # slownik fontow (zeby nie fontom o tej samej
# nazwie i rozmiarze odpowiadal jeden obiekt klasy Font)
self.__page = None # aktualnie przetwarzana strona (obiekt PDFMinerNode)
self.__num = -1 # numer strony liczony od 0 (PDFMinerNode.__pageid)
self.__font = None # ostatnio przetwarzany font
self.__stack = [
] # stos na ktorym sa przodkowie aktualnie przetwarzanego elementu
self.__lib = lib # zaslepka XMLLib w ktorej musimy zainicjalizowac bounding boxy stron
# i ktora zawiera obiekt __ptree z ktorego pobierzemy fonty
self.__pdfminerpage = None # aktualnie przetwarzana strona (obiekt pdfminera)
return
def paint_path(self, gstate, stroke, fill, evenodd, path):
"""
Creates a LTNetwork out of the different drawing elements.
"""
# ignore lines above header
if path[0][0] in 'lm' and path[0][2] > HEADER_MIN_Y - 5:
return
path_string = ''.join(x[0] for x in path)
# ignore curves
if 'c' in path_string:
return
# a rectangle is never part of a table, parse it as other.
if path_string == 'mlllh':
return PDFLayoutAnalyzer.paint_path(self, gstate, stroke, fill,
evenodd, path)
# a line is parsed both as a line and as part of a network.
elif path_string == 'ml':
PDFLayoutAnalyzer.paint_path(self, gstate, stroke, fill,
evenodd, path)
# this situation may occur on the first page of the PDF; we thus
# set it here explicitly.
elif path_string == 'mlml':
PDFLayoutAnalyzer.paint_path(self, gstate, stroke, fill,
evenodd, path[:2])
PDFLayoutAnalyzer.paint_path(self, gstate, stroke, fill,
evenodd, path[2:])
# ignore (non-rectangle) filled stuff
if fill:
return
self._paint_network(path)
def begin_page(self, page, ctm):
self.__pdfminerpage = page
PDFLayoutAnalyzer.begin_page(self, page, ctm)
def __init__(self, rsrcmgr, pageno=1, laparams=None):
PDFLayoutAnalyzer.__init__(self, rsrcmgr, pageno=pageno, laparams=laparams)
self.__bbox = None # bounding box przetwarzanego napisu
self.__itembbox = None # bounding box aktualnie przetwarzanego znaku
self.__charbboxes = [] # bounding boxy znakow przetwarzanego napisu
return
def _get_analyzer(self):
analyzer = PDFLayoutAnalyzer(None)
analyzer.set_ctm([1, 0, 0, 1, 0, 0])
return analyzer
def begin_page(self, page, ctm):
PDFLayoutAnalyzer.begin_page(self, page, ctm)
self.cur_item = MyLTPage(self.cur_item.pageid, self.cur_item.bbox)
def __init__(self, rsrcmgr, pageno=1, laparams=None,
showpageno=False):
PDFLayoutAnalyzer.__init__(self, rsrcmgr, pageno=pageno, laparams=laparams)
self.showpageno = showpageno
self.text=""