Update annotation_coordinates

NuCLS_dataset.py

@@ -76,31 +76,24 @@ class NuCLSDataset(GeneratorBasedBuilder):
         ])
         type = ClassLabel(names=['rectangle', 'polyline'])
 
-        # Assuming a maximum length for polygon coordinates.
-        max_polygon_length = 20
-
         # Define features
         features = Features({
-            # Images will be loaded as arrays; you'll dynamically handle the varying sizes in the generator function
-                'rgb_image': Image(decode=False),
-                'mask_image': Image(decode=False),
-                'visualization_image': Image(decode=False),
-
-            # Annotation coordinates
-                'annotation_coordinates': Features({
-                    'raw_classification': raw_classification,
-                    'main_classification': main_classification,
-                    'super_classification': super_classification,
-                    'type': type,
-                    'xmin': Value('int64'),
-                    'ymin': Value('int64'),
-                    'xmax': Value('int64'),
-                    'ymax': Value('int64'),
-                    'coords_x': Sequence(Value('float32')),
-                    'coords_y': Sequence(Value('float32')),
-                })
+            'rgb_image': Image(decode=True),
+            'mask_image': Image(decode=True),
+            'visualization_image': Image(decode=True),
+            'annotation_coordinates': Features({
+                'raw_classification': Sequence(Value("string")),
+                'main_classification': Sequence(Value("string")),
+                'super_classification': Sequence(Value("string")),
+                'type': Sequence(Value("string")),
+                'xmin': Sequence(Value('int64')),
+                'ymin': Sequence(Value('int64')),
+                'xmax': Sequence(Value('int64')),
+                'ymax': Sequence(Value('int64')),
+                'coords_x': Sequence(Sequence(Value('int64'))),  # Lists of integers
+                'coords_y': Sequence(Sequence(Value('int64'))),  # Lists of integers
+            })
         })
-
         return DatasetInfo(
             description=_DESCRIPTION,
             features=features,
@@ -163,41 +156,63 @@ class NuCLSDataset(GeneratorBasedBuilder):
         """Yield examples as (key, example) tuples."""
 
         for key, paths in filepaths.items():
-            # Initialize an example dictionary
-            example = {
-                'rgb_image': self._read_image_file(paths['fov']),
-                'mask_image': self._read_image_file(paths['mask']),
-                'visualization_image': self._read_image_file(paths['visualization']),
-                'annotation_coordinates': self._read_csv_file(paths['csv']),
+            # Read the images using a method to handle the image files
+            rgb_image = self._read_image_file(paths['rgb'])
+            mask_image = self._read_image_file(paths['mask'])
+            visualization_image = self._read_image_file(paths['visualization'])
+
+            # Read the CSV and format the data as per the defined features
+            annotation_coordinates = self._read_csv_file(paths['csv'])
+
+            # Yield the example
+            yield key, {
+                'rgb_image': rgb_image,
+                'mask_image': mask_image,
+                'visualization_image': visualization_image,
+                'annotation_coordinates': annotation_coordinates,
             }
 
-            yield key, example
-
-    def _read_image_file(self, file_path: str) -> PilImage:
-        """Reads an image file and returns it as a PIL Image object."""
+    def _read_image_file(self, file_path: str, ) -> bytes:
+        """Reads an image file and returns it as a bytes_like object."""
         try:
             with open(file_path, 'rb') as f:
-                image = PilImage.open(f)
-                return np.array(image)
+                return f.read()
         except Exception as e:
             print(f"Error reading image file {file_path}: {e}")
             return None
 
-    def _read_csv_file(self, file_path: str):
-        """Reads a CSV file and returns the contents in the expected format."""
-        try:
-            csv_df = pd.read_csv(file_path)
-            if csv_df.empty:
-                print(f"Warning: CSV file {file_path} is empty.")
-                return None
-            else:
-                # Convert the DataFrame into the structure that matches your features' annotation_coordinates
-                return self._process_csv_data(csv_df)
-        except Exception as e:
-            print(f"Error reading CSV file {file_path}: {e}")
-            return None
+    def _read_csv_file(self, filepath):
+        """Reads the annotation CSV file and formats the data."""
+
+        with open(filepath, 'r', encoding='utf-8') as csvfile:
+            reader = csv.DictReader(csvfile)
+            annotations = {
+                'raw_classification': [],
+                'main_classification': [],
+                'super_classification': [],
+                'type': [],
+                'xmin': [],
+                'ymin': [],
+                'xmax': [],
+                'ymax': [],
+                'coords_x': [],
+                'coords_y': []
+            }
 
-    # Implement this method to process and convert CSV data into the format expected by your dataset's features
-    def _process_csv_data(self, csv_df):
-        # Process the DataFrame and return the data in the correct format
-        pass
+            for row in reader:
+                annotations['raw_classification'].append(row.get('raw_classification', ''))
+                annotations['main_classification'].append(row.get('main_classification', ''))
+                annotations['super_classification'].append(row.get('super_classification', ''))
+                annotations['type'].append(row.get('type', ''))
+                annotations['xmin'].append(int(row.get('xmin', 0)))
+                annotations['ymin'].append(int(row.get('ymin', 0)))
+                annotations['xmax'].append(int(row.get('xmax', 0)))
+                annotations['ymax'].append(int(row.get('ymax', 0)))
+
+                # Handle coords_x and coords_y safely
+                coords_x = row.get('coords_x', '')
+                coords_y = row.get('coords_y', '')
+                annotations['coords_x'].append([int(coord) if coord.isdigit() else 0 for coord in coords_x.split(',')])
+                annotations['coords_y'].append([int(coord) if coord.isdigit() else 0 for coord in coords_y.split(',')])
+        
+            return annotations