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'][5:25], 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()