NuCLS_dataset.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 12 16:13:56 2024

@author: tominhanh
"""

# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# 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.

# Test 6

import pandas as pd
from PIL import Image as PilImage  # Import PIL Image with an alias
import datasets
from datasets import DatasetBuilder, GeneratorBasedBuilder, DownloadManager, DatasetInfo, Features, Image, ClassLabel, Value, Sequence, load_dataset, SplitGenerator
import os
import io
from typing import Tuple, Dict, List
import numpy as np
import zipfile
import requests
import random
from io import BytesIO
import csv

_CITATION = """\
https://arxiv.org/abs/2102.09099
"""

_DESCRIPTION = """\
The comprehensive dataset contains over 220,000 single-rater and multi-rater labeled nuclei from breast cancer images
obtained from TCGA, making it one of the largest datasets for nucleus detection, classification, and segmentation in hematoxylin and eosin-stained
digital slides of breast cancer. This version of the dataset is a revised single-rater dataset, featuring over 125,000 nucleus csvs.
These nuclei were annotated through a collaborative effort involving pathologists, pathology residents, and medical students, using the Digital Slide Archive.
"""

_HOMEPAGE = "https://sites.google.com/view/nucls/home?authuser=0"

_LICENSE = "CC0 1.0 license"

_URL = "https://www.dropbox.com/scl/fi/srq574rdgvp7f5gwr60xw/NuCLS_dataset.zip?rlkey=qjc9q8shgvnqpfy4bktbqybd1&dl=1"

class NuCLSDataset(GeneratorBasedBuilder):
    """The NuCLS dataset."""

    VERSION = datasets.Version("1.1.0")

    def _info(self):
        """Returns the dataset info."""

        # Define the classes for the classifications
        raw_classification = ClassLabel(names=[
            'apoptotic_body', 'ductal_epithelium', 'eosinophil','fibroblast', 'lymphocyte',
            'macrophage', 'mitotic_figure', 'myoepithelium', 'neutrophil',
            'plasma_cell','tumor', 'unlabeled', 'vascular_endothelium'
        ])
        main_classification = ClassLabel(names=[
            'AMBIGUOUS', 'lymphocyte', 'macrophage', 'nonTILnonMQ_stromal',
            'plasma_cell', 'tumor_mitotic', 'tumor_nonMitotic',
        ])
        super_classification = ClassLabel(names=[
            'AMBIGUOUS','nonTIL_stromal','sTIL', 'tumor_any',
        ])
        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')),
                })
        })

        return DatasetInfo(
            description=_DESCRIPTION,
            features=features,
            supervised_keys=None,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            citation=_CITATION,
          )

    def _split_generators(self, dl_manager: DownloadManager):
        # Download source data
        data_dir = dl_manager.download_and_extract(_URL)

        # Directory paths
        rgb_dir = os.path.join(data_dir, "rgb")
        visualization_dir = os.path.join(data_dir, "visualization")
        mask_dir = os.path.join(data_dir, "mask")
        csv_dir = os.path.join(data_dir, "csv")

        # Generate a list of unique filenames (without extensions)
        unique_filenames = [os.path.splitext(f)[0] for f in os.listdir(rgb_dir)]

        # Split filenames into training and testing sets
        random.shuffle(unique_filenames)
        split_idx = int(0.8 * len(unique_filenames))
        train_filenames = unique_filenames[:split_idx]
        test_filenames = unique_filenames[split_idx:]

        # Map filenames to file paths for each split
        train_filepaths = self._map_filenames_to_paths(train_filenames, rgb_dir, visualization_dir, mask_dir, csv_dir)
        test_filepaths = self._map_filenames_to_paths(test_filenames, rgb_dir, visualization_dir, mask_dir, csv_dir)

        # Create the split generators
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={"filepaths": train_filepaths}
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={"filepaths": test_filepaths}
            ),
        ]

    def _map_filenames_to_paths(self, filenames, rgb_dir, visualization_dir, mask_dir, csv_dir):
        """Maps filenames to file paths for each split."""
        filepaths = {}
        for filename in filenames:
            filepaths[filename] = {
                'fov': os.path.join(rgb_dir, filename + '.png'),
                'visualization': os.path.join(visualization_dir, filename + '.png'),
                'mask': os.path.join(mask_dir, filename + '.png'),
                'csv': os.path.join(csv_dir, filename + '.csv'),
            }
        return filepaths


    def _generate_examples(self, filepaths):
        """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']),
            }

            yield key, example

    def _read_image_file(self, file_path: str) -> PilImage:
        """Reads an image file and returns it as a PIL Image object."""
        try:
            with open(file_path, 'rb') as f:
                return PilImage.open(f)
        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

    # 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