mapreader 1.3.2__tar.gz → 1.3.4__tar.gz

{mapreader-1.3.2 → mapreader-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mapreader
-Version: 1.3.2
+Version: 1.3.4
 Summary: A computer vision pipeline for the semantic exploration of maps/images at scale
 Home-page: https://github.com/Living-with-machines/MapReader
 Download-URL: https://github.com/Living-with-machines/MapReader/archive/refs/heads/main.zip

{mapreader-1.3.2 → mapreader-1.3.4}/mapreader/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-15T11:10:51+0100",
+ "date": "2024-07-05T11:21:59+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "282b8733c2c83412b979c2c234adda1432691862",
- "version": "1.3.2"
+ "full-revisionid": "add823a499b1d0763327f9d56962c2a6af0e2d42",
+ "version": "1.3.4"
 }
 '''  # END VERSION_JSON
 

{mapreader-1.3.2 → mapreader-1.3.4}/mapreader/load/images.py

@@ -990,6 +990,7 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
         output_format: str | None = "png",
         rewrite: bool | None = False,
         verbose: bool | None = False,
+        overlap: int = 0,
     ) -> None:
         """
         Patchify all images in the specified ``tree_level`` and (if ``add_to_parents=True``) add the patches to the MapImages instance's ``images`` dictionary.
@@ -1024,6 +1025,8 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
         verbose : bool, optional
             If True, progress updates will be printed throughout, by default
             ``False``.
+        overlap : int, optional
+            Fractional overlap between patches, by default ``0``.
 
         Returns
         -------
@@ -1088,6 +1091,7 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
                     output_format=output_format,
                     rewrite=rewrite,
                     verbose=verbose,
+                    overlap=overlap,
                 )
 
     def _patchify_by_pixel(
@@ -1100,6 +1104,7 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
         output_format: str | None = "png",
         rewrite: bool | None = False,
         verbose: bool | None = False,
+        overlap: int | None = 0,
     ):
         """Patchify one image and (if ``add_to_parents=True``) add the patch to the MapImages instance's ``images`` dictionary.
 
@@ -1123,6 +1128,8 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
         verbose : bool, optional
             If True, progress updates will be printed throughout, by default
             ``False``.
+        overlap : int, optional
+            Fractional overlap between patches, by default ``0``.
         """
         tree_level = self._get_tree_level(image_id)
 
@@ -1140,15 +1147,14 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
 
         height, width = img.height, img.width
 
-        for x in range(0, width, patch_size):
-            for y in range(0, height, patch_size):
+        x = 0
+        while x < width:
+            y = 0
+            while y < height:
                 max_x = min(x + patch_size, width)
                 max_y = min(y + patch_size, height)
 
-                min_x = x
-                min_y = y
-
-                patch_id = f"patch-{min_x}-{min_y}-{max_x}-{max_y}-#{image_id}#.{output_format}"
+                patch_id = f"patch-{x}-{y}-{max_x}-{max_y}-#{image_id}#.{output_format}"
                 patch_path = os.path.join(path_save, patch_id)
                 patch_path = os.path.abspath(patch_path)
 
@@ -1158,7 +1164,7 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
                     )
 
                 else:
-                    patch = img.crop((min_x, min_y, max_x, max_y))
+                    patch = img.crop((x, y, max_x, max_y))
                     if max_x == width:
                         patch = ImageOps.pad(
                             patch, (patch_size, patch.height), centering=(0, 0)
@@ -1181,11 +1187,15 @@ See https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes for mor
                         image_path=patch_path,
                         parent_path=parent_path,
                         tree_level="patch",
-                        pixel_bounds=(min_x, min_y, max_x, max_y),
+                        pixel_bounds=(x, y, max_x, max_y),
                     )
                     self._add_patch_coords_id(patch_id)
                     self._add_patch_polygons_id(patch_id)
 
+                overlap_pixels = int(patch_size * overlap)
+                y = y + patch_size - overlap_pixels
+            x = x + patch_size - overlap_pixels
+
     def _patchify_by_pixel_square(
         self,
         image_id: str,

mapreader-1.3.4/mapreader/spot_text/deepsolo_runner.py

@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import pathlib
+import pickle
+
+try:
+    import adet
+except ImportError:
+    raise ImportError(
+        "[ERROR] Please install DeepSolo from the following link: https://github.com/rwood-97/DeepSolo"
+    )
+
+import numpy as np
+import pandas as pd
+from adet.config import get_cfg
+
+try:
+    from detectron2.engine import DefaultPredictor
+except ImportError:
+    raise ImportError("[ERROR] Please install Detectron2")
+
+from shapely import LineString, MultiPolygon, Polygon
+
+# first assert we are using the deep solo version of adet
+if adet.__version__ != "0.2.0-deepsolo":
+    raise ImportError(
+        "[ERROR] Please install DeepSolo from the following link: https://github.com/rwood-97/DeepSolo"
+    )
+
+from .runner_base import Runner
+
+
+class DeepSoloRunner(Runner):
+    def __init__(
+        self,
+        patch_df: pd.DataFrame = None,
+        parent_df: pd.DataFrame = None,
+        cfg_file: str
+        | pathlib.Path = "./DeepSolo/configs/R_50/IC15/finetune_150k_tt_mlt_13_15_textocr.yaml",
+        weights_file: str
+        | pathlib.Path = "./ic15_res50_finetune_synth-tt-mlt-13-15-textocr.pth",
+        device: str = "cpu",
+    ) -> None:
+        # setup the dataframes
+        self.patch_df = patch_df
+        self.parent_df = parent_df
+
+        # set up predictions as dictionaries
+        self.patch_predictions = {}
+        self.parent_predictions = {}
+        self.geo_predictions = {}
+
+        # setup the config
+        cfg = get_cfg()  # get a fresh new config
+        cfg.merge_from_file(cfg_file)
+        cfg.MODEL.WEIGHTS = weights_file
+        cfg.MODEL.DEVICE = device
+
+        self.voc_size = cfg.MODEL.TRANSFORMER.VOC_SIZE
+        self.use_customer_dictionary = cfg.MODEL.TRANSFORMER.CUSTOM_DICT
+        if self.voc_size == 96:
+            self.CTLABELS = [
+                " ",
+                "!",
+                '"',
+                "#",
+                "$",
+                "%",
+                "&",
+                "'",
+                "(",
+                ")",
+                "*",
+                "+",
+                ",",
+                "-",
+                ".",
+                "/",
+                "0",
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                ":",
+                ";",
+                "<",
+                "=",
+                ">",
+                "?",
+                "@",
+                "A",
+                "B",
+                "C",
+                "D",
+                "E",
+                "F",
+                "G",
+                "H",
+                "I",
+                "J",
+                "K",
+                "L",
+                "M",
+                "N",
+                "O",
+                "P",
+                "Q",
+                "R",
+                "S",
+                "T",
+                "U",
+                "V",
+                "W",
+                "X",
+                "Y",
+                "Z",
+                "[",
+                "\\",
+                "]",
+                "^",
+                "_",
+                "`",
+                "a",
+                "b",
+                "c",
+                "d",
+                "e",
+                "f",
+                "g",
+                "h",
+                "i",
+                "j",
+                "k",
+                "l",
+                "m",
+                "n",
+                "o",
+                "p",
+                "q",
+                "r",
+                "s",
+                "t",
+                "u",
+                "v",
+                "w",
+                "x",
+                "y",
+                "z",
+                "{",
+                "|",
+                "}",
+                "~",
+            ]
+        elif self.voc_size == 37:
+            self.CTLABELS = [
+                "a",
+                "b",
+                "c",
+                "d",
+                "e",
+                "f",
+                "g",
+                "h",
+                "i",
+                "j",
+                "k",
+                "l",
+                "m",
+                "n",
+                "o",
+                "p",
+                "q",
+                "r",
+                "s",
+                "t",
+                "u",
+                "v",
+                "w",
+                "x",
+                "y",
+                "z",
+                "0",
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+            ]
+        else:
+            with open(self.use_customer_dictionary, "rb") as fp:
+                self.CTLABELS = pickle.load(fp)
+        # voc_size includes the unknown class, which is not in self.CTABLES
+        assert int(self.voc_size - 1) == len(
+            self.CTLABELS
+        ), f"voc_size is not matched dictionary size, got {int(self.voc_size - 1)} and {len(self.CTLABELS)}."
+
+        # setup the predictor
+        self.predictor = DefaultPredictor(cfg)
+
+    def get_patch_predictions(
+        self,
+        outputs: dict,
+        return_dataframe: bool = False,
+        min_ioa: float = 0.7,
+    ) -> dict | pd.DataFrame:
+        """Post process the model outputs to get patch predictions.
+
+        Parameters
+        ----------
+        outputs : dict
+            The outputs from the model.
+        return_dataframe : bool, optional
+            Whether to return the predictions as a pandas DataFrame, by default False
+        min_ioa : float, optional
+            The minimum intersection over area to consider two polygons the same, by default 0.7
+
+        Returns
+        -------
+        dict or pd.DataFrame
+            A dictionary containing the patch predictions or a DataFrame if `as_dataframe` is True.
+        """
+        # key for predictions
+        image_id = outputs["image_id"]
+        self.patch_predictions[image_id] = []
+
+        # get instances
+        instances = outputs["instances"].to("cpu")
+        ctrl_pnts = instances.ctrl_points.numpy()
+        scores = instances.scores.tolist()
+        recs = instances.recs
+        bd_pts = np.asarray(instances.bd)
+
+        self._post_process(image_id, ctrl_pnts, scores, recs, bd_pts)
+        self._deduplicate(image_id, min_ioa=min_ioa)
+
+        if return_dataframe:
+            return self._dict_to_dataframe(self.patch_predictions, geo=False)
+        return self.patch_predictions
+
+    def _process_ctrl_pnt(self, pnt):
+        points = pnt.reshape(-1, 2)
+        return points
+
+    def _ctc_decode_recognition(self, rec):
+        last_char = "###"
+        s = ""
+        for c in rec:
+            c = int(c)
+            if c < self.voc_size - 1:
+                if last_char != c:
+                    if self.voc_size == 37 or self.voc_size == 96:
+                        s += self.CTLABELS[c]
+                        last_char = c
+                    else:
+                        s += str(chr(self.CTLABELS[c]))
+                        last_char = c
+            else:
+                last_char = "###"
+        return s
+
+    def _post_process(self, image_id, ctrl_pnts, scores, recs, bd_pnts, alpha=0.4):
+        for ctrl_pnt, score, rec, bd in zip(ctrl_pnts, scores, recs, bd_pnts):
+            # draw polygons
+            if bd is not None:
+                bd = np.hsplit(bd, 2)
+                bd = np.vstack([bd[0], bd[1][::-1]])
+                polygon = Polygon(bd).buffer(0)
+
+                if isinstance(polygon, MultiPolygon):
+                    polygon = polygon.convex_hull
+
+            # draw center lines
+            line = self._process_ctrl_pnt(ctrl_pnt)
+            line = LineString(line)
+
+            # draw text
+            text = self._ctc_decode_recognition(rec)
+            if self.voc_size == 37:
+                text = text.upper()
+            # text = "{:.2f}: {}".format(score, text)
+            text = f"{text}"
+            score = f"{score:.2f}"
+
+            self.patch_predictions[image_id].append([polygon, text, score])
+
+    @staticmethod
+    def _dict_to_dataframe(
+        preds: dict,
+        geo: bool = False,
+        parent: bool = False,
+    ) -> pd.DataFrame:
+        """Convert the predictions dictionary to a pandas DataFrame.
+
+        Parameters
+        ----------
+        preds : dict
+            A dictionary of predictions.
+        geo : bool, optional
+            Whether the dictionary is georeferenced coords (or pixel bounds), by default True
+        parent : bool, optional
+            Whether the dictionary is at parent level, by default False
+
+        Returns
+        -------
+        pd.DataFrame
+            A pandas DataFrame containing the predictions.
+        """
+        if geo:
+            columns = ["polygon", "crs", "text", "score"]
+        else:
+            columns = ["polygon", "text", "score"]
+
+        if parent:
+            columns.append("patch_id")
+
+        preds_df = pd.concat(
+            pd.DataFrame(
+                preds[k],
+                index=np.full(len(preds[k]), k),
+                columns=columns,
+            )
+            for k in preds.keys()
+        )
+        preds_df.index.name = "image_id"
+        preds_df.reset_index(inplace=True)  # reset index to get image_id as a column
+        return preds_df

mapreader-1.3.4/mapreader/spot_text/dptext_detr_runner.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import pathlib
+
+try:
+    import adet
+except ImportError:
+    raise ImportError(
+        "[ERROR] Please install DPText-DETR from the following link: https://github.com/rwood-97/DPText-DETR"
+    )
+
+import numpy as np
+import pandas as pd
+from adet.config import get_cfg
+
+try:
+    from detectron2.engine import DefaultPredictor
+except ImportError:
+    raise ImportError("[ERROR] Please install Detectron2")
+
+from shapely import MultiPolygon, Polygon
+
+# first assert we are using the dptext detr version of adet
+if adet.__version__ != "0.2.0-dptext-detr":
+    raise ImportError(
+        "[ERROR] Please install DPText-DETR from the following link: https://github.com/rwood-97/DPText-DETR"
+    )
+
+from .runner_base import Runner
+
+
+class DPTextDETRRunner(Runner):
+    def __init__(
+        self,
+        patch_df: pd.DataFrame = None,
+        parent_df: pd.DataFrame = None,
+        cfg_file: str
+        | pathlib.Path = "./DPText-DETR/configs/DPText_DETR/ArT/R_50_poly.yaml",
+        weights_file: str | pathlib.Path = "./art_final.pth",
+        device: str = "cpu",
+    ) -> None:
+        # setup the dataframes
+        self.patch_df = patch_df
+        self.parent_df = parent_df
+
+        # set up predictions as dictionaries
+        self.patch_predictions = {}
+        self.parent_predictions = {}
+        self.geo_predictions = {}
+
+        # setup the config
+        cfg = get_cfg()  # get a fresh new config
+        cfg.merge_from_file(cfg_file)
+        cfg.MODEL.WEIGHTS = weights_file
+        cfg.MODEL.DEVICE = device
+
+        # setup the predictor
+        self.predictor = DefaultPredictor(cfg)
+
+    def get_patch_predictions(
+        self,
+        outputs: dict,
+        return_dataframe: bool = False,
+        min_ioa: float = 0.7,
+    ) -> dict | pd.DataFrame:
+        """Post process the model outputs to get patch predictions.
+
+        Parameters
+        ----------
+        outputs : dict
+            The outputs from the model.
+        return_dataframe : bool, optional
+            Whether to return the predictions as a pandas DataFrame, by default False
+        min_ioa : float, optional
+            The minimum intersection over area to consider two polygons the same, by default 0.7
+
+        Returns
+        -------
+        dict or pd.DataFrame
+            A dictionary containing the patch predictions or a DataFrame if `as_dataframe` is True.
+        """
+        # key for predictions
+        image_id = outputs["image_id"]
+        self.patch_predictions[image_id] = []
+
+        # get instances
+        instances = outputs["instances"].to("cpu")
+        scores = instances.scores.tolist()
+        pred_classes = instances.pred_classes.tolist()
+        bd_pts = np.asarray(instances.polygons)
+
+        self._post_process(image_id, scores, pred_classes, bd_pts)
+        self._deduplicate(image_id, min_ioa=min_ioa)
+
+        if return_dataframe:
+            return self._dict_to_dataframe(self.patch_predictions, geo=False)
+        return self.patch_predictions
+
+    def _post_process(self, image_id, scores, pred_classes, bd_pnts):
+        for score, _pred_class, bd in zip(scores, pred_classes, bd_pnts):
+            # draw polygons
+            if bd is not None:
+                bd = bd.reshape(-1, 2)
+                polygon = Polygon(bd).buffer(0)
+
+                if isinstance(polygon, MultiPolygon):
+                    polygon = polygon.convex_hull
+
+            score = f"{score:.2f}"
+
+            self.patch_predictions[image_id].append([polygon, score])
+
+    @staticmethod
+    def _dict_to_dataframe(
+        preds: dict,
+        geo: bool = False,
+        parent: bool = False,
+    ) -> pd.DataFrame:
+        """Convert the predictions dictionary to a pandas DataFrame.
+
+        Parameters
+        ----------
+        preds : dict
+            A dictionary of predictions.
+        geo : bool, optional
+            Whether the dictionary is georeferenced coords (or pixel bounds), by default True
+        parent : bool, optional
+            Whether the dictionary is at the parent level, by default False
+
+        Returns
+        -------
+        pd.DataFrame
+            A pandas DataFrame containing the predictions.
+        """
+        if geo:
+            columns = ["polygon", "crs", "score"]
+        else:
+            columns = ["polygon", "score"]
+
+        if parent:
+            columns.append("patch_id")
+
+        preds_df = pd.concat(
+            pd.DataFrame(
+                preds[k],
+                index=np.full(len(preds[k]), k),
+                columns=columns,
+            )
+            for k in preds.keys()
+        )
+        preds_df.index.name = "image_id"
+        preds_df.reset_index(inplace=True)
+        return preds_df