Upload 3 files

save_parquet.py

@@ -0,0 +1,167 @@
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from pathlib import Path
+import cv2
+import logging
+from typing import List, Dict, Tuple
+import json
+
+
+class ArabicOCRDatasetConverter:
+    def __init__(self, dataset_dir: str):
+        self.dataset_dir = Path(dataset_dir)
+        self.setup_logging()
+
+    def setup_logging(self):
+        logging.basicConfig(
+            level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+        )
+        self.logger = logging.getLogger(__name__)
+
+    def get_image_annotation_pairs(self) -> List[Tuple[Path, Path]]:
+        pairs = []
+        for img_path in self.dataset_dir.glob("*.jpg"):
+            txt_path = img_path.with_suffix(".txt")
+            if txt_path.exists():
+                pairs.append((img_path, txt_path))
+            else:
+                self.logger.warning(f"No annotation file found for {img_path}")
+        return pairs
+
+    def order_text_instances(self, annotations: List[Dict]) -> str:
+        """
+        Order text instances from top to bottom, right to left using coordinates
+        """
+
+        # For each annotation, get the top y-coordinate and rightmost x-coordinate
+        def parse_coordinates(flattened):
+            return [
+                (flattened[i], flattened[i + 1]) for i in range(0, len(flattened), 2)
+            ]
+
+        def get_center(flattened_coordinates):
+            polygon = parse_coordinates(flattened_coordinates)
+            x_coords = [point[0] for point in polygon]
+            y_coords = [point[1] for point in polygon]
+            return (sum(x_coords) / len(polygon), sum(y_coords) / len(polygon))
+
+        def arabic_sort_key(annotation):
+            center = get_center(annotation["coordinates"])
+            return (center[1], -center[0])
+
+        def non_arabic_sort_key(annotation):
+            center = get_center(annotation["coordinates"])
+            return (center[1], center[0])
+
+        arabic_annotations = [a for a in annotations if a["language"] == "Arabic"]
+
+        arabic_annotations = sorted(arabic_annotations, key=arabic_sort_key)
+        english_annotations = [a for a in annotations if a["language"] != "Arabic"]
+        english_annotations = sorted(english_annotations, key=non_arabic_sort_key)
+        # Join all text with spaces
+        full_text = " ".join(
+            ann["text"] for ann in arabic_annotations + english_annotations
+        )
+
+        return full_text
+
+    def parse_annotation_file(self, annotation_path: Path) -> List[Dict]:
+        annotations = []
+        try:
+            with open(annotation_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip().rstrip(",")
+                    parts = line.split(",")
+                    if len(parts) >= 10:
+                        annotation = {
+                            "coordinates": [float(x) for x in parts[:8]],
+                            "language": parts[8],
+                            "text": parts[9],
+                        }
+                        annotations.append(annotation)
+                    else:
+                        self.logger.warning(
+                            f"Line has insufficient elements in {annotation_path}: {line}"
+                        )
+        except Exception as e:
+            self.logger.error(f"Error parsing {annotation_path}: {e}")
+        return annotations
+
+    def create_dataset(self, include_images: bool = False) -> pd.DataFrame:
+        data = []
+        pairs = self.get_image_annotation_pairs()
+
+        for img_path, txt_path in pairs:
+            try:
+                # Read image properties
+                img = cv2.imread(str(img_path))
+                if img is None:
+                    self.logger.warning(f"Could not read image: {img_path}")
+                    continue
+
+                img_height, img_width = img.shape[:2]
+
+                # Get annotations
+                annotations = self.parse_annotation_file(txt_path)
+
+                # Create a single entry for the image
+                entry = {
+                    "image_name": img_path.stem,
+                    "instances": [
+                        {
+                            "coordinates": ann["coordinates"],
+                            "language": ann["language"],
+                            "text": ann["text"],
+                        }
+                        for ann in annotations
+                    ],
+                    "full_text": self.order_text_instances(annotations),
+                }
+
+                if include_images:
+                    entry["image_data"] = img.tobytes()
+
+                data.append(entry)
+
+            except Exception as e:
+                self.logger.error(f"Error processing {img_path}: {e}")
+
+        return pd.DataFrame(data)
+
+    def save_parquet(self, output_path: str, include_images: bool = False) -> None:
+        df = self.create_dataset(include_images)
+
+        if df.empty:
+            self.logger.error("No data to save!")
+            return
+
+        try:
+            # Convert the instances list to a JSON string for storage
+            df["instances"] = df["instances"].apply(json.dumps)
+
+            table = pa.Table.from_pandas(df)
+            pq.write_table(table, output_path, compression="snappy")
+
+            self.logger.info(f"Created parquet file at {output_path}")
+            self.logger.info(f"Dataset shape: {df.shape}")
+            self.logger.info("\nSample data:")
+            print("\nSample entry:")
+            sample = df.iloc[0]
+            print(f"Image: {sample['image_name']}")
+            print(f"Full text: {sample['full_text']}")
+            print(f"Instances: {json.loads(sample['instances'])}")
+
+        except Exception as e:
+            self.logger.error(f"Error saving parquet file: {e}")
+
+
+# Example usage
+if __name__ == "__main__":
+    converter = ArabicOCRDatasetConverter(dataset_dir=r"Det_train")
+
+    converter.save_parquet(output_path="train.parquet", include_images=False)
+
+    converter = ArabicOCRDatasetConverter(dataset_dir=r"Det_test")
+
+    converter.save_parquet(output_path="test.parquet", include_images=False)

test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef3e81a1e57b940c1a04a50903c1a58f6360c82b0c529e3f0d9c6b82e030c486
+size 91446

train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9d364aa97a8b098f4ed34414bbeaaaab6bc651e961c72e3188f4c0d412adfc5
+size 273203