rawmaker 2.40.3__py3-none-any.whl

rawmaker/miner/images.py

@@ -0,0 +1,448 @@
+# =============================================================================
+# C O P Y R I G H T
+# -----------------------------------------------------------------------------
+# Copyright (c) 2019-2023 by Helmut Konrad Schewe. All rights reserved.
+# This file is property of Helmut Konrad Schewe. Any unauthorized copy,
+# use or distribution is an offensive act against international law and may
+# be prosecuted under federal law. Its content is company confidential.
+# =============================================================================
+"""Extract images out of a PDF-Page
+
+There are 2 types of images to extract:
+
+    One the one hand, there is the image which stored in internal format
+    One the other hand, there is the image that is generated by a color table
+
+Furthermore there are some images which are composed out of other
+images. Sometimes one Image is splitted into two or three parts. The
+maximum of this split is one image per pixel line.
+
+NOTE Currently this feature is experimental.
+"""
+
+import array
+import collections
+import io
+import os
+
+import pdfminer.converter
+import pdfminer.image
+import pdfminer.layout
+import pdfminer.pdfdocument
+import pdfminer.pdfinterp
+import pdfminer.pdftypes
+import pdfminer.psparser
+import PIL.Image
+import PIL.ImageDraw
+import PIL.ImageDraw2
+import PIL.PngImagePlugin
+import utilo
+
+import rawmaker.converter.images
+import rawmaker.miner.colorspace
+
+MergedImage = collections.namedtuple('MergedImage', 'image, ext, bounding')
+WrittenImage = collections.namedtuple('WrittenImage', 'filename, bounding')
+LTImages = list[pdfminer.layout.LTImage]
+
+
+def extract_images(
+    document: pdfminer.pdfdocument.PDFDocument,
+    outputfolder,
+    pages: tuple = None,
+) -> dict:
+    """Extract all images of `document` of selected `pages`.
+
+    Hint: `Outputfolder` is only created if `document` contains some images.
+
+    Args:
+        document: source to extract images from
+        outputfolder(str): write extracted images to
+        pages(tuple): selective list to process pages
+    Returns:
+        dict with one list per page with containing images of this page
+    """
+    # ensure that page computation works correct
+    if pages:
+        pages = utilo.ensure_tuple(pages)
+        pages = sorted(pages)
+    # Processing layout
+    content = pdfminer.pdfpage.PDFPage.create_pages(document)
+    # setup collector
+    collect = CollectAndMerge(outputfolder)
+    firstpage = pages[0] if pages else 0
+    interpreter = rawmaker.converter.images.create_fastimageextractor(
+        collect.imagereciver,
+        firstpage=firstpage,
+    )
+    # iterate pages
+    with utilo.SkipCollector(pages) as collector:
+        for number, page in enumerate(content):
+            if collector.skip(number):
+                continue
+            page.pageid = number
+            interpreter.process_page(page)
+    # determine result
+    result = collect.merge_and_write()
+    return result
+
+
+class CollectAndMerge:
+
+    def __init__(self, outputfolder):
+        self.outputfolder = outputfolder
+        self.to_merge = collections.defaultdict(list)
+        self.written = collections.defaultdict(list)
+
+    def imagereciver(self, page, image):
+        self.to_merge[page].append(image)
+
+    def merge_and_write(self) -> dict:
+        if not self.to_merge:
+            # no images given
+            return {}
+        os.makedirs(self.outputfolder, exist_ok=True)
+        merged = merge_document_images(self.to_merge)
+        # write merged images
+        for page, values in merged.items():
+            for index, extracted in enumerate(values):
+                if not extracted:
+                    continue
+                written = write_image(
+                    extracted,
+                    write_to=self.outputfolder,
+                    page=page,
+                    index=index,
+                )
+                self.written[page].append(written)
+        self.to_merge.clear()
+        # convert defaultdict to normal dict, remove empty pages
+        result = {key: value for key, value in self.written.items() if value}
+        return result
+
+
+IMAGE_WIDTH_MAX = 2048
+IMAGE_HEIGHT_MAX = 2048
+
+
+def write_image(extracted, write_to, page, index) -> WrittenImage:
+    """Write image `extracted` to directory `write_to`.
+
+    The file is named {page}_{index}.{extracted.ext}.
+    """
+    assert extracted
+    ext = extracted.ext
+    filename = f'{page}_{index}.{ext}'
+    if isinstance(extracted.image, PIL.Image.Image):
+        outpath = os.path.join(write_to, filename)
+        with open(outpath, mode='wb') as output:
+            ext = ext.replace('jpg', 'jpeg')
+            try:
+                extracted.image.save(output, format=ext)
+            except Exception:  # pylint:disable=broad-except
+                utilo.error(f'could not use save method: {filename}')
+    else:
+        try:
+            # images writer add file extention bt themself
+            writer = pdfminer.image.ImageWriter(write_to)
+            rawimage = extracted.image
+            rawimage.name = f'{page}_{index}'
+            if rawimage.width < IMAGE_WIDTH_MAX and rawimage.height < IMAGE_HEIGHT_MAX:
+                raw_data = rawimage.stream.get_rawdata()
+                if not raw_data:
+                    utilo.error(f'empty image data, {rawimage.name}')
+                else:
+                    writer.export_image(rawimage)
+            else:
+                msg = f'skip image size: {rawimage.srcsize} name: {rawimage.name}'
+                utilo.info(msg)
+        except pdfminer.pdftypes.PDFNotImplementedError as error:
+            utilo.error(f'could not export: {error}')
+        except TypeError:
+            utilo.error(f'empty export: {extracted.image.name}')
+        except ValueError:
+            utilo.error(f'decompression error: {extracted.image.name}')
+    return WrittenImage(filename=filename, bounding=extracted.bounding)
+
+
+def merge_document_images(items):
+    result = collections.defaultdict(list)
+    # merge pages by yposition
+    for page, content in items.items():
+        merged = merge_page(content, page)
+        result[page].extend(merged)
+    return result
+
+
+def merge_page(images: LTImages, page: int):
+    todo = [
+        utilo.roundme((image.x0, image.y0, image.x1, image.y1))
+        for image in images
+    ]
+    # cluster image parts into mergable image
+    lookup = {str(item): line for item, line in zip(todo, images)}
+    # assert len(lookup) == len(todo), f'{len(lookup)} != {len(todo)}'
+    grouped = group_rectangles(todo)
+    # convert back
+    lines = [[lookup[str(item)] for item in group] for group in grouped]
+    result = []
+    try:
+        result = [raw_images_merge(item) for item in lines]
+    except ValueError as error:
+        utilo.error(f'could not parse images on page: {page}')
+        utilo.error(error)
+    return result
+
+
+def group_rectangles(rectangles):
+    """Split potential images by distance in y-coordiante."""
+    border = range(0, 1000, 10)
+    bucket = utilo.Buckets(border, sorting=True)
+    bucket.selector = lambda x: x[1]  # TODO: REMOVE THIS HACK
+    for item in rectangles:
+        bucket.add(item)
+    grouped = utilo.groupby_empty(bucket)
+    if not grouped:
+        return []
+    # merge neighbors which are huger than bucket size
+    result = [list(grouped[0])]
+    for current in grouped[1:]:
+        before = result[-1][-1]
+        if utilo.near(before[3], current[0][1], diff=5.0):
+            result[-1].extend(current)
+        elif any(utilo.rectangles_intersecting(result[-1], item) for item in current): # yapf:disable
+            # verify if any rectangle intersects to detect rectangles
+            # inside each other
+            result[-1].extend(current)
+        else:
+            result.append(list(current))
+    return result
+
+
+BITMAP = '1'
+
+
+# pylint:disable=R1260,R0914,R0915
+def raw_images_merge(images: LTImages) -> MergedImage:
+    """Merge list of images to one image."""
+    ext = extention(images[0])
+    bounding = tuple(images[0].bbox)
+    if ext == 'jbig2':
+        images = [jbig2(images[0])]
+        ext = 'jpg'
+    if len(images) == 1:
+        # TODO: png is not supported by pdfimage exporter properly
+        if ext != 'png':
+            # no merge required
+            return MergedImage(images[0], ext, bounding)
+        utilo.debug(f'extraction not supported: {images[0]}')
+    # determine rectangle bounding
+    x00 = min(item.x0 for item in images)  # pylint:disable=no-member
+    x11 = max(item.x1 for item in images)  # pylint:disable=no-member
+    y00 = min(item.y0 for item in images)  # pylint:disable=no-member
+    y11 = max(item.y1 for item in images)  # pylint:disable=no-member
+    # create empty image to render sub images into
+    image_width = x11 - x00
+    image_height = y11 - y00
+    size = (int(image_width), int(image_height))
+    mode = 'RGB'
+    result = PIL.Image.new(mode, size, color=0)
+    renderer = PIL.ImageDraw.Draw(result, mode=mode)
+    # render sub-images
+    for image in images:
+        ext = extention(image)
+        current = image_fromlt(image)
+        if not current:
+            continue
+        # render to common image
+        current = ensure_bitmap(current)
+        renderer.bitmap((image.x0 - x00, image.y0 - y00), bitmap=current)  # pylint:disable=no-member
+    # update bottom bounding of merged rectangle
+    multi_bounding = (x00, y00, x11, y11)
+    return MergedImage(result, ext, multi_bounding)
+
+
+def ensure_bitmap(image):
+    if isinstance(image, PIL.PngImagePlugin.PngImageFile):
+        image = image.convert(mode=BITMAP, colors=1024, palette='1')
+    return image
+
+
+def jbig2(image):
+    # convert size, cause later fill method requests int
+    size = (int(image.width), int(image.height))
+
+    monochrom = '1'
+    result = PIL.Image.new(mode=monochrom, size=size, color=1)
+    renderer = PIL.ImageDraw.Draw(result, mode=monochrom)
+
+    data = image.stream.get_data()
+    width = image.width
+    for cursor, item in enumerate(data):
+        cursor = cursor * 8
+        x, y = cursor % width, cursor // (width / 8)
+        for pos in range(8):
+            datum = item << pos & 0b00000001
+            renderer.point((x + pos, y), datum)
+    return result
+
+
+def image_fromlt(image) -> PIL.Image:  # pylint:disable=R0912
+    try:
+        colorspace = rawmaker.miner.colorspace.parse(image.colorspace)
+    except AttributeError as error:
+        utilo.print_stacktrace()
+        utilo.error(error)
+        colorspace = 'DeviceRGB'
+    try:
+        data = image.stream.get_data()
+    except ValueError as error:
+        utilo.error(error)
+        return None
+    except pdfminer.pdftypes.PDFNotImplementedError as error:
+        if 'JPXDecode' in str(error):
+            utilo.debug(error)
+            utilo.debug('use own png converter')
+            rawdata = image.stream.get_rawdata()
+            return png_load(rawdata)
+        utilo.error(error)
+        return None
+    # try to load images
+    mode = '1'  # default mode
+    size = image.srcsize
+    bits = image.bits
+    if colorspace == 'DeviceGray':
+        mode = BITMAP
+    elif colorspace:
+        data = rgb256_decoder(data, colorspace, bits=bits)
+    else:
+        # black and white
+        mode = BITMAP
+
+    if bits == 4:
+        # TODO Do not know why this is required
+        size = (size[0] + 1, size[1])
+        mode = 'RGB'
+    if colorspace == 'DeviceRGB':
+        try:
+            # open jpg etc.
+            buffer = io.BytesIO(data)
+            current = PIL.Image.open(buffer)
+        except IOError:
+            try:
+                current = PIL.Image.frombytes(mode, size, data)
+            except ValueError:
+                # TODO: REMOVE THIS DIRTY SHIT
+                current = PIL.Image.frombytes('1', size, data)
+    else:
+        try:
+            current = PIL.Image.frombytes(mode, size, data)
+        except ValueError:
+            utilo.error(f'could not decode: {image}')
+            return None
+    # convert to bitmap
+    try:
+        current = current.convert(mode=BITMAP, colors=1024, palette='1')
+        loaded = io.BytesIO(current.tobitmap())
+        current = PIL.Image.open(loaded)
+    except OSError:
+        current = PIL.Image.new(mode, size, color=0)
+    return current
+
+
+def png_load(rawdata) -> PIL.Image:
+    """Convert JPEG2000 to png data."""
+    # TODO: MOVE THIS CODE TO PDFMINER
+    buffer = io.BytesIO(rawdata)
+    buffer.seek(0)
+    with PIL.Image.open(buffer) as fp:
+        converted = io.BytesIO()
+        try:
+            fp.save(converted, 'png')
+        except OSError:
+            utilo.error('invalid png file, maybe an other type')
+            utilo.error(rawdata[0:50])
+            return None
+        converted.seek(0)
+    loaded = PIL.Image.open(converted)
+    return loaded
+
+
+def rgb256_decoder(data, dataspace, bits=8):
+    # RGB
+    # TODO: FIX TABLE ERRORS
+    table = []
+    if isinstance(dataspace, pdfminer.pdftypes.PDFStream):
+        dataspace = dataspace.get_data()
+    for index in range(0, len(dataspace), 3):
+        try:
+            table.append([
+                dataspace[index],
+                dataspace[index + 1],
+                dataspace[index + 2],
+            ])
+        except IndexError:
+            utilo.debug('rgb256 decoder out of bounds')
+            return data
+    result = []
+    for item in data:
+        try:
+            if bits == 4:
+                lower = table[item & (15)]
+                higher = table[item & (15 >> 4 - 1)]
+                result.extend(lower)
+                result.extend(higher)
+            elif bits == 8:
+                result.extend(table[item])
+            else:
+                raise ValueError(f'{bits} bits not supported')
+        except IndexError:
+            utilo.debug('rgb256 decoder out of bounds')
+            return data
+    try:
+        data = array.array("B", result).tobytes()
+    except TypeError:
+        return data
+    return data
+
+
+def extention(image) -> str:
+    """\
+    #JBIG2Decode: monochrom 1bit per pixel data
+    """
+    decoder = {
+        'DCTDecode': 'jpg',
+        'JPXDecode': 'png',
+        'CCITTFaxDecode': 'tiff',
+        'Default': 'png',
+        'FlateDecode': 'png',
+        'JBIG2Decode': 'jbig2',
+        'RunLengthDecode': 'png',
+    }
+    try:
+        filters = image.stream['Filter']
+        if isinstance(filters, list):
+            # TODO: SUPPORT MULTIPLE FILTER
+            if len(filters) > 1:
+                utilo.error(f'more than one filter: {filters}')
+            # assert len(filter_) == 1, str(filter_)
+            filters = filters[0]
+        imagefilter = filters.name
+    except KeyError:
+        imagefilter = 'Default'
+    ext = decoder[imagefilter]
+    return ext
+
+
+# def extention(image) -> str:
+#     stream = image.stream
+#     filters = stream.get_filters()
+#     (width, height) = image.srcsize
+#     if len(filters) == 1 and filters[0][0] in LITERALS_DCT_DECODE:
+#         ext = 'jpg'
+#     elif (image.bits == 1 or image.bits == 8 and
+#           image.colorspace in (LITERAL_DEVICE_RGB, LITERAL_DEVICE_GRAY)):
+#         ext = 'bmp'
+#     else:
+#         ext = 'png'
+#     return ext

rawmaker/miner/position.py

@@ -0,0 +1,121 @@
+# =============================================================================
+# C O P Y R I G H T
+# -----------------------------------------------------------------------------
+# Copyright (c) 2019-2023 by Helmut Konrad Schewe. All rights reserved.
+# This file is property of Helmut Konrad Schewe. Any unauthorized copy,
+# use or distribution is an offensive act against international law and may
+# be prosecuted under federal law. Its content is company confidential.
+# =============================================================================
+"""Save position of element by object hash"""
+
+import contextlib
+import statistics
+
+import iamraw
+import utilo
+
+
+class DocumentItemHasher:
+
+    # TODO: REMOVE THIS SENSELESS CLASS?
+    def __init__(self, page: int = -1):
+        self.data = {}
+        self.page = page
+
+    def hashitem(self, item: str, position):
+        hashid = hash(item)
+        # assert that hashid is not saved before, 'collision %s'  % item
+        # TODO: Investigate later, how to avoid collision
+        assert hashid not in self.data, f'collision "{item}"'
+        # while hashid in self.data:
+        #     hashid += 1
+        self.data[hashid] = position
+
+    def position(self, item):
+        hashid = hash(item)
+        try:
+            current = self.data[hashid]
+            return current
+        except KeyError as error:
+            # TODO: CHANGE TO KEY ERROR
+            raise ItemNotFound(f'not stored: {item} {hashid}') from error
+
+    def __eq__(self, value):
+        return value and (str(self) == str(value))
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __str__(self):
+        result = [f'DocumentItemHasher, size: {len(self.data)}']
+        for key, value in self.data.items():
+            result.append(f'{key} {value}')
+        return utilo.NEWLINE.join(result)
+
+
+def load_hasher(content: str) -> DocumentItemHasher:
+    loaded = utilo.yaml_load(content)
+    result = []
+    for page in loaded:
+        pagenumber = int(page['page'])
+        hasher = DocumentItemHasher(page=pagenumber)
+        for item in page['content']:
+            key, position = item.split(maxsplit=1)
+            hasher.data[int(key)] = iamraw.BoundingBox.from_str(position)
+        result.append(hasher)
+    return result
+
+
+def hash_positions(
+    document: iamraw.Document,
+    pages=None,
+) -> iamraw.PageContentTextPositions:
+    assert isinstance(document, iamraw.Document), type(document)
+    collected = []
+    with utilo.SkipCollector(pages) as collector:
+        for page in document:
+            pagenumber = page.page
+            if collector.skip(pagenumber):
+                continue
+            hasher = DocumentItemHasher(pagenumber)
+            collected.append(hasher)
+            index = 0
+            for item in page:
+                try:
+                    # TODO: REMOVE?
+                    # Not every element has text
+                    _ = item.text
+                except AttributeError:
+                    continue
+                # TODO: COMPUTE FOR OTHER LINES THAN ZERO
+                mean = mean_height(item.lines[0])
+                hasher.hashitem(
+                    index,
+                    iamraw.TextPosition(bounding=item.box, mean=mean),
+                )
+                index += 1
+    result = []
+    for page in collected:
+        pagenumber = page.page
+        content = dict(page.data)
+        result.append(
+            iamraw.PageContentTextPosition(
+                content=content,
+                page=pagenumber,
+            ))
+    return result
+
+
+def mean_height(chars):
+    height = []
+    for char in chars:
+        with contextlib.suppress(AttributeError):
+            height.append(char.box.y1 - char.box.y0)
+    if not height:
+        return 0.0
+    mean = statistics.mean(height)
+    return utilo.roundme(mean)
+
+
+class ItemNotFound(ValueError):
+    pass