Upload goteborgs_poliskammare_fore_1900.py

goteborgs_poliskammare_fore_1900.py

@@ -1,5 +1,4 @@
-# ladda upp datasetet i en zip av imgs och en zip av xml, skapa flera archive iterators och använd dom (men hur blir det med ordningen?)
-
+import io
 import os
 import xml.etree.ElementTree as ET
 from glob import glob
@@ -13,49 +12,97 @@ from datasets import (
     Features,
     GeneratorBasedBuilder,
     Image,
+    Sequence,
     Split,
     SplitGenerator,
     Value,
 )
 from PIL import Image as PILImage
+from shapely.geometry import Polygon
 
 
 class HTRDatasetConfig(BuilderConfig):
-    """BuilderConfig for HTRDataset"""
+    """Configuration for each dataset variant."""
 
-    def __init__(self, **kwargs):
-        super(HTRDatasetConfig, self).__init__(**kwargs)
+    def __init__(self, name, description, process_func, features, **kwargs):
+        super().__init__(name=name, description=description, **kwargs)
+        self.process_func = process_func
+        self.features = features
 
 
 class HTRDataset(GeneratorBasedBuilder):
+    # Define feature structures for each dataset type
+    text_recognition_features = Features(
+        {
+            "image": Image(),
+            "transcription": Value("string"),
+        }
+    )
+
+    segmentation_features = Features(
+        {
+            "image_name": Value("string"),
+            "image": Image(),
+            "annotations": Sequence(
+                {
+                    "polygon": Sequence(Sequence(Value("float32"))),
+                    "transcription": Value("string"),
+                    "class": Value("string"),
+                }
+            ),
+        }
+    )
+
     BUILDER_CONFIGS = [
         HTRDatasetConfig(
-            name="htr_dataset",
-            version="1.0.0",
-            description="Line dataset for text recognition of historical swedish",
-        )
+            name="text_recognition",
+            description="textline dataset for text recognition of historical Swedish",
+            process_func="text_recognition",
+            features=text_recognition_features,
+        ),
+        HTRDatasetConfig(
+            name="inst_seg_lines_within_regions",
+            description="Cropped text region images with text line annotations",
+            process_func="inst_seg_lines_within_regions",
+            features=segmentation_features,
+        ),
+        HTRDatasetConfig(
+            name="inst_seg_regions_and_lines",
+            description="Original images with both region and line annotations",
+            process_func="inst_seg_regions_and_lines",
+            features=segmentation_features,
+        ),
+        HTRDatasetConfig(
+            name="inst_seg_lines",
+            description="Original images with text line annotations only",
+            process_func="inst_seg_lines",
+            features=segmentation_features,
+        ),
+        HTRDatasetConfig(
+            name="inst_seg_regions",
+            description="Original images with text region annotations only",
+            process_func="inst_seg_regions",
+            features=segmentation_features,
+        ),
     ]
 
     def _info(self):
-        features = Features({"image": Image(), "transcription": Value("string")})
-        return DatasetInfo(features=features)
+        return DatasetInfo(features=self.config.features)
 
     def _split_generators(self, dl_manager):
+        # Define URLs for images and XMLs
         """
-        images = dl_manager.download_and_extract(
-            [
-                f"https://huggingface.co/datasets/Riksarkivet/alvsborgs_losen/resolve/main/data/images/alvsborgs_losen_imgs_{i}.tar.gz"
-                for i in range(1, 3)
-            ]
-        )
-        xmls = dl_manager.download_and_extract(
-            [
-                f"https://huggingface.co/datasets/Riksarkivet/alvsborgs_losen/resolve/main/data/page_xmls/alvsborgs_losen_page_xmls_{i}.tar.gz"
-                for i in range(1, 3)
-            ]
-        )
-        """
+        images_url = [
+            f"https://huggingface.co/datasets/Riksarkivet/ra_enstaka_sidor/resolve/main/data/images/ra_enstaka_sidor_images_{i}.tar.gz"
+            for i in range(1, 3)
+        ]
+        xmls_url = [
+            f"https://huggingface.co/datasets/Riksarkivet/ra_enstaka_sidor/resolve/main/data/page_xmls/ra_enstaka_sidor_page_xmls_{i}.tar.gz"
+            for i in range(1, 3)
+        ]
 
+        """
+        
         images = dl_manager.download_and_extract(
                             [
                                 f"https://huggingface.co/datasets/Riksarkivet/goteborgs_poliskammare_fore_1900/resolve/main/data/images/goteborgs_poliskammare_fore_1900_images_{i}.tar.gz"
@@ -68,6 +115,12 @@ class HTRDataset(GeneratorBasedBuilder):
                                 for i in range(1, 3)
                             ]
                         )
+
+        # Download and extract images and XMLs
+        # images = dl_manager.download_and_extract(images_url)
+        # xmls = dl_manager.download_and_extract(xmls_url)
+
+        # Define supported image file extensions
         image_extensions = [
             "*.jpg",
             "*.jpeg",
@@ -84,16 +137,18 @@ class HTRDataset(GeneratorBasedBuilder):
             "*.TIF",
             "*.TIFF",
         ]
-        imgs_nested = [glob(os.path.join(x, "**", ext), recursive=True) for ext in image_extensions for x in images]
-        imgs_flat = [item for sublist in imgs_nested for item in sublist]
-        sorted_imgs = sorted(imgs_flat, key=lambda x: Path(x).stem)
-        xmls_nested = [glob(os.path.join(x, "**", "*.xml"), recursive=True) for x in xmls]
-        xmls_flat = [item for sublist in xmls_nested for item in sublist]
-        sorted_xmls = sorted(xmls_flat, key=lambda x: Path(x).stem)
-        assert len(sorted_imgs) == len(sorted_xmls)
-        imgs_xmls = []
-        for img, xml in zip(sorted_imgs, sorted_xmls):
-            imgs_xmls.append((img, xml))
+
+        # Collect and sort image and XML file paths
+        imgs_flat = self._collect_file_paths(images, image_extensions)
+        xmls_flat = self._collect_file_paths(xmls, ["*.xml"])
+
+        # Ensure the number of images matches the number of XML files
+        assert len(imgs_flat) == len(xmls_flat)
+
+        # Pair images and XML files
+        imgs_xmls = list(
+            zip(sorted(imgs_flat, key=lambda x: Path(x).stem), sorted(xmls_flat, key=lambda x: Path(x).stem))
+        )
 
         return [
             SplitGenerator(
@@ -102,110 +157,330 @@ class HTRDataset(GeneratorBasedBuilder):
             )
         ]
 
+    def _collect_file_paths(self, folders, extensions):
+        """Collects file paths recursively from specified folders."""
+        files_nested = [
+            glob(os.path.join(folder, "**", ext), recursive=True) for ext in extensions for folder in folders
+        ]
+        return [file for sublist in files_nested for file in sublist]
+
     def _generate_examples(self, imgs_xmls):
-        for img, xml in imgs_xmls:
-            assert Path(img).stem == Path(xml).stem
-            img_filename = Path(img).stem
-            volume = PurePath(img).parts[-2]
+        process_func = getattr(self, self.config.process_func)
+        return process_func(imgs_xmls)
 
+    def text_recognition(self, imgs_xmls):
+        """Process for line dataset with cropped images and transcriptions."""
+        for img, xml in imgs_xmls:
+            img_filename, volume = self._extract_filename_and_volume(img, xml)
             lines_data = self.parse_pagexml(xml)
-
-            # Convert the bytes to a NumPy array
             image_array = cv2.imread(img)
 
             for i, line in enumerate(lines_data):
                 line_id = str(i).zfill(4)
-                try:
-                    cropped_image = self.crop_line_image(image_array, line["coords"])
-                except Exception as e:
-                    print(e)
-                    continue
+                cropped_image = self.crop_line_image(image_array, line["coords"])
+                transcription = line["transcription"]
 
-                # Logging to ensure data types and shapes
-                cropped_image_np = np.array(cropped_image, dtype=np.uint8)
-
-                # Ensure transcription is a string and not None
-                transcription = str(line["transcription"])
-                if transcription is None or not isinstance(transcription, str) or transcription == "":
+                if not transcription:
                     print(f"Invalid transcription: {transcription}")
                     continue
 
-                # Generate and log the unique key
                 unique_key = f"{volume}_{img_filename}_{line_id}"
-
-                try:
-                    yield (
-                        unique_key,
-                        {"image": cropped_image, "transcription": transcription},
+                yield unique_key, {"image": cropped_image, "transcription": transcription}
+
+    def inst_seg_lines_within_regions(self, imgs_xmls):
+        """Process for cropped images with text line annotations."""
+        for img_path, xml_path in imgs_xmls:
+            img_filename, volume = self._extract_filename_and_volume(img_path, xml_path)
+            image = PILImage.open(img_path)
+            root = self._parse_xml(xml_path)
+            namespaces = {"ns": "http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15"}
+
+            # Iterate through each TextRegion
+            try:
+                for reg_ind, region in enumerate(root.findall(".//ns:TextRegion", namespaces=namespaces)):
+                    reg_id = str(reg_ind).zfill(4)
+                    region_polygon = self._get_polygon(region, namespaces)
+                    min_x, min_y, max_x, max_y = self._get_bbox(region_polygon)
+                    cropped_region_image = self.crop_image(image, region_polygon)
+
+                    annotations = self._get_line_annotations_within_region(
+                        region, namespaces, min_x, min_y, region_polygon
                     )
-                except Exception as e:
-                    print(f"Error yielding example {unique_key}: {e}")
 
-    def parse_pagexml(self, xml):
+                    unique_key = f"{volume}_{img_filename}_{reg_id}"
+                    try:
+                        yield (
+                            unique_key,
+                            {
+                                "image": {"bytes": self._image_to_bytes(cropped_region_image)},
+                                "annotations": annotations,
+                                "image_name": unique_key,
+                            },
+                        )
+                    except:
+                        print("still error")
+                        continue
+            except Exception:
+                continue
+
+    def inst_seg_regions_and_lines(self, imgs_xmls):
+        """Process for original images with both region and line annotations."""
+        for img_path, xml_path in imgs_xmls:
+            img_filename, volume = self._extract_filename_and_volume(img_path, xml_path)
+            image = PILImage.open(img_path)
+            root = self._parse_xml(xml_path)
+            annotations = self._get_region_and_line_annotations(root)
+
+            unique_key = f"{volume}_{img_filename}"
+            yield unique_key, {"image_name": unique_key, "image": image, "annotations": annotations}
+
+    def inst_seg_lines(self, imgs_xmls):
+        """Process for original images with text line annotations only."""
+        for img_path, xml_path in imgs_xmls:
+            img_filename, volume = self._extract_filename_and_volume(img_path, xml_path)
+            image = PILImage.open(img_path)
+            root = self._parse_xml(xml_path)
+
+            annotations = self._get_line_annotations(root)
+
+            unique_key = f"{volume}_{img_filename}"
+            yield unique_key, {"image_name": unique_key, "image": image, "annotations": annotations}
+
+    def inst_seg_regions(self, imgs_xmls):
+        """Process for original images with text region annotations only."""
+        for img_path, xml_path in imgs_xmls:
+            img_filename, volume = self._extract_filename_and_volume(img_path, xml_path)
+            image = PILImage.open(img_path)
+            root = self._parse_xml(xml_path)
+
+            annotations = self._get_region_annotations(root)
+
+            unique_key = f"{volume}_{img_filename}"
+            yield unique_key, {"image_name": unique_key, "image": image, "annotations": annotations}
+
+    def _extract_filename_and_volume(self, img, xml):
+        """Extracts the filename and volume from the image and XML paths."""
+        assert Path(img).stem == Path(xml).stem
+        img_filename = Path(img).stem
+        volume = PurePath(img).parts[-2]
+        return img_filename, volume
+
+    def _parse_xml(self, xml_path):
+        """Parses the XML file and returns the root element."""
         try:
-            tree = ET.parse(xml)
-            root = tree.getroot()
+            tree = ET.parse(xml_path)
+            return tree.getroot()
         except ET.ParseError as e:
-            print(e)
-            return []
+            print(f"XML Parse Error: {e}")
+            return None
+
+    def _get_line_annotations_within_region(self, region, namespaces, min_x, min_y, region_polygon):
+        """Generates annotations for text lines within a region."""
+        annotations = []
+        for line in region.findall(".//ns:TextLine", namespaces=namespaces):
+            line_polygon = self._get_polygon(line, namespaces)
+            clipped_line_polygon = self.clip_polygon_to_region(line_polygon, region_polygon)
+
+            if len(clipped_line_polygon) < 3:
+                print(f"Invalid polygon detected for line: {line_polygon}, clipped: {clipped_line_polygon}")
+                continue
+
+            translated_polygon = [(x - min_x, y - min_y) for x, y in clipped_line_polygon]
+            transcription = "".join(line.itertext()).strip()
+
+            annotations.append(
+                {
+                    "polygon": translated_polygon,
+                    "transcription": transcription,
+                    "class": "textline",
+                }
+            )
+        return annotations
+
+    def _get_region_and_line_annotations(self, root):
+        """Generates annotations for both text regions and lines."""
+        annotations = []
+
+        # Get region annotations
+        annotations.extend(self._get_region_annotations(root))
+
+        # Get line annotations
+        annotations.extend(self._get_line_annotations(root))
+
+        return annotations
 
+    def _get_line_annotations(self, root):
+        """Generates annotations for text lines only."""
         namespaces = {"ns": "http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15"}
-        page = root.find("ns:Page", namespaces)
-        if page is None:
-            print("no page")
+        annotations = []
+        for region in root.findall(".//ns:TextRegion", namespaces=namespaces):
+            for line in region.findall(".//ns:TextLine", namespaces=namespaces):
+                line_polygon = self._get_polygon(line, namespaces)
+                transcription = "".join(line.itertext()).strip()
+                annotations.append(
+                    {
+                        "polygon": line_polygon,
+                        "transcription": transcription,
+                        "class": "textline",
+                    }
+                )
+        return annotations
+
+    def _get_region_annotations(self, root):
+        """Generates annotations for text regions only."""
+        namespaces = {"ns": "http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15"}
+        annotations = []
+        for region in root.findall(".//ns:TextRegion", namespaces=namespaces):
+            region_polygon = self._get_polygon(region, namespaces)
+            annotations.append(
+                {
+                    "polygon": region_polygon,
+                    "transcription": "",
+                    "class": "textregion",
+                }
+            )
+        return annotations
+
+    def _image_to_bytes(self, image):
+        """Converts a PIL image to bytes."""
+        with io.BytesIO() as output:
+            image.save(output, format="PNG")
+            return output.getvalue()
+
+    def crop_image(self, img_pil, coords):
+        coords = np.array(coords)
+        img = np.array(img_pil)
+        mask = np.zeros(img.shape[0:2], dtype=np.uint8)
+
+        try:
+            # Ensure the coordinates are within the bounds of the image
+            coords[:, 0] = np.clip(coords[:, 0], 0, img.shape[1] - 1)
+            coords[:, 1] = np.clip(coords[:, 1], 0, img.shape[0] - 1)
+
+            # Draw the mask
+            cv2.drawContours(mask, [coords], -1, (255, 255, 255), -1, cv2.LINE_AA)
+
+            # Apply mask to image
+            res = cv2.bitwise_and(img, img, mask=mask)
+            rect = cv2.boundingRect(coords)
+
+            # Ensure the bounding box is within the image dimensions
+            rect = (
+                max(0, rect[0]),
+                max(0, rect[1]),
+                min(rect[2], img.shape[1] - rect[0]),
+                min(rect[3], img.shape[0] - rect[1]),
+            )
+
+            wbg = np.ones_like(img, np.uint8) * 255
+            cv2.bitwise_not(wbg, wbg, mask=mask)
+
+            # Overlap the resulted cropped image on the white background
+            dst = wbg + res
+
+            # Use validated rect for cropping
+            cropped = dst[rect[1] : rect[1] + rect[3], rect[0] : rect[0] + rect[2]]
+
+            # Convert the NumPy array back to a PIL image
+            cropped_pil = PILImage.fromarray(cropped)
+
+            return cropped_pil
+
+        except Exception as e:
+            print(f"Error in cropping: {e}")
+            return img_pil  # Return the original image if there's an error
+
+    def _create_mask(self, shape, coords):
+        """Creates a mask for the specified polygon coordinates."""
+        mask = np.zeros(shape, dtype=np.uint8)
+        cv2.drawContours(mask, [np.array(coords)], -1, (255, 255, 255), -1, cv2.LINE_AA)
+        return mask
+
+    def parse_pagexml(self, xml):
+        """Parses the PAGE XML and extracts line data."""
+        root = self._parse_xml(xml)
+        if not root:
             return []
 
-        text_regions = page.findall("ns:TextRegion", namespaces)
+        namespaces = {"ns": "http://schema.primaresearch.org/PAGE/gts/pagecontent/2013-07-15"}
         lines_data = []
-        for region in text_regions:
-            lines = region.findall("ns:TextLine", namespaces)
-
-            for line in lines:
+        for region in root.findall(".//ns:TextRegion", namespaces):
+            for line in region.findall(".//ns:TextLine", namespaces):
                 try:
                     line_id = line.get("id")
-                    coords = line.find("ns:Coords", namespaces).get("points")
-                    coords = [tuple(map(int, p.split(","))) for p in coords.split()]
-                    transcription = line.find("ns:TextEquiv/ns:Unicode", namespaces).text
-
+                    coords = self._get_polygon(line, namespaces)
+                    transcription = line.find("ns:TextEquiv/ns:Unicode", namespaces).text or ""
                     lines_data.append({"line_id": line_id, "coords": coords, "transcription": transcription})
                 except Exception as e:
-                    print(e)
-                    continue
-
+                    print(f"Error parsing line: {e}")
         return lines_data
 
     def crop_line_image(self, img, coords):
+        """Crops a line image based on the provided coordinates."""
+        mask = self._create_mask(img.shape[:2], coords)
+
         coords = np.array(coords)
-        # img = HTRDataset.np_to_cv2(image)
-        mask = np.zeros(img.shape[0:2], dtype=np.uint8)
 
-        try:
-            cv2.drawContours(mask, [coords], -1, (255, 255, 255), -1, cv2.LINE_AA)
-        except Exception as e:
-            print(e)
+        # Apply mask to image
         res = cv2.bitwise_and(img, img, mask=mask)
         rect = cv2.boundingRect(coords)
 
+        # Create a white background and overlay the cropped image
         wbg = np.ones_like(img, np.uint8) * 255
         cv2.bitwise_not(wbg, wbg, mask=mask)
-
-        # overlap the resulted cropped image on the white background
         dst = wbg + res
 
         cropped = dst[rect[1] : rect[1] + rect[3], rect[0] : rect[0] + rect[2]]
 
-        cropped = HTRDataset.cv2_to_pil(cropped)
-        return cropped
+        return self.cv2_to_pil(cropped)
+
+    def _get_polygon(self, element, namespaces):
+        """Extracts polygon points from a PAGE XML element."""
+        coords = element.find(".//ns:Coords", namespaces=namespaces).attrib["points"]
+        return [tuple(map(int, p.split(","))) for p in coords.split()]
 
-    def np_to_cv2(image_array):
-        image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
-        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-        return image_rgb
+    def _get_bbox(self, polygon):
+        """Calculates the bounding box from polygon points."""
+        min_x = min(p[0] for p in polygon)
+        min_y = min(p[1] for p in polygon)
+        max_x = max(p[0] for p in polygon)
+        max_y = max(p[1] for p in polygon)
+        return min_x, min_y, max_x, max_y
 
-    # Convert OpenCV image to PIL Image
-    def cv2_to_pil(cv2_image):
-        # Convert BGR to RGB
+    def clip_polygon_to_region(self, line_polygon, region_polygon):
+        """
+        Clips a line polygon to ensure it's inside the region polygon using Shapely.
+        Returns the original line polygon if the intersection is empty.
+        """
+        # Convert lists of points to Shapely Polygons
+        line_poly = Polygon(line_polygon)
+        region_poly = Polygon(region_polygon)
+
+        # Compute the intersection of the line polygon with the region polygon
+        try:
+            intersection = line_poly.intersection(region_poly)
+        except Exception:
+            return line_polygon
+
+        # Return the intersection points as a list of tuples
+        if intersection.is_empty:
+            print(
+                f"No intersection found for line_polygon {line_polygon} within region_polygon {region_polygon}, returning original polygon."
+            )
+            return line_polygon
+        elif intersection.geom_type == "Polygon":
+            return list(intersection.exterior.coords)
+        elif intersection.geom_type == "MultiPolygon":
+            # If the result is a MultiPolygon, take the largest by area (or another heuristic)
+            largest_polygon = max(intersection.geoms, key=lambda p: p.area)
+            return list(largest_polygon.exterior.coords)
+        elif intersection.geom_type == "LineString":
+            return list(intersection.coords)
+        else:
+            print(f"Unexpected intersection type: {intersection.geom_type}")
+            return line_polygon
+
+    def cv2_to_pil(self, cv2_image):
+        """Converts an OpenCV image to a PIL Image."""
         cv2_image_rgb = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2RGB)
-        # Convert NumPy array to PIL image
-        pil_image = PILImage.fromarray(cv2_image_rgb)
-        return pil_image
+        return PILImage.fromarray(cv2_image_rgb)