minor changes

README.md

@@ -90,29 +90,14 @@ xami_dataset = XAMIDataset(
     dataset_name="xami_dataset", 
     data_path='./dest_dir')
 ```
-**or**
+###
+Or you can simply download only the dataset zip file from HuggingFace using a CLI command:
 
-- using a CLI command
 ```bash
 DEST_DIR='/path/to/local/dataset/dir'
 
 huggingface-cli download iulia-elisa/XAMI-dataset xami_dataset.zip --repo-type dataset --local-dir "$DEST_DIR" && unzip "$DEST_DIR/xami_dataset.zip" -d "$DEST_DIR" && rm "$DEST_DIR/xami_dataset.zip"
-
 ```
-<!-- 
-# Dataset Split with SKF (Optional)
-
-- The below method allows for dataset splitting, using the pre-generated splits in CSV files. This step is useful when training multiple dataset splits versions to gain mor generalised view on metrics. 
-```python
-import utils
-
-# run multilabel SKF split with the standard k=4
-csv_files = ['mskf_0.csv', 'mskf_1.csv', 'mskf_2.csv', 'mskf_3.csv'] 
-
-for idx, csv_file in enumerate(csv_files):
-    mskf = pd.read_csv(csv_file)
-    utils.create_directories_and_copy_files(images_dir, data_in, mskf, idx)
-``` -->
 
 ## Licence 
 **[CC BY-NC 3.0 IGO](https://creativecommons.org/licenses/by-nc/3.0/igo/deed.en).**

utils.py

@@ -1,322 +0,0 @@
-import os
-import json
-from shutil import copy
-import pandas as pd
-from pathlib import Path
-from PIL import Image, ImageDraw
-import cv2
-import numpy as np
-import re
-import datasets
-from datasets import Value
-from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-
-def create_directories_and_copy_files(images_dir, coco_data, image_data, k):
-    base_dir = os.path.join(images_dir, f'mskf_{k}')
-    os.makedirs(base_dir, exist_ok=True)
-
-    for split in np.unique(image_data['SPLIT']):
-        split_dir = os.path.join(base_dir, split)
-        os.makedirs(split_dir, exist_ok=True)
-
-        # Filter the annotations
-        split_ids = image_data[image_data['SPLIT'] == split]['IMADE_ID'].tolist()
-        annotations = {
-            'images': [img for img in coco_data['images'] if img['id'] in split_ids],
-            'annotations': [ann for ann in coco_data['annotations'] if ann['image_id'] in split_ids],
-            'categories': coco_data['categories']
-        }
-            
-        # Write the filtered annotations to a file
-        with open(os.path.join(split_dir, '_annotations.coco.json'), 'w') as f:
-            json.dump(annotations, f, indent=4)
-        
-        # Copy the images
-        split_data = image_data[image_data['SPLIT'] == split]
-        for _, row in split_data.iterrows():
-            source = row['IMAGE_PATH']
-            destination = os.path.join(split_dir, os.path.basename(source))
-            copy(source, destination)
-            
-    print(f'Dataset split for mskf_{k} was successful.')
-
-def split_to_df(dataset_dir, split):
-    annotations_path = Path(dataset_dir+split+'/_annotations.coco.json')
-    
-    with annotations_path.open('r') as f:
-        coco_data = json.load(f)
-    
-    def image_from_path(file_path):
-        image = cv2.imread(file_path)
-        return image
-    
-    def gen_segmentation(segmentation, width, height):
-        mask_img = np.zeros((height, width, 3), dtype=np.uint8)
-        for segment in segmentation:
-            pts = np.array(segment, np.int32).reshape((-1, 1, 2))
-            cv2.fillPoly(mask_img, [pts], (255, 255, 255))  # Fill color in BGR
-        
-        return mask_img
-        
-    images_df = pd.DataFrame(coco_data['images'][:50], columns=['id', 'file_name', 'width', 'height'])
-    annotations_df = pd.DataFrame(coco_data['annotations'])
-    df = pd.merge(annotations_df, images_df, left_on='image_id', right_on='id')
-    image_folder = annotations_path.parent 
-    df['file_path'] = df['file_name'].apply(lambda x: str(image_folder / x))
-    df['observation'] = df['file_name'].apply(lambda x: x.split('.')[0].replace('_png', ''))
-    df['image'] = df['file_path'].apply(image_from_path)
-    df['segmentation'] = df.apply(lambda row: gen_segmentation(row['segmentation'], row['width'], row['height']), axis=1)
-    df = df.drop('file_path', axis=1)
-    df = df.drop('file_name', axis=1)
-    df['annot_id'] = df['id_x'] 
-    df = df.drop('id_x', axis=1)
-    df = df.drop('id_y', axis=1)
-    
-    # take image fro df, and the corresponging annotations and plot them on image
-    # for i in range(5):
-    #     img = df['image'][i]
-    #     annot_id = df['annot_id'][i]
-    #     # plot the image with the annotation using plt
-    #     if img.dtype != np.uint8:
-    #         img = img.astype(np.uint8)
-    #     # plot
-    #     segm_polygon = df['segmentation'][i]
-    #     plt.imshow(segm_polygon)
-    #     plt.axis('off')
-    #     plt.show()
-    #     plt.close()
-    
-    return df, coco_data
-	
-def df_to_dataset_dict(df, coco_data, cats_to_colours):
-
-    def annot_on_image(annot_id, img_array, cat_id, annot_type='segm'):
-        if img_array.dtype != np.uint8:
-            img_array = img_array.astype(np.uint8)
-    
-        pil_image = Image.fromarray(img_array)
-        draw = ImageDraw.Draw(pil_image)
-        if annot_type=='bbox':
-            bbox = [annot for annot in coco_data['annotations'] if annot['id'] == annot_id][0]['bbox']
-            x_min, y_min, width, height = bbox
-            top_left = (x_min, y_min)
-            bottom_right = (x_min + width, y_min + height)
-            
-            draw.rectangle([top_left, bottom_right], outline=cats_to_colours[cat_id][1], width=2)
-        else:
-            # look for the annotation in coco_data that corresponds to the annot_id
-            segm_polygon = [annot for annot in coco_data['annotations'] if annot['id'] == annot_id][0]['segmentation'][0]
-            polygon = [(segm_polygon[i], segm_polygon[i+1]) for i in range(0, len(segm_polygon), 2)]
-            draw.polygon(polygon, outline=cats_to_colours[cat_id][1], width=2)  
-         
-        # plt.imshow(pil_image)
-        # plt.axis('off')
-        # plt.show()
-        # plt.close()
-           
-        byte_io = BytesIO()
-        pil_image.save(byte_io, 'PNG')
-        byte_io.seek(0)
-        png_image = Image.open(byte_io)
-    
-        return png_image
-    
-    dictionary = df.to_dict(orient='list')
-    feats=datasets.Features({"observation id":Value(dtype='string'), \
-                             'segmentation': datasets.Image(), \
-                             'bbox':datasets.Image() , \
-                             'label': Value(dtype='string'),\
-                             'area':Value(dtype='string'), 
-                             'image shape':Value(dtype='string')})
-    
-    dataset_data = {"observation id":dictionary['observation'],  \
-                  'segmentation': [annot_on_image(dictionary['annot_id'][i], dictionary['image'][i], dictionary['category_id'][i]) \
-                      for i in range(len(dictionary['segmentation']))], \
-                  'bbox': [annot_on_image(dictionary['annot_id'][i], dictionary['image'][i], dictionary['category_id'][i], annot_type='bbox') \
-                      for i in range(len(dictionary['bbox']))], \
-                  'label': [cats_to_colours[cat][0] for cat in dictionary['category_id']],\
-                  'area':['%.3f'%(value) for value in dictionary['area']], \
-                  'image shape':[f"({dictionary['width'][i]}, {dictionary['height'][i]})" for i in range(len(dictionary['width']))]}
-    the_dataset=datasets.Dataset.from_dict(dataset_data,features=feats)
-
-    return the_dataset
-
-def merge_coco_jsons(first_json, second_json, output_path):
-        
-    # Load the first JSON file
-    with open(first_json) as f:
-        coco1 = json.load(f)
-
-    # Load the second JSON file
-    with open(second_json) as f:
-        coco2 = json.load(f)
-
-    # Update IDs in coco2 to ensure they are unique and do not overlap with coco1
-    max_image_id = max(image['id'] for image in coco1['images'])
-    max_annotation_id = max(annotation['id'] for annotation in coco1['annotations'])
-    max_category_id = max(category['id'] for category in coco1['categories'])
-
-    # Add an offset to the second coco IDs
-    image_id_offset = max_image_id + 1
-    annotation_id_offset = max_annotation_id + 1
-    # category_id_offset = max_category_id + 1
-
-    # Apply offset to images, annotations, and categories in the second JSON
-    for image in coco2['images']:
-        image['id'] += image_id_offset
-
-    for annotation in coco2['annotations']:
-        annotation['id'] += annotation_id_offset
-        annotation['image_id'] += image_id_offset  # Update the image_id reference
-
-    # Merge the two datasets
-    merged_coco = {
-        'images': coco1['images'] + coco2['images'],
-        'annotations': coco1['annotations'] + coco2['annotations'],
-        'categories': coco1['categories']  # If categories are the same; otherwise, merge as needed
-    }
-
-    # Save the merged annotations to a new JSON file
-    with open(output_path, 'w') as f:
-        json.dump(merged_coco, f)
-
-def percentages(n_splits, image_ids, labels):
-    labels_percentages = {}
-    for i in range(n_splits):
-        train_k, valid_k = 0, 0
-        train_labels_counts = {'0':0, '1':0, '2':0, '3':0, '4':0, '5':0}
-        valid_labels_counts = {'0':0, '1':0, '2':0, '3':0, '4':0, '5':0}
-        for j in range(len(image_ids[i]['train'])):
-            for cat in list(labels[i]['train'][j]):
-                train_labels_counts[cat] += 1
-                train_k+=1
-        
-        for j in range(len(image_ids[i]['valid'])):
-            for cat in list(labels[i]['valid'][j]):
-                valid_labels_counts[cat] += 1
-                valid_k+=1
-    
-        train_labels_counts = {cat:counts * 1.0/train_k for cat, counts in train_labels_counts.items()}
-        valid_labels_counts = {cat:counts * 1.0/valid_k for cat, counts in valid_labels_counts.items()}
-                
-        labels_percentages[i] = {'train':train_labels_counts, 'valid':  valid_labels_counts}
-        
-    return labels_percentages
-
-def make_split(data_in, train_index, valid_index):
-    
-    data_in_train = data_in.copy()
-    data_in_valid = data_in.copy()
-    
-    data_in_train['images'] = [data_in['images'][train_index[i][0]] for i in range(len(train_index))]
-    data_in_valid['images'] = [data_in['images'][valid_index[i][0]] for i in range(len(valid_index))]
-    train_annot_ids, valid_annot_ids = [], []
-    
-    for img_i in data_in_train['images']:
-        annotation_ids = [annot['id'] for annot in data_in_train['annotations'] if annot['image_id'] == img_i['id']]
-        train_annot_ids +=annotation_ids
-        
-    for img_i in data_in_valid['images']:
-        annotation_ids = [annot['id'] for annot in data_in_valid['annotations'] if annot['image_id'] == img_i['id']]
-        valid_annot_ids +=annotation_ids
-        
-    data_in_train['annotations'] = [data_in_train['annotations'][id] for id in train_annot_ids]
-    data_in_valid['annotations'] = [data_in_valid['annotations'][id] for id in valid_annot_ids]
-    
-    print(len(data_in_train['images']), len(data_in_valid['images']))
-    return data_in_train, data_in_valid
-
-def correct_bboxes(annotations):
-        for ann in annotations:
-            # If the segmentation is in polygon format (COCO polygon)
-            if isinstance(ann['segmentation'], list):
-    
-                points = np.array(ann['segmentation']).reshape(-1, 2)
-                x_min, y_min = np.inf, np.inf
-                x_max, y_max = -np.inf, -np.inf
-                x_min = min(x_min, points[:, 0].min())
-                y_min = min(y_min, points[:, 1].min())
-                x_max = max(x_max, points[:, 0].max())
-                y_max = max(y_max, points[:, 1].max())
-        
-                width = x_max - x_min
-                height = y_max - y_min
-            
-                # The bbox in COCO format [x_min, y_min, width, height]
-                bbox = [x_min, y_min, width, height]
-                x, y, w, h = map(int, bbox)
-                ann['bbox'] = [x, y, w, h]
-    
-        return annotations
-    
-def highlight_max(s):
-    is_max = s == s.max()
-    return ['background-color: yellow' if v else '' for v in is_max]
-
-def highlight_max_str(s):
-    
-    cats = []
-    for cat in s:
-        cats.append([float(match) for match in re.findall(r"[-+]?[0-9]*\.?[0-9]+", cat)][0])
-        
-    is_max = cats == np.max(cats)
-    return ['background-color: yellow' if v else '' for v in is_max]
-
-def read_yolo_annotations(annotation_file):
-    with open(annotation_file, 'r') as file:
-        lines = file.readlines()
-
-    annotations = []
-    for line in lines:
-        parts = line.strip().split()
-        class_id = int(parts[0])
-        points = list(map(float, parts[1:]))
-        annotations.append((class_id, points))
-    
-    return annotations
-
-def display_image_with_annotations(coco, cat_names, image_id):
-    img = coco.loadImgs(image_id)[0]
-    image_path = os.path.join('./mskf_0/train/', img['file_name'])
-    I = Image.open(image_path)
-    plt.imshow(I); plt.axis('off')
-    ann_ids = coco.getAnnIds(imgIds=img['id'], iscrowd=None)
-    anns = coco.loadAnns(ann_ids)
-    ax = plt.gca()
-    
-    for ann in anns:
-        bbox = ann['bbox']
-        rect = patches.Rectangle((bbox[0], bbox[1]), bbox[2], bbox[3],
-                                 linewidth=2, edgecolor='b', facecolor='none')
-        ax.add_patch(rect)
-        ax.text(bbox[0], bbox[1] - 5, cat_names[ann['category_id']],
-                color='blue', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
-
-    plt.show()
-
-def plot_segmentations(image_path, annotations, category_mapping):
-    image = Image.open(image_path)
-    width, height = image.size
-    draw = ImageDraw.Draw(image)
-
-    try:
-        font = ImageFont.truetype("DejaVuSans.ttf", 16)  # Load a font
-    except IOError:
-        font = ImageFont.load_default()
-
-    for class_id, points in annotations:
-        # Scale points from normalized coordinates to image dimensions
-        scaled_points = [(p[0] * width, p[1] * height) for p in zip(points[0::2], points[1::2])]
-        draw.polygon(scaled_points, outline='green', fill=None)  
-
-        category_name = category_mapping[class_id][0]
-        centroid_x = sum([p[0] for p in scaled_points]) / len(scaled_points)
-        centroid_y = sum([p[1] for p in scaled_points]) / len(scaled_points)
-        draw.text((centroid_x, centroid_y), category_name, fill='red', font=font, anchor='ms')
-
-    plt.imshow(image)
-    plt.axis('off')
-    plt.show()