custom-layoutparser 0.1.0__py3-none-any.whl

layoutparser/elements/utils.py

@@ -0,0 +1,82 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List, Union, Dict, Dict, Any, Optional, Tuple
+
+import numpy as np
+from PIL import Image
+
+
+def cvt_coordinates_to_points(coords: Tuple[float, float, float, float]) -> np.ndarray:
+
+    x_1, y_1, x_2, y_2 = coords
+    return np.array(
+        [
+            [x_1, y_1],  # Top Left
+            [x_2, y_1],  # Top Right
+            [x_2, y_2],  # Bottom Right
+            [x_1, y_2],  # Bottom Left
+        ]
+    )
+
+
+def cvt_points_to_coordinates(points: np.ndarray) -> Tuple[float, float, float, float]:
+    x_1 = points[:, 0].min()
+    y_1 = points[:, 1].min()
+    x_2 = points[:, 0].max()
+    y_2 = points[:, 1].max()
+    return (x_1, y_1, x_2, y_2)
+
+
+def perspective_transformation(
+    M: np.ndarray, points: np.ndarray, is_inv: bool = False
+) -> np.ndarray:
+
+    if is_inv:
+        M = np.linalg.inv(M)
+
+    src_mid = np.hstack([points, np.ones((points.shape[0], 1))]).T  # 3x4
+    dst_mid = np.matmul(M, src_mid)
+
+    dst = (dst_mid / dst_mid[-1]).T[:, :2]  # 4x2
+
+    return dst
+
+
+def vertice_in_polygon(vertice: np.ndarray, polygon_points: np.ndarray) -> bool:
+    # The polygon_points are ordered clockwise
+
+    # The implementation is based on the algorithm from
+    # https://demonstrations.wolfram.com/AnEfficientTestForAPointToBeInAConvexPolygon/
+
+    points = polygon_points - vertice  # shift the coordinates origin to the vertice
+    edges = np.append(points, points[0:1, :], axis=0)
+    return all([np.linalg.det([e1, e2]) >= 0 for e1, e2 in zip(edges, edges[1:])])
+    # If the points are ordered clockwise, the det should <=0
+
+
+def polygon_area(xs: np.ndarray, ys: np.ndarray) -> float:
+    """Calculate the area of polygons using
+    `Shoelace Formula <https://en.wikipedia.org/wiki/Shoelace_formula>`_.
+
+    Args:
+        xs (`np.ndarray`): The x coordinates of the points
+        ys (`np.ndarray`): The y coordinates of the points
+    """
+
+    # Refer to: https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
+    # The formula is equivalent to the original one indicated in the wikipedia
+    # page.
+
+    return 0.5 * np.abs(np.dot(xs, np.roll(ys, 1)) - np.dot(ys, np.roll(xs, 1)))

layoutparser/file_utils.py

@@ -0,0 +1,235 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Some code are adapted from
+# https://github.com/huggingface/transformers/blob/master/src/transformers/file_utils.py
+
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Union
+import sys
+import os
+import logging
+import importlib.util
+from types import ModuleType
+
+logger = logging.getLogger(__name__)  # pylint: disable=invalid-name
+
+# The package importlib_metadata is in a different place, depending on the python version.
+if sys.version_info < (3, 8):
+    import importlib_metadata
+else:
+    import importlib.metadata as importlib_metadata
+
+###########################################
+############ Layout Model Deps ############
+###########################################
+
+_torch_available = importlib.util.find_spec("torch") is not None
+try:
+    _torch_version = importlib_metadata.version("torch")
+    logger.debug(f"PyTorch version {_torch_version} available.")
+except importlib_metadata.PackageNotFoundError:
+    _torch_available = False
+
+_detectron2_available = importlib.util.find_spec("detectron2") is not None
+try:
+    _detectron2_version = importlib_metadata.version("detectron2")
+    logger.debug(f"Detectron2 version {_detectron2_version} available")
+except importlib_metadata.PackageNotFoundError:
+    _detectron2_available = False
+
+_paddle_available = importlib.util.find_spec("paddle") is not None
+try:
+    # The name of the paddlepaddle library:
+    # Install name: pip install paddlepaddle
+    # Import name: import paddle
+    _paddle_version = importlib_metadata.version("paddlepaddle")
+    logger.debug(f"Paddle version {_paddle_version} available.")
+except importlib_metadata.PackageNotFoundError:
+    _paddle_available = False
+
+_effdet_available = importlib.util.find_spec("effdet") is not None
+try:
+    _effdet_version = importlib_metadata.version("effdet")
+    logger.debug(f"Effdet version {_effdet_version} available.")
+except importlib_metadata.PackageNotFoundError:
+    _effdet_version = False
+
+###########################################
+############## OCR Tool Deps ##############
+###########################################
+
+_pytesseract_available = importlib.util.find_spec("pytesseract") is not None
+try:
+    _pytesseract_version = importlib_metadata.version("pytesseract")
+    logger.debug(f"Pytesseract version {_pytesseract_version} available.")
+except importlib_metadata.PackageNotFoundError:
+    _pytesseract_available = False
+
+try:
+    _gcv_available = importlib.util.find_spec("google.cloud.vision") is not None
+    try:
+        _gcv_version = importlib_metadata.version(
+            "google-cloud-vision"
+        )  # This is slightly different
+        logger.debug(f"Google Cloud Vision Utils version {_gcv_version} available.")
+    except importlib_metadata.PackageNotFoundError:
+        _gcv_available = False
+except ModuleNotFoundError:
+    _gcv_available = False
+
+
+def is_torch_available():
+    return _torch_available
+
+
+def is_torch_cuda_available():
+    if is_torch_available():
+        import torch
+
+        return torch.cuda.is_available()
+    else:
+        return False
+
+
+def is_detectron2_available():
+    return _detectron2_available
+
+
+def is_paddle_available():
+    return _paddle_available
+
+
+def is_effdet_available():
+    return _effdet_available
+
+
+def is_pytesseract_available():
+    return _pytesseract_available
+
+
+def is_gcv_available():
+    return _gcv_available
+
+
+PYTORCH_IMPORT_ERROR = """
+{0} requires the PyTorch library but it was not found in your environment. Checkout the instructions on the
+installation page: https://pytorch.org/get-started/locally/ and follow the ones that match your environment.
+"""
+
+DETECTRON2_IMPORT_ERROR = """
+{0} requires the detectron2 library but it was not found in your environment. Checkout the instructions on the
+installation page: https://github.com/facebookresearch/detectron2/blob/master/INSTALL.md and follow the ones
+that match your environment. Typically the following would work for MacOS or Linux CPU machines:
+    pip install 'git+https://github.com/facebookresearch/detectron2.git@v0.4#egg=detectron2' 
+"""
+
+PADDLE_IMPORT_ERROR = """
+{0} requires the PaddlePaddle library but it was not found in your environment. Checkout the instructions on the
+installation page: https://github.com/PaddlePaddle/Paddle and follow the ones that match your environment.
+"""
+
+EFFDET_IMPORT_ERROR = """
+{0} requires the effdet library but it was not found in your environment. You can install it with pip:
+`pip install effdet`
+"""
+
+PYTESSERACT_IMPORT_ERROR = """
+{0} requires the PyTesseract library but it was not found in your environment. You can install it with pip:
+`pip install pytesseract`
+"""
+
+GCV_IMPORT_ERROR = """
+{0} requires the Google Cloud Vision Python utils but it was not found in your environment. You can install it with pip:
+`pip install google-cloud-vision==1`
+"""
+
+BACKENDS_MAPPING = dict(
+    [
+        ("torch", (is_torch_available, PYTORCH_IMPORT_ERROR)),
+        ("detectron2", (is_detectron2_available, DETECTRON2_IMPORT_ERROR)),
+        ("paddle", (is_paddle_available, PADDLE_IMPORT_ERROR)),
+        ("effdet", (is_effdet_available, EFFDET_IMPORT_ERROR)),
+        ("pytesseract", (is_pytesseract_available, PYTESSERACT_IMPORT_ERROR)),
+        ("google-cloud-vision", (is_gcv_available, GCV_IMPORT_ERROR)),
+    ]
+)
+
+
+def requires_backends(obj, backends):
+    if not isinstance(backends, (list, tuple)):
+        backends = [backends]
+
+    name = obj.__name__ if hasattr(obj, "__name__") else obj.__class__.__name__
+    if not all(BACKENDS_MAPPING[backend][0]() for backend in backends):
+        raise ImportError(
+            "".join([BACKENDS_MAPPING[backend][1].format(name) for backend in backends])
+        )
+
+
+class _LazyModule(ModuleType):
+    """
+    Module class that surfaces all objects but only performs associated imports when the objects are requested.
+    """
+
+    # Adapted from HuggingFace
+    # https://github.com/huggingface/transformers/blob/c37573806ab3526dd805c49cbe2489ad4d68a9d7/src/transformers/file_utils.py#L1990
+
+    def __init__(
+        self, name, module_file, import_structure, module_spec=None, extra_objects=None
+    ):
+        super().__init__(name)
+        self._modules = set(import_structure.keys())
+        self._class_to_module = {}
+        for key, values in import_structure.items():
+            for value in values:
+                self._class_to_module[value] = key
+        # Needed for autocompletion in an IDE
+        self.__all__ = list(import_structure.keys()) + sum(
+            import_structure.values(), []
+        )
+        self.__file__ = module_file
+        self.__spec__ = module_spec
+        self.__path__ = [os.path.dirname(module_file)]
+        self._objects = {} if extra_objects is None else extra_objects
+        self._name = name
+        self._import_structure = import_structure
+
+        # Following [PEP 366](https://www.python.org/dev/peps/pep-0366/)
+        # The __package__ variable should be set
+        # https://docs.python.org/3/reference/import.html#__package__
+        self.__package__ = self.__name__
+
+    # Needed for autocompletion in an IDE
+    def __dir__(self):
+        return super().__dir__() + self.__all__
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self._objects:
+            return self._objects[name]
+        if name in self._modules:
+            value = self._get_module(name)
+        elif name in self._class_to_module.keys():
+            module = self._get_module(self._class_to_module[name])
+            value = getattr(module, name)
+        else:
+            raise AttributeError(f"module {self.__name__} has no attribute {name}")
+
+        setattr(self, name, value)
+        return value
+
+    def _get_module(self, module_name: str):
+        return importlib.import_module("." + module_name, self.__name__)
+
+    def __reduce__(self):
+        return (self.__class__, (self._name, self.__file__, self._import_structure))

layoutparser/io/__init__.py

@@ -0,0 +1,2 @@
+from .basic import load_json, load_dict, load_csv, load_dataframe
+from .pdf import load_pdf

layoutparser/io/basic.py

@@ -0,0 +1,148 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import ast
+import json
+from typing import List, Union, Dict, Dict, Any
+
+import pandas as pd
+
+from ..elements import (
+    BaseLayoutElement,
+    TextBlock,
+    Layout,
+    BASECOORD_ELEMENT_NAMEMAP,
+)
+
+
+def load_json(filename: str) -> Union[BaseLayoutElement, Layout]:
+    """Load a JSON file and save it as a layout object with appropriate data types.
+
+    Args:
+        filename (str):
+            The name of the JSON file.
+
+    Returns:
+        Union[BaseLayoutElement, Layout]:
+            Based on the JSON file format, it will automatically parse
+            the type of the data and load it accordingly.
+    """
+    with open(filename, "r") as fp:
+        res = json.load(fp)
+
+    return load_dict(res)
+
+
+def load_dict(data: Union[Dict, List[Dict]]) -> Union[BaseLayoutElement, Layout]:
+    """Load a dict of list of dict representations of some layout data,
+    automatically parse its type, and save it as any of BaseLayoutElement
+    or Layout datatype.
+
+    Args:
+        data (Union[Dict, List]):
+            A dict of list of dict representations of the layout data
+
+    Raises:
+        ValueError:
+            If the data format is incompatible with the layout-data-JSON format,
+            raise a `ValueError`.
+        ValueError:
+            If any `block_type` name is not in the available list of layout element
+            names defined in `BASECOORD_ELEMENT_NAMEMAP`, raise a `ValueError`.
+
+    Returns:
+        Union[BaseLayoutElement, Layout]:
+            Based on the dict format, it will automatically parse the type of
+            the data and load it accordingly.
+    """
+    if isinstance(data, dict):
+        if "page_data" in data:
+            # It is a layout instance
+            return Layout(load_dict(data["blocks"])._blocks, page_data=data["page_data"])
+        else:
+
+            if data["block_type"] not in BASECOORD_ELEMENT_NAMEMAP:
+                raise ValueError(f"Invalid block_type {data['block_type']}")
+
+            # Check if it is a textblock
+            is_textblock = any(ele in data for ele in TextBlock._features)
+            if is_textblock:
+                return TextBlock.from_dict(data)
+            else:
+                return BASECOORD_ELEMENT_NAMEMAP[data["block_type"]].from_dict(data)
+
+    elif isinstance(data, list):
+        return Layout([load_dict(ele) for ele in data])
+
+    else:
+        raise ValueError(f"Invalid input JSON structure.")
+
+
+def load_csv(filename: str, block_type: str = None) -> Layout:
+    """Load the Layout object from the given CSV file.
+
+    Args:
+        filename (str):
+            The name of the CSV file. A row of the table represents
+            an individual layout element.
+
+        block_type (str):
+            If there's no block_type column in the CSV file,
+            you must pass in a block_type variable such that layout parser
+            can appropriately detect the type of the layout elements.
+
+    Returns:
+        Layout:
+            The parsed Layout object from the CSV file.
+    """
+
+    return load_dataframe(pd.read_csv(filename), block_type=block_type)
+
+
+def load_dataframe(df: pd.DataFrame, block_type: str = None) -> Layout:
+    """Load the Layout object from the given dataframe.
+
+    Args:
+        df (pd.DataFrame):
+
+        block_type (str):
+            If there's no block_type column in the CSV file,
+            you must pass in a block_type variable such that layout parser
+            can appropriately detect the type of the layout elements.
+
+    Returns:
+        Layout:
+            The parsed Layout object from the CSV file.
+    """
+    df = df.copy()
+    if "points" in df.columns:
+        if df["points"].dtype == object:
+            df["points"] = df["points"].map(
+                lambda x: ast.literal_eval(x) if not pd.isna(x) else x
+            )
+
+    if block_type is None:
+        if "block_type" not in df.columns:
+            raise ValueError(
+                "`block_type` not specified both in dataframe and arguments"
+            )
+    else:
+        df["block_type"] = block_type
+
+    if any(col in TextBlock._features for col in df.columns):
+        # Automatically setting index for textblock
+        if "id" not in df.columns:
+            df["id"] = df.index
+            
+    return load_dict(df.apply(lambda x: x.dropna().to_dict(), axis=1).to_list())

layoutparser/io/pdf.py

@@ -0,0 +1,225 @@
+# Copyright 2021 The Layout Parser team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List, Union, Optional, Dict, Tuple
+
+import pdfplumber
+import pandas as pd
+
+from ..elements import Layout
+from .basic import load_dataframe
+
+DEFAULT_PDF_DPI = 72
+
+
+def extract_words_for_page(
+    page: pdfplumber.page.Page,
+    x_tolerance=1.5,
+    y_tolerance=2,
+    keep_blank_chars=False,
+    use_text_flow=True,
+    horizontal_ltr=True,
+    vertical_ttb=True,
+    extra_attrs=None,
+) -> Layout:
+    """The helper function used for extracting words from a pdfplumber page
+    object. 
+
+    Returns:
+        Layout: a layout object representing all extracted pdf tokens on this page. 
+    """
+    if extra_attrs is None:
+        extra_attrs = ["fontname", "size"]
+
+    tokens = page.extract_words(
+        x_tolerance=x_tolerance,
+        y_tolerance=y_tolerance,
+        keep_blank_chars=keep_blank_chars,
+        use_text_flow=use_text_flow,
+        horizontal_ltr=horizontal_ltr,
+        vertical_ttb=vertical_ttb,
+        extra_attrs=extra_attrs,
+    )
+
+    df = pd.DataFrame(tokens)
+    
+    if len(df) == 0:
+        return Layout()
+    
+    df[["x0", "x1"]] = (
+        df[["x0", "x1"]].clip(lower=0, upper=int(page.width)).astype("float")
+    )
+    df[["top", "bottom"]] = (
+        df[["top", "bottom"]].clip(lower=0, upper=int(page.height)).astype("float")
+    )
+
+    page_tokens = load_dataframe(
+        df.reset_index().rename(
+            columns={
+                "x0": "x_1",
+                "x1": "x_2",
+                "top": "y_1",
+                "bottom": "y_2",
+                "index": "id",
+                "fontname": "type",  # also loading fontname as "type"
+            }
+        ),
+        block_type="rectangle",
+    )
+
+    return page_tokens
+
+
+def load_pdf(
+    filename: str,
+    load_images: bool = False,
+    x_tolerance: int = 1.5,
+    y_tolerance: int = 2,
+    keep_blank_chars: bool = False,
+    use_text_flow: bool = True,
+    horizontal_ltr: bool = True,
+    vertical_ttb: bool = True,
+    extra_attrs: Optional[List[str]] = None,
+    dpi: int = DEFAULT_PDF_DPI,
+) -> Union[List[Layout], Tuple[List[Layout], List["Image.Image"]]]:
+    """Load all tokens for each page from a PDF file, and save them
+    in a list of Layout objects with the original page order.
+
+    Args:
+        filename (str): The path to the PDF file.
+        load_images (bool, optional):
+            Whether load screenshot for each page of the PDF file.
+            When set to true, the function will return both the layout and
+            screenshot image for each page.
+            Defaults to False.
+        x_tolerance (int, optional):
+            The threshold used for extracting "word tokens" from the pdf file.
+            It will merge the pdf characters into a word token if the difference
+            between the x_2 of one character and the x_1 of the next is less than
+            or equal to x_tolerance. See details in `pdf2plumber's documentation
+            <https://github.com/jsvine/pdfplumber#the-pdfplumberpage-class>`_.
+            Defaults to 1.5.
+        y_tolerance (int, optional):
+            The threshold used for extracting "word tokens" from the pdf file.
+            It will merge the pdf characters into a word token if the difference
+            between the y_2 of one character and the y_1 of the next is less than
+            or equal to y_tolerance. See details in `pdf2plumber's documentation
+            <https://github.com/jsvine/pdfplumber#the-pdfplumberpage-class>`_.
+            Defaults to 2.
+        keep_blank_chars (bool, optional):
+            When keep_blank_chars is set to True, it will treat blank characters
+            are treated as part of a word, not as a space between words. See
+            details in `pdf2plumber's documentation
+            <https://github.com/jsvine/pdfplumber#the-pdfplumberpage-class>`_.
+            Defaults to False.
+        use_text_flow (bool, optional):
+            When use_text_flow is set to True, it will use the PDF's underlying
+            flow of characters as a guide for ordering and segmenting the words,
+            rather than presorting the characters by x/y position. (This mimics
+            how dragging a cursor highlights text in a PDF; as with that, the
+            order does not always appear to be logical.) See details in
+            `pdf2plumber's documentation
+            <https://github.com/jsvine/pdfplumber#the-pdfplumberpage-class>`_.
+            Defaults to True.
+        horizontal_ltr (bool, optional):
+            When horizontal_ltr is set to True, it means the doc should read
+            text from left to right, vice versa.
+            Defaults to True.
+        vertical_ttb (bool, optional):
+            When vertical_ttb is set to True, it means the doc should read
+            text from top to bottom, vice versa.
+            Defaults to True.
+        extra_attrs (Optional[List[str]], optional):
+            Passing a list of extra_attrs (e.g., ["fontname", "size"]) will
+            restrict each words to characters that share exactly the same
+            value for each of those `attributes extracted by pdfplumber
+            <https://github.com/jsvine/pdfplumber/blob/develop/README.md#char-properties>`_,
+            and the resulting word dicts will indicate those attributes.
+            See details in `pdf2plumber's documentation
+            <https://github.com/jsvine/pdfplumber#the-pdfplumberpage-class>`_.
+            Defaults to `["fontname", "size"]`.
+        dpi (int, optional):
+            When loading images of the pdf, you can also specify the resolution
+            (or `DPI, dots per inch <https://en.wikipedia.org/wiki/Dots_per_inch>`_)
+            for rendering the images. Higher DPI values mean clearer images (also
+            larger file sizes).
+            Setting dpi will also automatically resizes the extracted pdf_layout
+            to match the sizes of the images. Therefore, when visualizing the
+            pdf_layouts, it can be rendered appropriately.
+            Defaults to `DEFAULT_PDF_DPI=72`, which is also the default rendering dpi
+            from the pdfplumber PDF parser.
+
+    Returns:
+        List[Layout]:
+            When `load_images=False`, it will only load the pdf_tokens from
+            the PDF file. Each element of the list denotes all the tokens appeared
+            on a single page, and the list is ordered the same as the original PDF
+            page order.
+        Tuple[List[Layout], List["Image.Image"]]:
+            When `load_images=True`, besides the `all_page_layout`, it will also
+            return a list of page images.
+
+    Examples::
+        >>> import layoutparser as lp
+        >>> pdf_layout = lp.load_pdf("path/to/pdf")
+        >>> pdf_layout[0] # the layout for page 0
+        >>> pdf_layout, pdf_images = lp.load_pdf("path/to/pdf", load_images=True)
+        >>> lp.draw_box(pdf_images[0], pdf_layout[0])
+    """
+
+    plumber_pdf_object = pdfplumber.open(filename)
+
+    all_page_layout = []
+    for page_id in range(len(plumber_pdf_object.pages)):
+        cur_page = plumber_pdf_object.pages[page_id]
+
+        page_tokens = extract_words_for_page(
+            cur_page,
+            x_tolerance=x_tolerance,
+            y_tolerance=y_tolerance,
+            keep_blank_chars=keep_blank_chars,
+            use_text_flow=use_text_flow,
+            horizontal_ltr=horizontal_ltr,
+            vertical_ttb=vertical_ttb,
+            extra_attrs=extra_attrs,
+        )
+
+        # Adding metadata for the current page
+        page_tokens.page_data["width"] = float(cur_page.width)
+        page_tokens.page_data["height"] = float(cur_page.height)
+        page_tokens.page_data["index"] = page_id
+        
+        all_page_layout.append(page_tokens)
+
+    if not load_images:
+        return all_page_layout
+    else:
+        import pdf2image
+
+        pdf_images = pdf2image.convert_from_path(filename, dpi=dpi)
+
+        for page_id, page_image in enumerate(pdf_images):
+            image_width, image_height = page_image.size
+            page_layout = all_page_layout[page_id]
+            layout_width = page_layout.page_data["width"]
+            layout_height = page_layout.page_data["height"]
+            if image_width != layout_width or image_height != layout_height:
+                scale_x = image_width / layout_width
+                scale_y = image_height / layout_height
+                page_layout = page_layout.scale((scale_x, scale_y))
+                page_layout.page_data["width"] = image_width
+                page_layout.page_data["height"] = image_height
+                all_page_layout[page_id] = page_layout
+
+        return all_page_layout, pdf_images